WebRadioApp  0.1
ewgfxdriver.h
Go to the documentation of this file.
1 /*******************************************************************************
2  *
3  * E M B E D D E D W I Z A R D P R O J E C T
4  *
5  * Copyright (c) TARA Systems
6  *GmbH written by Paul Banach and Manfred Schweyer
7  *
8  ********************************************************************************
9  *
10  * This software and related documentation ("Software") are intellectual
11  * property owned by TARA Systems and are copyright of TARA Systems.
12  * Any modification, copying, reproduction or redistribution of the Software in
13  * whole or in part by any means not in accordance with the End-User License
14  * Agreement for Embedded Wizard is expressly prohibited. The removal of this
15  * preamble is expressly prohibited.
16  *
17  ********************************************************************************
18  *
19  * DESCRIPTION:
20  * This is an internal header of the Embedded Wizard Graphics Engine EWGFX.
21  *
22  * The module 'ewgfxdriver' implements the platform independent layer to the
23  * software pixel driver. Its functionality provides a kind of reserve in case
24  * the underlying graphics subsystem can not handle the necessary operations.
25  * For example, if there is no support for index8 surfaces, 'ewgfxdriver' will
26  * recompense it by a software emulated index8 surface including all necessary
27  * drawing operations.
28  *
29  * This header file provides a generic and platform independent interface to
30  * the software pixel driver functionality. The interface consists of two
31  * categories of functions:
32  *
33  * 1. 'per row' worker functions. These functions build the low-level software
34  * pixel driver. They are intended to perform drawing operations optimized
35  * for the particular pixel format and the drawing mode. The declarations,
36  * any way, are platform independent.
37  *
38  * 2. 'per area' drawing functions. These functions provide the top-level view
39  * to the software pixel driver. They are intended to drive the 'per row'
40  * worker functions for the affected fill/copy/warp operation. When called,
41  * the top-level function will receive a pointer to one of the low-level
42  * worker functions. The passed worker function can be used thereupon to
43  * perform row-wise the operation without any dependency to the underlying
44  * pixel format.
45  *
46  * Additionally, the header file provides generic declarations to simplify
47  * the integration of external graphics subsystem drivers into the Embedded
48  * Wizard Graphics Engine.
49  *
50  *******************************************************************************/
51 
52 #ifndef EWGFXDRIVER_H
53 #define EWGFXDRIVER_H
54 
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58 
59 /*******************************************************************************
60  * MACRO:
61  * EW_RED
62  * EW_GREEN
63  * EW_BLUE
64  * EW_ALPHA
65  *
66  * DESCRIPTION:
67  * The following macros provide a generic way to extract the RGBA color
68  * channels from the RGBA8888 aColor value as it is passed to all driver
69  * functions.
70  *
71  * Note, the RGBA8888 color format is the internal, platform independent way
72  * to store color values.
73  *
74  *******************************************************************************/
75 #define EW_RED(aColor) (((aColor) >> 0) & 0xFF)
76 #define EW_GREEN(aColor) (((aColor) >> 8) & 0xFF)
77 #define EW_BLUE(aColor) (((aColor) >> 16) & 0xFF)
78 #define EW_ALPHA(aColor) (((aColor) >> 24) & 0xFF)
79 
80 /*******************************************************************************
81  * MACRO:
82  * EW_PIXEL_FORMAT_XXX
83  *
84  * DESCRIPTION:
85  * The following enumeration defines the 3 fundamental surface formats. They
86  * are needed amongst other things to specify the desired pixel format, when
87  * creating new surfaces or when accessing surface memory directly.
88  *
89  * ELEMENTS:
90  * EW_PIXEL_FORMAT_SCREEN - Represents the pixel format of the frame buffer.
91  * Usually this format corresponds to the EW_PIXEL_FORMAT_NATIVE. In special
92  * cases, however, it is necessary to distinguish between operations to run
93  * on the frame buffer or on the normal (native) destination when these use
94  * different color formats.
95  * The pixel format does not make any assumption regarding the respective
96  * color space, color channels, etc. In this manner the Graphics Engine
97  * remains platform and color independent.
98  * Please note, surfaces with this color format can serve as a destination
99  * only in all drawing operations.
100  * EW_PIXEL_FORMAT_NATIVE - Represents the main pixel format valid within the
101  * particular graphics subsystem without any assumptions about the
102  *respective color space, color channels, etc. This is the pixel format, the
103  *subsystem is working with internally. In this manner the Graphics Engine
104  *remains platform and color independent. Please note, surfaces with this color
105  *format can serve as a destination and source in all drawing operations.
106  * EW_PIXEL_FORMAT_INDEX8 - Universal 8 bit per pixel CLUT format. This format
107  * expects an additional color look-up table for translation between an 8
108  *bit index and the native color value. Please note, surfaces with this color
109  *format can serve as a source only in all drawing operations.
110  * EW_PIXEL_FORMAT_ALPHA8 - Universal 8 bit per pixel alpha only format.
111  *Useful as storage for glyphs, masks, etc. Please note, surfaces with this
112  *color format can serve as a source only in all drawing operations.
113  * EW_PIXEL_FORMAT_RGB565 - Represents a color-only pixel format with 16-bit
114  * per pixel. The support for this format is optional depending on the used
115  * target system and the Native color format in the target system.
116  * Please note, surfaces with this color format can serve as a source only
117  * in all drawing operations.
118  *
119  *******************************************************************************/
120 #define EW_PIXEL_FORMAT_SCREEN -1
121 #define EW_PIXEL_FORMAT_NATIVE 0
122 #define EW_PIXEL_FORMAT_INDEX8 1
123 #define EW_PIXEL_FORMAT_ALPHA8 2
124 #define EW_PIXEL_FORMAT_RGB565 3
125 
126 /*******************************************************************************
127  * MACRO:
128  * EW_DRIVER_VARIANT_XXX
129  *
130  * DESCRIPTION:
131  * Following macros specify the basic color formats supported by the Graphics
132  * Engine. These are used for verification purpose and plausibility tests.
133  *
134  *******************************************************************************/
135 #define EW_DRIVER_VARIANT_RGBA8888 1
136 #define EW_DRIVER_VARIANT_RGBA4444 2
137 #define EW_DRIVER_VARIANT_RGB565A8 3
138 #define EW_DRIVER_VARIANT_RGB555A8 4
139 #define EW_DRIVER_VARIANT_YUVA8888 5
140 #define EW_DRIVER_VARIANT_LUMA44 6
141 #define EW_DRIVER_VARIANT_RGB565 7
142 #define EW_DRIVER_VARIANT_RGB888 8
143 #define EW_DRIVER_VARIANT_INDEX8 11
144 #define EW_DRIVER_VARIANT_ALPHA8 12
145 #define EW_DRIVER_VARIANT_RGB565_RGBA8888 \
146  ((EW_DRIVER_VARIANT_RGB565 << 8) | EW_DRIVER_VARIANT_RGBA8888)
147 #define EW_DRIVER_VARIANT_RGB888_RGBA8888 \
148  ((EW_DRIVER_VARIANT_RGB888 << 8) | EW_DRIVER_VARIANT_RGBA8888)
149 
150 /*******************************************************************************
151  * VARIABLE:
152  * EwPixelDriverVariant
153  *
154  * DESCRIPTION:
155  * This global variable stores the target basic color format supported by this
156  * pixel driver. It is used at the runtime to verify, whether correct pixel
157  * driver are linked together with the application.
158  *
159  * This variable can take one of EW_DRIVER_VARIANT_XXX values.
160  *
161  *******************************************************************************/
162 extern const int EwPixelDriverVariant;
163 
164 /*******************************************************************************
165  * TYPE:
166  * XSurfaceMemory
167  *
168  * DESCRIPTION:
169  * The XSurfaceMemory structure provides a lightweight storage for adresses to
170  * color planes and (if any) to the color table of a previously locked
171  *surface. It is used by the software pixel driver to read and modify surface
172  *content.
173  *
174  * ELEMENTS:
175  * Pixel1 - Pointer to the first surface plane.
176  * Pitch1X - Distance between two pixel columns of the first surface plane.
177  * Pitch1Y - Distance between two pixel rows of the first surface plane.
178  * Pixel2 - Pointer to the second (optional) surface plane.
179  * Pitch2X - Distance between two pixel columns of the second surface plane.
180  * Pitch2Y - Distance between two pixel rows of the second surface plane.
181  * Clut - Pointer to the (optional) color table of the surface. In order
182  * to cover all color formats, a single entry of the clut is always 32 bit
183  * wide - even when the target color format is 16 or 8 bit wide.
184  *
185  *******************************************************************************/
186 typedef struct {
187  void *Pixel1;
188  int Pitch1X;
189  int Pitch1Y;
190  void *Pixel2;
191  int Pitch2X;
192  int Pitch2Y;
193  unsigned int *Clut;
194 } XSurfaceMemory;
195 
196 /*******************************************************************************
197  * TYPE:
198  * XGradient
199  *
200  * DESCRIPTION:
201  * The XGradient structure provides a storage for the components of a 2D color
202  * or 2D opacity gradient. It defines a start value and slopes. For precision
203  * purpose, the values are codes as 12.20 fixed point numbers.
204  *
205  * ELEMENTS:
206  * R0, R1, R2, R3 - Startvalues and slopes for the red channel.
207  * G0, G1, G2, G3 - Startvalues and slopes for the green channel.
208  * B0, B1, B2, B3 - Startvalues and slopes for the blue channel.
209  * A0, A1, A2, A3 - Startvalues and slopes for the alpha channel.
210  * Width, Height - Size of the gradient area.
211  * InvWidth,
212  * InvHeight - Reciprocal values of the gradient area width and height.
213  * IsVertical - != 0 if the gradient has a vertical trend.
214  * IsHorizontal - != 0 if the gradient has a horizontal trend.
215  *
216  *******************************************************************************/
217 typedef struct {
218  int R0, R1, R2, R3;
219  int G0, G1, G2, G3;
220  int B0, B1, B2, B3;
221  int A0, A1, A2, A3;
222  int Width;
223  int Height;
224  int InvWidth;
225  int InvHeight;
226  int IsVertical;
227  int IsHorizontal;
228 } XGradient;
229 
230 /*******************************************************************************
231  * PROTOTYPE:
232  * XLineWorker
233  *
234  * DESCRIPTION:
235  * The following type declares a prototype for a worker function, which should
236  * perform the low level software 'draw line pixel' operation.
237  *
238  * ARGUMENTS:
239  * aDst - Pointer to the first pixel of the destination surface.
240  * aX, aY - Position of the pixel to draw.
241  * aGradient - Color information to draw the pixel.
242  *
243  * RETURN VALUE:
244  * None
245  *
246  *******************************************************************************/
247 typedef void (*XLineWorker)(XSurfaceMemory *aDst, int aX, int aY,
248  XGradient *aGradient);
249 
250 /*******************************************************************************
251  * PROTOTYPE:
252  * XFillWorker
253  *
254  * DESCRIPTION:
255  * The following type declares a prototype for a worker function, which should
256  * perform the low level software 'fill pixel row' operation.
257  *
258  * ARGUMENTS:
259  * aDst - Pointer to the first pixel of the affected row.
260  * aWidth - Length of the row in pixel.
261  * aGradient - Color information to fill the row.
262  *
263  * RETURN VALUE:
264  * None
265  *
266  *******************************************************************************/
267 typedef void (*XFillWorker)(XSurfaceMemory *aDst, int aWidth,
268  XGradient *aGradient);
269 
270 /*******************************************************************************
271  * PROTOTYPE:
272  * XCopyWorker
273  *
274  * DESCRIPTION:
275  * The following type declares a prototype for a worker function, which should
276  * perform the low level software 'copy pixel row' operation.
277  *
278  * ARGUMENTS:
279  * aDst - Pointer to the first pixel of the destination row.
280  * aSrc - Pointer to the first pixel of the source row.
281  * aWidth - Length of the row in pixel.
282  * aGradient - Color or opacity information to modulate the copied pixel.
283  *
284  * RETURN VALUE:
285  * None
286  *
287  *******************************************************************************/
288 typedef void (*XCopyWorker)(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
289  int aWidth, XGradient *aGradient);
290 
291 /*******************************************************************************
292  * PROTOTYPE:
293  * XWarpWorker
294  *
295  * DESCRIPTION:
296  * The following type declares a prototype for a worker function, which should
297  * perform the low level software 'warp pixel row' operation.
298  *
299  * ARGUMENTS:
300  * aDst - Pointer to the first pixel of the destination row.
301  * aSrc - Pointer to the first pixel of the source surface area to
302  * project on the destination row.
303  * aWidth - Length of the row in pixel.
304  * aS, aT - Source surface coordinates corresponding to the first pixel
305  * of the destination row.
306  * aSS, aTS - Factors to interpolate the s and t coefficients for next
307  * following pixel of the destination row.
308  * aSrcWidth,
309  * aSrcHeight - Size of the source area in pixel to limit the operation.
310  * aGradient - Color or opacity information to modulate the copied pixel.
311  *
312  * RETURN VALUE:
313  * None
314  *
315  *******************************************************************************/
316 typedef void (*XWarpWorker)(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
317  int aWidth, int aS, int aT, int aSS, int aTS,
318  int aSrcWidth, int aSrcHeight,
319  XGradient *aGradient);
320 
321 /*******************************************************************************
322  * PROTOTYPE:
323  * XLineDriver
324  *
325  * DESCRIPTION:
326  * The following type declares a prototype for an external graphics subsystem
327  * function, which should perform the 'draw line' operation by using solid or
328  * gradient color values.
329  *
330  * ARGUMENTS:
331  * aDstHandle - Handle to the screen/native destination surface.
332  * aDstX1,
333  * aDstY1 - Start position to draw the line (relative to the top-left
334  * corner of the destination surface).
335  * aDstX2,
336  * aDstY2 - End position to draw the line (relative to the top-left
337  * corner of the destination surface). The pixel at the end position does
338  * not belong to the line - it is invisible. In this manner polylines can
339  * be drawn.
340  * aClipX,
341  * aClipY,
342  * aClipWidth,
343  * aClipHeight - Optional clipping area relative to the top-left corner of the
344  * destination surface. No pixel outside this area may be drawn.
345  * aBlend - != 0 if the operation should be performed with alpha
346  *blending. aColors - Array with 2 RGBA8888 color values. The both color
347  *values do correspond to the start and to the end pixel of the drawn line.
348  *
349  * RETURN VALUE:
350  * None
351  *
352  *******************************************************************************/
353 typedef void (*XLineDriver)(unsigned long aDstHandle, int aDstX1, int aDstY1,
354  int aDstX2, int aDstY2, int aClipX, int aClipY,
355  int aClipWidth, int aClipHeight, int aBlend,
356  unsigned long *aColors);
357 
358 /*******************************************************************************
359  * PROTOTYPE:
360  * XFillDriver
361  *
362  * DESCRIPTION:
363  * The following type declares a prototype for an external graphics subsystem
364  * function, which should perform the 'fill rectangular area' operation by
365  * using solid or gradient color values.
366  *
367  * ARGUMENTS:
368  * aDstHandle - Handle to the screen/native destination surface.
369  * aDstX,
370  * aDstY - Origin of the area to fill (relative to the top-left corner
371  * of the destination surface).
372  * aWidth,
373  * aHeight - Size of the area to fill.
374  * aBlend - != 0 if the operation should be performed with alpha
375  *blending. aColors - Array with 4 RGBA8888 color values. The four color
376  *values do correspond to the four corners of the area: top-left, top-right,
377  *bottom- right and bottom-left.
378  *
379  * RETURN VALUE:
380  * None
381  *
382  *******************************************************************************/
383 typedef void (*XFillDriver)(unsigned long aDstHandle, int aDstX, int aDstY,
384  int aWidth, int aHeight, int aBlend,
385  unsigned long *aColors);
386 
387 /*******************************************************************************
388  * PROTOTYPE:
389  * XCopyDriver
390  *
391  * DESCRIPTION:
392  * The following type declares a prototype for an external graphics subsystem
393  * function, which should perform the 'copy rectangular area' operation from a
394  * native, index8, alpha8 or rgb565 surface to a screen or native surface. The
395  * copied pixel can optionally be modulated by solid or gradient color/opacity
396  * values.
397  *
398  * ARGUMENTS:
399  * aDstHandle - Handle to the screen/native destination surface.
400  * aSrcHandle - Handle to the native/index8/alpha8/rgb565 source surface.
401  * aDstX,
402  * aDstY - Origin of the area to fill with the copied source surface
403  * pixel (relative to the top-left corner of the destination surface).
404  * aWidth,
405  * aHeight - Size of the area to fill with the copied source surface
406  *pixel. aSrcX, aSrcY - Origin of the area to copy from the source
407  *surface. aBlend - != 0 if the operation should be performed with alpha
408  *blending. aColors - Array with 4 color values. These four values do
409  *correspond to the four corners of the area: top-left, top-right, bottom-right
410  *and bottom-left.
411  *
412  * RETURN VALUE:
413  * None
414  *
415  *******************************************************************************/
416 typedef void (*XCopyDriver)(unsigned long aDstHandle, unsigned long aSrcHandle,
417  int aDstX, int aDstY, int aSrcX, int aSrcY,
418  int aWidth, int aHeight, int aBlend,
419  unsigned long *aColors);
420 
421 /*******************************************************************************
422  * PROTOTYPE:
423  * XTileDriver
424  *
425  * DESCRIPTION:
426  * The following type declares a prototype for an external graphics subsystem
427  * function, which will perform the 'multiple copy rectangular area' operation
428  * from a native, index8, alpha8 or rgb565 surface to a screen or native
429  *surface. The copied pixel can be modulated by solid or gradient color/opacity
430  *values.
431  *
432  * ARGUMENTS:
433  * aDstHandle - Handle to the screen/native destination surface.
434  * aSrcHandle - Handle to the native/index8/alpha8/rgb565 source surface.
435  * aDstX,
436  * aDstY - Origin of the area to fill with the copied source surface
437  * pixel (relative to the top-left corner of the destination surface).
438  * aDstWidth,
439  * aDstHeight - Size of the area to fill with the copied source surface
440  *pixel. aSrcX, aSrcY - Origin of the area to copy from the source
441  *surface. aSrcWidth, aSrcHeight - Size of the source area to copy. aOfsX,
442  * aOfsY - Offset to the first visible source pixel at the origin of the
443  * destination area.
444  * aBlend - != 0 if the operation should be performed with alpha
445  *blending. aColors - Array with 4 color values. These four values do
446  *correspond to the four corners of the area: top-left, top-right, bottom-right
447  *and bottom-left.
448  *
449  * RETURN VALUE:
450  * None
451  *
452  *******************************************************************************/
453 typedef void (*XTileDriver)(unsigned long aDstHandle, unsigned long aSrcHandle,
454  int aDstX, int aDstY, int aDstWidth, int aDstHeight,
455  int aSrcX, int aSrcY, int aSrcWidth, int aSrcHeight,
456  int aOfsX, int aOfsY, int aBlend,
457  unsigned long *aColors);
458 
459 /*******************************************************************************
460  * PROTOTYPE:
461  * XWarpDriver
462  *
463  * DESCRIPTION:
464  * The following type declares a prototype for an external graphics subsystem
465  * function, which can perform the 'copy and warp rectangular area' operation
466  * from native, index8, alpha8 or rgb565 surface to a screen or native
467  *surface. The copied pixel can optionally be modulated by solid or gradient
468  *color/ opacity values.
469  *
470  * The warp operation abstracts the scale, rotate and perspective projection
471  * operations. The operation is limited to convex polygons only. In case of a
472  * non convex polygon, the operation may fail.
473  *
474  * ARGUMENTS:
475  * aDstHandle - Handle to the screen/native destination surface.
476  * aSrcHandle - Handle to the native/index8/alpha8/rgb565 source surface.
477  * DstX1,
478  * DstY1,
479  * DstW1,
480  * ...
481  * DstX4,
482  * DstY4,
483  * DstW4 - Coordinates of the polygon to fill with the source bitmap as
484  * floating point values for sub-pixel precision (Relative to the top-left
485  * corner of the destination bitmap). The 'W' coefficients do control the
486  * perspective distortion as it is realized in 3D graphics hardware (see
487  * OpenGL homogeneous coordinates for more information).
488  * aSrcX,
489  * aSrcY - Origin of the area to copy from the source surface.
490  * aSrcWidth,
491  * aSrcHeight - Size of the source area to copy.
492  * aClipX,
493  * aClipY,
494  * aClipWidth,
495  * aClipHeight - Optional clipping area relative to the top-left corner of the
496  * destination surface. No pixel outside this area may be drawn.
497  * aBlend - != 0 if the operation should be performed with alpha
498  *blending. aFilter - != 0 if the bi-linear filter should be applied to the
499  *copied pixel. This argument is optional and controls the output quality only.
500  * aColors - Array with 4 color values. These four values do correspond to
501  * the respective corners of the polygon.
502  *
503  * RETURN VALUE:
504  * None
505  *
506  *******************************************************************************/
507 typedef void (*XWarpDriver)(unsigned long aDstHandle, unsigned long aSrcHandle,
508  float aDstX1, float aDstY1, float aDstW1,
509  float aDstX2, float aDstY2, float aDstW2,
510  float aDstX3, float aDstY3, float aDstW3,
511  float aDstX4, float aDstY4, float aDstW4, int aSrcX,
512  int aSrcY, int aSrcWidth, int aSrcHeight,
513  int aClipX, int aClipY, int aClipWidth,
514  int aClipHeight, int aBlend, int aFilter,
515  unsigned long *aColors);
516 
517 /*******************************************************************************
518 * PROTOTYPE:
519 * XPolygonDriver
520 *
521 * DESCRIPTION:
522 * The following type declares a prototype for an external graphics subsystem
523 * function, which should perform the 'fill polygon' operation by using solid
524 * or gradient color values. The polygon is described by values in the aPaths
525 * parameter.
526 *
527 * aPaths stores the edges as a serie of X,Y pairs starting always with a value
528 * specifying the number of existing edges. With this approach one path can
529 * consist of several sub-paths. The end of the list is determined by a sub-
530 * path with 0 edges.
531 *
532 * +-------+------+------+------+------+------+------+-------+ +-----+
533 * | edges | X0 | Y0 | X1 | Y1 | X2 | Y2 | edges | ... | 0 |
534 * +-------+------+------+------+------+------+------+-------+ +-----+
535 
536 *
537 * ARGUMENTS:
538 * aDstHandle - Handle to the screen/native destination surface.
539 * aPaths - An array containing the path data. The array starts with
540 * the number of edges a path is composed of. Then follow the coordinates of
541 * all path corners as X,Y pairs. After the last coordinate pair next path
542 * can follow starting again with the number of edges. The end of the path
543 * data is signed with 0. The X,Y coordinates are stored as signed integer
544 * with 4-bit fixpoint precision.
545 * aDstX,
546 * aDstY - Origin of the area to fill (relative to the top-left
547 * corner of the destination surface).
548 * aWidth,
549 * aHeight - Size of the area to fill.
550 * aBlend - = 0 if the operation should be performed with alpha
551 * blending.
552 * aAntialiased - If != 0, the antialiasing should be applied to every
553 * pixel.
554 * aNonZeroWinding - Controls the fill rule to be used by the algorithm. If
555 * this parameter is == 0, the even-odd fill rule is used. If this parameter
556 * is != 0, the non-zero winding rule is used.
557 * aColors - Array with 4 RGBA8888 color values. The four color values
558 * do correspond to the four corners of the area: top-left, top-right,
559 * bottom-right and bottom-left.
560 *
561 * RETURN VALUE:
562 * None
563 *
564 *******************************************************************************/
565 typedef void (*XPolygonDriver)(unsigned long aDstHandle, int *aPaths, int aDstX,
566  int aDstY, int aWidth, int aHeight, int aBlend,
567  int aAntialiased, int aNonZeroWinding,
568  unsigned long *aColors);
569 
570 /*******************************************************************************
571  * FUNCTION:
572  * EwCreateScreenSurface
573  *
574  * DESCRIPTION:
575  * The function EwCreateScreenSurface() has the job to create and return a new
576  * screen surface with the given size. If no surface could be created due to
577  * memory deficit, 0 is returned.
578  *
579  * The function is used, if the underlying graphics subsystem doesn't provide
580  * any adequate functionality. The function creates a pure software surface
581  * within the CPU address space only.
582  *
583  * ARGUMENTS:
584  * aWidth,
585  * aHeight - Size of the surface to create.
586  *
587  * RETURN VALUE:
588  * If successful, returns a handle to the new surface. Otherwise 0 is
589  *returned.
590  *
591  *******************************************************************************/
592 unsigned long EwCreateScreenSurface(int aWidth, int aHeight);
593 
594 /*******************************************************************************
595  * FUNCTION:
596  * EwDestroyScreenSurface
597  *
598  * DESCRIPTION:
599  * The function EwDestroyScreenSurface() has the job to release resources of
600  * a previously created screen surface.
601  *
602  * The function is used, if the underlying graphics subsystem doesn't provide
603  * any adequate functionality. The function destroys pure software surfaces
604  * previously created by the function EwCreateScreenSurface() only.
605  *
606  * ARGUMENTS:
607  * aSurface - Handle to the surface to destroy.
608  *
609  * RETURN VALUE:
610  * None
611  *
612  *******************************************************************************/
613 void EwDestroyScreenSurface(unsigned long aSurface);
614 
615 /*******************************************************************************
616  * FUNCTION:
617  * EwGetScreenSurfaceMemory
618  *
619  * DESCRIPTION:
620  * The function EwGetScreenSurfaceMemory() has the job to obtain pointers to
621  * the memory planes of the given surface.
622  *
623  * The returned pointers are calculated for the given pixel position aX, aY.
624  *
625  * The function is used, if the underlying graphics subsystem doesn't provide
626  * any adequate functionality. The function can handle with the pure software
627  * surfaces previously created by the function EwCreateScreenSurface() only.
628  *
629  * ARGUMENTS:
630  * aSurface - Handle to the surface to obtain the addresses.
631  * aX, aY - Position within the surface to calculate the pixel address.
632  * aReserved - Should be 0.
633  * aWriteAccess - If != 0 the caller has the intention to modify the returned
634  * memory content.
635  * aMemory - Structure to receive the desired address information.
636  *
637  * RETURN VALUE:
638  * If successful, the function fills the given aMemory structure with the
639  * address information and returns != 0. Otherwise 0 is returned.
640  *
641  *******************************************************************************/
642 int EwGetScreenSurfaceMemory(unsigned long aSurface, int aX, int aY,
643  int aReserved, int aWriteAccess,
644  XSurfaceMemory *aMemory);
645 
646 /*******************************************************************************
647  * FUNCTION:
648  * EwGetScreenSurfaceMemSize
649  *
650  * DESCRIPTION:
651  * The function EwGetScreenSurfaceMemSize() has the job to determine the
652  *number of memory bytes occupied by a screen surface with the given size.
653  *
654  * ARGUMENTS:
655  * aWidth,
656  * aHeight - Size of the surface in pixel.
657  *
658  * RETURN VALUE:
659  * If successful, the function return the surface size in bytes.
660  *
661  *******************************************************************************/
662 int EwGetScreenSurfaceMemSize(int aWidth, int aHeight);
663 
664 /*******************************************************************************
665  * FUNCTION:
666  * EwCreateNativeSurface
667  *
668  * DESCRIPTION:
669  * The function EwCreateNativeSurface() has the job to create and return a new
670  * native surface with the given size. If no surface could be created due to
671  * memory deficit, 0 is returned.
672  *
673  * The function is used, if the underlying graphics subsystem doesn't provide
674  * any adequate functionality. The function creates a pure software surface
675  * within the CPU address space only.
676  *
677  * ARGUMENTS:
678  * aWidth,
679  * aHeight - Size of the surface to create.
680  *
681  * RETURN VALUE:
682  * If successful, returns a handle to the new surface. Otherwise 0 is
683  *returned.
684  *
685  *******************************************************************************/
686 unsigned long EwCreateNativeSurface(int aWidth, int aHeight);
687 
688 /*******************************************************************************
689  * FUNCTION:
690  * EwCreateConstNativeSurface
691  *
692  * DESCRIPTION:
693  * The function EwCreateConstNativeSurface() has the job to create and return
694  * a new native surface with the given size and pixel data content. Important
695  * here is the fact that the function doesn't reserve any memory to store the
696  * pixel information. Instead it, the surface associates the pixel data passed
697  * in the parameter aMemory.
698  *
699  * This function is thus intended to create surfaces from the pixel data
700  *stored directly within a ROM area. Accordingly it is essential that the ROM
701  *content does exactly correspond to the native surface pixel format. It
702  *includes the order of color channels, premultiplication with alpha value,
703  *etc..
704  *
705  * If no surface could be created due to memory deficit, 0 is returned.
706  *
707  * The function is used, if the underlying graphics subsystem doesn't provide
708  * any adequate functionality.
709  *
710  * Please note, the surfaces created with this function are signed internally
711  * as constant. Trying to obtrain write-access to such surface will result in
712  * a runtime error.
713  *
714  * ARGUMENTS:
715  * aWidth,
716  * aHeight - Size of the surface to create.
717  * aMemory - Structure to pass the ROM address information.
718  *
719  * RETURN VALUE:
720  * If successful, returns a handle to the new surface. Otherwise 0 is
721  *returned.
722  *
723  *******************************************************************************/
724 unsigned long EwCreateConstNativeSurface(int aWidth, int aHeight,
725  XSurfaceMemory *aMemory);
726 
727 /*******************************************************************************
728  * FUNCTION:
729  * EwDestroyNativeSurface
730  *
731  * DESCRIPTION:
732  * The function EwDestroyNativeSurface() has the job to release resources of
733  * a previously created native surface.
734  *
735  * The function is used, if the underlying graphics subsystem doesn't provide
736  * any adequate functionality. The function destroys pure software surfaces
737  * previously created by the function EwCreateNativeSurface() only.
738  *
739  * ARGUMENTS:
740  * aSurface - Handle to the surface to destroy.
741  *
742  * RETURN VALUE:
743  * None
744  *
745  *******************************************************************************/
746 void EwDestroyNativeSurface(unsigned long aSurface);
747 
748 /*******************************************************************************
749  * FUNCTION:
750  * EwGetNativeSurfaceMemory
751  *
752  * DESCRIPTION:
753  * The function EwGetNativeSurfaceMemory() has the job to obtain pointers to
754  * the memory planes and if existing to the color table of the given surface.
755  *
756  * The returned pointers are calculated for the given pixel position aX, aY
757  *and in case of an existing color table, to the entry at the position aIndex.
758  *
759  * Please note, if the affected surface has been created with constant pixel
760  * information by using EwCreateConstNativeSurface(), you can't obtain the
761  * write access to such surface. In such case the function will fail with the
762  * return value 0.
763  *
764  * The function is used, if the underlying graphics subsystem doesn't provide
765  * any adequate functionality. The function can handle with the pure software
766  * surfaces previously created by the function EwCreateNativeSurface() and
767  * EwCreateConstNativeSurface() only.
768  *
769  * ARGUMENTS:
770  * aSurface - Handle to the surface to obtain the addresses.
771  * aX, aY - Position within the surface to calculate the pixel address.
772  * aIndex - Index within the color table to calculate the CLUT address.
773  * aWriteAccess - If != 0 the caller has the intention to modify the returned
774  * memory content.
775  * aMemory - Structure to receive the desired address information.
776  *
777  * RETURN VALUE:
778  * If successful, the function fills the given aMemory structure with the
779  * address information and returns != 0. Otherwise 0 is returned.
780  *
781  *******************************************************************************/
782 int EwGetNativeSurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex,
783  int aWriteAccess, XSurfaceMemory *aMemory);
784 
785 /*******************************************************************************
786  * FUNCTION:
787  * EwGetNativeSurfaceMemSize
788  *
789  * DESCRIPTION:
790  * The function EwGetNativeSurfaceMemSize() has the job to determine the
791  *number of memory bytes occupied by a native surface with the given size.
792  *
793  * ARGUMENTS:
794  * aWidth,
795  * aHeight - Size of the surface in pixel.
796  *
797  * RETURN VALUE:
798  * If successful, the function return the surface size in bytes.
799  *
800  *******************************************************************************/
801 int EwGetNativeSurfaceMemSize(int aWidth, int aHeight);
802 
803 /*******************************************************************************
804  * FUNCTION:
805  * EwCreateConstIndex8Surface
806  *
807  * DESCRIPTION:
808  * The function EwCreateConstIndex8Surface() has the job to create and return
809  * a new index8 surface with the given size and pixel data content. Important
810  * here is the fact that the function doesn't reserve any memory to store the
811  * pixel information. Instead it, the surface associates the pixel data passed
812  * in the parameter aMemory.
813  *
814  * This function is thus intended to create surfaces from the pixel data
815  *stored directly within a ROM area. Accordingly it is essential that the ROM
816  *content does exactly correspond to the index8 surface pixel format. It
817  *includes the order of CLUT color channels, premultiplication with alpha value,
818  *etc..
819  *
820  * If no surface could be created due to memory deficit, 0 is returned.
821  *
822  * The function is used, if the underlying graphics subsystem doesn't provide
823  * any adequate functionality.
824  *
825  * Please note, the surfaces created with this function are signed internally
826  * as constant. Trying to obtrain write-access to such surface will result in
827  * a runtime error.
828  *
829  * ARGUMENTS:
830  * aWidth,
831  * aHeight - Size of the surface to create.
832  * aMemory - Structure to pass the ROM address information.
833  *
834  * RETURN VALUE:
835  * If successful, returns a handle to the new surface. Otherwise 0 is
836  *returned.
837  *
838  *******************************************************************************/
839 unsigned long EwCreateConstIndex8Surface(int aWidth, int aHeight,
840  XSurfaceMemory *aMemory);
841 
842 /*******************************************************************************
843  * FUNCTION:
844  * EwCreateIndex8Surface
845  *
846  * DESCRIPTION:
847  * The function EwCreateIndex8Surface() has the job to create and return a new
848  * index8 surface with the given size. If no surface could be created due to
849  * memory deficit, 0 is returned.
850  *
851  * The function is used, if the underlying graphics subsystem doesn't provide
852  * any adequate functionality. The function creates a pure software surface
853  * within the CPU address space only.
854  *
855  * ARGUMENTS:
856  * aWidth,
857  * aHeight - Size of the surface to create.
858  *
859  * RETURN VALUE:
860  * If successful, returns a handle to the new surface. Otherwise 0 is
861  *returned.
862  *
863  *******************************************************************************/
864 unsigned long EwCreateIndex8Surface(int aWidth, int aHeight);
865 
866 /*******************************************************************************
867  * FUNCTION:
868  * EwDestroyIndex8Surface
869  *
870  * DESCRIPTION:
871  * The function EwDestroyIndex8Surface() has the job to release resources of
872  * a previously created index8 surface.
873  *
874  * The function is used, if the underlying graphics subsystem doesn't provide
875  * any adequate functionality. The function destroys pure software surfaces
876  * previously created by the function EwCreateIndex8Surface() only.
877  *
878  * ARGUMENTS:
879  * aSurface - Handle to the surface to destroy.
880  *
881  * RETURN VALUE:
882  * None
883  *
884  *******************************************************************************/
885 void EwDestroyIndex8Surface(unsigned long aSurface);
886 
887 /*******************************************************************************
888  * FUNCTION:
889  * EwGetIndex8SurfaceMemory
890  *
891  * DESCRIPTION:
892  * The function EwGetIndex8SurfaceMemory() has the job to obtain the pointer
893  *to the index8 memory plane and to the color table of the given surface.
894  *
895  * The returned pointer is calculated for the given pixel position aX, aY and
896  * in case of the color table, to the entry at the position aIndex.
897  *
898  * Please note, if the affected surface has been created with constant pixel
899  * information by using EwCreateConstIndex8Surface(), you can't obtain the
900  * write access to such surface. In such case the function will fail with the
901  * return value 0.
902  *
903  * The function is used, if the underlying graphics subsystem doesn't provide
904  * any adequate functionality. The function can handle with the pure software
905  * surfaces previously created by the function EwCreateIndex8Surface() and
906  * EwCreateConstIndex8Surface() only.
907  *
908  * ARGUMENTS:
909  * aSurface - Handle to the surface to obtain the addresses.
910  * aX, aY - Position within the surface to calculate the pixel address.
911  * aIndex - Index within the color table to calculate the CLUT address.
912  * aWriteAccess - If != 0 the caller has the intention to modify the returned
913  * memory content.
914  * aMemory - Structure to receive the desired address information.
915  *
916  * RETURN VALUE:
917  * If successful, the function fills the given aMemory structure with the
918  * address information and returns != 0. Otherwise 0 is returned.
919  *
920  *******************************************************************************/
921 int EwGetIndex8SurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex,
922  int aWriteAccess, XSurfaceMemory *aMemory);
923 
924 /*******************************************************************************
925  * FUNCTION:
926  * EwGetIndex8SurfaceMemSize
927  *
928  * DESCRIPTION:
929  * The function EwGetIndex8SurfaceMemSize() has the job to determine the
930  *number of memory bytes occupied by an index8 surface with the given size.
931  *
932  * ARGUMENTS:
933  * aWidth,
934  * aHeight - Size of the surface in pixel.
935  *
936  * RETURN VALUE:
937  * If successful, the function return the surface size in bytes.
938  *
939  *******************************************************************************/
940 int EwGetIndex8SurfaceMemSize(int aWidth, int aHeight);
941 
942 /*******************************************************************************
943  * FUNCTION:
944  * EwCreateAlpha8Surface
945  *
946  * DESCRIPTION:
947  * The function EwCreateAlpha8Surface() has the job to create and return a new
948  * alpha8 surface with the given size. If no surface could be created due to
949  * memory deficit, 0 is returned.
950  *
951  * The function is used, if the underlying graphics subsystem doesn't provide
952  * any adequate functionality. The function creates a pure software surface
953  * within the CPU address space only.
954  *
955  * ARGUMENTS:
956  * aWidth,
957  * aHeight - Size of the surface to create.
958  *
959  * RETURN VALUE:
960  * If successful, returns a handle to the new surface. Otherwise 0 is
961  *returned.
962  *
963  *******************************************************************************/
964 unsigned long EwCreateAlpha8Surface(int aWidth, int aHeight);
965 
966 /*******************************************************************************
967  * FUNCTION:
968  * EwCreateConstAlpha8Surface
969  *
970  * DESCRIPTION:
971  * The function EwCreateConstAlpha8Surface() has the job to create and return
972  * a new alpha8 surface with the given size and pixel data content. Important
973  * here is the fact that the function doesn't reserve any memory to store the
974  * pixel information. Instead it, the surface associates the pixel data passed
975  * in the parameter aMemory.
976  *
977  * This function is thus intended to create surfaces from the pixel data
978  *stored directly within a ROM area. Accordingly it is essential that the ROM
979  *content does exactly correspond to the alpha8 surface pixel format.
980  *
981  * If no surface could be created due to memory deficit, 0 is returned.
982  *
983  * The function is used, if the underlying graphics subsystem doesn't provide
984  * any adequate functionality.
985  *
986  * Please note, the surfaces created with this function are signed internally
987  * as constant. Trying to obtrain write-access to such surface will result in
988  * a runtime error.
989  *
990  * ARGUMENTS:
991  * aWidth,
992  * aHeight - Size of the surface to create.
993  * aMemory - Structure to pass the ROM address information.
994  *
995  * RETURN VALUE:
996  * If successful, returns a handle to the new surface. Otherwise 0 is
997  *returned.
998  *
999  *******************************************************************************/
1000 unsigned long EwCreateConstAlpha8Surface(int aWidth, int aHeight,
1001  XSurfaceMemory *aMemory);
1002 
1003 /*******************************************************************************
1004  * FUNCTION:
1005  * EwDestroyAlpha8Surface
1006  *
1007  * DESCRIPTION:
1008  * The function EwDestroyAlphaSurface() has the job to release resources of
1009  * a previously created alpha8 surface.
1010  *
1011  * The function is used, if the underlying graphics subsystem doesn't provide
1012  * any adequate functionality. The function destroys pure software surfaces
1013  * previously created by the function EwCreateAlpha8Surface() only.
1014  *
1015  * ARGUMENTS:
1016  * aSurface - Handle to the surface to destroy.
1017  *
1018  * RETURN VALUE:
1019  * None
1020  *
1021  *******************************************************************************/
1022 void EwDestroyAlpha8Surface(unsigned long aSurface);
1023 
1024 /*******************************************************************************
1025  * FUNCTION:
1026  * EwGetAlpha8SurfaceMemory
1027  *
1028  * DESCRIPTION:
1029  * The function EwGetAlpha8SurfaceMemory() has the job to obtain pointers to
1030  * the memory planes of the given surface.
1031  *
1032  * The returned pointer is calculated for the given pixel position aX, aY.
1033  *
1034  * Please note, if the affected surface has been created with constant pixel
1035  * information by using EwCreateConstAlpha8Surface(), you can't obtain the
1036  * write access to such surface. In such case the function will fail with the
1037  * return value 0.
1038  *
1039  * The function is used, if the underlying graphics subsystem doesn't provide
1040  * any adequate functionality. The function can handle with the pure software
1041  * surfaces previously created by the function EwCreateIAlpha8Surface() and
1042  * EwCreateConstAlpha8Surface() only.
1043  *
1044  * ARGUMENTS:
1045  * aSurface - Handle to the surface to obtain the addresses.
1046  * aX, aY - Position within the surface to calculate the pixel address.
1047  * aReserved - Should be 0.
1048  * aWriteAccess - If != 0 the caller has the intention to modify the returned
1049  * memory content.
1050  * aMemory - Structure to receive the desired address information.
1051  *
1052  * RETURN VALUE:
1053  * If successful, the function fills the given aMemory structure with the
1054  * address information and returns != 0. Otherwise 0 is returned.
1055  *
1056  *******************************************************************************/
1057 int EwGetAlpha8SurfaceMemory(unsigned long aSurface, int aX, int aY,
1058  int aReserved, int aWriteAccess,
1059  XSurfaceMemory *aMemory);
1060 
1061 /*******************************************************************************
1062  * FUNCTION:
1063  * EwGetAlpha8SurfaceMemSize
1064  *
1065  * DESCRIPTION:
1066  * The function EwGetAlpha8SurfaceMemSize() has the job to determine the
1067  *number of memory bytes occupied by an alpha8 surface with the given size.
1068  *
1069  * ARGUMENTS:
1070  * aWidth,
1071  * aHeight - Size of the surface in pixel.
1072  *
1073  * RETURN VALUE:
1074  * If successful, the function return the surface size in bytes.
1075  *
1076  *******************************************************************************/
1077 int EwGetAlpha8SurfaceMemSize(int aWidth, int aHeight);
1078 
1079 /*******************************************************************************
1080  * FUNCTION:
1081  * EwCreateConstRGB565Surface
1082  *
1083  * DESCRIPTION:
1084  * The function EwCreateConstRGB565Surface() has the job to create and return
1085  * a new rgb565 surface with the given size and pixel data content. Important
1086  * here is the fact that the function doesn't reserve any memory to store the
1087  * pixel information. Instead it, the surface associates the pixel data passed
1088  * in the parameter aMemory.
1089  *
1090  * This function is thus intended to create surfaces from the pixel data
1091  *stored directly within a ROM area. Accordingly it is essential that the ROM
1092  *content does exactly correspond to the rgb565 surface pixel format. It
1093  *includes the order of CLUT color channels, premultiplication with alpha value,
1094  *etc..
1095  *
1096  * If no surface could be created due to memory deficit, 0 is returned.
1097  *
1098  * The function is used, if the underlying graphics subsystem doesn't provide
1099  * any adequate functionality.
1100  *
1101  * Please note, the surfaces created with this function are signed internally
1102  * as constant. Trying to obtrain write-access to such surface will result in
1103  * a runtime error.
1104  *
1105  * ARGUMENTS:
1106  * aWidth,
1107  * aHeight - Size of the surface to create.
1108  * aMemory - Structure to pass the ROM address information.
1109  *
1110  * RETURN VALUE:
1111  * If successful, returns a handle to the new surface. Otherwise 0 is
1112  *returned.
1113  *
1114  *******************************************************************************/
1115 unsigned long EwCreateConstRGB565Surface(int aWidth, int aHeight,
1116  XSurfaceMemory *aMemory);
1117 
1118 /*******************************************************************************
1119  * FUNCTION:
1120  * EwCreateRGB565Surface
1121  *
1122  * DESCRIPTION:
1123  * The function EwCreateRGB565Surface() has the job to create and return a new
1124  * rgb565 surface with the given size. If no surface could be created due to
1125  * memory deficit, 0 is returned.
1126  *
1127  * The function is used, if the underlying graphics subsystem doesn't provide
1128  * any adequate functionality. The function creates a pure software surface
1129  * within the CPU address space only.
1130  *
1131  * ARGUMENTS:
1132  * aWidth,
1133  * aHeight - Size of the surface to create.
1134  *
1135  * RETURN VALUE:
1136  * If successful, returns a handle to the new surface. Otherwise 0 is
1137  *returned.
1138  *
1139  *******************************************************************************/
1140 unsigned long EwCreateRGB565Surface(int aWidth, int aHeight);
1141 
1142 /*******************************************************************************
1143  * FUNCTION:
1144  * EwDestroyRGB565Surface
1145  *
1146  * DESCRIPTION:
1147  * The function EwDestroyRGB565Surface() has the job to release resources of
1148  * a previously created rgb565 surface.
1149  *
1150  * The function is used, if the underlying graphics subsystem doesn't provide
1151  * any adequate functionality. The function destroys pure software surfaces
1152  * previously created by the function EwCreateRGB565Surface() only.
1153  *
1154  * ARGUMENTS:
1155  * aSurface - Handle to the surface to destroy.
1156  *
1157  * RETURN VALUE:
1158  * None
1159  *
1160  *******************************************************************************/
1161 void EwDestroyRGB565Surface(unsigned long aSurface);
1162 
1163 /*******************************************************************************
1164  * FUNCTION:
1165  * EwGetRGB565SurfaceMemory
1166  *
1167  * DESCRIPTION:
1168  * The function EwGetRGB565SurfaceMemory() has the job to obtain the pointer
1169  *to the rgb565 memory plane and to the color table of the given surface.
1170  *
1171  * The returned pointer is calculated for the given pixel position aX, aY and
1172  * in case of the color table, to the entry at the position aIndex.
1173  *
1174  * Please note, if the affected surface has been created with constant pixel
1175  * information by using EwCreateConstRGB565Surface(), you can't obtain the
1176  * write access to such surface. In such case the function will fail with the
1177  * return value 0.
1178  *
1179  * The function is used, if the underlying graphics subsystem doesn't provide
1180  * any adequate functionality. The function can handle with the pure software
1181  * surfaces previously created by the function EwCreateRGB565Surface() and
1182  * EwCreateConstRGB565Surface() only.
1183  *
1184  * ARGUMENTS:
1185  * aSurface - Handle to the surface to obtain the addresses.
1186  * aX, aY - Position within the surface to calculate the pixel address.
1187  * aIndex - Index within the color table to calculate the CLUT address.
1188  * aWriteAccess - If != 0 the caller has the intention to modify the returned
1189  * memory content.
1190  * aMemory - Structure to receive the desired address information.
1191  *
1192  * RETURN VALUE:
1193  * If successful, the function fills the given aMemory structure with the
1194  * address information and returns != 0. Otherwise 0 is returned.
1195  *
1196  *******************************************************************************/
1197 int EwGetRGB565SurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex,
1198  int aWriteAccess, XSurfaceMemory *aMemory);
1199 
1200 /*******************************************************************************
1201  * FUNCTION:
1202  * EwGetRGB565SurfaceMemSize
1203  *
1204  * DESCRIPTION:
1205  * The function EwGetRGB565SurfaceMemSize() has the job to determine the
1206  *number of memory bytes occupied by an rgb565 surface with the given size.
1207  *
1208  * ARGUMENTS:
1209  * aWidth,
1210  * aHeight - Size of the surface in pixel.
1211  *
1212  * RETURN VALUE:
1213  * If successful, the function return the surface size in bytes.
1214  *
1215  *******************************************************************************/
1216 int EwGetRGB565SurfaceMemSize(int aWidth, int aHeight);
1217 
1218 /*******************************************************************************
1219  * FUNCTION:
1220  * EwInitColorGradient
1221  *
1222  * DESCRIPTION:
1223  * The function EwInitColorGradient() has the job to initialize a rectangular,
1224  * linear gradient from 4 color values. The color values do correspond to the
1225  * four corners of the rectangular gradient: top-left, top-right, bottom-right
1226  * and bottom-left.
1227  *
1228  * ARGUMENTS:
1229  * aWidth,
1230  * aHeight - Size of the gradient area in pixel.
1231  * aColors - Array of 4 color values in the universal RGBA8888 color format.
1232  * aGradient - Destination gradient structure to initialize.
1233  *
1234  * RETURN VALUE:
1235  * None
1236  *
1237  *******************************************************************************/
1238 void EwInitColorGradient(int aWidth, int aHeight, unsigned int *aColors,
1239  XGradient *aGradient);
1240 
1241 /*******************************************************************************
1242  * FUNCTION:
1243  * EwInitOpacityGradient
1244  *
1245  * DESCRIPTION:
1246  * The function EwInitOpacityGradient() has the job to initialize a new
1247  *linear, rectangular gradient from 4 color values. The color values do
1248  *correspond to the four corners of the gradient area: top-left, top-right,
1249  *bottom-right and bottom-left.
1250  *
1251  * ARGUMENTS:
1252  * aWidth,
1253  * aHeight - Size of the gradient area in pixel.
1254  * aColors - Array of 4 color values in the universal RGBA8888 color format.
1255  * aGradient - Destination gradient structure to initialize.
1256  *
1257  * RETURN VALUE:
1258  * None
1259  *
1260  *******************************************************************************/
1261 void EwInitOpacityGradient(int aWidth, int aHeight, unsigned int *aColors,
1262  XGradient *aGradient);
1263 
1264 /*******************************************************************************
1265  * FUNCTION:
1266  * EwGetColorFromGradient
1267  *
1268  * DESCRIPTION:
1269  * The function EwGetColorFromGradient() has the job to interpolate the color
1270  * value for the given position within a color gradient.
1271  *
1272  * ARGUMENTS:
1273  * aGradient - Color gradient to get the color.
1274  * aX, aY - Position relative to the upper-left corner of the gradient to
1275  * get the color value.
1276  *
1277  * RETURN VALUE:
1278  * Interpolated color value in the universal RGBA8888 color format.
1279  *
1280  *******************************************************************************/
1281 unsigned int EwGetColorFromGradient(XGradient *aGradient, int aX, int aY);
1282 
1283 /*******************************************************************************
1284  * FUNCTION:
1285  * EwGetOpacityFromGradient
1286  *
1287  * DESCRIPTION:
1288  * The function EwGetOpacityFromGradient() has the job to interpolate the
1289  * opacity value for the given position within a color gradient.
1290  *
1291  * ARGUMENTS:
1292  * aGradient - Color gradient to get the value.
1293  * aX, aY - Position relative to the upper-left corner of the gradient to
1294  * get the opacity value.
1295  *
1296  * RETURN VALUE:
1297  * Interpolated color value in the universal RGBA8888 color format. Only the
1298  * alpha channel is valid.
1299  *
1300  *******************************************************************************/
1301 unsigned int EwGetOpacityFromGradient(XGradient *aGradient, int aX, int aY);
1302 
1303 /*******************************************************************************
1304  * FUNCTION:
1305  * EwRasterAlpha8Polygon
1306  *
1307  * DESCRIPTION:
1308  * The function EwRasterAlpha8Polygon() implements an algorithm to estimate the
1309  * content of an ALPHA8 bitmap from polygon data determined by edges in the
1310  * array aPaths. aPaths stores the edges as a serie of X,Y pairs starting
1311  *always with a value specifying the number of existing edges. With this
1312  *approach one path can consist of several sub-paths. The end of the list is
1313  *determined by a sub-path with 0 edges.
1314  *
1315  * +-------+------+------+------+------+------+------+-------+ +-----+
1316  * | edges | X0 | Y0 | X1 | Y1 | X2 | Y2 | edges | ... | 0 |
1317  * +-------+------+------+------+------+------+------+-------+ +-----+
1318  *
1319  * The function evaluates the path data for intersections between the edges and
1320  * the pixel within the destination area aDstX, aDstY, aWidth and aHeight. Then
1321  * the affected pixel are set or cleared according to whether they lie inside
1322  * or outside the polygon.
1323  *
1324  * ARGUMENTS:
1325  * aDst - Pointer to the first pixel of the destination ALPHA8
1326  * surface. The caller is responsable for clearing the surface before.
1327  * aPaths - An array containing the path data. The array starts with
1328  * the number of edges a path is composed of. Then follow the coordinates of
1329  * all path corners as X,Y pairs. After the last coordinate pair next path
1330  * can follow starting again with the number of edges. The end of the path
1331  * data is signed with 0. The X,Y coordinates are stored as signed integer
1332  * with 4-bit fixpoint precision. The coordinates are valid relative to the
1333  * top-left corner of the destination area aDstX, aDstY.
1334  * aDstX,
1335  * aDstY - Origin of the area to fill (relative to the top-left
1336  * corner of the destination surface).
1337  * aWidth,
1338  * aHeight - Size of the area to fill.
1339  * aX, aY - Path coordinate at the top-left corner of aDstX, aDstY
1340  * area. This value is expressed in in 4-bit fixpoint precision.
1341  * aAntialiased - If != 0, the function applies antialiasing to the pixel.
1342  * The antialiasing is based on supersampling with 4 samples in X and Y
1343  * direction.
1344  * aNonZeroWinding - Controls the fill rule to be used by the algorithm. If
1345  * this parameter is == 0, the even-odd fill rule is used. If this parameter
1346  * is != 0, the non-zero winding rule is used.
1347  *
1348  * RETURN VALUE:
1349  * None
1350  *
1351  *******************************************************************************/
1352 void EwRasterAlpha8Polygon(XSurfaceMemory *aDst, int *aPaths, int aDstX,
1353  int aDstY, int aWidth, int aHeight, int aX, int aY,
1354  int aAntialiased, int aNonZeroWinding);
1355 
1356 /*******************************************************************************
1357  * FUNCTION:
1358  * EwEmulateLine
1359  *
1360  * DESCRIPTION:
1361  * The function EwEmulateLine() drives a draw line operation by using solid or
1362  * gradient color values.
1363  *
1364  * The function provides the top-level interface to the software pixel driver.
1365  * The real drawing operation will be driven by the passed worker function.
1366  *
1367  * ARGUMENTS:
1368  * aDst - Pointer to the first pixel of the destination surface.
1369  * aDstX1,
1370  * aDstY1 - Start position to draw the line (relative to the top-left
1371  * corner of the destination surface).
1372  * aDstX2,
1373  * aDstY2 - End position to draw the line (relative to the top-left
1374  * corner of the destination surface). The pixel at the end position does
1375  * not belong to the line - it is invisible. In this manner polylines can
1376  * be drawn.
1377  * aClipX1,
1378  * aClipY1,
1379  * aClipX2,
1380  * aClipY2 - Optional clipping area relative to the top-left corner of the
1381  * destination surface. No pixel outside this area may be drawn.
1382  * aGradient - Color information to modulate the drawn pixel.
1383  * aWorker - Low-level worker function to perform the operation.
1384  *
1385  * RETURN VALUE:
1386  * None
1387  *
1388  *******************************************************************************/
1389 void EwEmulateLine(XSurfaceMemory *aDst, int aDstX1, int aDstY1, int aDstX2,
1390  int aDstY2, int aClipX1, int aClipY1, int aClipX2,
1391  int aClipY2, XGradient *aGradient, XLineWorker aWorker);
1392 
1393 /*******************************************************************************
1394  * FUNCTION:
1395  * EwEmulateFill
1396  *
1397  * DESCRIPTION:
1398  * The function EwEmulateFill() drives a fill operation for a rectangular area
1399  * by using solid or gradient color values.
1400  *
1401  * The function provides the top-level interface to the software pixel driver.
1402  * The real drawing operation will be driven by the passed worker function.
1403  *
1404  * ARGUMENTS:
1405  * aDst - Pointer to the first pixel of the destination surface.
1406  * aDstX,
1407  * aDstY - Origin of the area to fill (relative to the top-left corner of
1408  * the destination surface).
1409  * aWidth,
1410  * aHeight - Size of the area to fill.
1411  * aGradient - Color information to modulate the filled pixel.
1412  * aGrdX,
1413  * aGrdY - Origin of the affected area in the gradient coordinate space.
1414  * aWorker - Low-level worker function to perform the operation row-wise.
1415  *
1416  * RETURN VALUE:
1417  * None
1418  *
1419  *******************************************************************************/
1420 void EwEmulateFill(XSurfaceMemory *aDst, int aDstX, int aDstY, int aWidth,
1421  int aHeight, XGradient *aGradient, int aGrdX, int aGrdY,
1422  XFillWorker aWorker);
1423 
1424 /*******************************************************************************
1425  * FUNCTION:
1426  * EwEmulateCopy
1427  *
1428  * DESCRIPTION:
1429  * The function EwEmulateCopy() drives a copy operation for a rectangular area
1430  * from a native, index8, alpha8 or rgb565 surface to a screen or native
1431  *surface. The function modulates the copied pixel by solid or gradient opacity
1432  *values.
1433  *
1434  * The function provides the top-level interface to the software pixel driver.
1435  * The real drawing operation will be driven by the passed worker function.
1436  *
1437  * ARGUMENTS:
1438  * aDst - Pointer to the first pixel of the destination surface.
1439  * aSrc - Pointer to the first pixel of the source surface.
1440  * aDstX,
1441  * aDstY - Origin of the area to fill (relative to the top-left corner of
1442  * the destination surface).
1443  * aWidth,
1444  * aHeight - Size of the area to fill.
1445  * aSrcX,
1446  * aSrcY - Origin of the source area to copy (relative to the top-left
1447  * corner of the source surface).
1448  * aGradient - Color information to modulate the copied pixel.
1449  * aGrdX,
1450  * aGrdY - Origin of the affected area in the gradient coordinate space.
1451  * aWorker - Low-level worker function to perform the operation row-wise.
1452  *
1453  * RETURN VALUE:
1454  * None
1455  *
1456  *******************************************************************************/
1457 void EwEmulateCopy(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aDstX,
1458  int aDstY, int aWidth, int aHeight, int aSrcX, int aSrcY,
1459  XGradient *aGradient, int aGrdX, int aGrdY,
1460  XCopyWorker aWorker);
1461 
1462 /*******************************************************************************
1463  * FUNCTION:
1464  * EwEmulateWarp
1465  *
1466  * DESCRIPTION:
1467  * The function EwEmulateWarp() drives a warp operation for a rectangular area
1468  * of a native, index8, alpha8 or rgb565 surface to a polygon within a screen
1469  * or native surface. The function modulates the copied pixel by solid or
1470  * gradient opacity values.
1471  *
1472  * The function provides the top-level interface to the software pixel driver.
1473  * The real drawing operation will be driven by the passed worker function.
1474  *
1475  * ARGUMENTS:
1476  * aDst - Pointer to the first pixel of the destination surface.
1477  * aSrc - Pointer to the first pixel of the source surface.
1478  * DstX1,
1479  * DstY1,
1480  * DstW1,
1481  * ...
1482  * DstX4,
1483  * DstY4,
1484  * DstW4 - Coordinates of the polygon to fill with the source bitmap
1485  * (Relative to the top-left corner of the destination bitmap). The 'X', 'Y'
1486  * coefficients are specified in 29.3 fixed point format due to the
1487  * sub-pixel precision. The 'W' coefficients in 16.16.
1488  * aSrcX,
1489  * aSrcY - Origin of the source area to copy (relative to the top-left
1490  * corner of the source surface).
1491  * aSrcWidth,
1492  * aSrcHeight - Size of the source area to copy and warp.
1493  * aClipX1,
1494  * aClipY1,
1495  * aClipX2,
1496  * aClipY2 - Optional clipping area relative to the top-left corner of the
1497  * destination surface. No pixel outside this area may be drawn.
1498  * aGradient - Color information to modulate the copied pixel.
1499  * aWorker - Low-level worker function to perform the operation row-wise.
1500  *
1501  * RETURN VALUE:
1502  * None
1503  *
1504  *******************************************************************************/
1505 void EwEmulateWarp(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aDstX1,
1506  int aDstY1, int aDstW1, int aDstX2, int aDstY2, int aDstW2,
1507  int aDstX3, int aDstY3, int aDstW3, int aDstX4, int aDstY4,
1508  int aDstW4, int aSrcX, int aSrcY, int aSrcWidth,
1509  int aSrcHeight, int aClipX1, int aClipY1, int aClipX2,
1510  int aClipY2, XGradient *aGradient, XWarpWorker aWorker);
1511 
1512 /*******************************************************************************
1513  * FUNCTION:
1514  * EwEmulateFillPolygon
1515  *
1516  * DESCRIPTION:
1517  * The function EwEmulateFillPolygon() drives a fill polygon operation with
1518  * polygon data provided in the array aPaths. aPaths stores polygon edges as a
1519  * serie of X,Y coordinate pairs starting always with a value specifying the
1520  * number of edges the path is composed of. With this approach one path can
1521  * consist of several sub-paths. The end of the list is determined by a sub-
1522  * path with 0 edges:
1523  *
1524  * +-------+------+------+------+------+------+------+-------+ +-----+
1525  * | edges | X0 | Y0 | X1 | Y1 | X2 | Y2 | edges | ... | 0 |
1526  * +-------+------+------+------+------+------+------+-------+ +-----+
1527  *
1528  * The function evaluates the path data for intersections between the edges and
1529  * the pixel within the destination area aDstX, aDstY, aWidth and aHeight. The
1530  * function modulates the pixel by solid or gradient color values.
1531  *
1532  * The function provides the top-level interface to the software pixel driver.
1533  * The real drawing operation will be driven by the passed worker function.
1534  *
1535  * ARGUMENTS:
1536  * aDst - Pointer to the first pixel of the destination surface.
1537  * aPaths - An array containing the path data. The array starts with
1538  * the number of edges a path is composed of. Then follow the coordinates of
1539  * all path corners as X,Y pairs. After the last coordinate pair next path
1540  * can follow starting again with the number of edges. The end of the path
1541  * data is signed with 0. The X,Y coordinates are stored as signed integer
1542  * with 4-bit fixpoint precision. The coordinates are valid relative to the
1543  * top-left corner of the destination bitmap.
1544  * aDstX,
1545  * aDstY - Origin of the area to fill (relative to the top-left
1546  * corner of the destination surface).
1547  * aWidth,
1548  * aHeight - Size of the area to fill.
1549  * aAntialiased - If != 0, the function applies antialiasing to the pixel.
1550  * The antialiasing is based on supersampling with 4 samples in X and Y
1551  * direction.
1552  * aNonZeroWinding - Controls the fill rule to be used by the algorithm. If
1553  * this parameter is == 0, the even-odd fill rule is used. If this parameter
1554  * is != 0, the non-zero winding rule is used.
1555  * aGradient - Color information to modulate the copied pixel.
1556  * aGrdX,
1557  * aGrdY - Origin of the affected area in the gradient coordinate
1558  * space.
1559  * aWorker - Low-level worker function to perform the final copy
1560  * operation of the rasterized pixel row-wise.
1561  *
1562  * RETURN VALUE:
1563  * None
1564  *
1565  *******************************************************************************/
1566 void EwEmulateFillPolygon(XSurfaceMemory *aDst, int *aPaths, int aDstX,
1567  int aDstY, int aWidth, int aHeight, int aAntialiased,
1568  int aNonZeroWinding, XGradient *aGradient, int aGrdX,
1569  int aGrdY, XCopyWorker aWorker);
1570 
1571 /*******************************************************************************
1572  * FUNCTION:
1573  * EwPackColor
1574  *
1575  * DESCRIPTION:
1576  * The following EwPackColor() function has the job to convert the given RGBA
1577  * color channels into a generic packed 32 bit format as it is used internally
1578  * by the Graphics Engine.
1579  *
1580  * The generic packed 32 bit color format provides an abstraction of a 32 bit
1581  * color value consisting of three color channels and one alpha channel. The
1582  * content of the three color chanels is a subject of the particular target
1583  * system - Graphics Engine doesn't need to know anything about the meaning of
1584  * these channels - they are abstract.
1585  *
1586  * The generic packed 32 bit color format stores the channels in the following
1587  * order:
1588  *
1589  * 31 24 16 8 0
1590  * +------------+---------------------------------------+
1591  * | alpha | channel 3 | channel 2 | channel 1 |
1592  * +------------+---------------------------------------+
1593  *
1594  * Depending on the target color format, the function can modify and convert
1595  * the values of the channels. For example, the RGB -> YUV conversion can be
1596  * executed or the color channels can be pre-multiplied by the alpha value.
1597  *
1598  * The resulting 32 bit value is particular for the respective target color
1599  * format. It is predestined to be used more effectively durring all drawing
1600  * operations.
1601  *
1602  * ARGUMENTS:
1603  * aRed,
1604  * aGreen,
1605  * aBlue,
1606  * aAlpha - Non-premultiplied color channel values in the range 0 .. 255.
1607  *
1608  * RETURN VALUE:
1609  * Packed 32 bit color value. Particular for the target color format.
1610  *
1611  *******************************************************************************/
1612 unsigned int EwPackColor(int aRed, int aGreen, int aBlue, int aAlpha);
1613 
1614 /*******************************************************************************
1615  * FUNCTION:
1616  * EwPackClutEntry
1617  *
1618  * DESCRIPTION:
1619  * The following EwPackClutEntry() function has the job to convert the given
1620  * RGBA color channels into a 32 bit wide clut entry as it is used by Index8
1621  * surfaces internally.
1622  *
1623  * Like the EwPackColor() function, the resulting value depends on the used
1624  * native color format. Therefore, the order of color channels, color spaces,
1625  * etc. are not predetermined here. The result is just a 32 bit value without
1626  * any assumptions about its structure.
1627  *
1628  * The resulting 32 bit value is particular for the respective target color
1629  * format. It is predestined to be used more effectively durring all drawing
1630  * Index8 bitmaps.
1631  *
1632  * ARGUMENTS:
1633  * aRed,
1634  * aGreen,
1635  * aBlue,
1636  * aAlpha - Non-premultiplied color channel values in the range 0 .. 255.
1637  *
1638  * RETURN VALUE:
1639  * 32 bit clut entry. Particular for the target color format.
1640  *
1641  *******************************************************************************/
1642 unsigned int EwPackClutEntry(int aRed, int aGreen, int aBlue, int aAlpha);
1643 
1644 /*******************************************************************************
1645  * FUNCTION:
1646  * EwSetPixelSolid
1647  * EwScreenSetPixelSolid
1648  *
1649  * DESCRIPTION:
1650  * The following function defines the low-level, pixel-wise drawing operation
1651  * to draw a single pixel with a solid color. The new pixel overwrites the
1652  * existing pixel within the destination.
1653  *
1654  * ARGUMENTS:
1655  * aDst - Pointer to the first pixel of the destination surface.
1656  * aX, aY - Position to draw the pixel.
1657  * aGradient - Solid color information.
1658  *
1659  * RETURN VALUE:
1660  * None
1661  *
1662  *******************************************************************************/
1663 void EwSetPixelSolid(XSurfaceMemory *aDst, int aX, int aY,
1664  XGradient *aGradient);
1665 
1666 void EwScreenSetPixelSolid(XSurfaceMemory *aDst, int aX, int aY,
1667  XGradient *aGradient);
1668 
1669 /*******************************************************************************
1670  * FUNCTION:
1671  * EwSetPixelSolidBlend
1672  * EwScreenSetPixelSolidBlend
1673  *
1674  * DESCRIPTION:
1675  * The following function defines the low-level, pixel-wise drawing operation
1676  * to draw a single pixel with a solid color. The new pixel will be alpha
1677  * blended with the existing pixel of the destination.
1678  *
1679  * ARGUMENTS:
1680  * aDst - Pointer to the first pixel of the destination surface.
1681  * aX, aY - Position to draw the pixel.
1682  * aGradient - Solid color information.
1683  *
1684  * RETURN VALUE:
1685  * None
1686  *
1687  *******************************************************************************/
1688 void EwSetPixelSolidBlend(XSurfaceMemory *aDst, int aX, int aY,
1689  XGradient *aGradient);
1690 
1691 void EwScreenSetPixelSolidBlend(XSurfaceMemory *aDst, int aX, int aY,
1692  XGradient *aGradient);
1693 
1694 /*******************************************************************************
1695  * FUNCTION:
1696  * EwFillRowSolid
1697  * EwScreenFillRowSolid
1698  *
1699  * DESCRIPTION:
1700  * The following function defines the low-level, pixel-wise drawing operation
1701  * to fill a horizontal pixel row with a solid color. The new pixel overwrites
1702  * the existing pixel within the destination.
1703  *
1704  * ARGUMENTS:
1705  * aDst - Pointer to the first pixel of the destination row.
1706  * aWidth - Width of the row.
1707  * aGradient - Solid color information.
1708  *
1709  * RETURN VALUE:
1710  * None
1711  *
1712  *******************************************************************************/
1713 void EwFillRowSolid(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient);
1714 
1715 void EwScreenFillRowSolid(XSurfaceMemory *aDst, int aWidth,
1716  XGradient *aGradient);
1717 
1718 /*******************************************************************************
1719  * FUNCTION:
1720  * EwFillRowSolidBlend
1721  * EwScreenFillRowSolidBlend
1722  *
1723  * DESCRIPTION:
1724  * The following function defines the low-level, pixel-wise drawing operation
1725  * to fill a horizontal pixel row with a solid color. The new pixel will be
1726  * alpha blended with the existing pixel of the destination.
1727  *
1728  * ARGUMENTS:
1729  * aDst - Pointer to the first pixel of the destination row.
1730  * aWidth - Width of the row.
1731  * aGradient - Solid color information.
1732  *
1733  * RETURN VALUE:
1734  * None
1735  *
1736  *******************************************************************************/
1737 void EwFillRowSolidBlend(XSurfaceMemory *aDst, int aWidth,
1738  XGradient *aGradient);
1739 
1740 void EwScreenFillRowSolidBlend(XSurfaceMemory *aDst, int aWidth,
1741  XGradient *aGradient);
1742 
1743 /*******************************************************************************
1744  * FUNCTION:
1745  * EwFillRowGradient
1746  * EwScreenFillRowGradient
1747  *
1748  * DESCRIPTION:
1749  * The following function defines the low-level, pixel-wise drawing operation
1750  * to fill a horizontal pixel row with a color gradient. The new pixel will
1751  * overwrite the existing pixel within the destination.
1752  *
1753  * ARGUMENTS:
1754  * aDst - Pointer to the first pixel of the destination row.
1755  * aWidth - Width of the row.
1756  * aGradient - Color gradient information.
1757  *
1758  * RETURN VALUE:
1759  * None
1760  *
1761  *******************************************************************************/
1762 void EwFillRowGradient(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient);
1763 
1764 void EwScreenFillRowGradient(XSurfaceMemory *aDst, int aWidth,
1765  XGradient *aGradient);
1766 
1767 /*******************************************************************************
1768  * FUNCTION:
1769  * EwFillRowGradientBlend
1770  * EwScreenFillRowGradientBlend
1771  *
1772  * DESCRIPTION:
1773  * The following function defines the low-level, pixel-wise drawing operation
1774  * to fill a horizontal pixel row with a color gradient. The new pixel will be
1775  * alpha blended with the existing pixel of the destination.
1776  *
1777  * ARGUMENTS:
1778  * aDst - Pointer to the first pixel of the destination row.
1779  * aWidth - Width of the row.
1780  * aGradient - Color gradient information.
1781  *
1782  * RETURN VALUE:
1783  * None
1784  *
1785  *******************************************************************************/
1786 void EwFillRowGradientBlend(XSurfaceMemory *aDst, int aWidth,
1787  XGradient *aGradient);
1788 
1789 void EwScreenFillRowGradientBlend(XSurfaceMemory *aDst, int aWidth,
1790  XGradient *aGradient);
1791 
1792 /*******************************************************************************
1793  * FUNCTION:
1794  * EwCopyNativeRow
1795  * EwScreenCopyNativeRow
1796  *
1797  * DESCRIPTION:
1798  * The following function defines the low-level, pixel-wise drawing operation
1799  * to copy a horizontal pixel row between two native surfaces. The operation
1800  * is executed without any additional opacity values. The new pixel overwrites
1801  * the existing pixel within the destination.
1802  *
1803  * ARGUMENTS:
1804  * aDst - Pointer to the first pixel of the destination row.
1805  * aSrc - Pointer to the first pixel of the source row.
1806  * aWidth - Width of the row.
1807  * aGradient - <Unused in this function>
1808  *
1809  * RETURN VALUE:
1810  * None
1811  *
1812  *******************************************************************************/
1813 void EwCopyNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
1814  XGradient *aGradient);
1815 
1816 void EwScreenCopyNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1817  int aWidth, XGradient *aGradient);
1818 
1819 /*******************************************************************************
1820  * FUNCTION:
1821  * EwCopyNativeRowBlend
1822  * EwScreenCopyNativeRowBlend
1823  *
1824  * DESCRIPTION:
1825  * The following function defines the low-level, pixel-wise drawing operation
1826  * to copy a horizontal pixel row between two native surfaces. The operation
1827  * is executed without any additional opacity values. The new pixel will be
1828  * alpha blended withe the existing pixel of the destination.
1829  *
1830  * ARGUMENTS:
1831  * aDst - Pointer to the first pixel of the destination row.
1832  * aSrc - Pointer to the first pixel of the source row.
1833  * aWidth - Width of the row.
1834  * aGradient - <Unused in this function>
1835  *
1836  * RETURN VALUE:
1837  * None
1838  *
1839  *******************************************************************************/
1840 void EwCopyNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1841  int aWidth, XGradient *aGradient);
1842 
1843 void EwScreenCopyNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1844  int aWidth, XGradient *aGradient);
1845 
1846 /*******************************************************************************
1847  * FUNCTION:
1848  * EwCopyNativeRowSolid
1849  * EwScreenCopyNativeRowSolid
1850  *
1851  * DESCRIPTION:
1852  * The following function defines the low-level, pixel-wise drawing operation
1853  * to copy a horizontal pixel row between two native surfaces. The operation
1854  * is executed with an additional solid opacity value. The new pixel will
1855  * overwrite the existing pixel within the destination.
1856  *
1857  * ARGUMENTS:
1858  * aDst - Pointer to the first pixel of the destination row.
1859  * aSrc - Pointer to the first pixel of the source row.
1860  * aWidth - Width of the row.
1861  * aGradient - Solid opacity information.
1862  *
1863  * RETURN VALUE:
1864  * None
1865  *
1866  *******************************************************************************/
1867 void EwCopyNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1868  int aWidth, XGradient *aGradient);
1869 
1870 void EwScreenCopyNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1871  int aWidth, XGradient *aGradient);
1872 
1873 /*******************************************************************************
1874  * FUNCTION:
1875  * EwCopyNativeRowSolidBlend
1876  * EwScreenCopyNativeRowSolidBlend
1877  *
1878  * DESCRIPTION:
1879  * The following function defines the low-level, pixel-wise drawing operation
1880  * to copy a horizontal pixel row between two native surfaces. The operation
1881  * is executed with an additional solid opacity value. The new pixel will be
1882  * alpha blended with the existing pixel of the destination.
1883  *
1884  * ARGUMENTS:
1885  * aDst - Pointer to the first pixel of the destination row.
1886  * aSrc - Pointer to the first pixel of the source row.
1887  * aWidth - Width of the row.
1888  * aGradient - Solid opacity information.
1889  *
1890  * RETURN VALUE:
1891  * None
1892  *
1893  *******************************************************************************/
1894 void EwCopyNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1895  int aWidth, XGradient *aGradient);
1896 
1897 void EwScreenCopyNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1898  int aWidth, XGradient *aGradient);
1899 
1900 /*******************************************************************************
1901  * FUNCTION:
1902  * EwCopyNativeRowGradient
1903  * EwScreenCopyNativeRowGradient
1904  *
1905  * DESCRIPTION:
1906  * The following function defines the low-level, pixel-wise drawing operation
1907  * to copy a horizontal pixel row between two native surfaces. The operation
1908  * is executed with an additional opacity gradient. The new pixel overwrites
1909  * the existing pixel within the destination.
1910  *
1911  * ARGUMENTS:
1912  * aDst - Pointer to the first pixel of the destination row.
1913  * aSrc - Pointer to the first pixel of the source row.
1914  * aWidth - Width of the row.
1915  * aGradient - Opacity gradient information.
1916  *
1917  * RETURN VALUE:
1918  * None
1919  *
1920  *******************************************************************************/
1921 void EwCopyNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1922  int aWidth, XGradient *aGradient);
1923 
1924 void EwScreenCopyNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1925  int aWidth, XGradient *aGradient);
1926 
1927 /*******************************************************************************
1928  * FUNCTION:
1929  * EwCopyNativeRowGradientBlend
1930  * EwScreenCopyNativeRowGradientBlend
1931  *
1932  * DESCRIPTION:
1933  * The following function defines the low-level, pixel-wise drawing operation
1934  * to copy a horizontal pixel row between two native surfaces. The operation
1935  * is executed with an additional opacity gradient. The new pixel will be
1936  *alpha blended with the existing pixel of the destination.
1937  *
1938  * ARGUMENTS:
1939  * aDst - Pointer to the first pixel of the destination row.
1940  * aSrc - Pointer to the first pixel of the source row.
1941  * aWidth - Width of the row.
1942  * aGradient - Opacity gradient information.
1943  *
1944  * RETURN VALUE:
1945  * None
1946  *
1947  *******************************************************************************/
1948 void EwCopyNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1949  int aWidth, XGradient *aGradient);
1950 
1951 void EwScreenCopyNativeRowGradientBlend(XSurfaceMemory *aDst,
1952  XSurfaceMemory *aSrc, int aWidth,
1953  XGradient *aGradient);
1954 
1955 /*******************************************************************************
1956  * FUNCTION:
1957  * EwCopyIndex8Row
1958  * EwScreenCopyIndex8Row
1959  *
1960  * DESCRIPTION:
1961  * The following function defines the low-level, pixel-wise drawing operation
1962  * to copy a horizontal pixel row from an index8 to a native surface. The
1963  * operation is executed without any additional opacity values. The new pixel
1964  * overwrites the existing pixel within the destination.
1965  *
1966  * ARGUMENTS:
1967  * aDst - Pointer to the first pixel of the destination row.
1968  * aSrc - Pointer to the first pixel of the source row.
1969  * aWidth - Width of the row.
1970  * aGradient - <Unused in this function>
1971  *
1972  * RETURN VALUE:
1973  * None
1974  *
1975  *******************************************************************************/
1976 void EwCopyIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
1977  XGradient *aGradient);
1978 
1979 void EwScreenCopyIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
1980  int aWidth, XGradient *aGradient);
1981 
1982 /*******************************************************************************
1983  * FUNCTION:
1984  * EwCopyIndex8RowBlend
1985  * EwScreenCopyIndex8RowBlend
1986  *
1987  * DESCRIPTION:
1988  * The following function defines the low-level, pixel-wise drawing operation
1989  * to copy a horizontal pixel row from an index8 to a native surface. The
1990  * operation is executed without any additional opacity values. The new pixel
1991  * will be alpha blended withe the existing pixel of the destination.
1992  *
1993  * ARGUMENTS:
1994  * aDst - Pointer to the first pixel of the destination row.
1995  * aSrc - Pointer to the first pixel of the source row.
1996  * aWidth - Width of the row.
1997  * aGradient - <Unused in this function>
1998  *
1999  * RETURN VALUE:
2000  * None
2001  *
2002  *******************************************************************************/
2003 void EwCopyIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2004  int aWidth, XGradient *aGradient);
2005 
2006 void EwScreenCopyIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2007  int aWidth, XGradient *aGradient);
2008 
2009 /*******************************************************************************
2010  * FUNCTION:
2011  * EwCopyIndex8RowSolid
2012  * EwScreenCopyIndex8RowSolid
2013  *
2014  * DESCRIPTION:
2015  * The following function defines the low-level, pixel-wise drawing operation
2016  * to copy a horizontal pixel row from an index8 to a native surface. The
2017  * operation is executed with an additional solid opacity value. The new pixel
2018  * will overwrite the existing pixel within the destination.
2019  *
2020  * ARGUMENTS:
2021  * aDst - Pointer to the first pixel of the destination row.
2022  * aSrc - Pointer to the first pixel of the source row.
2023  * aWidth - Width of the row.
2024  * aGradient - Solid opacity information.
2025  *
2026  * RETURN VALUE:
2027  * None
2028  *
2029  *******************************************************************************/
2030 void EwCopyIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2031  int aWidth, XGradient *aGradient);
2032 
2033 void EwScreenCopyIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2034  int aWidth, XGradient *aGradient);
2035 
2036 /*******************************************************************************
2037  * FUNCTION:
2038  * EwCopyIndex8RowSolidBlend
2039  * EwScreenCopyIndex8RowSolidBlend
2040  *
2041  * DESCRIPTION:
2042  * The following function defines the low-level, pixel-wise drawing operation
2043  * to copy a horizontal pixel row from an index8 to a native surface. The
2044  * operation is executed with an additional solid opacity value. The new pixel
2045  * will be alpha blended with the existing pixel of the destination.
2046  *
2047  * ARGUMENTS:
2048  * aDst - Pointer to the first pixel of the destination row.
2049  * aSrc - Pointer to the first pixel of the source row.
2050  * aWidth - Width of the row.
2051  * aGradient - Solid opacity information.
2052  *
2053  * RETURN VALUE:
2054  * None
2055  *
2056  *******************************************************************************/
2057 void EwCopyIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2058  int aWidth, XGradient *aGradient);
2059 
2060 void EwScreenCopyIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2061  int aWidth, XGradient *aGradient);
2062 
2063 /*******************************************************************************
2064  * FUNCTION:
2065  * EwCopyIndex8RowGradient
2066  * EwScreenCopyIndex8RowGradient
2067  *
2068  * DESCRIPTION:
2069  * The following function defines the low-level, pixel-wise drawing operation
2070  * to copy a horizontal pixel row from an index8 to a native surface. The
2071  * operation is executed with an additional opacity gradient. The new pixel
2072  * overwrites the existing pixel within the destination.
2073  *
2074  * ARGUMENTS:
2075  * aDst - Pointer to the first pixel of the destination row.
2076  * aSrc - Pointer to the first pixel of the source row.
2077  * aWidth - Width of the row.
2078  * aGradient - Opacity gradient information.
2079  *
2080  * RETURN VALUE:
2081  * None
2082  *
2083  *******************************************************************************/
2084 void EwCopyIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2085  int aWidth, XGradient *aGradient);
2086 
2087 void EwScreenCopyIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2088  int aWidth, XGradient *aGradient);
2089 
2090 /*******************************************************************************
2091  * FUNCTION:
2092  * EwCopyIndex8RowGradientBlend
2093  * EwScreenCopyIndex8RowGradientBlend
2094  *
2095  * DESCRIPTION:
2096  * The following function defines the low-level, pixel-wise drawing operation
2097  * to copy a horizontal pixel row from an index8 to a native surface. The
2098  * operation is executed with an additional opacity gradient. The new pixel
2099  * will be alpha blended with the existing pixel of the destination.
2100  *
2101  * ARGUMENTS:
2102  * aDst - Pointer to the first pixel of the destination row.
2103  * aSrc - Pointer to the first pixel of the source row.
2104  * aWidth - Width of the row.
2105  * aGradient - Opacity gradient information.
2106  *
2107  * RETURN VALUE:
2108  * None
2109  *
2110  *******************************************************************************/
2111 void EwCopyIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2112  int aWidth, XGradient *aGradient);
2113 
2114 void EwScreenCopyIndex8RowGradientBlend(XSurfaceMemory *aDst,
2115  XSurfaceMemory *aSrc, int aWidth,
2116  XGradient *aGradient);
2117 
2118 /*******************************************************************************
2119  * FUNCTION:
2120  * EwCopyAlpha8RowSolid
2121  * EwScreenCopyAlpha8RowSolid
2122  *
2123  * DESCRIPTION:
2124  * The following function defines the low-level, pixel-wise drawing operation
2125  * to fill a horizontal pixel row with a solid color additionally modulated by
2126  * the opacity values from the source alpha8 surface. The new pixel overwrite
2127  * the existing pixel within the destination.
2128  *
2129  * ARGUMENTS:
2130  * aDst - Pointer to the first pixel of the destination row.
2131  * aSrc - Pointer to the first pixel of the source row.
2132  * aWidth - Width of the row.
2133  * aGradient - Solid color information.
2134  *
2135  * RETURN VALUE:
2136  * None
2137  *
2138  *******************************************************************************/
2139 void EwCopyAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2140  int aWidth, XGradient *aGradient);
2141 
2142 void EwScreenCopyAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2143  int aWidth, XGradient *aGradient);
2144 
2145 /*******************************************************************************
2146  * FUNCTION:
2147  * EwCopyAlpha8RowSolidBlend
2148  * EwScreenCopyAlpha8RowSolidBlend
2149  *
2150  * DESCRIPTION:
2151  * The following function defines the low-level, pixel-wise drawing operation
2152  * to fill a horizontal pixel row with a solid color additionally modulated by
2153  * the opacity values from the source alpha8 surface. The new pixel will be
2154  * alpha blended with the existing pixel of the destination.
2155  *
2156  * ARGUMENTS:
2157  * aDst - Pointer to the first pixel of the destination row.
2158  * aSrc - Pointer to the first pixel of the source row.
2159  * aWidth - Width of the row.
2160  * aGradient - Solid color information.
2161  *
2162  * RETURN VALUE:
2163  * None
2164  *
2165  *******************************************************************************/
2166 void EwCopyAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2167  int aWidth, XGradient *aGradient);
2168 
2169 void EwScreenCopyAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2170  int aWidth, XGradient *aGradient);
2171 
2172 /*******************************************************************************
2173  * FUNCTION:
2174  * EwCopyAlpha8RowGradient
2175  * EwScreenCopyAlpha8RowGradient
2176  *
2177  * DESCRIPTION:
2178  * The following function defines the low-level, pixel-wise drawing operation
2179  * to fill a horizontal pixel row with a color gradient additionally modulated
2180  * by the opacity values from the source alpha8 surface. The new pixel will
2181  * overwrite the existing pixel within the destination.
2182  *
2183  * ARGUMENTS:
2184  * aDst - Pointer to the first pixel of the destination row.
2185  * aSrc - Pointer to the first pixel of the source row.
2186  * aWidth - Width of the row.
2187  * aGradient - Color gradient information.
2188  *
2189  * RETURN VALUE:
2190  * None
2191  *
2192  *******************************************************************************/
2193 void EwCopyAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2194  int aWidth, XGradient *aGradient);
2195 
2196 void EwScreenCopyAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2197  int aWidth, XGradient *aGradient);
2198 
2199 /*******************************************************************************
2200  * FUNCTION:
2201  * EwCopyAlpha8RowGradientBlend
2202  * EwScreenCopyAlpha8RowGradientBlend
2203  *
2204  * DESCRIPTION:
2205  * The following function defines the low-level, pixel-wise drawing operation
2206  * to fill a horizontal pixel row with a color gradient additionally modulated
2207  * by the opacity values from the source alpha8 surface. The new pixel will be
2208  * alpha blended with the existing pixel of the destination.
2209  *
2210  * ARGUMENTS:
2211  * aDst - Pointer to the first pixel of the destination row.
2212  * aSrc - Pointer to the first pixel of the source row.
2213  * aWidth - Width of the row.
2214  * aGradient - Color gradient information.
2215  *
2216  * RETURN VALUE:
2217  * None
2218  *
2219  *******************************************************************************/
2220 void EwCopyAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2221  int aWidth, XGradient *aGradient);
2222 
2223 void EwScreenCopyAlpha8RowGradientBlend(XSurfaceMemory *aDst,
2224  XSurfaceMemory *aSrc, int aWidth,
2225  XGradient *aGradient);
2226 
2227 /*******************************************************************************
2228  * FUNCTION:
2229  * EwCopyRGB565Row
2230  * EwScreenCopyRGB565Row
2231  *
2232  * DESCRIPTION:
2233  * The following function defines the low-level, pixel-wise drawing operation
2234  * to copy a horizontal pixel row from an rgb565 to a native surface. The
2235  * operation is executed without any additional opacity values. The new pixel
2236  * overwrites the existing pixel within the destination.
2237  *
2238  * ARGUMENTS:
2239  * aDst - Pointer to the first pixel of the destination row.
2240  * aSrc - Pointer to the first pixel of the source row.
2241  * aWidth - Width of the row.
2242  * aGradient - <Unused in this function>
2243  *
2244  * RETURN VALUE:
2245  * None
2246  *
2247  *******************************************************************************/
2248 void EwCopyRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
2249  XGradient *aGradient);
2250 
2251 void EwScreenCopyRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2252  int aWidth, XGradient *aGradient);
2253 
2254 /*******************************************************************************
2255  * FUNCTION:
2256  * EwCopyRGB565RowSolid
2257  * EwScreenCopyRGB565RowSolid
2258  *
2259  * DESCRIPTION:
2260  * The following function defines the low-level, pixel-wise drawing operation
2261  * to copy a horizontal pixel row from an rgb565 to a native surface. The
2262  * operation is executed with an additional solid opacity value. The new pixel
2263  * will overwrite the existing pixel within the destination.
2264  *
2265  * ARGUMENTS:
2266  * aDst - Pointer to the first pixel of the destination row.
2267  * aSrc - Pointer to the first pixel of the source row.
2268  * aWidth - Width of the row.
2269  * aGradient - Solid opacity information.
2270  *
2271  * RETURN VALUE:
2272  * None
2273  *
2274  *******************************************************************************/
2275 void EwCopyRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2276  int aWidth, XGradient *aGradient);
2277 
2278 void EwScreenCopyRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2279  int aWidth, XGradient *aGradient);
2280 
2281 /*******************************************************************************
2282  * FUNCTION:
2283  * EwCopyRGB565RowSolidBlend
2284  * EwScreenCopyRGB565RowSolidBlend
2285  *
2286  * DESCRIPTION:
2287  * The following function defines the low-level, pixel-wise drawing operation
2288  * to copy a horizontal pixel row from an rgb565 to a native surface. The
2289  * operation is executed with an additional solid opacity value. The new pixel
2290  * will be alpha blended with the existing pixel of the destination.
2291  *
2292  * ARGUMENTS:
2293  * aDst - Pointer to the first pixel of the destination row.
2294  * aSrc - Pointer to the first pixel of the source row.
2295  * aWidth - Width of the row.
2296  * aGradient - Solid opacity information.
2297  *
2298  * RETURN VALUE:
2299  * None
2300  *
2301  *******************************************************************************/
2302 void EwCopyRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2303  int aWidth, XGradient *aGradient);
2304 
2305 void EwScreenCopyRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2306  int aWidth, XGradient *aGradient);
2307 
2308 /*******************************************************************************
2309  * FUNCTION:
2310  * EwCopyRGB565RowGradient
2311  * EwScreenCopyRGB565RowGradient
2312  *
2313  * DESCRIPTION:
2314  * The following function defines the low-level, pixel-wise drawing operation
2315  * to copy a horizontal pixel row from an rgb565 to a native surface. The
2316  * operation is executed with an additional opacity gradient. The new pixel
2317  * overwrites the existing pixel within the destination.
2318  *
2319  * ARGUMENTS:
2320  * aDst - Pointer to the first pixel of the destination row.
2321  * aSrc - Pointer to the first pixel of the source row.
2322  * aWidth - Width of the row.
2323  * aGradient - Opacity gradient information.
2324  *
2325  * RETURN VALUE:
2326  * None
2327  *
2328  *******************************************************************************/
2329 void EwCopyRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2330  int aWidth, XGradient *aGradient);
2331 
2332 void EwScreenCopyRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2333  int aWidth, XGradient *aGradient);
2334 
2335 /*******************************************************************************
2336  * FUNCTION:
2337  * EwCopyRGB565RowGradientBlend
2338  * EwScreenCopyRGB565RowGradientBlend
2339  *
2340  * DESCRIPTION:
2341  * The following function defines the low-level, pixel-wise drawing operation
2342  * to copy a horizontal pixel row from an rgb565 to a native surface. The
2343  * operation is executed with an additional opacity gradient. The new pixel
2344  * will be alpha blended with the existing pixel of the destination.
2345  *
2346  * ARGUMENTS:
2347  * aDst - Pointer to the first pixel of the destination row.
2348  * aSrc - Pointer to the first pixel of the source row.
2349  * aWidth - Width of the row.
2350  * aGradient - Opacity gradient information.
2351  *
2352  * RETURN VALUE:
2353  * None
2354  *
2355  *******************************************************************************/
2356 void EwCopyRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2357  int aWidth, XGradient *aGradient);
2358 
2359 void EwScreenCopyRGB565RowGradientBlend(XSurfaceMemory *aDst,
2360  XSurfaceMemory *aSrc, int aWidth,
2361  XGradient *aGradient);
2362 
2363 /*******************************************************************************
2364  * FUNCTION:
2365  * EwWarpNativeRow
2366  * EwScreenWarpNativeRow
2367  *
2368  * DESCRIPTION:
2369  * The following function defines the low-level, pixel-wise drawing operation
2370  * to fill a horizontal pixel row with a transformed content of the source
2371  * surface. The new pixel will overwrite the existing pixel in the destination
2372  * memory.
2373  *
2374  * ARGUMENTS:
2375  * aDst - Pointer to the first pixel of the destination row.
2376  * aSrc - Pointer to the first pixel of the source surface.
2377  * aWidth - Width of the row.
2378  * aS, aT - Start values for the S and T texture mapping coordinates.
2379  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2380  * aSrcWidth,
2381  * aSrcHeight - Size of the source surface to warp.
2382  * aGradient - <Unused in this function>
2383  *
2384  * RETURN VALUE:
2385  * None
2386  *
2387  *******************************************************************************/
2388 void EwWarpNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
2389  int aS, int aT, int aSS, int aTS, int aSrcWidth,
2390  int aSrcHeight, XGradient *aGradient);
2391 
2392 void EwScreenWarpNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2393  int aWidth, int aS, int aT, int aSS, int aTS,
2394  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2395 
2396 /*******************************************************************************
2397  * FUNCTION:
2398  * EwWarpNativeRowFilter
2399  * EwScreenWarpNativeRowFilter
2400  *
2401  * DESCRIPTION:
2402  * The following function defines the low-level, pixel-wise drawing operation
2403  * to fill a horizontal pixel row with a transformed content of the source
2404  * surface. For better output quality the source pixel are interpolated by a
2405  * bi-linear filter. The resulting pixel will overwrite the existing pixel in
2406  * the destination memory.
2407  *
2408  * ARGUMENTS:
2409  * aDst - Pointer to the first pixel of the destination row.
2410  * aSrc - Pointer to the first pixel of the source surface.
2411  * aWidth - Width of the row.
2412  * aS, aT - Start values for the S and T texture mapping coordinates.
2413  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2414  * aSrcWidth,
2415  * aSrcHeight - Size of the source surface to warp.
2416  * aGradient - <Unused in this function>
2417  *
2418  * RETURN VALUE:
2419  * None
2420  *
2421  *******************************************************************************/
2422 void EwWarpNativeRowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2423  int aWidth, int aS, int aT, int aSS, int aTS,
2424  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2425 
2426 void EwScreenWarpNativeRowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2427  int aWidth, int aS, int aT, int aSS, int aTS,
2428  int aSrcWidth, int aSrcHeight,
2429  XGradient *aGradient);
2430 
2431 /*******************************************************************************
2432  * FUNCTION:
2433  * EwWarpNativeRowBlend
2434  * EwScreenWarpNativeRowBlend
2435  *
2436  * DESCRIPTION:
2437  * The following function defines the low-level, pixel-wise drawing operation
2438  * to fill a horizontal pixel row with a transformed content of the source
2439  * surface. The new pixel will be alpha-blended with the existing pixel in the
2440  * destination memory.
2441  *
2442  * ARGUMENTS:
2443  * aDst - Pointer to the first pixel of the destination row.
2444  * aSrc - Pointer to the first pixel of the source surface.
2445  * aWidth - Width of the row.
2446  * aS, aT - Start values for the S and T texture mapping coordinates.
2447  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2448  * aSrcWidth,
2449  * aSrcHeight - Size of the source surface to warp.
2450  * aGradient - <Unused in this function>
2451  *
2452  * RETURN VALUE:
2453  * None
2454  *
2455  *******************************************************************************/
2456 void EwWarpNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2457  int aWidth, int aS, int aT, int aSS, int aTS,
2458  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2459 
2460 void EwScreenWarpNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2461  int aWidth, int aS, int aT, int aSS, int aTS,
2462  int aSrcWidth, int aSrcHeight,
2463  XGradient *aGradient);
2464 
2465 /*******************************************************************************
2466  * FUNCTION:
2467  * EwWarpNativeRowFilterBlend
2468  * EwScreenWarpNativeRowFilterBlend
2469  *
2470  * DESCRIPTION:
2471  * The following function defines the low-level, pixel-wise drawing operation
2472  * to fill a horizontal pixel row with a transformed content of the source
2473  * surface. For better output quality the source pixel are interpolated by a
2474  * bi-linear filter. The new pixel will be alpha-blended with the existing
2475  * pixel in the destination memory.
2476  *
2477  * ARGUMENTS:
2478  * aDst - Pointer to the first pixel of the destination row.
2479  * aSrc - Pointer to the first pixel of the source surface.
2480  * aWidth - Width of the row.
2481  * aS, aT - Start values for the S and T texture mapping coordinates.
2482  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2483  * aSrcWidth,
2484  * aSrcHeight - Size of the source surface to warp.
2485  * aGradient - <Unused in this function>
2486  *
2487  * RETURN VALUE:
2488  * None
2489  *
2490  *******************************************************************************/
2491 void EwWarpNativeRowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2492  int aWidth, int aS, int aT, int aSS, int aTS,
2493  int aSrcWidth, int aSrcHeight,
2494  XGradient *aGradient);
2495 
2496 void EwScreenWarpNativeRowFilterBlend(XSurfaceMemory *aDst,
2497  XSurfaceMemory *aSrc, int aWidth, int aS,
2498  int aT, int aSS, int aTS, int aSrcWidth,
2499  int aSrcHeight, XGradient *aGradient);
2500 
2501 /*******************************************************************************
2502  * FUNCTION:
2503  * EwWarpNativeRowGradient
2504  * EwWarpNativeRowSolid
2505  * EwScreenWarpNativeRowGradient
2506  * EwScreenWarpNativeRowSolid
2507  *
2508  * DESCRIPTION:
2509  * The following function defines the low-level, pixel-wise drawing operation
2510  * to fill a horizontal pixel row with a transformed content of the source
2511  * surface and modulate the pixel with opacity values from a gradient. The new
2512  * pixel will overwrite the existing pixel in the destination memory.
2513  *
2514  * ARGUMENTS:
2515  * aDst - Pointer to the first pixel of the destination row.
2516  * aSrc - Pointer to the first pixel of the source surface.
2517  * aWidth - Width of the row.
2518  * aS, aT - Start values for the S and T texture mapping coordinates.
2519  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2520  * aSrcWidth,
2521  * aSrcHeight - Size of the source surface to warp.
2522  * aGradient - Color gradient information.
2523  *
2524  * RETURN VALUE:
2525  * None
2526  *
2527  *******************************************************************************/
2528 void EwWarpNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2529  int aWidth, int aS, int aT, int aSS, int aTS,
2530  int aSrcWidth, int aSrcHeight,
2531  XGradient *aGradient);
2532 
2533 void EwWarpNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2534  int aWidth, int aS, int aT, int aSS, int aTS,
2535  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2536 
2537 void EwScreenWarpNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2538  int aWidth, int aS, int aT, int aSS, int aTS,
2539  int aSrcWidth, int aSrcHeight,
2540  XGradient *aGradient);
2541 
2542 void EwScreenWarpNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2543  int aWidth, int aS, int aT, int aSS, int aTS,
2544  int aSrcWidth, int aSrcHeight,
2545  XGradient *aGradient);
2546 
2547 /*******************************************************************************
2548  * FUNCTION:
2549  * EwWarpNativeRowFilterGradient
2550  * EwWarpNativeRowFilterSolid
2551  * EwScreenWarpNativeRowFilterGradient
2552  * EwScreenWarpNativeRowFilterSolid
2553  *
2554  * DESCRIPTION:
2555  * The following function defines the low-level, pixel-wise drawing operation
2556  * to fill a horizontal pixel row with a transformed content of the source
2557  * surface and modulate the pixel with opacity values from a gradient. For
2558  * better output quality the pixel are interpolated by a bi-linear filter. The
2559  * new pixel will overwrite the existing pixel in the destination memory.
2560  *
2561  * ARGUMENTS:
2562  * aDst - Pointer to the first pixel of the destination row.
2563  * aSrc - Pointer to the first pixel of the source surface.
2564  * aWidth - Width of the row.
2565  * aS, aT - Start values for the S and T texture mapping coordinates.
2566  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2567  * aSrcWidth,
2568  * aSrcHeight - Size of the source surface to warp.
2569  * aGradient - Color gradient information.
2570  *
2571  * RETURN VALUE:
2572  * None
2573  *
2574  *******************************************************************************/
2575 void EwWarpNativeRowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2576  int aWidth, int aS, int aT, int aSS, int aTS,
2577  int aSrcWidth, int aSrcHeight,
2578  XGradient *aGradient);
2579 
2580 void EwWarpNativeRowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2581  int aWidth, int aS, int aT, int aSS, int aTS,
2582  int aSrcWidth, int aSrcHeight,
2583  XGradient *aGradient);
2584 
2585 void EwScreenWarpNativeRowFilterGradient(XSurfaceMemory *aDst,
2586  XSurfaceMemory *aSrc, int aWidth,
2587  int aS, int aT, int aSS, int aTS,
2588  int aSrcWidth, int aSrcHeight,
2589  XGradient *aGradient);
2590 
2591 void EwScreenWarpNativeRowFilterSolid(XSurfaceMemory *aDst,
2592  XSurfaceMemory *aSrc, int aWidth, int aS,
2593  int aT, int aSS, int aTS, int aSrcWidth,
2594  int aSrcHeight, XGradient *aGradient);
2595 
2596 /*******************************************************************************
2597  * FUNCTION:
2598  * EwWarpNativeRowGradientBlend
2599  * EwWarpNativeRowSolidBlend
2600  * EwScreenWarpNativeRowGradientBlend
2601  * EwScreenWarpNativeRowSolidBlend
2602  *
2603  * DESCRIPTION:
2604  * The following function defines the low-level, pixel-wise drawing operation
2605  * to fill a horizontal pixel row with a transformed content of the source
2606  * surface and modulate the pixel with opacity values from a gradient. The
2607  * resulting pixel will be alpha-blended with the pixel in the destination
2608  * memory.
2609  *
2610  * ARGUMENTS:
2611  * aDst - Pointer to the first pixel of the destination row.
2612  * aSrc - Pointer to the first pixel of the source surface.
2613  * aWidth - Width of the row.
2614  * aS, aT - Start values for the S and T texture mapping coordinates.
2615  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2616  * aSrcWidth,
2617  * aSrcHeight - Size of the source surface to warp.
2618  * aGradient - Color gradient information.
2619  *
2620  * RETURN VALUE:
2621  * None
2622  *
2623  *******************************************************************************/
2624 void EwWarpNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2625  int aWidth, int aS, int aT, int aSS, int aTS,
2626  int aSrcWidth, int aSrcHeight,
2627  XGradient *aGradient);
2628 
2629 void EwWarpNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2630  int aWidth, int aS, int aT, int aSS, int aTS,
2631  int aSrcWidth, int aSrcHeight,
2632  XGradient *aGradient);
2633 
2634 void EwScreenWarpNativeRowGradientBlend(XSurfaceMemory *aDst,
2635  XSurfaceMemory *aSrc, int aWidth,
2636  int aS, int aT, int aSS, int aTS,
2637  int aSrcWidth, int aSrcHeight,
2638  XGradient *aGradient);
2639 
2640 void EwScreenWarpNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2641  int aWidth, int aS, int aT, int aSS,
2642  int aTS, int aSrcWidth, int aSrcHeight,
2643  XGradient *aGradient);
2644 
2645 /*******************************************************************************
2646  * FUNCTION:
2647  * EwWarpNativeRowFilterGradientBlend
2648  * EwWarpNativeRowFilterSolidBlend
2649  * EwScreenWarpNativeRowFilterGradientBlend
2650  * EwScreenWarpNativeRowFilterSolidBlend
2651  *
2652  * DESCRIPTION:
2653  * The following function defines the low-level, pixel-wise drawing operation
2654  * to fill a horizontal pixel row with a transformed content of the source
2655  * surface and modulate the pixel with opacity values from a gradient. For
2656  * better output quality the pixel are interpolated by a bi-linear filter.
2657  * The resulting pixel will be alpha-blended with the existing pixel in the
2658  * destination memory.
2659  *
2660  * ARGUMENTS:
2661  * aDst - Pointer to the first pixel of the destination row.
2662  * aSrc - Pointer to the first pixel of the source surface.
2663  * aWidth - Width of the row.
2664  * aS, aT - Start values for the S and T texture mapping coordinates.
2665  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2666  * aSrcWidth,
2667  * aSrcHeight - Size of the source surface to warp.
2668  * aGradient - Color gradient information.
2669  *
2670  * RETURN VALUE:
2671  * None
2672  *
2673  *******************************************************************************/
2674 void EwWarpNativeRowFilterGradientBlend(XSurfaceMemory *aDst,
2675  XSurfaceMemory *aSrc, int aWidth,
2676  int aS, int aT, int aSS, int aTS,
2677  int aSrcWidth, int aSrcHeight,
2678  XGradient *aGradient);
2679 
2680 void EwWarpNativeRowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2681  int aWidth, int aS, int aT, int aSS,
2682  int aTS, int aSrcWidth, int aSrcHeight,
2683  XGradient *aGradient);
2684 
2685 void EwScreenWarpNativeRowFilterGradientBlend(XSurfaceMemory *aDst,
2686  XSurfaceMemory *aSrc, int aWidth,
2687  int aS, int aT, int aSS, int aTS,
2688  int aSrcWidth, int aSrcHeight,
2689  XGradient *aGradient);
2690 
2691 void EwScreenWarpNativeRowFilterSolidBlend(XSurfaceMemory *aDst,
2692  XSurfaceMemory *aSrc, int aWidth,
2693  int aS, int aT, int aSS, int aTS,
2694  int aSrcWidth, int aSrcHeight,
2695  XGradient *aGradient);
2696 
2697 /*******************************************************************************
2698  * FUNCTION:
2699  * EwWarpIndex8Row
2700  * EwScreenWarpIndex8Row
2701  *
2702  * DESCRIPTION:
2703  * The following function defines the low-level, pixel-wise drawing operation
2704  * to fill a horizontal pixel row with a transformed content of the source
2705  * surface. The new pixel will overwrite the existing pixel in the destination
2706  * memory.
2707  *
2708  * ARGUMENTS:
2709  * aDst - Pointer to the first pixel of the destination row.
2710  * aSrc - Pointer to the first pixel of the source surface.
2711  * aWidth - Width of the row.
2712  * aS, aT - Start values for the S and T texture mapping coordinates.
2713  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2714  * aSrcWidth,
2715  * aSrcHeight - Size of the source surface to warp.
2716  * aGradient - <Unused in this function>
2717  *
2718  * RETURN VALUE:
2719  * None
2720  *
2721  *******************************************************************************/
2722 void EwWarpIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
2723  int aS, int aT, int aSS, int aTS, int aSrcWidth,
2724  int aSrcHeight, XGradient *aGradient);
2725 
2726 void EwScreenWarpIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2727  int aWidth, int aS, int aT, int aSS, int aTS,
2728  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2729 
2730 /*******************************************************************************
2731  * FUNCTION:
2732  * EwWarpIndex8RowFilter
2733  * EwScreenWarpIndex8RowFilter
2734  *
2735  * DESCRIPTION:
2736  * The following function defines the low-level, pixel-wise drawing operation
2737  * to fill a horizontal pixel row with a transformed content of the source
2738  * surface. For better output quality the source pixel are interpolated by a
2739  * bi-linear filter. The resulting pixel will overwrite the existing pixel in
2740  * the destination memory.
2741  *
2742  * ARGUMENTS:
2743  * aDst - Pointer to the first pixel of the destination row.
2744  * aSrc - Pointer to the first pixel of the source surface.
2745  * aWidth - Width of the row.
2746  * aS, aT - Start values for the S and T texture mapping coordinates.
2747  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2748  * aSrcWidth,
2749  * aSrcHeight - Size of the source surface to warp.
2750  * aGradient - <Unused in this function>
2751  *
2752  * RETURN VALUE:
2753  * None
2754  *
2755  *******************************************************************************/
2756 void EwWarpIndex8RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2757  int aWidth, int aS, int aT, int aSS, int aTS,
2758  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2759 
2760 void EwScreenWarpIndex8RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2761  int aWidth, int aS, int aT, int aSS, int aTS,
2762  int aSrcWidth, int aSrcHeight,
2763  XGradient *aGradient);
2764 
2765 /*******************************************************************************
2766  * FUNCTION:
2767  * EwWarpIndex8RowBlend
2768  * EwScreenWarpIndex8RowBlend
2769  *
2770  * DESCRIPTION:
2771  * The following function defines the low-level, pixel-wise drawing operation
2772  * to fill a horizontal pixel row with a transformed content of the source
2773  * surface. The new pixel will be alpha-blended with the existing pixel in the
2774  * destination memory.
2775  *
2776  * ARGUMENTS:
2777  * aDst - Pointer to the first pixel of the destination row.
2778  * aSrc - Pointer to the first pixel of the source surface.
2779  * aWidth - Width of the row.
2780  * aS, aT - Start values for the S and T texture mapping coordinates.
2781  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2782  * aSrcWidth,
2783  * aSrcHeight - Size of the source surface to warp.
2784  * aGradient - <Unused in this function>
2785  *
2786  * RETURN VALUE:
2787  * None
2788  *
2789  *******************************************************************************/
2790 void EwWarpIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2791  int aWidth, int aS, int aT, int aSS, int aTS,
2792  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2793 
2794 void EwScreenWarpIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2795  int aWidth, int aS, int aT, int aSS, int aTS,
2796  int aSrcWidth, int aSrcHeight,
2797  XGradient *aGradient);
2798 
2799 /*******************************************************************************
2800  * FUNCTION:
2801  * EwWarpIndex8RowFilterBlend
2802  * EwScreenWarpIndex8RowFilterBlend
2803  *
2804  * DESCRIPTION:
2805  * The following function defines the low-level, pixel-wise drawing operation
2806  * to fill a horizontal pixel row with a transformed content of the source
2807  * surface. For better output quality the source pixel are interpolated by a
2808  * bi-linear filter. The new pixel will be alpha-blended with the existing
2809  * pixel in the destination memory.
2810  *
2811  * ARGUMENTS:
2812  * aDst - Pointer to the first pixel of the destination row.
2813  * aSrc - Pointer to the first pixel of the source surface.
2814  * aWidth - Width of the row.
2815  * aS, aT - Start values for the S and T texture mapping coordinates.
2816  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2817  * aSrcWidth,
2818  * aSrcHeight - Size of the source surface to warp.
2819  * aGradient - <Unused in this function>
2820  *
2821  * RETURN VALUE:
2822  * None
2823  *
2824  *******************************************************************************/
2825 void EwWarpIndex8RowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2826  int aWidth, int aS, int aT, int aSS, int aTS,
2827  int aSrcWidth, int aSrcHeight,
2828  XGradient *aGradient);
2829 
2830 void EwScreenWarpIndex8RowFilterBlend(XSurfaceMemory *aDst,
2831  XSurfaceMemory *aSrc, int aWidth, int aS,
2832  int aT, int aSS, int aTS, int aSrcWidth,
2833  int aSrcHeight, XGradient *aGradient);
2834 
2835 /*******************************************************************************
2836  * FUNCTION:
2837  * EwWarpIndex8RowGradient
2838  * EwWarpIndex8RowSolid
2839  * EwScreenWarpIndex8RowGradient
2840  * EwScreenWarpIndex8RowSolid
2841  *
2842  * DESCRIPTION:
2843  * The following function defines the low-level, pixel-wise drawing operation
2844  * to fill a horizontal pixel row with a transformed content of the source
2845  * surface and modulate the pixel with opacity values from a gradient. The new
2846  * pixel will overwrite the existing pixel in the destination memory.
2847  *
2848  * ARGUMENTS:
2849  * aDst - Pointer to the first pixel of the destination row.
2850  * aSrc - Pointer to the first pixel of the source surface.
2851  * aWidth - Width of the row.
2852  * aS, aT - Start values for the S and T texture mapping coordinates.
2853  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2854  * aSrcWidth,
2855  * aSrcHeight - Size of the source surface to warp.
2856  * aGradient - Color gradient information.
2857  *
2858  * RETURN VALUE:
2859  * None
2860  *
2861  *******************************************************************************/
2862 void EwWarpIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2863  int aWidth, int aS, int aT, int aSS, int aTS,
2864  int aSrcWidth, int aSrcHeight,
2865  XGradient *aGradient);
2866 
2867 void EwWarpIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2868  int aWidth, int aS, int aT, int aSS, int aTS,
2869  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
2870 
2871 void EwScreenWarpIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2872  int aWidth, int aS, int aT, int aSS, int aTS,
2873  int aSrcWidth, int aSrcHeight,
2874  XGradient *aGradient);
2875 
2876 void EwScreenWarpIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2877  int aWidth, int aS, int aT, int aSS, int aTS,
2878  int aSrcWidth, int aSrcHeight,
2879  XGradient *aGradient);
2880 
2881 /*******************************************************************************
2882  * FUNCTION:
2883  * EwWarpIndex8RowFilterGradient
2884  * EwWarpIndex8RowFilterSolid
2885  * EwScreenWarpIndex8RowFilterGradient
2886  * EwScreenWarpIndex8RowFilterSolid
2887  *
2888  * DESCRIPTION:
2889  * The following function defines the low-level, pixel-wise drawing operation
2890  * to fill a horizontal pixel row with a transformed content of the source
2891  * surface and modulate the pixel with opacity values from a gradient. For
2892  * better output quality the pixel are interpolated by a bi-linear filter.
2893  * The new pixel will overwrite the existing pixel in the destination memory.
2894  *
2895  * ARGUMENTS:
2896  * aDst - Pointer to the first pixel of the destination row.
2897  * aSrc - Pointer to the first pixel of the source surface.
2898  * aWidth - Width of the row.
2899  * aS, aT - Start values for the S and T texture mapping coordinates.
2900  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2901  * aSrcWidth,
2902  * aSrcHeight - Size of the source surface to warp.
2903  * aGradient - Color gradient information.
2904  *
2905  * RETURN VALUE:
2906  * None
2907  *
2908  *******************************************************************************/
2909 void EwWarpIndex8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2910  int aWidth, int aS, int aT, int aSS, int aTS,
2911  int aSrcWidth, int aSrcHeight,
2912  XGradient *aGradient);
2913 
2914 void EwWarpIndex8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2915  int aWidth, int aS, int aT, int aSS, int aTS,
2916  int aSrcWidth, int aSrcHeight,
2917  XGradient *aGradient);
2918 
2919 void EwScreenWarpIndex8RowFilterGradient(XSurfaceMemory *aDst,
2920  XSurfaceMemory *aSrc, int aWidth,
2921  int aS, int aT, int aSS, int aTS,
2922  int aSrcWidth, int aSrcHeight,
2923  XGradient *aGradient);
2924 
2925 void EwScreenWarpIndex8RowFilterSolid(XSurfaceMemory *aDst,
2926  XSurfaceMemory *aSrc, int aWidth, int aS,
2927  int aT, int aSS, int aTS, int aSrcWidth,
2928  int aSrcHeight, XGradient *aGradient);
2929 
2930 /*******************************************************************************
2931  * FUNCTION:
2932  * EwWarpIndex8RowGradientBlend
2933  * EwWarpIndex8RowSolidBlend
2934  * EwScreenWarpIndex8RowGradientBlend
2935  * EwScreenWarpIndex8RowSolidBlend
2936  *
2937  * DESCRIPTION:
2938  * The following function defines the low-level, pixel-wise drawing operation
2939  * to fill a horizontal pixel row with a transformed content of the source
2940  * surface and modulate the pixel with opacity values from a gradient. The
2941  * resulting pixel will be alpha-blended with the pixel in the destination
2942  * memory.
2943  *
2944  * ARGUMENTS:
2945  * aDst - Pointer to the first pixel of the destination row.
2946  * aSrc - Pointer to the first pixel of the source surface.
2947  * aWidth - Width of the row.
2948  * aS, aT - Start values for the S and T texture mapping coordinates.
2949  * aSS, aTS - Per pixel increment for the interpolation of S and T.
2950  * aSrcWidth,
2951  * aSrcHeight - Size of the source surface to warp.
2952  * aGradient - Color gradient information.
2953  *
2954  * RETURN VALUE:
2955  * None
2956  *
2957  *******************************************************************************/
2958 void EwWarpIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2959  int aWidth, int aS, int aT, int aSS, int aTS,
2960  int aSrcWidth, int aSrcHeight,
2961  XGradient *aGradient);
2962 
2963 void EwWarpIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2964  int aWidth, int aS, int aT, int aSS, int aTS,
2965  int aSrcWidth, int aSrcHeight,
2966  XGradient *aGradient);
2967 
2968 void EwScreenWarpIndex8RowGradientBlend(XSurfaceMemory *aDst,
2969  XSurfaceMemory *aSrc, int aWidth,
2970  int aS, int aT, int aSS, int aTS,
2971  int aSrcWidth, int aSrcHeight,
2972  XGradient *aGradient);
2973 
2974 void EwScreenWarpIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
2975  int aWidth, int aS, int aT, int aSS,
2976  int aTS, int aSrcWidth, int aSrcHeight,
2977  XGradient *aGradient);
2978 
2979 /*******************************************************************************
2980  * FUNCTION:
2981  * EwWarpIndex8RowFilterGradientBlend
2982  * EwWarpIndex8RowFilterSolidBlend
2983  * EwScreenWarpIndex8RowFilterGradientBlend
2984  * EwScreenWarpIndex8RowFilterSolidBlend
2985  *
2986  * DESCRIPTION:
2987  * The following function defines the low-level, pixel-wise drawing operation
2988  * to fill a horizontal pixel row with a transformed content of the source
2989  * surface and modulate the pixel with opacity values from a gradient. For
2990  * better output quality the pixel are interpolated by a bi-linear filter.
2991  * The resulting pixel will be alpha-blended with the existing pixel in the
2992  * destination memory.
2993  *
2994  * ARGUMENTS:
2995  * aDst - Pointer to the first pixel of the destination row.
2996  * aSrc - Pointer to the first pixel of the source surface.
2997  * aWidth - Width of the row.
2998  * aS, aT - Start values for the S and T texture mapping coordinates.
2999  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3000  * aSrcWidth,
3001  * aSrcHeight - Size of the source surface to warp.
3002  * aGradient - Color gradient information.
3003  *
3004  * RETURN VALUE:
3005  * None
3006  *
3007  *******************************************************************************/
3008 void EwWarpIndex8RowFilterGradientBlend(XSurfaceMemory *aDst,
3009  XSurfaceMemory *aSrc, int aWidth,
3010  int aS, int aT, int aSS, int aTS,
3011  int aSrcWidth, int aSrcHeight,
3012  XGradient *aGradient);
3013 
3014 void EwWarpIndex8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3015  int aWidth, int aS, int aT, int aSS,
3016  int aTS, int aSrcWidth, int aSrcHeight,
3017  XGradient *aGradient);
3018 
3019 void EwScreenWarpIndex8RowFilterGradientBlend(XSurfaceMemory *aDst,
3020  XSurfaceMemory *aSrc, int aWidth,
3021  int aS, int aT, int aSS, int aTS,
3022  int aSrcWidth, int aSrcHeight,
3023  XGradient *aGradient);
3024 
3025 void EwScreenWarpIndex8RowFilterSolidBlend(XSurfaceMemory *aDst,
3026  XSurfaceMemory *aSrc, int aWidth,
3027  int aS, int aT, int aSS, int aTS,
3028  int aSrcWidth, int aSrcHeight,
3029  XGradient *aGradient);
3030 
3031 /*******************************************************************************
3032  * FUNCTION:
3033  * EwWarpAlpha8RowGradient
3034  * EwWarpAlpha8RowSolid
3035  * EwScreenWarpAlpha8RowGradient
3036  * EwScreenWarpAlpha8RowSolid
3037  *
3038  * DESCRIPTION:
3039  * The following function defines the low-level, pixel-wise drawing operation
3040  * to fill a horizontal pixel row with a transformed content of the source
3041  * surface and modulate the pixel with opacity values from a gradient. The new
3042  * pixel will overwrite the existing pixel in the destination memory.
3043  *
3044  * ARGUMENTS:
3045  * aDst - Pointer to the first pixel of the destination row.
3046  * aSrc - Pointer to the first pixel of the source surface.
3047  * aWidth - Width of the row.
3048  * aS, aT - Start values for the S and T texture mapping coordinates.
3049  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3050  * aSrcWidth,
3051  * aSrcHeight - Size of the source surface to warp.
3052  * aGradient - Color gradient information.
3053  *
3054  * RETURN VALUE:
3055  * None
3056  *
3057  *******************************************************************************/
3058 void EwWarpAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3059  int aWidth, int aS, int aT, int aSS, int aTS,
3060  int aSrcWidth, int aSrcHeight,
3061  XGradient *aGradient);
3062 
3063 void EwWarpAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3064  int aWidth, int aS, int aT, int aSS, int aTS,
3065  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
3066 
3067 void EwScreenWarpAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3068  int aWidth, int aS, int aT, int aSS, int aTS,
3069  int aSrcWidth, int aSrcHeight,
3070  XGradient *aGradient);
3071 
3072 void EwScreenWarpAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3073  int aWidth, int aS, int aT, int aSS, int aTS,
3074  int aSrcWidth, int aSrcHeight,
3075  XGradient *aGradient);
3076 
3077 /*******************************************************************************
3078  * FUNCTION:
3079  * EwWarpAlpha8RowFilterGradient
3080  * EwWarpAlpha8RowFilterSolid
3081  * EwScreenWarpAlpha8RowFilterGradient
3082  * EwScreenWarpAlpha8RowFilterSolid
3083  *
3084  * DESCRIPTION:
3085  * The following function defines the low-level, pixel-wise drawing operation
3086  * to fill a horizontal pixel row with a transformed content of the source
3087  * surface and modulate the pixel with opacity values from a gradient. For
3088  * better output quality the pixel are interpolated by a bi-linear filter. The
3089  * new pixel will overwrite the existing pixel in the destination memory.
3090  *
3091  * ARGUMENTS:
3092  * aDst - Pointer to the first pixel of the destination row.
3093  * aSrc - Pointer to the first pixel of the source surface.
3094  * aWidth - Width of the row.
3095  * aS, aT - Start values for the S and T texture mapping coordinates.
3096  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3097  * aSrcWidth,
3098  * aSrcHeight - Size of the source surface to warp.
3099  * aGradient - Color gradient information.
3100  *
3101  * RETURN VALUE:
3102  * None
3103  *
3104  *******************************************************************************/
3105 void EwWarpAlpha8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3106  int aWidth, int aS, int aT, int aSS, int aTS,
3107  int aSrcWidth, int aSrcHeight,
3108  XGradient *aGradient);
3109 
3110 void EwWarpAlpha8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3111  int aWidth, int aS, int aT, int aSS, int aTS,
3112  int aSrcWidth, int aSrcHeight,
3113  XGradient *aGradient);
3114 
3115 void EwScreenWarpAlpha8RowFilterGradient(XSurfaceMemory *aDst,
3116  XSurfaceMemory *aSrc, int aWidth,
3117  int aS, int aT, int aSS, int aTS,
3118  int aSrcWidth, int aSrcHeight,
3119  XGradient *aGradient);
3120 
3121 void EwScreenWarpAlpha8RowFilterSolid(XSurfaceMemory *aDst,
3122  XSurfaceMemory *aSrc, int aWidth, int aS,
3123  int aT, int aSS, int aTS, int aSrcWidth,
3124  int aSrcHeight, XGradient *aGradient);
3125 
3126 /*******************************************************************************
3127  * FUNCTION:
3128  * EwWarpAlpha8RowGradientBlend
3129  * EwWarpAlpha8RowSolidBlend
3130  * EwScreenWarpAlpha8RowGradientBlend
3131  * EwScreenWarpAlpha8RowSolidBlend
3132  *
3133  * DESCRIPTION:
3134  * The following function defines the low-level, pixel-wise drawing operation
3135  * to fill a horizontal pixel row with a transformed content of the source
3136  * surface and modulate the pixel with opacity values from a gradient. The
3137  * resulting pixel will be alpha-blended with the pixel in the destination
3138  * memory.
3139  *
3140  * ARGUMENTS:
3141  * aDst - Pointer to the first pixel of the destination row.
3142  * aSrc - Pointer to the first pixel of the source surface.
3143  * aWidth - Width of the row.
3144  * aS, aT - Start values for the S and T texture mapping coordinates.
3145  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3146  * aSrcWidth,
3147  * aSrcHeight - Size of the source surface to warp.
3148  * aGradient - Color gradient information.
3149  *
3150  * RETURN VALUE:
3151  * None
3152  *
3153  *******************************************************************************/
3154 void EwWarpAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3155  int aWidth, int aS, int aT, int aSS, int aTS,
3156  int aSrcWidth, int aSrcHeight,
3157  XGradient *aGradient);
3158 
3159 void EwWarpAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3160  int aWidth, int aS, int aT, int aSS, int aTS,
3161  int aSrcWidth, int aSrcHeight,
3162  XGradient *aGradient);
3163 
3164 void EwScreenWarpAlpha8RowGradientBlend(XSurfaceMemory *aDst,
3165  XSurfaceMemory *aSrc, int aWidth,
3166  int aS, int aT, int aSS, int aTS,
3167  int aSrcWidth, int aSrcHeight,
3168  XGradient *aGradient);
3169 
3170 void EwScreenWarpAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3171  int aWidth, int aS, int aT, int aSS,
3172  int aTS, int aSrcWidth, int aSrcHeight,
3173  XGradient *aGradient);
3174 
3175 /*******************************************************************************
3176  * FUNCTION:
3177  * EwWarpAlpha8RowFilterGradientBlend
3178  * EwWarpAlpha8RowFilterSolidBlend
3179  * EwScreenWarpAlpha8RowFilterGradientBlend
3180  * EwScreenWarpAlpha8RowFilterSolidBlend
3181  *
3182  * DESCRIPTION:
3183  * The following function defines the low-level, pixel-wise drawing operation
3184  * to fill a horizontal pixel row with a transformed content of the source
3185  * surface and modulate the pixel with opacity values from a gradient. For
3186  * better output quality the pixel are interpolated by a bi-linear filter.
3187  * The resulting pixel will be alpha-blended with the existing pixel in the
3188  * destination memory.
3189  *
3190  * ARGUMENTS:
3191  * aDst - Pointer to the first pixel of the destination row.
3192  * aSrc - Pointer to the first pixel of the source surface.
3193  * aWidth - Width of the row.
3194  * aS, aT - Start values for the S and T texture mapping coordinates.
3195  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3196  * aSrcWidth,
3197  * aSrcHeight - Size of the source surface to warp.
3198  * aGradient - Color gradient information.
3199  *
3200  * RETURN VALUE:
3201  * None
3202  *
3203  *******************************************************************************/
3204 void EwWarpAlpha8RowFilterGradientBlend(XSurfaceMemory *aDst,
3205  XSurfaceMemory *aSrc, int aWidth,
3206  int aS, int aT, int aSS, int aTS,
3207  int aSrcWidth, int aSrcHeight,
3208  XGradient *aGradient);
3209 
3210 void EwWarpAlpha8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3211  int aWidth, int aS, int aT, int aSS,
3212  int aTS, int aSrcWidth, int aSrcHeight,
3213  XGradient *aGradient);
3214 
3215 void EwScreenWarpAlpha8RowFilterGradientBlend(XSurfaceMemory *aDst,
3216  XSurfaceMemory *aSrc, int aWidth,
3217  int aS, int aT, int aSS, int aTS,
3218  int aSrcWidth, int aSrcHeight,
3219  XGradient *aGradient);
3220 
3221 void EwScreenWarpAlpha8RowFilterSolidBlend(XSurfaceMemory *aDst,
3222  XSurfaceMemory *aSrc, int aWidth,
3223  int aS, int aT, int aSS, int aTS,
3224  int aSrcWidth, int aSrcHeight,
3225  XGradient *aGradient);
3226 
3227 /*******************************************************************************
3228  * FUNCTION:
3229  * EwWarpRGB565Row
3230  * EwScreenWarpRGB565Row
3231  *
3232  * DESCRIPTION:
3233  * The following function defines the low-level, pixel-wise drawing operation
3234  * to fill a horizontal pixel row with a transformed content of the source
3235  * surface. The new pixel will overwrite the existing pixel in the destination
3236  * memory.
3237  *
3238  * ARGUMENTS:
3239  * aDst - Pointer to the first pixel of the destination row.
3240  * aSrc - Pointer to the first pixel of the source surface.
3241  * aWidth - Width of the row.
3242  * aS, aT - Start values for the S and T texture mapping coordinates.
3243  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3244  * aSrcWidth,
3245  * aSrcHeight - Size of the source surface to warp.
3246  * aGradient - <Unused in this function>
3247  *
3248  * RETURN VALUE:
3249  * None
3250  *
3251  *******************************************************************************/
3252 void EwWarpRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth,
3253  int aS, int aT, int aSS, int aTS, int aSrcWidth,
3254  int aSrcHeight, XGradient *aGradient);
3255 
3256 void EwScreenWarpRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3257  int aWidth, int aS, int aT, int aSS, int aTS,
3258  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
3259 
3260 /*******************************************************************************
3261  * FUNCTION:
3262  * EwWarpRGB565RowFilter
3263  * EwScreenWarpRGB565RowFilter
3264  *
3265  * DESCRIPTION:
3266  * The following function defines the low-level, pixel-wise drawing operation
3267  * to fill a horizontal pixel row with a transformed content of the source
3268  * surface. For better output quality the source pixel are interpolated by a
3269  * bi-linear filter. The resulting pixel will overwrite the existing pixel in
3270  * the destination memory.
3271  *
3272  * ARGUMENTS:
3273  * aDst - Pointer to the first pixel of the destination row.
3274  * aSrc - Pointer to the first pixel of the source surface.
3275  * aWidth - Width of the row.
3276  * aS, aT - Start values for the S and T texture mapping coordinates.
3277  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3278  * aSrcWidth,
3279  * aSrcHeight - Size of the source surface to warp.
3280  * aGradient - <Unused in this function>
3281  *
3282  * RETURN VALUE:
3283  * None
3284  *
3285  *******************************************************************************/
3286 void EwWarpRGB565RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3287  int aWidth, int aS, int aT, int aSS, int aTS,
3288  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
3289 
3290 void EwScreenWarpRGB565RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3291  int aWidth, int aS, int aT, int aSS, int aTS,
3292  int aSrcWidth, int aSrcHeight,
3293  XGradient *aGradient);
3294 
3295 /*******************************************************************************
3296  * FUNCTION:
3297  * EwWarpRGB565RowGradient
3298  * EwWarpRGB565RowSolid
3299  * EwScreenWarpRGB565RowGradient
3300  * EwScreenWarpRGB565RowSolid
3301  *
3302  * DESCRIPTION:
3303  * The following function defines the low-level, pixel-wise drawing operation
3304  * to fill a horizontal pixel row with a transformed content of the source
3305  * surface and modulate the pixel with opacity values from a gradient. The new
3306  * pixel will overwrite the existing pixel in the destination memory.
3307  *
3308  * ARGUMENTS:
3309  * aDst - Pointer to the first pixel of the destination row.
3310  * aSrc - Pointer to the first pixel of the source surface.
3311  * aWidth - Width of the row.
3312  * aS, aT - Start values for the S and T texture mapping coordinates.
3313  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3314  * aSrcWidth,
3315  * aSrcHeight - Size of the source surface to warp.
3316  * aGradient - Color gradient information.
3317  *
3318  * RETURN VALUE:
3319  * None
3320  *
3321  *******************************************************************************/
3322 void EwWarpRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3323  int aWidth, int aS, int aT, int aSS, int aTS,
3324  int aSrcWidth, int aSrcHeight,
3325  XGradient *aGradient);
3326 
3327 void EwWarpRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3328  int aWidth, int aS, int aT, int aSS, int aTS,
3329  int aSrcWidth, int aSrcHeight, XGradient *aGradient);
3330 
3331 void EwScreenWarpRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3332  int aWidth, int aS, int aT, int aSS, int aTS,
3333  int aSrcWidth, int aSrcHeight,
3334  XGradient *aGradient);
3335 
3336 void EwScreenWarpRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3337  int aWidth, int aS, int aT, int aSS, int aTS,
3338  int aSrcWidth, int aSrcHeight,
3339  XGradient *aGradient);
3340 
3341 /*******************************************************************************
3342  * FUNCTION:
3343  * EwWarpRGB565RowFilterGradient
3344  * EwWarpRGB565RowFilterSolid
3345  * EwScreenWarpRGB565RowFilterGradient
3346  * EwScreenWarpRGB565RowFilterSolid
3347  *
3348  * DESCRIPTION:
3349  * The following function defines the low-level, pixel-wise drawing operation
3350  * to fill a horizontal pixel row with a transformed content of the source
3351  * surface and modulate the pixel with opacity values from a gradient. For
3352  * better output quality the pixel are interpolated by a bi-linear filter.
3353  * The new pixel will overwrite the existing pixel in the destination memory.
3354  *
3355  * ARGUMENTS:
3356  * aDst - Pointer to the first pixel of the destination row.
3357  * aSrc - Pointer to the first pixel of the source surface.
3358  * aWidth - Width of the row.
3359  * aS, aT - Start values for the S and T texture mapping coordinates.
3360  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3361  * aSrcWidth,
3362  * aSrcHeight - Size of the source surface to warp.
3363  * aGradient - Color gradient information.
3364  *
3365  * RETURN VALUE:
3366  * None
3367  *
3368  *******************************************************************************/
3369 void EwWarpRGB565RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3370  int aWidth, int aS, int aT, int aSS, int aTS,
3371  int aSrcWidth, int aSrcHeight,
3372  XGradient *aGradient);
3373 
3374 void EwWarpRGB565RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3375  int aWidth, int aS, int aT, int aSS, int aTS,
3376  int aSrcWidth, int aSrcHeight,
3377  XGradient *aGradient);
3378 
3379 void EwScreenWarpRGB565RowFilterGradient(XSurfaceMemory *aDst,
3380  XSurfaceMemory *aSrc, int aWidth,
3381  int aS, int aT, int aSS, int aTS,
3382  int aSrcWidth, int aSrcHeight,
3383  XGradient *aGradient);
3384 
3385 void EwScreenWarpRGB565RowFilterSolid(XSurfaceMemory *aDst,
3386  XSurfaceMemory *aSrc, int aWidth, int aS,
3387  int aT, int aSS, int aTS, int aSrcWidth,
3388  int aSrcHeight, XGradient *aGradient);
3389 
3390 /*******************************************************************************
3391  * FUNCTION:
3392  * EwWarpRGB565RowGradientBlend
3393  * EwWarpRGB565RowSolidBlend
3394  * EwScreenWarpRGB565RowGradientBlend
3395  * EwScreenWarpRGB565RowSolidBlend
3396  *
3397  * DESCRIPTION:
3398  * The following function defines the low-level, pixel-wise drawing operation
3399  * to fill a horizontal pixel row with a transformed content of the source
3400  * surface and modulate the pixel with opacity values from a gradient. The
3401  * resulting pixel will be alpha-blended with the pixel in the destination
3402  * memory.
3403  *
3404  * ARGUMENTS:
3405  * aDst - Pointer to the first pixel of the destination row.
3406  * aSrc - Pointer to the first pixel of the source surface.
3407  * aWidth - Width of the row.
3408  * aS, aT - Start values for the S and T texture mapping coordinates.
3409  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3410  * aSrcWidth,
3411  * aSrcHeight - Size of the source surface to warp.
3412  * aGradient - Color gradient information.
3413  *
3414  * RETURN VALUE:
3415  * None
3416  *
3417  *******************************************************************************/
3418 void EwWarpRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3419  int aWidth, int aS, int aT, int aSS, int aTS,
3420  int aSrcWidth, int aSrcHeight,
3421  XGradient *aGradient);
3422 
3423 void EwWarpRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3424  int aWidth, int aS, int aT, int aSS, int aTS,
3425  int aSrcWidth, int aSrcHeight,
3426  XGradient *aGradient);
3427 
3428 void EwScreenWarpRGB565RowGradientBlend(XSurfaceMemory *aDst,
3429  XSurfaceMemory *aSrc, int aWidth,
3430  int aS, int aT, int aSS, int aTS,
3431  int aSrcWidth, int aSrcHeight,
3432  XGradient *aGradient);
3433 
3434 void EwScreenWarpRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3435  int aWidth, int aS, int aT, int aSS,
3436  int aTS, int aSrcWidth, int aSrcHeight,
3437  XGradient *aGradient);
3438 
3439 /*******************************************************************************
3440  * FUNCTION:
3441  * EwWarpRGB565RowFilterGradientBlend
3442  * EwWarpRGB565RowFilterSolidBlend
3443  * EwScreenWarpRGB565RowFilterGradientBlend
3444  * EwScreenWarpRGB565RowFilterSolidBlend
3445  *
3446  * DESCRIPTION:
3447  * The following function defines the low-level, pixel-wise drawing operation
3448  * to fill a horizontal pixel row with a transformed content of the source
3449  * surface and modulate the pixel with opacity values from a gradient. For
3450  * better output quality the pixel are interpolated by a bi-linear filter.
3451  * The resulting pixel will be alpha-blended with the existing pixel in the
3452  * destination memory.
3453  *
3454  * ARGUMENTS:
3455  * aDst - Pointer to the first pixel of the destination row.
3456  * aSrc - Pointer to the first pixel of the source surface.
3457  * aWidth - Width of the row.
3458  * aS, aT - Start values for the S and T texture mapping coordinates.
3459  * aSS, aTS - Per pixel increment for the interpolation of S and T.
3460  * aSrcWidth,
3461  * aSrcHeight - Size of the source surface to warp.
3462  * aGradient - Color gradient information.
3463  *
3464  * RETURN VALUE:
3465  * None
3466  *
3467  *******************************************************************************/
3468 void EwWarpRGB565RowFilterGradientBlend(XSurfaceMemory *aDst,
3469  XSurfaceMemory *aSrc, int aWidth,
3470  int aS, int aT, int aSS, int aTS,
3471  int aSrcWidth, int aSrcHeight,
3472  XGradient *aGradient);
3473 
3474 void EwWarpRGB565RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc,
3475  int aWidth, int aS, int aT, int aSS,
3476  int aTS, int aSrcWidth, int aSrcHeight,
3477  XGradient *aGradient);
3478 
3479 void EwScreenWarpRGB565RowFilterGradientBlend(XSurfaceMemory *aDst,
3480  XSurfaceMemory *aSrc, int aWidth,
3481  int aS, int aT, int aSS, int aTS,
3482  int aSrcWidth, int aSrcHeight,
3483  XGradient *aGradient);
3484 
3485 void EwScreenWarpRGB565RowFilterSolidBlend(XSurfaceMemory *aDst,
3486  XSurfaceMemory *aSrc, int aWidth,
3487  int aS, int aT, int aSS, int aTS,
3488  int aSrcWidth, int aSrcHeight,
3489  XGradient *aGradient);
3490 
3491 /*******************************************************************************
3492  * FUNCTION:
3493  * EwAllocVideo
3494  *
3495  * DESCRIPTION:
3496  * The function EwAllocVideo() has the job to reserve a block of memory which
3497  * is exclusively intended for pure software surfaces.
3498  *
3499  * The large size and the persistent character of surfaces may expect special
3500  * heap management and algorithms. The intension of this function is to handle
3501  * surface memory allocations in a separate way of any other allocations.
3502  *
3503  * ARGUMENTS:
3504  * aSize - Desired size of the new memory block in bytes.
3505  *
3506  * RETURN VALUE:
3507  * If successful, returns the pointer to the reserved memory block, otherwise
3508  * null is returned.
3509  *
3510  *******************************************************************************/
3511 void *EwAllocVideo(int aSize);
3512 
3513 /*******************************************************************************
3514  * FUNCTION:
3515  * EwFreeVideo
3516  *
3517  * DESCRIPTION:
3518  * The function EwFreeVideo() is the counterpart of EwAllocVideo() function.
3519  * Its job is to release the given memory block.
3520  *
3521  * The large size and the persistent character of surfaces may expect special
3522  * heap management and algorithms. The intension of this function is to handle
3523  * surface memory allocations in a separate way of any other allocations.
3524  *
3525  * ARGUMENTS:
3526  * aMemory - Address of the memory block to release.
3527  *
3528  * RETURN VALUE:
3529  * None
3530  *
3531  *******************************************************************************/
3532 void EwFreeVideo(void *aMemory);
3533 
3534 /*******************************************************************************
3535  * MACRO:
3536  * EW_REDIRECT_WARP_FUNC
3537  *
3538  * DESCRIPTION:
3539  * The macro EW_REDIRECT_WARP_FUNC defines a new function as wrapper to an
3540  * already existing warp operations implemented in another function.
3541  *
3542  * This macro is used in Software Pixel Driver modules implementing limited
3543  * set of possible warp operations. The wrapper function created by the macro
3544  * takes care of the right redirection of the operation to the corresponding
3545  * worker function.
3546  *
3547  * ARGUMENTS:
3548  * aFunc1 - Function to serve as the entry point for the operation.
3549  * aFunc2 - Function, which should be called by the wrapper.
3550  *
3551  *******************************************************************************/
3552 #define EW_REDIRECT_WARP_FUNC(aFunc1, aFunc2) \
3553  void aFunc1(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, \
3554  int aS, int aT, int aSS, int aTS, int aSrcWidth, \
3555  int aSrcHeight, XGradient *aGradient) \
3556  { \
3557  aFunc2(aDst, aSrc, aWidth, aS, aT, aSS, aTS, aSrcWidth, aSrcHeight, \
3558  aGradient); \
3559  }
3560 
3561 #ifdef __cplusplus
3562 }
3563 #endif
3564 
3565 #endif /* EWGFXDRIVER_H */
3566 
3567 /* pba */
EwCopyNativeRowBlend
void EwCopyNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
XSurfaceMemory
Definition: ewgfxdriver.h:186
EwScreenWarpIndex8RowFilterGradientBlend
void EwScreenWarpIndex8RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwGetOpacityFromGradient
unsigned int EwGetOpacityFromGradient(XGradient *aGradient, int aX, int aY)
EwScreenCopyIndex8RowGradient
void EwScreenCopyIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpRGB565RowGradientBlend
void EwScreenWarpRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyAlpha8RowSolid
void EwCopyAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwDestroyNativeSurface
void EwDestroyNativeSurface(unsigned long aSurface)
EwWarpNativeRowFilterGradientBlend
void EwWarpNativeRowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpIndex8RowFilterGradient
void EwWarpIndex8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpIndex8RowFilterSolidBlend
void EwWarpIndex8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyNativeRowGradientBlend
void EwCopyNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenCopyAlpha8RowSolid
void EwScreenCopyAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpNativeRowFilterBlend
void EwWarpNativeRowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpIndex8RowFilterGradientBlend
void EwWarpIndex8RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpAlpha8RowSolid
void EwWarpAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwEmulateLine
void EwEmulateLine(XSurfaceMemory *aDst, int aDstX1, int aDstY1, int aDstX2, int aDstY2, int aClipX1, int aClipY1, int aClipX2, int aClipY2, XGradient *aGradient, XLineWorker aWorker)
XCopyDriver
void(* XCopyDriver)(unsigned long aDstHandle, unsigned long aSrcHandle, int aDstX, int aDstY, int aSrcX, int aSrcY, int aWidth, int aHeight, int aBlend, unsigned long *aColors)
Definition: ewgfxdriver.h:416
EwWarpIndex8RowBlend
void EwWarpIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyNativeRowSolidBlend
void EwScreenCopyNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpIndex8RowSolidBlend
void EwScreenWarpIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwEmulateCopy
void EwEmulateCopy(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aDstX, int aDstY, int aWidth, int aHeight, int aSrcX, int aSrcY, XGradient *aGradient, int aGrdX, int aGrdY, XCopyWorker aWorker)
EwScreenCopyNativeRowGradient
void EwScreenCopyNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpRGB565RowSolid
void EwScreenWarpRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpRGB565RowGradient
void EwScreenWarpRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpAlpha8RowSolidBlend
void EwWarpAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowGradientBlend
void EwScreenWarpIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwGetAlpha8SurfaceMemory
int EwGetAlpha8SurfaceMemory(unsigned long aSurface, int aX, int aY, int aReserved, int aWriteAccess, XSurfaceMemory *aMemory)
EwScreenCopyIndex8RowBlend
void EwScreenCopyIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8Row
void EwWarpIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwDestroyRGB565Surface
void EwDestroyRGB565Surface(unsigned long aSurface)
EwAllocVideo
void * EwAllocVideo(int aSize)
EwWarpRGB565RowFilterGradient
void EwWarpRGB565RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpIndex8RowGradient
void EwWarpIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowGradient
void EwScreenWarpNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowFilterSolidBlend
void EwScreenWarpNativeRowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCreateAlpha8Surface
unsigned long EwCreateAlpha8Surface(int aWidth, int aHeight)
EwWarpAlpha8RowFilterSolidBlend
void EwWarpAlpha8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyNativeRow
void EwCopyNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwGetNativeSurfaceMemSize
int EwGetNativeSurfaceMemSize(int aWidth, int aHeight)
EwScreenCopyAlpha8RowSolidBlend
void EwScreenCopyAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwPackColor
unsigned int EwPackColor(int aRed, int aGreen, int aBlue, int aAlpha)
XCopyWorker
void(* XCopyWorker)(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
Definition: ewgfxdriver.h:288
EwScreenWarpIndex8RowFilterBlend
void EwScreenWarpIndex8RowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpNativeRow
void EwWarpNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowBlend
void EwScreenWarpNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyNativeRowSolidBlend
void EwCopyNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwGetScreenSurfaceMemSize
int EwGetScreenSurfaceMemSize(int aWidth, int aHeight)
void
XRect CoreOutline aOutline void(CoreRoot _this, GraphicsCanvas aCanvas, XRect aClip, XPoint aOffset, XInt32 aOpacity, XBool aBlend) EW_METHOD(HandleEvent
EwCreateConstAlpha8Surface
unsigned long EwCreateConstAlpha8Surface(int aWidth, int aHeight, XSurfaceMemory *aMemory)
EwDestroyScreenSurface
void EwDestroyScreenSurface(unsigned long aSurface)
EwEmulateFillPolygon
void EwEmulateFillPolygon(XSurfaceMemory *aDst, int *aPaths, int aDstX, int aDstY, int aWidth, int aHeight, int aAntialiased, int aNonZeroWinding, XGradient *aGradient, int aGrdX, int aGrdY, XCopyWorker aWorker)
EwCreateConstIndex8Surface
unsigned long EwCreateConstIndex8Surface(int aWidth, int aHeight, XSurfaceMemory *aMemory)
EwCopyIndex8RowSolidBlend
void EwCopyIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8RowFilterBlend
void EwWarpIndex8RowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowSolidBlend
void EwScreenWarpNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwDestroyAlpha8Surface
void EwDestroyAlpha8Surface(unsigned long aSurface)
EwWarpRGB565RowSolid
void EwWarpRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyRGB565RowGradient
void EwScreenCopyRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8RowFilter
void EwWarpIndex8RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCreateScreenSurface
unsigned long EwCreateScreenSurface(int aWidth, int aHeight)
EwScreenWarpRGB565RowFilterSolidBlend
void EwScreenWarpRGB565RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwPixelDriverVariant
const int EwPixelDriverVariant
EwScreenWarpNativeRowFilterBlend
void EwScreenWarpNativeRowFilterBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyNativeRowSolid
void EwScreenCopyNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwFillRowSolidBlend
void EwFillRowSolidBlend(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwWarpNativeRowFilter
void EwWarpNativeRowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenSetPixelSolid
void EwScreenSetPixelSolid(XSurfaceMemory *aDst, int aX, int aY, XGradient *aGradient)
EwWarpAlpha8RowFilterGradient
void EwWarpAlpha8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpNativeRowGradientBlend
void EwWarpNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowGradient
void EwScreenWarpIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyNativeRowSolid
void EwCopyNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpAlpha8RowFilterSolid
void EwScreenWarpAlpha8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyRGB565RowSolidBlend
void EwScreenCopyRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpNativeRowBlend
void EwWarpNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
XPolygonDriver
void(* XPolygonDriver)(unsigned long aDstHandle, int *aPaths, int aDstX, int aDstY, int aWidth, int aHeight, int aBlend, int aAntialiased, int aNonZeroWinding, unsigned long *aColors)
Definition: ewgfxdriver.h:565
EwCopyRGB565RowSolid
void EwCopyRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCopyAlpha8RowGradientBlend
void EwCopyAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8RowFilterSolid
void EwWarpIndex8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwSetPixelSolid
void EwSetPixelSolid(XSurfaceMemory *aDst, int aX, int aY, XGradient *aGradient)
EwScreenWarpAlpha8RowSolidBlend
void EwScreenWarpAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpAlpha8RowFilterGradient
void EwScreenWarpAlpha8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCreateRGB565Surface
unsigned long EwCreateRGB565Surface(int aWidth, int aHeight)
EwScreenWarpRGB565RowFilter
void EwScreenWarpRGB565RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwGetColorFromGradient
unsigned int EwGetColorFromGradient(XGradient *aGradient, int aX, int aY)
XWarpDriver
void(* XWarpDriver)(unsigned long aDstHandle, unsigned long aSrcHandle, float aDstX1, float aDstY1, float aDstW1, float aDstX2, float aDstY2, float aDstW2, float aDstX3, float aDstY3, float aDstW3, float aDstX4, float aDstY4, float aDstW4, int aSrcX, int aSrcY, int aSrcWidth, int aSrcHeight, int aClipX, int aClipY, int aClipWidth, int aClipHeight, int aBlend, int aFilter, unsigned long *aColors)
Definition: ewgfxdriver.h:507
EwScreenCopyIndex8Row
void EwScreenCopyIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenCopyNativeRowBlend
void EwScreenCopyNativeRowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpNativeRow
void EwScreenWarpNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyIndex8RowBlend
void EwCopyIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8RowSolid
void EwWarpIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpAlpha8RowGradientBlend
void EwScreenWarpAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpRGB565RowFilterGradient
void EwScreenWarpRGB565RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwSetPixelSolidBlend
void EwSetPixelSolidBlend(XSurfaceMemory *aDst, int aX, int aY, XGradient *aGradient)
EwWarpRGB565RowFilter
void EwWarpRGB565RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpAlpha8RowFilterSolid
void EwWarpAlpha8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenFillRowSolidBlend
void EwScreenFillRowSolidBlend(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwScreenWarpNativeRowGradientBlend
void EwScreenWarpNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowSolid
void EwScreenWarpNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowBlend
void EwScreenWarpIndex8RowBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
XTileDriver
void(* XTileDriver)(unsigned long aDstHandle, unsigned long aSrcHandle, int aDstX, int aDstY, int aDstWidth, int aDstHeight, int aSrcX, int aSrcY, int aSrcWidth, int aSrcHeight, int aOfsX, int aOfsY, int aBlend, unsigned long *aColors)
Definition: ewgfxdriver.h:453
EwScreenWarpIndex8RowSolid
void EwScreenWarpIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpRGB565RowGradient
void EwWarpRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenFillRowSolid
void EwScreenFillRowSolid(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwWarpRGB565RowGradientBlend
void EwWarpRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyNativeRow
void EwScreenCopyNativeRow(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpNativeRowSolidBlend
void EwWarpNativeRowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyIndex8RowSolidBlend
void EwScreenCopyIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenSetPixelSolidBlend
void EwScreenSetPixelSolidBlend(XSurfaceMemory *aDst, int aX, int aY, XGradient *aGradient)
EwCreateIndex8Surface
unsigned long EwCreateIndex8Surface(int aWidth, int aHeight)
EwCopyIndex8RowGradientBlend
void EwCopyIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenCopyNativeRowGradientBlend
void EwScreenCopyNativeRowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenCopyAlpha8RowGradientBlend
void EwScreenCopyAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCopyRGB565RowSolidBlend
void EwCopyRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCopyRGB565RowGradientBlend
void EwCopyRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpNativeRowFilterGradientBlend
void EwScreenWarpNativeRowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowFilterGradient
void EwScreenWarpIndex8RowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpRGB565RowSolidBlend
void EwScreenWarpRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpRGB565RowFilterGradientBlend
void EwScreenWarpRGB565RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyNativeRowGradient
void EwCopyNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCreateConstNativeSurface
unsigned long EwCreateConstNativeSurface(int aWidth, int aHeight, XSurfaceMemory *aMemory)
EwInitOpacityGradient
void EwInitOpacityGradient(int aWidth, int aHeight, unsigned int *aColors, XGradient *aGradient)
EwWarpIndex8RowGradientBlend
void EwWarpIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowFilterSolid
void EwScreenWarpIndex8RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowFilter
void EwScreenWarpIndex8RowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwGetAlpha8SurfaceMemSize
int EwGetAlpha8SurfaceMemSize(int aWidth, int aHeight)
EwWarpNativeRowFilterGradient
void EwWarpNativeRowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwRasterAlpha8Polygon
void EwRasterAlpha8Polygon(XSurfaceMemory *aDst, int *aPaths, int aDstX, int aDstY, int aWidth, int aHeight, int aX, int aY, int aAntialiased, int aNonZeroWinding)
EwGetScreenSurfaceMemory
int EwGetScreenSurfaceMemory(unsigned long aSurface, int aX, int aY, int aReserved, int aWriteAccess, XSurfaceMemory *aMemory)
EwWarpRGB565Row
void EwWarpRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyAlpha8RowGradient
void EwCopyAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCopyIndex8RowGradient
void EwCopyIndex8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpNativeRowFilter
void EwScreenWarpNativeRowFilter(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpAlpha8RowGradient
void EwWarpAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyRGB565Row
void EwScreenCopyRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwDestroyIndex8Surface
void EwDestroyIndex8Surface(unsigned long aSurface)
EwScreenCopyRGB565RowGradientBlend
void EwScreenCopyRGB565RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwPackClutEntry
unsigned int EwPackClutEntry(int aRed, int aGreen, int aBlue, int aAlpha)
EwGetIndex8SurfaceMemory
int EwGetIndex8SurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex, int aWriteAccess, XSurfaceMemory *aMemory)
EwScreenWarpAlpha8RowFilterGradientBlend
void EwScreenWarpAlpha8RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwEmulateWarp
void EwEmulateWarp(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aDstX1, int aDstY1, int aDstW1, int aDstX2, int aDstY2, int aDstW2, int aDstX3, int aDstY3, int aDstW3, int aDstX4, int aDstY4, int aDstW4, int aSrcX, int aSrcY, int aSrcWidth, int aSrcHeight, int aClipX1, int aClipY1, int aClipX2, int aClipY2, XGradient *aGradient, XWarpWorker aWorker)
EwGetIndex8SurfaceMemSize
int EwGetIndex8SurfaceMemSize(int aWidth, int aHeight)
EwWarpRGB565RowSolidBlend
void EwWarpRGB565RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
XWarpWorker
void(* XWarpWorker)(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
Definition: ewgfxdriver.h:316
EwWarpNativeRowGradient
void EwWarpNativeRowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenFillRowGradientBlend
void EwScreenFillRowGradientBlend(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwCreateConstRGB565Surface
unsigned long EwCreateConstRGB565Surface(int aWidth, int aHeight, XSurfaceMemory *aMemory)
EwCopyAlpha8RowSolidBlend
void EwCopyAlpha8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
XGradient
Definition: ewgfxdriver.h:217
XLineDriver
void(* XLineDriver)(unsigned long aDstHandle, int aDstX1, int aDstY1, int aDstX2, int aDstY2, int aClipX, int aClipY, int aClipWidth, int aClipHeight, int aBlend, unsigned long *aColors)
Definition: ewgfxdriver.h:353
EwScreenWarpNativeRowFilterSolid
void EwScreenWarpNativeRowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwFreeVideo
void EwFreeVideo(void *aMemory)
XFillDriver
void(* XFillDriver)(unsigned long aDstHandle, int aDstX, int aDstY, int aWidth, int aHeight, int aBlend, unsigned long *aColors)
Definition: ewgfxdriver.h:383
EwGetNativeSurfaceMemory
int EwGetNativeSurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex, int aWriteAccess, XSurfaceMemory *aMemory)
EwScreenWarpAlpha8RowGradient
void EwScreenWarpAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpNativeRowSolid
void EwWarpNativeRowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
XLineWorker
void(* XLineWorker)(XSurfaceMemory *aDst, int aX, int aY, XGradient *aGradient)
Definition: ewgfxdriver.h:247
EwScreenWarpRGB565RowFilterSolid
void EwScreenWarpRGB565RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8RowFilterSolidBlend
void EwScreenWarpIndex8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpNativeRowFilterGradient
void EwScreenWarpNativeRowFilterGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyIndex8RowGradientBlend
void EwScreenCopyIndex8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwFillRowGradientBlend
void EwFillRowGradientBlend(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwScreenWarpAlpha8RowFilterSolidBlend
void EwScreenWarpAlpha8RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwFillRowSolid
void EwFillRowSolid(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwGetRGB565SurfaceMemory
int EwGetRGB565SurfaceMemory(unsigned long aSurface, int aX, int aY, int aIndex, int aWriteAccess, XSurfaceMemory *aMemory)
EwWarpAlpha8RowFilterGradientBlend
void EwWarpAlpha8RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyAlpha8RowGradient
void EwScreenCopyAlpha8RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpNativeRowFilterSolidBlend
void EwWarpNativeRowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyIndex8RowSolid
void EwCopyIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpRGB565Row
void EwScreenWarpRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwGetRGB565SurfaceMemSize
int EwGetRGB565SurfaceMemSize(int aWidth, int aHeight)
EwCopyRGB565Row
void EwCopyRGB565Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwCopyRGB565RowGradient
void EwCopyRGB565RowGradient(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpIndex8RowSolidBlend
void EwWarpIndex8RowSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyRGB565RowSolid
void EwScreenCopyRGB565RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
aBlend
XRect CoreOutline aOutline GraphicsCanvas XRect XPoint XInt32 XBool aBlend
Definition: _CoreOutline.h:172
XFillWorker
void(* XFillWorker)(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
Definition: ewgfxdriver.h:267
EwWarpNativeRowFilterSolid
void EwWarpNativeRowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwCopyIndex8Row
void EwCopyIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwScreenWarpAlpha8RowSolid
void EwScreenWarpAlpha8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenCopyIndex8RowSolid
void EwScreenCopyIndex8RowSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, XGradient *aGradient)
EwWarpAlpha8RowGradientBlend
void EwWarpAlpha8RowGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenWarpIndex8Row
void EwScreenWarpIndex8Row(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpRGB565RowFilterSolid
void EwWarpRGB565RowFilterSolid(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwWarpRGB565RowFilterGradientBlend
void EwWarpRGB565RowFilterGradientBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwScreenFillRowGradient
void EwScreenFillRowGradient(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)
EwEmulateFill
void EwEmulateFill(XSurfaceMemory *aDst, int aDstX, int aDstY, int aWidth, int aHeight, XGradient *aGradient, int aGrdX, int aGrdY, XFillWorker aWorker)
EwInitColorGradient
void EwInitColorGradient(int aWidth, int aHeight, unsigned int *aColors, XGradient *aGradient)
EwCreateNativeSurface
unsigned long EwCreateNativeSurface(int aWidth, int aHeight)
EwWarpRGB565RowFilterSolidBlend
void EwWarpRGB565RowFilterSolidBlend(XSurfaceMemory *aDst, XSurfaceMemory *aSrc, int aWidth, int aS, int aT, int aSS, int aTS, int aSrcWidth, int aSrcHeight, XGradient *aGradient)
EwFillRowGradient
void EwFillRowGradient(XSurfaceMemory *aDst, int aWidth, XGradient *aGradient)