![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to fb-xlat-auto.sh CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [The Machine Emulator] / tme / generic|
Return to fb-xlat-auto.sh CVS log | Up to [The Machine Emulator] / tme / generic |
1.1 root 1: #! /bin/sh
2:
3: # $Id: fb-xlat-auto.sh,v 1.5 2003/09/29 11:42:56 fredette Exp $
4:
5: # generic/fb-xlat-auto.sh - automatically generates C code
6: # for many framebuffer translation functions:
7:
8: #
9: # Copyright (c) 2003 Matt Fredette
10: # All rights reserved.
11: #
12: # Redistribution and use in source and binary forms, with or without
13: # modification, are permitted provided that the following conditions
14: # are met:
15: # 1. Redistributions of source code must retain the above copyright
16: # notice, this list of conditions and the following disclaimer.
17: # 2. Redistributions in binary form must reproduce the above copyright
18: # notice, this list of conditions and the following disclaimer in the
19: # documentation and/or other materials provided with the distribution.
20: # 3. All advertising materials mentioning features or use of this software
21: # must display the following acknowledgement:
22: # This product includes software developed by Matt Fredette.
23: # 4. The name of the author may not be used to endorse or promote products
24: # derived from this software without specific prior written permission.
25: #
26: # THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
27: # IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
28: # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
29: # DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
30: # INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
31: # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
32: # SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
33: # HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
34: # STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
35: # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
36: # POSSIBILITY OF SUCH DAMAGE.
37: #
38:
39: # this script generates one or more C functions. each function
40: # translates an image from a source image format into a destination
41: # image format, optionally halving or doubling the image size in the
42: # process.
43: #
44: # the source and destination image formats are represented by "keys",
45: # strings that describe the different attributes of a format.
46: #
47: # a source image format key has the form: WxHdDbBsSpPoO[_X]
48: #
49: # a destination image format key has the form: dDbBsSpPoO
50: #
51: # all of the lowercase letters and underscores are literals, and all
52: # of the uppercase letters represent attribute values. the different
53: # attributes are:
54: #
55: # W is the width of the source image. if zero, the generated function
56: # will be able to translate source images of any width, but it will be
57: # suboptimal. if nonzero, the generated function will only be able to
58: # translate source images of that width, but it will have some
59: # optimization. this attribute is only used in source keys, since the
60: # destination width is always the scaled source width.
61: #
62: # H is the height of the source image. if zero, the generated
63: # function will be able to translate source images of any height, but
64: # it will be suboptimal. if nonzero, the generated function will only
65: # be able to translate source images of that height, but it will have
66: # some optimization. this attribute is only used in source keys,
67: # since the destination height is always the scaled source height.
68: #
69: # D is the color (d)epth, in bits, of the source/destination image.
70: # if zero, the generated function will be able to handle
71: # source/destination images of any depth, but it will be suboptimal.
72: # if nonzero, the generated function will only be able to handle
73: # source/destination images of that depth, but it will have some
74: # optimization.
75: #
76: # B is the (b)its-per-pixel of the source/destination image. this
77: # must be at least as large as the depth, and it may be larger. if
78: # zero, the generated function will be able to handle
79: # source/destination images of any bits-per-pixel, but it will be
80: # suboptimal. if nonzero, the generated function will only be able to
81: # handle source/destination images of that bits-per-pixel, but it will
82: # have some optimization.
83: #
84: # S is the (s)kip-x-bits of the source/destination image. this is the
85: # number of bits at the beginning of each image scanline that are not
86: # displayed. if an underscore, the generated function will be able to
87: # handle source/destination images with any skip-x-bits, but it will
88: # be suboptimal. if not an underscore, the generated function will
89: # only be able to handle source/destination images with that many
90: # skip-x-bits, but it will have some optimization.
91: #
92: # P is the (p)adding of the source/destination image. this is how
93: # many bits each image scanline is padded to. if zero, the generated
94: # function will be able to handle source/destination images with any
95: # padding, but it will be suboptimal. if nonzero, the generated
96: # function will only be able to handle source/destination images with
97: # that padding, but it will have some optimization.
98: #
99: # O is the byte and bit (o)rder of the source/destination image. this
100: # is always m or l for most- or least-significant, respectively.
101: # there is no "any" wildcard value. this script cannot handle image
102: # formats where a word-unit of pixels has one order for its bytes in
103: # memory, but the opposite order for its pixels within the word-unit.
104: #
105: # X is the optional scaling. it is `h' to halve the source image,
106: # or `d' to double it. this attribute is only used in source keys.
107:
108: # this script generates a set of functions for the product of all
109: # source image formats and all destination image formats.
110: #
111: # "all source image formats" includes all source image formats given
112: # on the command line, plus:
113: #
114: # the "any" source image format, unscaled
115: # the "any" source image format, halved
116: # the "any" source image format, doubled
117: #
118: # "all destination image formats" includes all destination
119: # image formats given on the command line, plus:
120: #
121: # the "any" destination image format
122: #
123: src_all=
124: dst_all=
125: for order in m l; do
126: src_key="0x0d0b0s_p0o${order}"
127: src_all="${src_all} ${src_key} ${src_key}_h ${src_key}_d"
128: dst_all="${dst_all} d0b0s_p0o${order}"
129: done
130:
131: which=
132: for arg
133: do
134: case $arg in
135: src|dst) which=$arg ;;
136: *)
137: if test "x${which}" != x; then
138: eval "${which}_all=\"$arg \$${which}_all\""
139: fi
140: ;;
141: esac
142: done
143:
144: PROG=`basename $0`
145: cat <<EOF
146: /* automatically generated by $PROG, do not edit! */
147:
148: /*
149: * Copyright (c) 2003 Matt Fredette
150: * All rights reserved.
151: *
152: * Redistribution and use in source and binary forms, with or without
153: * modification, are permitted provided that the following conditions
154: * are met:
155: * 1. Redistributions of source code must retain the above copyright
156: * notice, this list of conditions and the following disclaimer.
157: * 2. Redistributions in binary form must reproduce the above copyright
158: * notice, this list of conditions and the following disclaimer in the
159: * documentation and/or other materials provided with the distribution.
160: * 3. All advertising materials mentioning features or use of this software
161: * must display the following acknowledgement:
162: * This product includes software developed by Matt Fredette.
163: * 4. The name of the author may not be used to endorse or promote products
164: * derived from this software without specific prior written permission.
165: *
166: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
167: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
168: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
169: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
170: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
171: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
172: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
173: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
174: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
175: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
176: * POSSIBILITY OF SUCH DAMAGE.
177: */
178:
179: _TME_RCSID("\$Id: fb-xlat-auto.sh,v 1.5 2003/09/29 11:42:56 fredette Exp $");
180:
181: /* the central feature of these translation functions is the "bit
182: FIFO", a first-in, first-out stream of bits. source bit FIFOs are
183: used to read pixel bits out of source images, and destination bit
184: FIFOs are used to write pixel bits into destination images.
185:
186: a bit FIFO has a visible part and an invisible part.
187:
188: the visible part of a bit FIFO is 32 bits wide, meaning the
189: translation code can read (for a source bit FIFO) or write (for a
190: destination bit FIFO) up to 32 bits of pixel data before a bit
191: FIFO shift.
192:
193: the invisible part of a source bit FIFO contains pixel bits that
194: have already been read from the source image memory, but that have
195: yet to be shifted in to the visible part.
196:
197: the invisible part of a destination bit FIFO contains the pixel
198: bits that have been shifted out of the visible part, but that have
199: yet to be written to the destination image memory.
200:
201: depending on various attributes of an image format, it may be
202: possible for the translation code to always read or write the
203: entire 32 visible bits of a bit FIFO at a time, and as a result
204: always shift the bit FIFO 32 bits at a time. this is desirable
205: because it minimizes bit FIFO shifts.
206:
207: when this does happen, it may also be the case that the visible
208: part of the bit FIFO always perfectly corresponds to an aligned
209: 32-bit word in the image buffer.
210:
211: this is the optimal situation, as it makes it unnecessary to track
212: the invisible part in C local variables at all - each 32-bit FIFO
213: shift of a source bit FIFO just reads the next 32-bit word directly
214: into the visible part, and each 32-bit FIFO shift of a destination
215: bit FIFO just writes the next 32-bit word directly out of the
216: visible part.
217:
218: within the visible part of a bit FIFO, which bits belong to which
219: pixels depends on the "order" of the image format. most-significant
220: (big-endian) images have earlier (more to the left on the screen)
221: pixels in more-significant bit positions. least-significant
222: (little-endian) images have earlier pixels in less-significant bit
223: bit positions.
224:
225: bit significance *within* a pixel never depends on image order.
226: once the bits belonging to a pixel have been identified according
227: to image order, the least significant bit in that pixel's value is
228: always the bit with the least absolute value.
229:
230: some pictures may help explain this better. each picture shows the
231: 32 bit visible part of a bit FIFO, with the bits marked from 0
232: (least significant) to 31 (most significant). all of these
233: examples are for a two-bit-deep/two-bits-per-pixel image, and in
234: the visible part sixteen pixels are numbered. lesser numbered
235: pixels are earlier (more to the left on the screen). some of the
236: invisible part is also shown, along with the direction that the bit
237: FIFO shifts in:
238:
239: a source bit FIFO for a little-endian source image with two bits
240: per pixel looks like:
241:
242: |
243: | 31 30 29 28 7 6 5 4 3 2 1 0
244: --+--+--+--+--+--+|+--+--+--+--+- --+--+--+--+--+--+--+--+
245: .. p18 | p17 | p16 ||| p15 | p14 | .. p3 | p2 | p1 | p0 |
246: --+--+--+--+--+--+|+--+--+--+--+- --+--+--+--+--+--+--+--+
247: |
248: invisible part | visible part
249:
250: shift -> shift -> shift -> shift -> shift ->
251:
252: a source bit FIFO for a big-endian source image with two bits per
253: pixel looks like:
254:
255: |
256: 31 30 29 28 27 26 25 26 4 3 2 1 0 |
257: +--+--+--+--+--+--+--+-- -+--+--+--+--+|+--+--+--+--+--+--
258: | p0 | p1 | p2 | p3 .. | p14 | p15 ||| p16 | p17 | p18 ..
259: +--+--+--+--+--+--+--+-- -+--+--+--+--+|+--+--+--+--+--+--
260: |
261: visible part | invisible part
262:
263: <- shift <- shift <- shift <- shift <- shift
264:
265: a destination bit FIFO for a little-endian destination image with
266: two bits per pixel looks like:
267:
268: |
269: 31 30 29 28 27 26 25 26 4 3 2 1 0 |
270: +--+--+--+--+--+--+--+-- -+--+--+--+--+|+--+--+--+--+--+--
271: | p23 | p22 | p21 | p20 .. | p9 | p8 ||| p7 | p6 | p5 ..
272: +--+--+--+--+--+--+--+-- -+--+--+--+--+|+--+--+--+--+--+--
273: |
274: visible part | invisible part
275:
276: shift -> shift -> shift -> shift -> shift ->
277:
278: a destination bit FIFO for a big-endian destination image with
279: two bits per pixel looks like:
280:
281: |
282: | 31 30 29 28 7 6 5 4 3 2 1 0
283: --+--+--+--+--+--+|+--+--+--+--+- --+--+--+--+--+--+--+--+
284: .. p5 | p6 | p7 ||| p8 | p9 | .. p20 | p21 | p22 | p23 |
285: --+--+--+--+--+--+|+--+--+--+--+- --+--+--+--+--+--+--+--+
286: |
287: invisible part | visible part
288:
289: <- shift <- shift <- shift <- shift <- shift
290:
291: each translation function has at least one source bit FIFO and at
292: least one destination bit FIFO. the general idea is to read source
293: pixel value(s) from the source image, map those source pixel
294: value(s) somehow into destination pixel value(s), and write those
295: destination pixel value(s) to the destination image.
296:
297: translation functions that do not scale the image have exactly one
298: source bit FIFO and exactly one destination bit FIFO. one pixel
299: read from the source bit FIFO becomes one pixel written to the
300: destination bit FIFO.
301:
302: translation functions that halve the image size have two source bit
303: FIFOs and one destination bit FIFO. one source bit FIFO sources
304: bits from an even-numbered scanline, and the other sources bits from
305: an odd-numbered scanline. four pixels read from the source bit
306: FIFOs - two from each source bit FIFO, making a 2x2 square - become
307: one pixel written to the destination bit FIFO.
308:
309: translation functions that double the image size have one source
310: bit FIFO and two destination bit FIFOs. one destination bit FIFO
311: sinks bits for an even-numbered scanline, and the other sinks bits
312: for an odd-numbered scanline. one pixel read from the source bit
313: FIFO becomes four pixels written to the destination bit FIFOs -
314: two to each destination bit FIFO, making a 2x2 square.
315:
316: translation functions don't necessarily always translate the entire
317: source image into the entire destination image. instead, the buffer
318: holding the current source image is expected to be twice as large as
319: necessary (plus some overhead), with the second half of the buffer
320: holding a copy of the last translated ("old") source image.
321:
322: before setting up and translating pixels using bit FIFOs, a
323: translation function treats the the current and old source images as
324: an array of aligned 32-bit words and compares them. if it finds no
325: 32-bit word that has changed, no translation is done and the
326: function returns.
327:
328: otherwise, initial source pixel x and y coordinates are derived from
329: the offset of the 32-bit word that failed comparison, and the source
330: primary bit FIFO is primed. if this translation function halves the
331: image size, the source secondary bit FIFO is primed from the same x
332: coordinate on the "other" (think y ^ 1) scanline.
333:
334: then, initial destination pixel x and y coordinates are derived from
335: the initial source x and y coordinates, and the destination primary
336: bit FIFO is primed. if this translation function doubles the image
337: size, the destination secondary bit FIFO is primed from the same x
338: coordinate on the "other" (think y ^ 1) scanline.
339:
340: as mentioned previously, the buffer holding the current source image
341: is expected to be twice as large as necessary (plus some overhead),
342: with the second half of the buffer holding a copy of the last
343: translated ("old") source image.
344:
345: this "overhead" is approximately two extra scanlines worth of data,
346: that is initialized to all-bits-zero and must always remain zero.
347: this extra data is present at the end of both the current ("new")
348: and last translated ("old") source images.
349:
350: these extra, always-blank scanlines guarantee that the pixel
351: translation loop terminates. the pixel translation loop *never*
352: checks for the end of the image buffer. instead, it terminates only
353: after it has read in TME_FB_XLAT_RUN consecutive aligned 32-bit
354: words that have *not* changed between the new and old source images.
355: this small amount of extra memory overhead simplifies the pixel
356: translation loop, because it doesn't have to worry about going past
357: the end of the actual image.
358: */
359:
360:
361: /* macros: */
362:
363: /* given a 32-bit aligned pointer into the current source image, this
364: returns the corresponding 32-bit aligned pointer in the last
365: translated ("old") source image. since the old source image
366: follows the current source image, this is simple pointer arithmetic
367: using src_bypb: */
368: #define TME_FB_XLAT_SRC_OLD(raw) \\
369: ((tme_uint32_t *) (((tme_uint8_t *) (raw)) + src_bypb))
370:
371: /* when the fast, aligned 32-bit word comparison loop finds a word
372: that has changed in the source image, pixels are translated until
373: TME_FB_XLAT_RUN consecutive aligned 32-bit words are processed that
374: have *not* changed in the source image, at which point the fast
375: comparison loop resumes.
376:
377: the idea is that after you've started translating pixels, once the
378: FIFO shift operation has read TME_FB_XLAT_RUN consecutive raw,
379: unchanged 32-bit words, all of the pixels from previous, changed
380: 32-bit words have been translated and shifted out of the source bit
381: FIFO(s), and all bits remaining in the source bit FIFO(s) are for
382: pixels in those unchanged 32-bit words. since the pixels are
383: unchanged, pixel translation can stop, and the entire state of the
384: source bit FIFO(s) can be discarded.
385:
386: so, each time a raw, changed 32-bit word is read, xlat_run is
387: reloaded with TME_FB_XLAT_RUN, and each time 32 bits worth of
388: source image pixels are processed, it is decremented. when it
389: reaches zero, the source bit FIFO(s) are discarded, the destination
390: bit FIFO(s) are flushed, the pixel translation loop breaks and the
391: fast comparison loop continues: */
392: #define TME_FB_XLAT_RUN (2)
393:
394: /* this shifts a source FIFO: */
395: #define TME_FB_XLAT_SHIFT_SRC(unaligned, fifo, next, bits, shift, raw, order)\\
396: do { \\
397: \\
398: /* if the source FIFO may not be 32-bit aligned: */ \\
399: if (unaligned) { \\
400: \\
401: /* we must be shifting between 1 and 32 bits: */ \\
402: assert ((shift) >= 1 && (shift) <= 32); \\
403: \\
404: /* the FIFO must have more than 32 bits in it already: */ \\
405: assert (bits > 32); \\
406: \\
407: /* shift the FIFO: */ \\
408: if ((shift) == 32) { \\
409: fifo = next; \\
410: } \\
411: else if (order == TME_ENDIAN_BIG) { \\
412: fifo = (fifo << ((shift) & 31)) | (next >> (32 - (shift)));\\
413: next <<= ((shift) & 31); \\
414: } \\
415: else { \\
416: fifo = (fifo >> ((shift) & 31)) | (next << (32 - (shift)));\\
417: next >>= ((shift) & 31); \\
418: } \\
419: bits -= (shift); \\
420: \\
421: /* if we have a new 32-bit word to read: */ \\
422: if (bits <= 32) { \\
423: next = *raw; \\
424: if (*TME_FB_XLAT_SRC_OLD(raw) != next) { \\
425: *TME_FB_XLAT_SRC_OLD(raw) = next; \\
426: xlat_run = TME_FB_XLAT_RUN; \\
427: } \\
428: raw++; \\
429: next = (order == TME_ENDIAN_BIG \\
430: ? tme_betoh_u32(next) \\
431: : tme_letoh_u32(next)); \\
432: \\
433: /* before the load, if there were fewer than 32 bits \\
434: remaining in the FIFO, shift bits from the word \\
435: we just loaded into their proper positions: */ \\
436: if (bits < 32) { \\
437: if (order == TME_ENDIAN_BIG) { \\
438: fifo |= (next >> bits); \\
439: next <<= (32 - bits); \\
440: } \\
441: else { \\
442: fifo |= (next << bits); \\
443: next >>= (32 - bits); \\
444: } \\
445: } \\
446: \\
447: /* there are now 32 more bits in the FIFO: */ \\
448: bits += 32; \\
449: } \\
450: } \\
451: \\
452: /* otherwise, if the source FIFO is always 32-bit aligned: */ \\
453: else { \\
454: \\
455: /* we must be shifting exactly 32 bits: */ \\
456: assert((shift) == 32); \\
457: \\
458: /* load the next 32-bit word: */ \\
459: fifo = *raw; \\
460: if (*TME_FB_XLAT_SRC_OLD(raw) != fifo) { \\
461: *TME_FB_XLAT_SRC_OLD(raw) = fifo; \\
462: xlat_run = TME_FB_XLAT_RUN; \\
463: } \\
464: raw++; \\
465: fifo = (order == TME_ENDIAN_BIG \\
466: ? tme_betoh_u32(fifo) \\
467: : tme_letoh_u32(fifo)); \\
468: } \\
469: } while (/* CONSTCOND */ 0)
470:
471: /* this shifts a destination FIFO: */
472: #define TME_FB_XLAT_SHIFT_DST(unaligned, fifo, next, bits, shift, raw, order)\\
473: do { \\
474: \\
475: /* if the destination FIFO may not be 32-bit aligned: */ \\
476: if (unaligned) { \\
477: \\
478: /* we must be shifting between 1 and 32 bits: */ \\
479: assert ((shift) >= 1 && (shift) <= 32); \\
480: \\
481: /* the FIFO must have fewer than 32 bits in it: */ \\
482: assert (bits < 32); \\
483: \\
484: /* shift the FIFO: */ \\
485: if (order == TME_ENDIAN_BIG) { \\
486: next |= (fifo >> bits); \\
487: fifo <<= (32 - bits); \\
488: } \\
489: else { \\
490: next |= (fifo << bits); \\
491: fifo >>= (32 - bits); \\
492: } \\
493: bits += (shift); \\
494: \\
495: /* if we have a completed 32-bit word to write: */ \\
496: if (bits >= 32) { \\
497: *(raw++) = (order == TME_ENDIAN_BIG \\
498: ? tme_htobe_u32(next) \\
499: : tme_htole_u32(next)); \\
500: bits -= 32; \\
501: assert(bits != 0 || fifo == 0); \\
502: next = fifo; \\
503: } \\
504: } \\
505: \\
506: /* the destination FIFO is always 32-bit aligned: */ \\
507: else { \\
508: \\
509: /* we must be shifting exactly 32 bits: */ \\
510: assert((shift) == 32); \\
511: \\
512: /* store the next 32-bit word: */ \\
513: *(raw++) = (order == TME_ENDIAN_BIG \\
514: ? tme_htobe_u32(fifo) \\
515: : tme_htole_u32(fifo)); \\
516: \\
517: } \\
518: \\
519: /* clear the writable part of the FIFO: */ \\
520: fifo = 0; \\
521: } while (/* CONSTCOND */ 0)
522: EOF
523:
524: # the next function number:
525: xlat_next=0
526: xlat_array=
527:
528: # permute over the source possibilities:
529: for src_key in ${src_all}; do
530:
531: # take apart the source possibility:
532: src_parts=${src_key}
533:
534: # get the width:
535: width=`echo ${src_parts} | sed -e 's/^\([0-9][0-9]*\)\(.*\)$/\1/'`
536: src_parts=`echo ${src_parts} | sed -e 's/^\([0-9][0-9]*\)\(.*\)$/\2/'`
537:
538: # get the height:
539: height=`echo ${src_parts} | sed -e 's/^x\([0-9][0-9]*\)\(.*\)$/\1/'`
540: src_parts=`echo ${src_parts} | sed -e 's/^x\([0-9][0-9]*\)\(.*\)$/\2/'`
541:
542: # get the source depth:
543: src_depth=`echo ${src_parts} | sed -e 's/^d\([0-9][0-9]*\)\(.*\)$/\1/'`
544: src_parts=`echo ${src_parts} | sed -e 's/^d\([0-9][0-9]*\)\(.*\)$/\2/'`
545:
546: # get the source bits per pixel:
547: src_bipp=`echo ${src_parts} | sed -e 's/^b\([0-9][0-9]*\)\(.*\)$/\1/'`
548: src_parts=`echo ${src_parts} | sed -e 's/^b\([0-9][0-9]*\)\(.*\)$/\2/'`
549:
550: # get the source skip pixel count:
551: src_skipx=`echo ${src_parts} | sed -e 's/^s\([_0-9][0-9]*\)\(.*\)$/\1/'`
552: src_parts=`echo ${src_parts} | sed -e 's/^s\([_0-9][0-9]*\)\(.*\)$/\2/'`
553:
554: # get the source scanline pad:
555: src_pad=`echo ${src_parts} | sed -e 's/^p\([0-9][0-9]*\)\(.*\)$/\1/'`
556: src_parts=`echo ${src_parts} | sed -e 's/^p\([0-9][0-9]*\)\(.*\)$/\2/'`
557:
558: # get the source "order" - i.e., byte order and leftmost (first)
559: # pixel significance:
560: src_order=`echo ${src_parts} | sed -e 's/^o\([ml]\)\(.*\)$/\1/'`
561: src_parts=`echo ${src_parts} | sed -e 's/^o\([ml]\)\(.*\)$/\2/'`
562:
563: # get the source scaling:
564: scale="${src_parts}_"
565:
566: # permute over the destination possibilities:
567: for dst_key in ${dst_all}; do
568:
569: # take apart the destination possibility:
570: dst_parts=${dst_key}
571:
572: # get the destination depth:
573: dst_depth=`echo ${dst_parts} | sed -e 's/^d\([0-9][0-9]*\)\(.*\)$/\1/'`
574: dst_parts=`echo ${dst_parts} | sed -e 's/^d\([0-9][0-9]*\)\(.*\)$/\2/'`
575:
576: # get the destination bits per pixel:
577: dst_bipp=`echo ${dst_parts} | sed -e 's/^b\([0-9][0-9]*\)\(.*\)$/\1/'`
578: dst_parts=`echo ${dst_parts} | sed -e 's/^b\([0-9][0-9]*\)\(.*\)$/\2/'`
579:
580: # get the destination skip pixel count:
581: dst_skipx=`echo ${dst_parts} | sed -e 's/^s\([_0-9][0-9]*\)\(.*\)$/\1/'`
582: dst_parts=`echo ${dst_parts} | sed -e 's/^s\([_0-9][0-9]*\)\(.*\)$/\2/'`
583:
584: # get the destination scanline pad:
585: dst_pad=`echo ${dst_parts} | sed -e 's/^p\([0-9][0-9]*\)\(.*\)$/\1/'`
586: dst_parts=`echo ${dst_parts} | sed -e 's/^p\([0-9][0-9]*\)\(.*\)$/\2/'`
587:
588: # get the destination "order" - i.e., byte order and leftmost
589: # (first) pixel significance:
590: dst_order=`echo ${dst_parts} | sed -e 's/^o\([ml]\)\(.*\)$/\1/'`
591: dst_parts=`echo ${dst_parts} | sed -e 's/^o\([ml]\)\(.*\)$/\2/'`
592:
593: # when both source and destination depth are known, ignore
594: # this permutation if the source depth is greater:
595: if test $src_depth != 0 \
596: && test $dst_depth != 0 \
597: && test `expr ${src_depth} \> ${dst_depth}` = 1; then
598: continue
599: fi
600:
601: # allocate the xlat number:
602: xlat=${xlat_next}
603: xlat_next=`expr ${xlat_next} + 1`
604: xlat_info="tme_fb_xlat${xlat}"
605:
606: # start the function:
607: echo ""
608: echo "/* this translates frame buffer contents from this source format:"
609: case "${width}x${height}" in
610: 0x0) echo -n " any dimensions" ;;
611: *x0) echo -n " width $width, any height" ;;
612: 0x*) echo -n " any width, height ${height}" ;;
613: *) echo -n " ${width}x${height}" ;;
614: esac
615: xlat_info="${xlat_info}, ${width}, ${height}"
616: case ${scale} in
617: _h_) echo " (image will be halved)" ; value="HALF" ;;
618: _d_) echo " (image will be doubled)" ; value="DOUBLE" ;;
619: *) echo "" ; value="NONE" ;;
620: esac
621: xlat_info="${xlat_info}, TME_FB_XLAT_SCALE_${value}"
622: echo -n " "
623: case ${src_depth} in
624: 0) echo -n "any depth" ;;
625: 1) echo -n "1 bit deep" ;;
626: *) echo -n "${src_depth} bits deep" ;;
627: esac
628: xlat_info="${xlat_info}, ${src_depth}"
629: case ${src_bipp} in
630: 0) echo -n ", any bits per pixel" ;;
631: 1) echo -n ", 1 bit per pixel" ;;
632: *) echo -n ", ${src_bipp} bits per pixel" ;;
633: esac
634: xlat_info="${xlat_info}, ${src_bipp}"
635: case ${src_skipx} in
636: _) echo -n ", any number of pixels skipped" ; value="-1";;
637: *) echo -n ", ${src_skipx} pixels skipped" ; value=${src_skipx} ;;
638: esac
639: xlat_info="${xlat_info}, ${value}"
640: case ${src_pad} in
641: 0) echo -n ", any scanline padding" ;;
642: *) echo -n ", ${src_pad}-bit scanline padding" ;;
643: esac
644: xlat_info="${xlat_info}, ${src_pad}"
645: case ${src_order} in
646: m) echo -n ", MSB-first" ; value="BIG" ;;
647: l) echo -n ", LSB-first" ; value="LITTLE" ;;
648: esac
649: xlat_info="${xlat_info}, TME_ENDIAN_${value}"
650: echo ""
651: echo " to this destination format:"
652: echo -n " "
653: case ${dst_depth} in
654: 0) echo -n "any depth" ;;
655: 1) echo -n "1 bit deep" ;;
656: *) echo -n "${dst_depth} bits deep" ;;
657: esac
658: xlat_info="${xlat_info}, ${dst_depth}"
659: case ${dst_bipp} in
660: 0) echo -n ", any bits per pixel" ;;
661: 1) echo -n ", 1 bit per pixel" ;;
662: *) echo -n ", ${dst_bipp} bits per pixel" ;;
663: esac
664: xlat_info="${xlat_info}, ${dst_bipp}"
665: case ${dst_skipx} in
666: _) echo -n ", any number of pixels skipped" ; value="-1";;
667: *) echo -n ", ${dst_skipx} pixels skipped" ; value=${dst_skipx} ;;
668: esac
669: xlat_info="${xlat_info}, ${value}"
670: case ${dst_pad} in
671: 0) echo -n ", any scanline padding" ;;
672: *) echo -n ", ${dst_pad}-bit scanline padding" ;;
673: esac
674: xlat_info="${xlat_info}, ${dst_pad}"
675: case ${dst_order} in
676: m) echo -n ", MSB-first" ; value="BIG" ;;
677: l) echo -n ", LSB-first" ; value="LITTLE" ;;
678: esac
679: xlat_info="${xlat_info}, TME_ENDIAN_${value}"
680: save_IFS=$IFS
681: IFS=
682: xlat_array="${xlat_array}
683: { $xlat_info }, "
684: IFS=$save_IFS
685: echo ""
686: echo "*/"
687: echo "static int"
688: echo "tme_fb_xlat${xlat}(struct tme_fb_connection *src,"
689: echo " struct tme_fb_connection *dst)"
690: echo "{"
691: undef_macros=
692:
693: echo ""
694: echo " /* whenever possible we define macros instead of declaring"
695: echo " variables, for optimization: */"
696:
697: echo ""
698: echo " /* declare src_x and src_y. these are the current translation"
699: echo " coordinates in the source image: */"
700: echo " unsigned int src_x, src_y;"
701:
702: echo ""
703: echo " /* declare dst_x and dst_y. these are the current translation"
704: echo " coordinates in the destination image. since this function"
705: if test $scale = _; then
706: echo " does not scale the image, these coordinates are always"
707: echo " the same as the coordinates in the source image: */"
708: echo "#define dst_x (src_x)"
709: echo "#define dst_y (src_y)"
710: undef_macros="${undef_macros} dst_x dst_y"
711: scale_op=
712: scale_math=
713: else
714: if test $scale = _h_; then
715: scale_op='/'
716: scale_name='halves'
717: else
718: scale_op='*'
719: scale_name='doubles'
720: fi
721: scale_math=" ${scale_op} 2"
722: echo " ${scale_name} the image, the coordinates in the destination image"
723: echo " are always the coordinates in the source image${scale_math}: */"
724: echo " unsigned int dst_x, dst_y;"
725: fi
726:
727: echo ""
728: echo " /* declare pixel. this holds a single pixel value being translated"
729: echo " for the destination image: */"
730: echo " tme_uint32_t pixel;"
731:
732: if test $scale = _h_ && test $src_depth != 1; then
733: echo ""
734: echo " /* since this function halves the source image, and this"
735: echo " image isn't grayscale, we need to read all pixels in the"
736: echo " 2x2 square in the source image into separate variables"
737: echo " and then make a decision about how to map those four"
738: echo " pixels into one color value for the destination pixel."
739: echo " the above \"pixel\" will hold one of the four pixels,"
740: echo " and these three variables will hold the others: */"
741: echo " tme_uint32_t src_pixel1, src_pixel2, src_pixel3;"
742: fi
743:
744: echo ""
745: echo " /* declare src_width and dst_width. these are in terms of pixels: */"
746: value="(src_width${scale_math})"
747: if test ${width} = 0; then
748: echo " const unsigned int src_width = src->tme_fb_connection_width;"
749: if test $scale != _; then
750: echo " const unsigned int dst_width = ${value};"
751: else
752: echo "#define dst_width ${value}"
753: undef_macros="${undef_macros} dst_width"
754: fi
755: else
756: echo "#define src_width (${width})"
757: echo "#define dst_width ${value}"
758: undef_macros="${undef_macros} src_width dst_width"
759: fi
760:
761: echo ""
762: echo " /* declare src_depth, the source pixel depth, which is in"
763: echo " terms of bits. declare src_mask, which is the corresponding"
764: echo " mask of one bits: */"
765: value="(0xffffffff >> (32 - src_depth))"
766: if test ${src_depth} = 0; then
767: echo " const unsigned int src_depth = src->tme_fb_connection_depth;"
768: echo " const tme_uint32_t src_mask = ${value};"
769: else
770: echo "#define src_depth (${src_depth})"
771: echo "#define src_mask ${value}"
772: undef_macros="${undef_macros} src_depth src_mask"
773: fi
774:
775: echo ""
776: echo " /* declare src_bipp and dst_bipp. these are the bits-per-pixel"
777: echo " values for the source and destination images: */"
778: if test ${src_bipp} = 0; then
779: echo " const unsigned int src_bipp = src->tme_fb_connection_bits_per_pixel;"
780: else
781: echo "#define src_bipp (${src_bipp})"
782: undef_macros="${undef_macros} src_bipp"
783: fi
784: if test ${dst_bipp} = 0; then
785: echo " const unsigned int dst_bipp = dst->tme_fb_connection_bits_per_pixel;"
786: else
787: echo "#define dst_bipp (${dst_bipp})"
788: undef_macros="${undef_macros} dst_bipp"
789: fi
790:
791: echo ""
792: echo " /* declare src_skipx and dst_skipx. these are the counts of"
793: echo " undisplayed pixels at the beginning of each scanline in the"
794: echo " source and destination images: */"
795: if test ${src_skipx} = _; then
796: echo " const unsigned int src_skipx = src->tme_fb_connection_skipx;"
797: else
798: echo "#define src_skipx (${src_skipx})"
799: undef_macros="${undef_macros} src_skipx"
800: fi
801: if test ${dst_skipx} = _; then
802: echo " const unsigned int dst_skipx = dst->tme_fb_connection_skipx;"
803: else
804: echo "#define dst_skipx (${dst_skipx})"
805: undef_macros="${undef_macros} dst_skipx"
806: fi
807:
808: echo ""
809: echo " /* declare src_pad and dst_pad. these are the paddings, in bits,"
810: echo " of each scanline in the source and destination images: */"
811: if test ${src_pad} = 0; then
812: echo " const unsigned int src_pad = src->tme_fb_connection_scanline_pad;"
813: else
814: echo "#define src_pad (${src_pad})"
815: undef_macros="${undef_macros} src_pad"
816: fi
817: if test ${dst_pad} = 0; then
818: echo " const unsigned int dst_pad = dst->tme_fb_connection_scanline_pad;"
819: else
820: echo "#define dst_pad (${dst_pad})"
821: undef_macros="${undef_macros} dst_pad"
822: fi
823:
824: echo ""
825: echo " /* declare src_order and dst_order. these are the bit and byte"
826: echo " orders (either TME_ENDIAN_BIG or TME_ENDIAN_LITTLE) of the"
827: echo " source and destination images. since these values profoundly"
828: echo " affect optimization, they are always constant: */"
829: if test ${src_order} = m; then value=BIG; else value=LITTLE; fi
830: echo "#define src_order (TME_ENDIAN_${value})"
831: undef_macros="${undef_macros} src_order"
832: if test ${dst_order} = m; then value=BIG; else value=LITTLE; fi
833: echo "#define dst_order (TME_ENDIAN_${value})"
834: undef_macros="${undef_macros} dst_order"
835:
836: echo ""
837: echo " /* declare src_bypl and dst_bypl. these are the bytes per scanline"
838: echo " in the source and destination images. these values are calculated"
839: echo " from the count of undisplayed and displayed pixels per scanline,"
840: echo " the number of bits per pixel, and the scanline padding: */"
841: value="(((((src_skipx + src_width) * src_bipp) + (src_pad - 1)) & -src_pad) / 8)"
842: if test ${src_skipx} = _ || test ${width} = 0 || test ${src_bipp} = 0 || test ${src_pad} = 0; then
843: echo " const unsigned int src_bypl = ${value};"
844: src_bypl_var=true
845: else
846: echo "#define src_bypl ${value}"
847: undef_macros="${undef_macros} src_bypl"
848: src_bypl_var=false
849: fi
850: value="(((((dst_skipx + dst_width) * dst_bipp) + (dst_pad - 1)) & -dst_pad) / 8)"
851: if test ${dst_skipx} = _ || test ${width} = 0 || test ${dst_bipp} = 0 || test ${dst_pad} = 0; then
852: echo " const unsigned int dst_bypl = ${value};"
853: dst_bypl_var=true
854: else
855: echo "#define dst_bypl ${value}"
856: undef_macros="${undef_macros} dst_bypl"
857: dst_bypl_var=false
858: fi
859:
860: echo ""
861: echo " /* declare src_packed and dst_packed. these are nonzero iff"
862: echo " every last bit in a scanline belongs to a displayed pixel."
863: echo " put another way, this is zero iff a scanline has undisplayed"
864: echo " pixels at its beginning or padding bits at its end. when"
865: echo " a source image or destination image is packed, translation"
866: echo " doesn't have to worry about skipping FIFO bits to get to"
867: echo " bits belonging to displayed pixels: */"
868: value="((src_width * src_bipp) == (src_bypl * 8))"
869: if $src_bypl_var; then
870: echo " const unsigned int src_packed = ${value};"
871: else
872: echo "#define src_packed ${value}"
873: undef_macros="${undef_macros} src_packed"
874: fi
875: value="((dst_width * dst_bipp) == (dst_bypl * 8))"
876: if $dst_bypl_var; then
877: echo " const unsigned int dst_packed = ${value};"
878: else
879: echo "#define dst_packed ${value}"
880: undef_macros="${undef_macros} dst_packed"
881: fi
882:
883: echo ""
884: echo " /* declare src_bypb and src_bypb_real. src_bypb is the bytes"
885: echo " per source image buffer with the \"translation termination"
886: echo " overhead\" of approximately two extra scanlines. src_bypb_real"
887: echo " is the real bytes per source image buffer with no overhead."
888: echo " both values are padded to a multiple of 4 bytes (32 bits): */"
889: if test ${height} = 0; then
890: value="src->tme_fb_connection_height"
891: else
892: value="${height}"
893: fi
894: value_real="(((${value} * src_bypl) + 3) & -4)"
895: value="((src_bypb_real + (src_bypl * 2)) & -4)"
896: if test ${height} = 0 || $src_bypl_var; then
897: echo " const unsigned int src_bypb_real = ${value_real};"
898: echo " const unsigned int src_bypb = ${value};"
899: else
900: echo "#define src_bypb_real ${value_real}"
901: echo "#define src_bypb ${value}"
902: undef_macros="${undef_macros} src_bypb_real src_bypb"
903: fi
904:
905: echo ""
906: echo " /* declare the source primary bit FIFO:"
907: echo ""
908: echo " src_raw0 points to the next aligned 32-bit word to be"
909: echo " read from the image buffer."
910: echo ""
911: echo " src_fifo0 is the visible part of the bit FIFO."
912: echo ""
913: echo " src_fifo0_next and src_fifo0_bits are only used when the"
914: echo " visible part of the bit FIFO is not guaranteed to always"
915: echo " correspond to an aligned 32-bit word in the image buffer."
916: echo " src_fifo0_next is the invisible part of the bit FIFO,"
917: echo " and src_fifo0_bits tracks the total number of bits in the"
918: echo " visible and invisible parts of the FIFO. */"
919: echo " const tme_uint32_t *src_raw0;"
920: echo " tme_uint32_t src_fifo0, src_fifo0_next;"
921: echo " unsigned int src_fifo0_bits;"
922:
923: if test ${scale} = _h_; then
924: echo ""
925: echo " /* since this function ${scale_name} the image, declare the"
926: echo " source secondary bit FIFO. these variables work in "
927: echo " exactly the same way that their primary counterparts do: */"
928: echo " const tme_uint32_t *src_raw1;"
929: echo " tme_uint32_t src_fifo1, src_fifo1_next;"
930: echo " unsigned int src_fifo1_bits;"
931: fi
932:
933: echo ""
934: echo " /* declare the destination primary bit FIFO:"
935: echo ""
936: echo " dst_raw0 points to the next aligned 32-bit word to be"
937: echo " written into the image buffer."
938: echo ""
939: echo " dst_fifo0 is the visible part of the bit FIFO."
940: echo ""
941: echo " dst_fifo0_next and dst_fifo0_bits are only used when the"
942: echo " visible part of the bit FIFO is not guaranteed to always"
943: echo " correspond to an aligned 32-bit word in the image buffer."
944: echo " dst_fifo0_next is the invisible part of the bit FIFO,"
945: echo " and dst_fifo0_bits tracks the total number of bits in the"
946: echo " invisible part of the FIFO. */"
947: echo " tme_uint32_t *dst_raw0;"
948: echo " tme_uint32_t dst_fifo0, dst_fifo0_next;"
949: echo " unsigned int dst_fifo0_bits;"
950:
951: if test ${scale} = _d_; then
952: echo ""
953: echo " /* since this function ${scale_name} the image, declare"
954: echo " the destination secondary bit FIFO. these variables work"
955: echo " in exactly the same way that their primary counterparts"
956: echo " do: */"
957: echo " tme_uint32_t *dst_raw1;"
958: echo " tme_uint32_t dst_fifo1, dst_fifo1_next;"
959: echo " unsigned int dst_fifo1_bits;"
960: fi
961:
962: echo ""
963: echo " /* declare src_off and dst_off. these are used when priming a"
964: echo " source or destination bit FIFO, to identify an initial aligned"
965: echo " 32-bit word in the source or destination image buffer, and an"
966: echo " initial bit offset within that word: */"
967: echo " unsigned int src_off, dst_off;"
968:
969: echo ""
970: echo " /* declare src_fifo0_may_be_unaligned. this is zero iff all"
971: echo " aligned 32-bit words in the source buffer contain a whole"
972: echo " number of displayed pixels. this is *not* so if the source"
973: echo " buffer is not packed, or if there are 24 bits per pixel -"
974: echo " in this last case, it is possible for a pixel value to cross"
975: echo " a 32-bit boundary: */"
976: value="(!src_packed || (src_bipp == 24))"
977: if $src_bypl_var; then
978: echo " const unsigned int src_fifo0_may_be_unaligned = ${value};"
979: else
980: echo "#define src_fifo0_may_be_unaligned ${value}"
981: undef_macros="${undef_macros} src_fifo0_may_be_unaligned"
982: fi
983:
984: if test $scale = _h_; then
985: echo ""
986: echo " /* declare src_fifo1_may_be_unaligned. this is zero iff all"
987: echo " aligned 32-bit words in the source buffer contain a"
988: echo " whole number of displayed pixels, *and* for every aligned"
989: echo " 32-bit word on one scanline all other scanlines have an"
990: echo " aligned 32-bit word corresponding to the same x coordinate: */"
991: value="(src_fifo0_may_be_unaligned || (src_bypl & 3))"
992: if $src_bypl_var; then
993: echo " const unsigned int src_fifo1_may_be_unaligned = ${value};"
994: else
995: echo "#define src_fifo1_may_be_unaligned ${value}"
996: undef_macros="${undef_macros} src_fifo1_may_be_unaligned"
997: fi
998: fi
999:
1000: echo ""
1001: echo " /* declare dst_fifo0_may_be_unaligned. this is zero iff"
1002: echo " src_fifo0_may_be_unaligned is zero, dst_bypl is 32-bit aligned"
1003: echo " and we can guarantee that any initial dst_x will correspond to"
1004: echo " an aligned 32-bit word in the destination buffer. the motivation"
1005: echo " is to only prime and shift the destination primary bit FIFO if"
1006: echo " absolutely necessary."
1007: echo ""
1008: echo " since we require that src_fifo0_may_be_unaligned is zero, we"
1009: echo " know that the initial src_x = (Z * 32) / src_bipp for "
1010: echo " some Z. we also have the initial dst_x = src_x${scale_math}."
1011: echo " the initial destination bit offset will then be:"
1012: echo ""
1013: echo " (dst_skipx + dst_x) * dst_bipp"
1014: echo " = (dst_skipx * dst_bipp) + (dst_x * dst_bipp)"
1015: echo ""
1016: echo " if we additionally require that (dst_skipx * dst_bipp)"
1017: echo " be 32-bit aligned, this reduces things to:"
1018: echo ""
1019: echo " dst_x * dst_bipp"
1020: echo " = (src_x${scale_math}) * dst_bipp"
1021: echo " = (((Z * 32) / src_bipp)${scale_math}) * dst_bipp"
1022: echo ""
1023: echo " which will be a multiple of 32 iff:"
1024: echo ""
1025: echo " ((1 / src_bipp)${scale_math}) * dst_bipp >= 1 and integral"
1026: echo " */"
1027: denom="src_bipp"
1028: numer="dst_bipp"
1029: case $scale in
1030: _) ;;
1031: _h_) denom="(${denom} * 2)" ;;
1032: _d_) numer="(${numer} * 2)" ;;
1033: esac
1034: value="(src_fifo0_may_be_unaligned || !dst_packed || (dst_bipp == 24) || (dst_bypl % 4) || ((dst_skipx * dst_bipp) % 32) || (${numer} % ${denom}))"
1035: if $src_bypl_var || $dst_bypl_var; then
1036: echo " const unsigned int dst_fifo0_may_be_unaligned = ${value};"
1037: else
1038: echo "#define dst_fifo0_may_be_unaligned ${value}"
1039: undef_macros="${undef_macros} dst_fifo0_may_be_unaligned"
1040: fi
1041:
1042: if test $scale = _d_; then
1043: echo ""
1044: echo " /* declare dst_fifo1_may_be_unaligned. this is zero iff all"
1045: echo " 32-bit aligned values in the destination buffer contain a"
1046: echo " whole number of displayed pixels, and for every 32-bit"
1047: echo " aligned value on one scanline all other scanlines have a"
1048: echo " 32-bit aligned value corresponding to the same x coordinate: */"
1049: value="(dst_fifo0_may_be_unaligned || (dst_bypl & 3))"
1050: if $src_bypl_var || $dst_bypl_var; then
1051: echo " const unsigned int dst_fifo1_may_be_unaligned = ${value};"
1052: else
1053: echo "#define dst_fifo1_may_be_unaligned ${value}"
1054: undef_macros="${undef_macros} dst_fifo1_may_be_unaligned"
1055: fi
1056: fi
1057:
1058: echo ""
1059: echo " /* declare src_raw0_end. when treating the source image as"
1060: echo " an array of aligned 32-bit words, this variable holds the"
1061: echo " address of the first word after the real source image."
1062: echo " if the fast, aligned 32-bit word comparison loop passes"
1063: echo " this point, the entire source image has been processed and"
1064: echo " the function terminates: */"
1065: echo " const tme_uint32_t *src_raw0_end;"
1066:
1067: echo ""
1068: echo " /* declare xlat_run. see the comment for the TME_FB_XLAT_RUN"
1069: echo " macro for an explanation of what this variable does: */"
1070: echo " int xlat_run;"
1071:
1072: echo ""
1073: echo " /* this silences gcc -Wuninitialized: */"
1074: echo " src_fifo0_next = 0;"
1075: echo " src_fifo0_bits = 0;"
1076: if test ${scale} = _h_; then
1077: echo " src_fifo1_next = 0;"
1078: echo " src_fifo1_bits = 0;"
1079: fi
1080: echo " dst_fifo0_next = 0;"
1081: echo " dst_fifo0_bits = 0;"
1082: if test ${scale} = _d_; then
1083: echo " dst_fifo1_next = 0;"
1084: echo " dst_fifo1_bits = 0;"
1085: fi
1086:
1087: echo ""
1088: echo " /* initialize src_raw0 and src_raw0_end for the fast aligned 32-bit"
1089: echo " word comparison loop. on entry to (and when continuing) that loop,"
1090: echo " src_raw0 always points to the aligned 32-bit word *before* the"
1091: echo " next word to check. src_raw0_end always points after the last"
1092: echo " word to check."
1093: echo ""
1094: echo " src_raw0 is actually part of the source primary bit FIFO, which"
1095: echo " is good, because when the fast comparison fails on a word, src_raw0"
1096: echo " is already primed and ready to work for that bit FIFO: */"
1097: echo " src_raw0 = ((const tme_uint32_t *) src->tme_fb_connection_buffer) - 1;"
1098: echo " src_raw0_end = (const tme_uint32_t *) (src->tme_fb_connection_buffer + src_bypb_real);"
1099:
1100: echo ""
1101: echo " /* initialize xlat_run to -1. it can never go negative inside the"
1102: echo " pixel translation loop, so if xlat_run stays negative for the"
1103: echo " entire translation, it means that the source image hasn't changed"
1104: echo " since the last translation. this information is returned to the"
1105: echo " caller to hopefully save more work in updating the display: */"
1106: echo " xlat_run = -1;"
1107:
1108: echo ""
1109: echo " /* this is the main translation loop, which contains the fast aligned"
1110: echo " 32-bit word comparison loop, and the pixel translation loop: */"
1111: echo " for (;;) {"
1112:
1113: echo ""
1114: echo " /* this is the fast aligned 32-bit word comparison loop. it"
1115: echo " terminates either when a word fails comparison, or when the"
1116: echo " entire source image has been compared. the if test that"
1117: echo " follows checks for the latter case and breaks the main"
1118: echo " translation loop: */"
1119: echo " for (; (++src_raw0 < src_raw0_end"
1120: echo " && *src_raw0 == *TME_FB_XLAT_SRC_OLD(src_raw0)); );"
1121: echo " if (src_raw0 >= src_raw0_end) {"
1122: echo " break;"
1123: echo " }"
1124:
1125: echo ""
1126: echo " /* calculate the byte offset into the source buffer of the"
1127: echo " 32-bit word that failed comparison: */"
1128: echo " src_off = ((tme_uint8_t *) src_raw0) - src->tme_fb_connection_buffer;"
1129:
1130: echo ""
1131: echo " /* calculate the source y pixel coordinate, and reduce"
1132: echo " src_off from the byte offset into the buffer to the"
1133: echo " byte offset into that scanline: */"
1134: echo " src_y = src_off / src_bypl;"
1135: echo " src_off = src_off % src_bypl;"
1136:
1137: echo ""
1138: echo " /* while translating pixels, we use one or more \"bit FIFOs\","
1139: echo " each composed of one or more 32-bit integers. we load these"
1140: echo " FIFOs 32 bits at a time. */"
1141: echo ""
1142: echo " /* prime the visible part of the source primary bit FIFO: */"
1143: echo " src_fifo0 = *src_raw0;"
1144: echo " *TME_FB_XLAT_SRC_OLD(src_raw0) = src_fifo0;"
1145: echo " src_raw0++;"
1146: echo " src_fifo0 = ((src_order == TME_ENDIAN_BIG)"
1147: echo " ? tme_betoh_u32(src_fifo0)"
1148: echo " : tme_letoh_u32(src_fifo0));"
1149: echo ""
1150: echo " /* if the source primary bit FIFO may be unaligned: */"
1151: echo " if (src_fifo0_may_be_unaligned) {"
1152: echo ""
1153: echo " /* prime the invisible part of the source primary bit FIFO and"
1154: echo " assume that we will not have to shift it to finish: */"
1155: echo " src_fifo0_next = *src_raw0;"
1156: echo " *TME_FB_XLAT_SRC_OLD(src_raw0) = src_fifo0_next;"
1157: echo " src_raw0++;"
1158: echo " src_fifo0_next = ((src_order == TME_ENDIAN_BIG)"
1159: echo " ? tme_betoh_u32(src_fifo0_next)"
1160: echo " : tme_letoh_u32(src_fifo0_next));"
1161: echo " src_fifo0_bits = 0;"
1162: echo ""
1163: echo " /* if there are pixels that need to be skipped, the first 32 bits"
1164: echo " we loaded into the FIFO may have first bits that belong to"
1165: echo " those undisplayed (skipped) pixels. it is *not* possible for"
1166: echo " it to have first bits that belong to the scanline pad; there"
1167: echo " might be pad bits in the *middle* of the first 32 bits, but any"
1168: echo " first bits *must* belong to pixels, displayed or not: */"
1169: echo " if (src_skipx > 0"
1170: echo " && (src_off * 8) < (src_skipx * src_bipp)) {"
1171: echo ""
1172: echo " /* see how many bits we will need to skip: */"
1173: echo " src_fifo0_bits = (src_skipx * src_bipp) - (src_off * 8);"
1174: echo ""
1175: echo " /* if it is more than 31 bits, this is an entire 32 bits of"
1176: echo " undisplayed pixels. just advance: */"
1177: echo " if (src_fifo0_bits > 31) {"
1178: echo " src_raw0--;"
1179: echo " continue;"
1180: echo " }"
1181: echo ""
1182: echo " /* set the source x coordinate to zero: */"
1183: echo " src_x = 0;"
1184: echo " }"
1185: echo ""
1186: echo " /* otherwise, the first 32 bits we load will have first bits for"
1187: echo " a displayable pixel: */"
1188: echo " else {"
1189: echo ""
1190: echo " /* if the source bits per pixel is 24, calculate the number of"
1191: echo " bytes *before* the original src_raw0 of any split pixel, and"
1192: echo " subtract this from src_off, to leave src_off as the byte offset"
1193: echo " into the scanline of the beginning of a pixel: */"
1194: echo " if (src_bipp == 24) {"
1195: echo " src_fifo0_bits = (src_off % 3);"
1196: echo " src_off -= src_fifo0_bits;"
1197: echo ""
1198: echo " /* if this is a split pixel, we need to prime the source primary"
1199: echo " bit FIFO starting with the part *before* the original src_raw0."
1200: echo " we do not have to copy to the old; it passed comparison: */"
1201: echo " if (src_fifo0_bits) {"
1202: echo " src_raw0--;"
1203: echo " src_fifo0_next = src_fifo0;"
1204: echo " src_fifo0 = ((src_order == TME_ENDIAN_BIG)"
1205: echo " ? tme_betoh_u32(*(src_raw0 - 2))"
1206: echo " : tme_letoh_u32(*(src_raw0 - 2)));"
1207: echo " }"
1208: echo " }"
1209: echo ""
1210: echo " /* calculate the source x coordinate: */"
1211: echo " src_x = ((src_off * 8) / src_bipp) - src_skipx;"
1212: echo " }"
1213: echo ""
1214: echo " /* do any shifting to finish priming the source primary FIFO: */"
1215: echo " if (src_fifo0_bits) {"
1216: echo " if (src_order == TME_ENDIAN_BIG) {"
1217: echo " src_fifo0 = (src_fifo0 << src_fifo0_bits) | (src_fifo0_next >> (32 - src_fifo0_bits));"
1218: echo " src_fifo0_next <<= src_fifo0_bits;"
1219: echo " }"
1220: echo " else {"
1221: echo " src_fifo0 = (src_fifo0 >> src_fifo0_bits) | (src_fifo0_next << (32 - src_fifo0_bits));"
1222: echo " src_fifo0_next >>= src_fifo0_bits;"
1223: echo " }"
1224: echo " }"
1225: echo " src_fifo0_bits = 64 - src_fifo0_bits;"
1226: echo " }"
1227: echo ""
1228: echo " /* otherwise, the source primary FIFO is aligned: */"
1229: echo " else {"
1230: echo " src_x = ((src_off * 8) / src_bipp) - src_skipx;"
1231: echo " }"
1232:
1233: if test $scale = _h_; then
1234: echo ""
1235: echo " /* when halving the image, we have a source secondary bit "
1236: echo " FIFO, providing pixel values at the same source x coordinate"
1237: echo " but on the \"other\" line. prime the source secondary"
1238: echo " bit FIFO: */"
1239: echo " if (src_fifo1_may_be_unaligned) {"
1240: echo ""
1241: echo " /* calculate the bit offset into the source buffer of"
1242: echo " this exact same pixel on the other line: */"
1243: echo " src_off = ((src_y ^ 1) * src_bypl * 8) + ((src_skipx + src_x) * src_bipp);"
1244: echo ""
1245: echo " /* calculate how many bits offset from a 32-bit boundary the pixel is: */"
1246: echo " src_fifo1_bits = src_off % 32;"
1247: echo ""
1248: echo " /* set src_raw1: */"
1249: echo " src_raw1 = (const tme_uint32_t *)"
1250: echo " (src->tme_fb_connection_buffer"
1251: echo " + ((src_off - src_fifo1_bits) / 8));"
1252: echo ""
1253: echo " /* actually prime the FIFO by loading the first two words and"
1254: echo " shifting off any offset bits: */"
1255: echo " src_fifo1 = *src_raw1;"
1256: echo " *TME_FB_XLAT_SRC_OLD(src_raw1) = src_fifo1;"
1257: echo " src_raw1++;"
1258: echo " src_fifo1_next = *src_raw1;"
1259: echo " *TME_FB_XLAT_SRC_OLD(src_raw1) = src_fifo1_next;"
1260: echo " src_raw1++;"
1261: echo " if (src_order == TME_ENDIAN_BIG) {"
1262: echo " src_fifo1 = tme_betoh_u32(src_fifo1);"
1263: echo " src_fifo1_next = tme_betoh_u32(src_fifo1_next);"
1264: echo " if (src_fifo1_bits) {"
1265: echo " src_fifo1 = (src_fifo1 << src_fifo1_bits) | (src_fifo1_next >> (32 - src_fifo1_bits));"
1266: echo " src_fifo1_next <<= src_fifo1_bits;"
1267: echo " }"
1268: echo " }"
1269: echo " else {"
1270: echo " src_fifo1 = tme_letoh_u32(src_fifo1);"
1271: echo " src_fifo1_next = tme_letoh_u32(src_fifo1_next);"
1272: echo " if (src_fifo1_bits) {"
1273: echo " src_fifo1 = (src_fifo1 >> src_fifo1_bits) | (src_fifo1_next << (32 - src_fifo1_bits));"
1274: echo " src_fifo1_next >>= src_fifo1_bits;"
1275: echo " }"
1276: echo " }"
1277: echo " src_fifo1_bits = 64 - src_fifo1_bits;"
1278: echo " }"
1279: echo ""
1280: echo " /* otherwise the source secondary FIFO is aligned: */"
1281: echo " else {"
1282: echo " src_raw1 = (const tme_uint32_t *)"
1283: echo " (((tme_uint8_t *) src_raw0)"
1284: echo " + (("
1285: echo " /* if src_y is even, this addend is now src_bypl * 4,"
1286: echo " else if src_y is odd, this addend is now src_bypl * 2: */"
1287: echo " ((src_bypl * 4) >> (src_y & 1))"
1288: echo " /* if src_y is even, this addend is now src_bypl,"
1289: echo " else if src_y is odd, this addend is now -src_bypl: */"
1290: echo " - (src_bypl * 3))"
1291: echo " /* this -4 compensates for src_raw0 already having"
1292: echo " been advanced by one: */"
1293: echo " - 4));"
1294: echo " src_fifo1 = *src_raw1;"
1295: echo " *TME_FB_XLAT_SRC_OLD(src_raw1) = src_fifo1;"
1296: echo " src_raw1++;"
1297: echo " src_fifo1 = ((src_order == TME_ENDIAN_BIG)"
1298: echo " ? tme_betoh_u32(src_fifo1)"
1299: echo " : tme_letoh_u32(src_fifo1));"
1300: echo " }"
1301: fi
1302:
1303: if test $scale != _; then
1304: echo ""
1305: echo " /* calculate the destination coordinates: */"
1306: echo " dst_y = src_y${scale_math};"
1307: echo " dst_x = src_x${scale_math};"
1308: fi
1309:
1310: echo ""
1311: echo " /* prime the destination primary bit FIFO: */"
1312: echo " dst_fifo0 = 0;"
1313: echo " if (dst_fifo0_may_be_unaligned) {"
1314: echo ""
1315: echo " /* calculate the bit offset into the destination buffer of"
1316: echo " the destination pixel: */"
1317: echo " dst_off = (dst_y * dst_bypl * 8) + ((dst_skipx + dst_x) * dst_bipp);"
1318: echo ""
1319: echo " /* calculate the number of bits that will be in the primed FIFO: */"
1320: echo " dst_fifo0_bits = dst_off % 32;"
1321: echo ""
1322: echo " /* set dst_raw0: */"
1323: echo " dst_raw0 = (tme_uint32_t *)"
1324: echo " (dst->tme_fb_connection_buffer"
1325: echo " + ((dst_off - dst_fifo0_bits) / 8));"
1326: echo ""
1327: echo " /* prime the primary destination FIFO: */"
1328: echo " dst_fifo0_next = 0;"
1329: echo " if (dst_fifo0_bits) {"
1330: echo " dst_fifo0_next = (src_order == TME_ENDIAN_BIG"
1331: echo " ? (tme_betoh_u32(*dst_raw0) & (0xffffffffUL << (32 - dst_fifo0_bits)))"
1332: echo " : (tme_letoh_u32(*dst_raw0) & (0xffffffffUL >> (32 - dst_fifo0_bits))));"
1333: echo " }"
1334: echo " }"
1335: echo ""
1336: echo " /* otherwise the destination primary FIFO is aligned: */"
1337: echo " else {"
1338: echo " dst_off = (dst_y * dst_bypl) + (((dst_skipx + dst_x) * dst_bipp) / 8);"
1339: echo " dst_raw0 = (tme_uint32_t *) (dst->tme_fb_connection_buffer + dst_off);"
1340: echo " }"
1341:
1342: if test $scale = _d_; then
1343: echo ""
1344: echo " /* when doubling the image, we have a destination secondary bit "
1345: echo " FIFO, for pixel values at the same source x coordinate"
1346: echo " but on the \"other\" line. prime the destination secondary"
1347: echo " bit FIFO: */"
1348: echo " dst_fifo1 = 0;"
1349: echo " if (dst_fifo1_may_be_unaligned) {"
1350: echo ""
1351: echo " /* calculate the bit offset into the destination buffer of"
1352: echo " the destination pixel: */"
1353: echo " dst_off = ((dst_y + 1) * dst_bypl * 8) + ((dst_skipx + dst_x) * dst_bipp);"
1354: echo ""
1355: echo " /* calculate the number of bits that will be in the primed FIFO: */"
1356: echo " dst_fifo1_bits = dst_off % 32;"
1357: echo ""
1358: echo " /* set dst_raw1: */"
1359: echo " dst_raw1 = (tme_uint32_t *)"
1360: echo " (dst->tme_fb_connection_buffer"
1361: echo " + ((dst_off - dst_fifo1_bits) / 8));"
1362: echo ""
1363: echo " /* prime the primary destination FIFO: */"
1364: echo " dst_fifo1_next = 0;"
1365: echo " if (dst_fifo1_bits) {"
1366: echo " dst_fifo1_next = (src_order == TME_ENDIAN_BIG"
1367: echo " ? (tme_betoh_u32(*dst_raw1) & (0xffffffffUL << (32 - dst_fifo1_bits)))"
1368: echo " : (tme_letoh_u32(*dst_raw1) & (0xffffffffUL >> (32 - dst_fifo1_bits))));"
1369: echo " }"
1370: echo " }"
1371: echo ""
1372: echo " /* otherwise, the destination secondary FIFO is aligned: */"
1373: echo " else {"
1374: echo " dst_raw1 = (tme_uint32_t *)"
1375: echo " (((tme_uint8_t *) dst_raw0)"
1376: echo " + dst_bypl);"
1377: echo " }"
1378: fi
1379:
1380: # we want to unroll the pixel translation loop to read as many
1381: # source pixels as possible out of the source bit FIFOs and
1382: # write as many destination pixels as possible into the
1383: # destination bit FIFOs before shifting them.
1384: #
1385: # it is very common to want to unroll the translation loop a
1386: # different number of times on source and destination pixels,
1387: # so we always unroll the maximum possible, tracking within
1388: # each unrolled iteration the relative unrolled iteration for
1389: # the source and destination bit FIFOs.
1390: #
1391:
1392: # src_unroll and dst_unroll are the number of times we will
1393: # unroll the translation loop on source and destination
1394: # pixels, respectively. assume no unrolling:
1395: #
1396: src_unroll=1
1397: dst_unroll=1
1398:
1399: # src_iter_scale is the number of source pixels read out of a
1400: # source bit FIFO in one unrolled iteration of the translation
1401: # loop. if this function halves the source image, this is
1402: # two, otherwise this is one.
1403: #
1404: # dst_iter_scale is the number of destination pixels written
1405: # to a destination bit FIFO in one unrolled iteration of the
1406: # translation loop. if this function doubles the source
1407: # image, this is two, otherwise this is one.
1408: #
1409: # src_fifo_shift is the number of bits that the source bit
1410: # FIFO(s) must be shifted after all unrolled iterations on
1411: # source pixels. assume no unrolling, so if this function
1412: # halves the source image and src_bipp is less than 24, two
1413: # pixels' bits must be shifted, otherwise one pixel's bits
1414: # must be shifted.
1415: #
1416: # dst_fifo_shift is the number of bits that the destination bit
1417: # FIFO(s) must be shifted after all unrolled iterations on
1418: # destination pixels. we are assuming no unrolling, so if this
1419: # function doubles the source image and dst_bipp is less than
1420: # 24, two pixels' bits must be shifted, otherwise one pixel's
1421: # bits must be shifted:
1422: #
1423: if test $scale = _h_; then
1424: src_iter_scale=2
1425: src_fifo_shift="(src_bipp < 24 ? (src_bipp * 2) : src_bipp)"
1426: else
1427: src_iter_scale=1
1428: src_fifo_shift="src_bipp"
1429: fi
1430: if test $scale = _d_; then
1431: dst_iter_scale=2
1432: dst_fifo_shift="(dst_bipp < 24 ? (dst_bipp * 2) : dst_bipp)"
1433: else
1434: dst_iter_scale=1
1435: dst_fifo_shift="dst_bipp"
1436: fi
1437:
1438: # if src_bipp is known now, see how many times we can unroll the
1439: # translation loop on source pixels:
1440: #
1441: if test ${src_bipp} != 0; then
1442:
1443: # in general, we can unroll once for each pixel in the
1444: # visible part of a source bit FIFO:
1445: #
1446: src_unroll=`expr 32 / ${src_bipp}`
1447:
1448: # if this function halves the source image, we can unroll
1449: # half as many times:
1450: #
1451: src_unroll=`expr ${src_unroll} / ${src_iter_scale}`
1452:
1453: # if we think we can unroll zero times, this means that
1454: # src_bipp is greater than 16 and this function halves the
1455: # source image - the zero is telling us that two whole
1456: # pixels cannot fit in the visible part of a source bit
1457: # FIFO. so we unroll once on source pixels, and shift
1458: # only one pixel's bits after the unrolling (the halving
1459: # code will be shifting one pixel's worth of bits to get
1460: # to the next pixel it has to read):
1461: #
1462: if test ${src_unroll} = 0; then
1463: src_unroll=1
1464: src_fifo_shift=${src_bipp}
1465:
1466: # otherwise, we will be shifting the entire visible part
1467: # of the source bit FIFO(s) after all unrolled iterations:
1468: #
1469: else
1470: src_fifo_shift=32
1471: fi
1472:
1473: echo ""
1474: echo " /* since src_bipp is known at code-generation time, the"
1475: echo " pixel translation loop is unrolled to translate all"
1476: echo " source pixels in the 32-bit visible part of the source"
1477: echo " bit FIFO(s) before shifting."
1478: echo ""
1479: echo " in this case, src_bipp is known to be ${src_bipp}, so "`expr ${src_unroll} \* ${src_iter_scale}`" pixels will"
1480: echo " be read out of the source bit FIFO(s) before shifting, and"
1481: echo " when the source bit FIFO(s) are shifted, they are shifted"
1482: echo " ${src_fifo_shift} bits at a time: */"
1483: fi
1484:
1485: # if dst_bipp is known now, see how many times we can unroll the
1486: # translation loop on destination pixels:
1487: #
1488: if test ${dst_bipp} != 0; then
1489:
1490: # in general, we can unroll once for each pixel in the
1491: # visible part of a destination bit FIFO:
1492: #
1493: dst_unroll=`expr 32 / ${dst_bipp}`
1494:
1495: # if this function doubles the source image, we can unroll
1496: # half as many times:
1497: #
1498: dst_unroll=`expr ${dst_unroll} / ${dst_iter_scale}`
1499:
1500: # if we think we can unroll zero times, this means that
1501: # dst_bipp is greater than 16 and this function doubles the
1502: # source image - the zero is telling us that two whole
1503: # pixels cannot fit in the visible part of a destination bit
1504: # FIFO. so we unroll once on destination pixels, and shift
1505: # only one pixel's bits after the unrolling (the doubling
1506: # code will be shifting one pixel's worth of bits to get
1507: # out the first pixel it has to write):
1508: #
1509: if test ${dst_unroll} = 0; then
1510: dst_unroll=1
1511: dst_fifo_shift=${dst_bipp}
1512:
1513: # otherwise, we will be shifting the entire visible part
1514: # of the source bit FIFO(s) after all unrolled iterations:
1515: #
1516: else
1517: dst_fifo_shift=32
1518: fi
1519:
1520: echo ""
1521: echo " /* since dst_bipp is known at code-generation time, the pixel"
1522: echo " translation loop is unrolled to translate all destination"
1523: echo " pixels in the 32-bit visible part of the destination bit"
1524: echo " FIFO(s) before shifting."
1525: echo ""
1526: echo " in this case, dst_bipp is known to be ${dst_bipp}, so "`expr ${dst_unroll} \* ${dst_iter_scale}`" pixels will"
1527: echo " be written into the destination bit FIFO(s) before shifting,"
1528: echo " and when the destination bit FIFO(s) are shifted, they are"
1529: echo " shifted ${dst_fifo_shift} bits at a time: */"
1530: fi
1531:
1532: # unroll the translation loop the maximum number amount of times:
1533: #
1534: if test `expr ${src_unroll} \> ${dst_unroll}` = 1; then
1535: unroll=${src_unroll}
1536: else
1537: unroll=${dst_unroll}
1538: fi
1539:
1540: echo ""
1541: echo " /* src_unroll = ${src_unroll}, src_iter_scale = ${src_iter_scale}"
1542: echo " dst_unroll = ${dst_unroll}, dst_iter_scale = ${dst_iter_scale} */"
1543: echo " for (xlat_run = TME_FB_XLAT_RUN;"
1544: echo " xlat_run > 0; ) {"
1545: iter=0
1546:
1547: while test `expr ${iter} \< ${unroll}` = 1; do
1548: echo ""
1549: echo " /* iter #${iter} */"
1550: echo ""
1551: iter_next=`expr ${iter} + 1`
1552:
1553: # the number of bits to skip in a source FIFO to get to
1554: # this iteration's pixel:
1555: src_shift=`expr ${iter} % ${src_unroll}`
1556: src_shift='('`expr ${src_shift} \* ${src_iter_scale}`' * src_bipp)'
1557:
1558: echo " /* get a pixel from the source primary FIFO: */"
1559: echo " pixel ="
1560: echo " ((src_fifo0"
1561: echo " >> (src_order == TME_ENDIAN_BIG"
1562: echo " ? (32 - (src_bipp + ${src_shift}))"
1563: echo " : ${src_shift}))"
1564: echo " & src_mask);"
1565:
1566: if test $scale = _; then
1567:
1568: echo ""
1569: echo " /* map the pixel value from source to destination: */"
1570: echo " if (src_depth == 1) {"
1571: echo " pixel = dst->tme_fb_connection_depth1_map[pixel];"
1572: echo " }"
1573:
1574: elif test $scale = _h_; then
1575:
1576: echo ""
1577: echo " /* get a second pixel, from the source secondary FIFO: */"
1578: if test $src_depth != 1; then
1579: echo " src_pixel1 ="
1580: else
1581: echo " pixel +="
1582: fi
1583: echo " ((src_fifo1"
1584: echo " >> (src_order == TME_ENDIAN_BIG"
1585: echo " ? (32 - (src_bipp + ${src_shift}))"
1586: echo " : ${src_shift}))"
1587: echo " & src_mask);"
1588:
1589: echo ""
1590: echo " /* get third and fourth pixels, from the source primary"
1591: echo " FIFO and source secondary FIFO, respectively. if"
1592: echo " src_bipp is 24 or greater, these pixels are not yet"
1593: echo " entirely in the first parts of the FIFOs, so we need"
1594: echo " to shift: */"
1595: echo " if (src_bipp >= 24) {"
1596: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo0_may_be_unaligned,"
1597: echo " src_fifo0,"
1598: echo " src_fifo0_next,"
1599: echo " src_fifo0_bits,"
1600: echo " src_bipp,"
1601: echo " src_raw0,"
1602: echo " src_order);"
1603: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo1_may_be_unaligned,"
1604: echo " src_fifo1,"
1605: echo " src_fifo1_next,"
1606: echo " src_fifo1_bits,"
1607: echo " src_bipp,"
1608: echo " src_raw1,"
1609: echo " src_order);"
1610: if test $src_depth != 1; then
1611: echo " src_pixel2 ="
1612: else
1613: echo " pixel +="
1614: fi
1615: echo " ((src_fifo0"
1616: echo " >> (src_order == TME_ENDIAN_BIG"
1617: echo " ? (32 - (src_bipp + ${src_shift}))"
1618: echo " : ${src_shift}))"
1619: echo " & src_mask);"
1620: if test $src_depth != 1; then
1621: echo " src_pixel3 ="
1622: else
1623: echo " pixel +="
1624: fi
1625: echo " ((src_fifo1"
1626: echo " >> (src_order == TME_ENDIAN_BIG"
1627: echo " ? (32 - (src_bipp + ${src_shift}))"
1628: echo " : ${src_shift}))"
1629: echo " & src_mask);"
1630: echo " }"
1631: echo ""
1632: echo " /* otherwise, src_pixel2 and src_pixel3 are already in the"
1633: echo " visible parts of the source bit FIFOs; we just have to"
1634: echo " reach over the pixels we already read to get at them: */"
1635: echo " else {"
1636: if test $src_depth != 1; then
1637: echo " src_pixel2 ="
1638: else
1639: echo " pixel +="
1640: fi
1641: echo " ((src_fifo0"
1642: echo " >> (src_order == TME_ENDIAN_BIG"
1643: echo " ? (32 - (src_bipp + (${src_shift} + src_bipp)))"
1644: echo " : (${src_shift} + src_bipp)))"
1645: echo " & src_mask);"
1646: if test $src_depth != 1; then
1647: echo " src_pixel3 ="
1648: else
1649: echo " pixel +="
1650: fi
1651: echo " ((src_fifo1"
1652: echo " >> (src_order == TME_ENDIAN_BIG"
1653: echo " ? (32 - (src_bipp + (${src_shift} + src_bipp)))"
1654: echo " : (${src_shift} + src_bipp)))"
1655: echo " & src_mask);"
1656: echo " }"
1657:
1658: echo ""
1659: echo " /* map all four src_pixels into dst_pixel."
1660: echo " if src_depth is one, this is simple - add all of the"
1661: echo " single-bit pixel values together and look up the"
1662: echo " destination pixel value for that intensity: */"
1663: if test $src_depth = 1; then
1664: echo " pixel = dst->tme_fb_connection_depth1_map[pixel];"
1665: else
1666: echo " if (src_depth == 1) {"
1667: echo " pixel = dst->tme_fb_connection_depth1_map[pixel"
1668: echo " + src_pixel1"
1669: echo " + src_pixel2"
1670: echo " + src_pixel3];"
1671: echo " }"
1672: echo ""
1673: echo " /* otherwise, this is trickier - we need to get the"
1674: echo " R, G, and B values for all four pixels, average"
1675: echo " them together, and look up the (closest) destination"
1676: echo " pixel value for the resulting color: */"
1677: echo " else {"
1678: echo " /* TBD: */"
1679: echo " abort();"
1680: echo " }"
1681: fi
1682: fi
1683:
1684: echo ""
1685: if test $scale = _h_; then
1686:
1687: echo " /* if we just read the last pixels on these"
1688: echo " source scanlines: */"
1689: if test `expr ${iter_next} % ${src_unroll}` = 0; then
1690: echo " if ((src_x +="
1691: echo " (src_packed"
1692: echo " ? `expr ${src_unroll} \* 2`"
1693: echo " : 2))"
1694: echo " == src_width) {"
1695: else
1696: echo " if (!src_packed"
1697: echo " && (src_x += 2) == src_width) {"
1698: fi
1699: echo ""
1700: echo " /* we need to rapidly shift the source FIFOs"
1701: echo " to skip not only pad bits and undisplayed"
1702: echo " pixels on the next line, but actually the"
1703: echo " *entire* next line."
1704: echo ""
1705: echo " note that this sounds like when we're done,"
1706: echo " the bits at the fronts of the FIFOs will be"
1707: echo " the *first* pixels on the next scanlines."
1708: echo ""
1709: echo " but the bits at the fronts of the FIFOs now"
1710: echo " are the *last* pixels on the current scanlines -"
1711: echo " they haven't been shifted off yet. so when"
1712: echo " we're done, we want one pixel's worth of bits"
1713: echo " in the FIFOs before the first pixel on the"
1714: echo " next scanlines: */"
1715: echo ""
1716: echo " /* calculate the number of bits that we need"
1717: echo " to shift the source primary FIFO, after"
1718: echo " discarding any bits in it now: */"
1719: echo " src_off = ((src_bypl * 8) - (src_width * src_bipp)) + (src_bypl * 8);"
1720: echo " src_off -= (src_fifo0_may_be_unaligned"
1721: echo " ? src_fifo0_bits"
1722: echo " : 32);"
1723: echo ""
1724: echo " /* rapidly advance src_raw0 by the number of"
1725: echo " whole 32-bit words. this will leave it pointing"
1726: echo " to the 32-bit word that has the first bit that"
1727: echo " we want to end up as the first bit in the source"
1728: echo " primary FIFO: */"
1729: echo " src_raw0 += (src_off / 32);"
1730: echo ""
1731: echo " /* reprime the source primary FIFO: */"
1732: echo " src_fifo0 = *src_raw0;"
1733: echo " *TME_FB_XLAT_SRC_OLD(src_raw0) = src_fifo0;"
1734: echo " src_raw0++;"
1735: echo " src_fifo0 = ((src_order == TME_ENDIAN_BIG)"
1736: echo " ? tme_betoh_u32(src_fifo0)"
1737: echo " : tme_letoh_u32(src_fifo0));"
1738: echo ""
1739: echo " /* if the source primary FIFO may be unaligned: */"
1740: echo " if (src_fifo0_may_be_unaligned) {"
1741: echo ""
1742: echo " /* reprime the top half of the FIFO, leaving a"
1743: echo " total of 64 bits in it: */"
1744: echo " src_fifo0_next = *src_raw0;"
1745: echo " *TME_FB_XLAT_SRC_OLD(src_raw0) = src_fifo0_next;"
1746: echo " src_raw0++;"
1747: echo " src_fifo0_next = ((src_order == TME_ENDIAN_BIG)"
1748: echo " ? tme_betoh_u32(src_fifo0_next)"
1749: echo " : tme_letoh_u32(src_fifo0_next));"
1750: echo " src_fifo0_bits = 64;"
1751: echo ""
1752: echo " /* if we have to shift off bits left over"
1753: echo " from rapidly advancing whole 32-bit words: */"
1754: echo " src_off %= 32;"
1755: echo " if (src_off > 0) {"
1756: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo0_may_be_unaligned,"
1757: echo " src_fifo0,"
1758: echo " src_fifo0_next,"
1759: echo " src_fifo0_bits,"
1760: echo " src_off,"
1761: echo " src_raw0,"
1762: echo " src_order);"
1763: echo " }"
1764: echo " }"
1765: echo ""
1766: echo " /* otherwise, the source primary FIFO is always aligned: */"
1767: echo " else {"
1768: echo " assert ((src_off % 32) == 0);"
1769: echo " }"
1770: echo ""
1771: echo " /* calculate the number of bits that we need"
1772: echo " to shift the source secondary FIFO, after"
1773: echo " discarding any bits in it now: */"
1774: echo " src_off = ((src_bypl * 8) - (src_width * src_bipp)) + (src_bypl * 8);"
1775: echo " src_off -= (src_fifo1_may_be_unaligned"
1776: echo " ? src_fifo1_bits"
1777: echo " : 32);"
1778: echo ""
1779: echo " /* rapidly advance src_raw1 by the number of"
1780: echo " whole 32-bit words. this will leave it pointing"
1781: echo " to the 32-bit word that has the first bit that"
1782: echo " we want to end up as the first bit in the source"
1783: echo " secondary FIFO: */"
1784: echo " src_raw1 += (src_off / 32);"
1785: echo ""
1786: echo " /* reprime the source secondary FIFO: */"
1787: echo " src_fifo1 = *src_raw1;"
1788: echo " *TME_FB_XLAT_SRC_OLD(src_raw1) = src_fifo1;"
1789: echo " src_raw1++;"
1790: echo " src_fifo1 = ((src_order == TME_ENDIAN_BIG)"
1791: echo " ? tme_betoh_u32(src_fifo1)"
1792: echo " : tme_letoh_u32(src_fifo1));"
1793: echo ""
1794: echo " /* if the source secondary FIFO may be unaligned: */"
1795: echo " if (src_fifo1_may_be_unaligned) {"
1796: echo ""
1797: echo " /* reprime the top half of the FIFO, leaving a"
1798: echo " total of 64 bits in it: */"
1799: echo " src_fifo1_next = *src_raw1;"
1800: echo " *TME_FB_XLAT_SRC_OLD(src_raw1) = src_fifo1_next;"
1801: echo " src_raw1++;"
1802: echo " src_fifo1_next = ((src_order == TME_ENDIAN_BIG)"
1803: echo " ? tme_betoh_u32(src_fifo1_next)"
1804: echo " : tme_letoh_u32(src_fifo1_next));"
1805: echo " src_fifo1_bits = 64;"
1806: echo ""
1807: echo " /* if we have to shift off bits left over"
1808: echo " from rapidly advancing whole 32-bit words: */"
1809: echo " src_off %= 32;"
1810: echo " if (src_off > 0) {"
1811: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo1_may_be_unaligned,"
1812: echo " src_fifo1,"
1813: echo " src_fifo1_next,"
1814: echo " src_fifo1_bits,"
1815: echo " src_off,"
1816: echo " src_raw1,"
1817: echo " src_order);"
1818: echo " }"
1819: echo " }"
1820: echo ""
1821: echo " /* otherwise, the source secondary FIFO is always aligned: */"
1822: echo " else {"
1823: echo " assert ((src_off % 32) == 0);"
1824: echo " }"
1825: echo ""
1826: echo " /* we are now on the first pixel of the next scanline: */"
1827: echo " src_x = 0;"
1828: echo " }"
1829: else
1830: echo " /* if the source buffer is not packed, and we just"
1831: echo " read the last pixel on this source scanline: */"
1832: echo " if (!src_packed"
1833: echo " && ++src_x == src_width) {"
1834: echo ""
1835: echo " /* calculate the number of bits between the"
1836: echo " last bit of the last pixel and the first bit"
1837: echo " of the first displayed pixel on the next"
1838: echo " scanline. this is equal to the number of"
1839: echo " pad bits plus bits for undisplayed pixels: */"
1840: echo " src_off = ((src_bypl * 8) - (src_width * src_bipp));"
1841: echo ""
1842: echo " /* while there are bits to shift: */"
1843: echo " for (; src_off > 0; src_off -= TME_MIN(src_off, 32)) {"
1844: echo ""
1845: echo " /* shift the source primary FIFO: */"
1846: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo0_may_be_unaligned,"
1847: echo " src_fifo0,"
1848: echo " src_fifo0_next,"
1849: echo " src_fifo0_bits,"
1850: echo " TME_MIN(src_off, 32),"
1851: echo " src_raw0,"
1852: echo " src_order);"
1853: echo " }"
1854: echo ""
1855: echo " /* we are now on the first pixel of the next scanline: */"
1856: echo " src_x = 0;"
1857: echo " }"
1858: fi
1859:
1860: if test `expr ${iter_next} % ${src_unroll}` = 0; then
1861: echo ""
1862: echo " /* shift the source primary FIFO: */"
1863: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo0_may_be_unaligned,"
1864: echo " src_fifo0,"
1865: echo " src_fifo0_next,"
1866: echo " src_fifo0_bits,"
1867: echo " ${src_fifo_shift},"
1868: echo " src_raw0,"
1869: echo " src_order);"
1870: if test $scale = _h_; then
1871: echo ""
1872: echo " /* shift the source secondary FIFO: */"
1873: echo " TME_FB_XLAT_SHIFT_SRC(src_fifo1_may_be_unaligned,"
1874: echo " src_fifo1,"
1875: echo " src_fifo1_next,"
1876: echo " src_fifo1_bits,"
1877: echo " ${src_fifo_shift},"
1878: echo " src_raw1,"
1879: echo " src_order);"
1880: fi
1881: echo " xlat_run--;"
1882: fi
1883:
1884: # the number of bits to skip in a destination FIFO to get to
1885: # this iteration's pixel:
1886: dst_shift=`expr ${iter} % ${dst_unroll}`
1887: dst_shift='('`expr ${dst_shift} \* ${dst_iter_scale}`' * dst_bipp)'
1888:
1889: echo ""
1890: echo " /* put the pixel into the destination primary FIFO: */"
1891: echo " dst_fifo0 |="
1892: echo " (pixel"
1893: echo " << (dst_order == TME_ENDIAN_BIG"
1894: echo " ? ((32 - dst_bipp) - ${dst_shift})"
1895: echo " : ${dst_shift}));"
1896:
1897: if test $scale = _d_; then
1898:
1899: echo ""
1900: echo " /* put the pixel into the destination secondary FIFO: */"
1901: echo " dst_fifo1 |="
1902: echo " (pixel"
1903: echo " << (dst_order == TME_ENDIAN_BIG"
1904: echo " ? ((32 - dst_bipp) - ${dst_shift})"
1905: echo " : ${dst_shift}));"
1906:
1907: echo ""
1908: echo " /* put the pixel into both FIFOs again. if"
1909: echo " dst_bipp is 24 or greater, the FIFOs can"
1910: echo " not entirely take these further pixels,"
1911: echo " so we need to shift: */"
1912: echo " if (dst_bipp >= 24) {"
1913: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo0_may_be_unaligned,"
1914: echo " dst_fifo0,"
1915: echo " dst_fifo0_next,"
1916: echo " dst_fifo0_bits,"
1917: echo " dst_bipp,"
1918: echo " dst_raw0,"
1919: echo " dst_order);"
1920: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo1_may_be_unaligned,"
1921: echo " dst_fifo1,"
1922: echo " dst_fifo1_next,"
1923: echo " dst_fifo1_bits,"
1924: echo " dst_bipp,"
1925: echo " dst_raw1,"
1926: echo " dst_order);"
1927: echo " dst_fifo0 |="
1928: echo " (pixel"
1929: echo " << (dst_order == TME_ENDIAN_BIG"
1930: echo " ? ((32 - dst_bipp) - ${dst_shift})"
1931: echo " : ${dst_shift}));"
1932: echo " dst_fifo1 |="
1933: echo " (pixel"
1934: echo " << (dst_order == TME_ENDIAN_BIG"
1935: echo " ? ((32 - dst_bipp) - ${dst_shift})"
1936: echo " : ${dst_shift}));"
1937: echo " }"
1938: echo ""
1939: echo " /* otherwise, the FIFOs can take these further pixels: */"
1940: echo " else {"
1941: echo " dst_fifo0 |="
1942: echo " (pixel"
1943: echo " << (dst_order == TME_ENDIAN_BIG"
1944: echo " ? ((32 - dst_bipp) - (${dst_shift} + dst_bipp))"
1945: echo " : (${dst_shift} + dst_bipp)));"
1946: echo " dst_fifo1 |="
1947: echo " (pixel"
1948: echo " << (dst_order == TME_ENDIAN_BIG"
1949: echo " ? ((32 - dst_bipp) - (${dst_shift} + dst_bipp))"
1950: echo " : (${dst_shift} + dst_bipp)));"
1951: echo " }"
1952: fi
1953:
1954: echo ""
1955: echo " /* if the destination buffer is not packed, and we just"
1956: echo " wrote the last pixel on this destination scanline: */"
1957: if test $scale = _d_; then value=2; else value=1; fi
1958: echo " if (!dst_packed"
1959: echo " && (dst_x += ${value}) == dst_width) {"
1960: echo ""
1961: echo " /* calculate the number of bits between the"
1962: echo " last bit of the last pixel and the first bit"
1963: echo " of the first displayed pixel on the next"
1964: echo " scanline. this is equal to the number of"
1965: echo " pad bits plus bits for undisplayed pixels: */"
1966: echo " dst_off = ((dst_bypl * 8) - (dst_width * dst_bipp));"
1967: echo ""
1968: echo " /* while there are bits to shift: */"
1969: echo " for (; dst_off > 0; dst_off -= TME_MIN(dst_off, 32)) {"
1970: echo ""
1971: echo " /* shift the destination primary FIFO: */"
1972: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo0_may_be_unaligned,"
1973: echo " dst_fifo0,"
1974: echo " dst_fifo0_next,"
1975: echo " dst_fifo0_bits,"
1976: echo " TME_MIN(dst_off, 32),"
1977: echo " dst_raw0,"
1978: echo " dst_order);"
1979: if test $scale = _d_; then
1980: echo ""
1981: echo " /* shift the destination secondary FIFO: */"
1982: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo1_may_be_unaligned,"
1983: echo " dst_fifo1,"
1984: echo " dst_fifo1_next,"
1985: echo " dst_fifo1_bits,"
1986: echo " TME_MIN(dst_off, 32),"
1987: echo " dst_raw1,"
1988: echo " dst_order);"
1989: fi
1990: echo " }"
1991: echo ""
1992: echo " /* we are now on the first pixel of the next scanline: */"
1993: echo " dst_x = 0;"
1994: echo " }"
1995:
1996: if test `expr ${iter_next} % ${dst_unroll}` = 0; then
1997: echo ""
1998: echo " /* shift the destination primary FIFO: */"
1999: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo0_may_be_unaligned,"
2000: echo " dst_fifo0,"
2001: echo " dst_fifo0_next,"
2002: echo " dst_fifo0_bits,"
2003: echo " ${dst_fifo_shift},"
2004: echo " dst_raw0,"
2005: echo " dst_order);"
2006: if test $scale = _d_; then
2007: echo ""
2008: echo " /* shift the destination secondary FIFO: */"
2009: echo " TME_FB_XLAT_SHIFT_DST(dst_fifo1_may_be_unaligned,"
2010: echo " dst_fifo1,"
2011: echo " dst_fifo1_next,"
2012: echo " dst_fifo1_bits,"
2013: echo " ${dst_fifo_shift},"
2014: echo " dst_raw1,"
2015: echo " dst_order);"
2016: fi
2017: fi
2018:
2019: iter=${iter_next}
2020: done
2021: echo ""
2022: echo " }"
2023:
2024: if test `expr ${iter} % ${dst_unroll}` != 0; then
2025: echo "$PROG internal error - the last iter did not shift the destination FIFOs ($iter and $dst_unroll)" 1>&2
2026: exit 1
2027: fi
2028:
2029: echo ""
2030: echo " /* if the destination FIFOs may be unaligned, there"
2031: echo " may be bits left in the FIFO that we need to flush: */"
2032: echo " if (dst_fifo0_may_be_unaligned"
2033: echo " && dst_fifo0_bits > 0) {"
2034: echo " dst_fifo0 = *dst_raw0;"
2035: echo " if (dst_order == TME_ENDIAN_BIG) {"
2036: echo " dst_fifo0_next |= (tme_betoh_u32(dst_fifo0) & (0xffffffff >> dst_fifo0_bits));"
2037: echo " dst_fifo0_next = tme_htobe_u32(dst_fifo0_next);"
2038: echo " }"
2039: echo " else {"
2040: echo " dst_fifo0_next |= (tme_letoh_u32(dst_fifo0) & (0xffffffff << dst_fifo0_bits));"
2041: echo " dst_fifo0_next = tme_htole_u32(dst_fifo0_next);"
2042: echo " }"
2043: echo " *dst_raw0 = dst_fifo0;"
2044: echo " }"
2045: if test $scale = _d_; then
2046: echo " if (dst_fifo1_may_be_unaligned"
2047: echo " && dst_fifo1_bits > 0) {"
2048: echo " dst_fifo1 = *dst_raw1;"
2049: echo " if (dst_order == TME_ENDIAN_BIG) {"
2050: echo " dst_fifo1_next |= (tme_betoh_u32(dst_fifo1) & (0xffffffff >> dst_fifo1_bits));"
2051: echo " dst_fifo1_next = tme_htobe_u32(dst_fifo1_next);"
2052: echo " }"
2053: echo " else {"
2054: echo " dst_fifo1_next |= (tme_letoh_u32(dst_fifo1) & (0xffffffff << dst_fifo1_bits));"
2055: echo " dst_fifo1_next = tme_htole_u32(dst_fifo1_next);"
2056: echo " }"
2057: echo " *dst_raw1 = dst_fifo1;"
2058: echo " }"
2059: fi
2060:
2061: echo ""
2062: echo " /* loop back to compare more 32-bit words: */"
2063: echo " src_raw0--;"
2064: echo " }"
2065:
2066: echo ""
2067: echo " /* return nonzero iff we did some translating: */"
2068: echo " return (xlat_run >= 0);"
2069:
2070: echo ""
2071: for macro in ${undef_macros}; do
2072: echo "#undef ${macro}"
2073: done
2074: echo "}"
2075:
2076: done
2077: done
2078:
2079: echo ""
2080: echo "/* the xlat function array: */"
2081: echo "static const struct tme_fb_xlat tme_fb_xlats[] = {$xlat_array
2082: };"
2083:
2084: # done:
2085: exit 0
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.