1 /***************************************************************************
2 * Copyright (c) 2024 Microsoft Corporation
3 *
4 * This program and the accompanying materials are made available under the
5 * terms of the MIT License which is available at
6 * https://opensource.org/licenses/MIT.
7 *
8 * SPDX-License-Identifier: MIT
9 **************************************************************************/
10
11
12 /**************************************************************************/
13 /**************************************************************************/
14 /** */
15 /** GUIX Component */
16 /** */
17 /** Display Management (Display) */
18 /** */
19 /**************************************************************************/
20
21 #define GX_SOURCE_CODE
22
23
24 /* Include necessary system files. */
25
26 #include "gx_api.h"
27 #include "gx_display.h"
28 #include "gx_context.h"
29
30 /**************************************************************************/
31 /* */
32 /* FUNCTION RELEASE */
33 /* */
34 /* _gx_display_driver_8bpp_rotated_pixelmap_raw_write PORTABLE C */
35 /* 6.1.4 */
36 /* AUTHOR */
37 /* */
38 /* Kenneth Maxwell, Microsoft Corporation */
39 /* */
40 /* DESCRIPTION */
41 /* */
42 /* Internal helper function that handles writing of uncompressed */
43 /* pixlemap file without alpha channel. */
44 /* */
45 /* INPUT */
46 /* */
47 /* context Drawing context */
48 /* xpos x-coord of top-left draw point*/
49 /* ypos y-coord of top-left draw point*/
50 /* pixelmap Pointer to GX_PIXELMAP struct */
51 /* */
52 /* OUTPUT */
53 /* */
54 /* None */
55 /* */
56 /* CALLED BY */
57 /* */
58 /* GUIX Internal Code */
59 /* */
60 /* RELEASE HISTORY */
61 /* */
62 /* DATE NAME DESCRIPTION */
63 /* */
64 /* 02-02-2021 Kenneth Maxwell Initial Version 6.1.4 */
65 /* */
66 /**************************************************************************/
_gx_display_driver_8bpp_rotated_pixelmap_raw_write(GX_DRAW_CONTEXT * context,INT xpos,INT ypos,GX_PIXELMAP * pixelmap)67 static VOID _gx_display_driver_8bpp_rotated_pixelmap_raw_write(GX_DRAW_CONTEXT *context,
68 INT xpos, INT ypos, GX_PIXELMAP *pixelmap)
69 {
70 INT xval;
71 INT yval;
72 GX_UBYTE *putrow;
73 GX_UBYTE *getrow;
74 GX_UBYTE *put;
75 GX_CONST GX_UBYTE *get;
76
77 GX_RECTANGLE *clip = context -> gx_draw_context_clip;
78 GX_RECTANGLE rotated_clip;
79
80 GX_SWAP_VALS(xpos, ypos);
81
82 if (context -> gx_draw_context_display -> gx_display_rotation_angle == GX_SCREEN_ROTATION_CW)
83 {
84 rotated_clip.gx_rectangle_left = clip -> gx_rectangle_top;
85 rotated_clip.gx_rectangle_right = clip -> gx_rectangle_bottom;
86 rotated_clip.gx_rectangle_top = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_right - 1);
87 rotated_clip.gx_rectangle_bottom = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_left - 1);
88 ypos = (context -> gx_draw_context_canvas -> gx_canvas_x_resolution - ypos - pixelmap -> gx_pixelmap_width);
89 }
90 else
91 {
92 rotated_clip.gx_rectangle_left = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_bottom - 1);
93 rotated_clip.gx_rectangle_right = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_top - 1);
94 rotated_clip.gx_rectangle_top = clip -> gx_rectangle_left;
95 rotated_clip.gx_rectangle_bottom = clip -> gx_rectangle_right;
96 xpos = (context -> gx_draw_context_canvas -> gx_canvas_y_resolution - xpos - pixelmap -> gx_pixelmap_height);
97 }
98
99 putrow = (GX_UBYTE *)context -> gx_draw_context_memory;
100 putrow += rotated_clip.gx_rectangle_top * context -> gx_draw_context_pitch;
101 putrow += rotated_clip.gx_rectangle_left;
102
103 getrow = (GX_UBYTE *)(pixelmap -> gx_pixelmap_data);
104 getrow += pixelmap -> gx_pixelmap_height * (rotated_clip.gx_rectangle_top - ypos);
105 getrow += (rotated_clip.gx_rectangle_left - xpos);
106
107 for (yval = rotated_clip.gx_rectangle_top; yval <= rotated_clip.gx_rectangle_bottom; yval++)
108 {
109 put = putrow;
110 get = getrow;
111
112 for (xval = rotated_clip.gx_rectangle_left; xval <= rotated_clip.gx_rectangle_right; xval++)
113 {
114 *put++ = *get++;
115 }
116 putrow += context -> gx_draw_context_pitch;
117 getrow += pixelmap -> gx_pixelmap_height;
118 }
119 }
120
121
122
123 /**************************************************************************/
124 /* */
125 /* FUNCTION RELEASE */
126 /* */
127 /* _gx_display_driver_8bpp_rotated_pixelmap_compressed_write */
128 /* PORTABLE C */
129 /* 6.1.4 */
130 /* AUTHOR */
131 /* */
132 /* Kenneth Maxwell, Microsoft Corporation */
133 /* */
134 /* DESCRIPTION */
135 /* */
136 /* Internal helper function that handles writing of compressed */
137 /* pixlemap file. */
138 /* */
139 /* INPUT */
140 /* */
141 /* context Drawing context */
142 /* xpos x-coord of top-left draw point*/
143 /* ypos y-coord of top-left draw point*/
144 /* pixelmap Pointer to GX_PIXELMAP struct */
145 /* */
146 /* OUTPUT */
147 /* */
148 /* None */
149 /* */
150 /* CALLS */
151 /* */
152 /* None */
153 /* */
154 /* CALLED BY */
155 /* */
156 /* GUIX Internal Code */
157 /* */
158 /* RELEASE HISTORY */
159 /* */
160 /* DATE NAME DESCRIPTION */
161 /* */
162 /* 02-02-2021 Kenneth Maxwell Initial Version 6.1.4 */
163 /* */
164 /**************************************************************************/
_gx_display_driver_8bpp_rotated_pixelmap_compressed_write(GX_DRAW_CONTEXT * context,INT xpos,INT ypos,GX_PIXELMAP * pixelmap)165 static VOID _gx_display_driver_8bpp_rotated_pixelmap_compressed_write(GX_DRAW_CONTEXT *context,
166 INT xpos, INT ypos, GX_PIXELMAP *pixelmap)
167 {
168 INT yval;
169 INT xval;
170 GX_CONST GX_UBYTE *get;
171 GX_UBYTE *put;
172 GX_UBYTE *putrow;
173 GX_UBYTE count;
174 GX_UBYTE pixel = 0;
175 GX_RECTANGLE *clip = context -> gx_draw_context_clip;
176
177 GX_RECTANGLE rotated_clip;
178
179 GX_SWAP_VALS(xpos, ypos);
180
181 if (context -> gx_draw_context_display -> gx_display_rotation_angle == GX_SCREEN_ROTATION_CW)
182 {
183 rotated_clip.gx_rectangle_left = clip -> gx_rectangle_top;
184 rotated_clip.gx_rectangle_right = clip -> gx_rectangle_bottom;
185 rotated_clip.gx_rectangle_top = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_right - 1);
186 rotated_clip.gx_rectangle_bottom = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_left - 1);
187 ypos = (context -> gx_draw_context_canvas -> gx_canvas_x_resolution - ypos - pixelmap -> gx_pixelmap_width);
188 }
189 else
190 {
191 rotated_clip.gx_rectangle_left = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_bottom - 1);
192 rotated_clip.gx_rectangle_right = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_top - 1);
193 rotated_clip.gx_rectangle_top = clip -> gx_rectangle_left;
194 rotated_clip.gx_rectangle_bottom = clip -> gx_rectangle_right;
195 xpos = (context -> gx_draw_context_canvas -> gx_canvas_y_resolution - xpos - pixelmap -> gx_pixelmap_height);
196 }
197
198 get = (GX_CONST GX_UBYTE *)pixelmap -> gx_pixelmap_data;
199
200 /* First, skip to the starting row. */
201 for (yval = ypos; yval < rotated_clip.gx_rectangle_top; yval++)
202 {
203 xval = 0;
204 while (xval < pixelmap -> gx_pixelmap_height)
205 {
206 count = *get++;
207
208 if (count & 0x80)
209 {
210 count = (GX_UBYTE)((count & 0x7f) + 1);
211
212 /* Skip repeated pixel value. */
213 get++;
214 }
215 else
216 {
217 count++;
218
219 /* Skip raw pixel values. */
220 get += count;
221 }
222 xval += count;
223 }
224 }
225
226 /* Now we are on the first visible row, copy pixels until we get
227 to the end of the last visible row. */
228 putrow = (GX_UBYTE *)context -> gx_draw_context_memory;
229 putrow += yval * context -> gx_draw_context_pitch;
230 putrow += xpos;
231
232 while (yval <= rotated_clip.gx_rectangle_bottom)
233 {
234 put = putrow;
235 xval = xpos;
236
237 while (xval < (xpos + pixelmap -> gx_pixelmap_height))
238 {
239 count = *get++;
240
241 if (count & 0x80)
242 {
243
244 /* Repeated value. */
245 count = (GX_UBYTE)((count & 0x7f) + 1);
246 pixel = *get++;
247
248 while (count--)
249 {
250 if (xval >= rotated_clip.gx_rectangle_left &&
251 xval <= rotated_clip.gx_rectangle_right)
252 {
253 *put = pixel;
254 }
255 put++;
256 xval++;
257 }
258 }
259 else
260 {
261
262 /* String of non-repeated values. */
263 count++;
264
265 while (count--)
266 {
267 if (xval >= rotated_clip.gx_rectangle_left &&
268 xval <= rotated_clip.gx_rectangle_right)
269 {
270 *put = *get;
271 }
272 put++;
273 get++;
274 xval++;
275 }
276 }
277 }
278 putrow += context -> gx_draw_context_pitch;
279 yval++;
280 }
281 }
282
283 /**************************************************************************/
284 /* */
285 /* FUNCTION RELEASE */
286 /* */
287 /* _gx_display_driver_8bpp_rotated_pixelmap_transparent_write */
288 /* PORTABLE C */
289 /* 6.1.4 */
290 /* AUTHOR */
291 /* */
292 /* Kenneth Maxwell, Microsoft Corporation */
293 /* */
294 /* DESCRIPTION */
295 /* */
296 /* Internal helper function that handles writing of uncompressed */
297 /* pixlemap file with alpha channel. */
298 /* */
299 /* INPUT */
300 /* */
301 /* context Drawing context */
302 /* xpos x-coord of top-left draw point*/
303 /* ypos y-coord of top-left draw point*/
304 /* pixelmap Pointer to GX_PIXELMAP struct */
305 /* */
306 /* OUTPUT */
307 /* */
308 /* None */
309 /* */
310 /* CALLS */
311 /* */
312 /* None */
313 /* */
314 /* CALLED BY */
315 /* */
316 /* GUIX Internal Code */
317 /* */
318 /* RELEASE HISTORY */
319 /* */
320 /* DATE NAME DESCRIPTION */
321 /* */
322 /* 02-02-2021 Kenneth Maxwell Initial Version 6.1.4 */
323 /* */
324 /**************************************************************************/
_gx_display_driver_8bpp_rotated_pixelmap_transparent_write(GX_DRAW_CONTEXT * context,INT xpos,INT ypos,GX_PIXELMAP * pixelmap)325 static VOID _gx_display_driver_8bpp_rotated_pixelmap_transparent_write(GX_DRAW_CONTEXT *context,
326 INT xpos, INT ypos, GX_PIXELMAP *pixelmap)
327 {
328 INT xval;
329 INT yval;
330 GX_UBYTE *putrow;
331 GX_UBYTE *getrow;
332 GX_UBYTE *put;
333 GX_UBYTE inval;
334 GX_CONST GX_UBYTE *get;
335
336 GX_RECTANGLE *clip = context -> gx_draw_context_clip;
337 GX_RECTANGLE rotated_clip;
338
339 GX_SWAP_VALS(xpos, ypos);
340
341 if (context -> gx_draw_context_display -> gx_display_rotation_angle == GX_SCREEN_ROTATION_CW)
342 {
343 rotated_clip.gx_rectangle_left = clip -> gx_rectangle_top;
344 rotated_clip.gx_rectangle_right = clip -> gx_rectangle_bottom;
345 rotated_clip.gx_rectangle_top = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_right - 1);
346 rotated_clip.gx_rectangle_bottom = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_left - 1);
347 ypos = (context -> gx_draw_context_canvas -> gx_canvas_x_resolution - ypos - pixelmap -> gx_pixelmap_width);
348 }
349 else
350 {
351 rotated_clip.gx_rectangle_left = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_bottom - 1);
352 rotated_clip.gx_rectangle_right = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_top - 1);
353 rotated_clip.gx_rectangle_top = clip -> gx_rectangle_left;
354 rotated_clip.gx_rectangle_bottom = clip -> gx_rectangle_right;
355 xpos = (context -> gx_draw_context_canvas -> gx_canvas_y_resolution - xpos - pixelmap -> gx_pixelmap_height);
356 }
357
358 putrow = (GX_UBYTE *)context -> gx_draw_context_memory;
359 putrow += rotated_clip.gx_rectangle_top * context -> gx_draw_context_pitch;
360 putrow += rotated_clip.gx_rectangle_left;
361
362 getrow = (GX_UBYTE *)(pixelmap -> gx_pixelmap_data);
363 getrow += pixelmap -> gx_pixelmap_height * (rotated_clip.gx_rectangle_top - ypos);
364 getrow += (rotated_clip.gx_rectangle_left - xpos);
365
366 for (yval = rotated_clip.gx_rectangle_top; yval <= rotated_clip.gx_rectangle_bottom; yval++)
367 {
368 put = putrow;
369 get = getrow;
370
371 for (xval = rotated_clip.gx_rectangle_left; xval <= rotated_clip.gx_rectangle_right; xval++)
372 {
373 inval = *get++;
374 if (inval == pixelmap -> gx_pixelmap_transparent_color)
375 {
376 put++;
377 }
378 else
379 {
380 *put++ = inval;
381 }
382 }
383 putrow += context -> gx_draw_context_pitch;
384 getrow += pixelmap -> gx_pixelmap_height;
385 }
386 }
387
388 /**************************************************************************/
389 /* */
390 /* FUNCTION RELEASE */
391 /* */
392 /* _gx_display_driver_8bpp_rotated_pixelmap_compressed_transparent_ */
393 /* write */
394 /* PORTABLE C */
395 /* 6.1.4 */
396 /* AUTHOR */
397 /* */
398 /* Kenneth Maxwell, Microsoft Corporation */
399 /* */
400 /* DESCRIPTION */
401 /* */
402 /* Internal helper function that handles writing of compressed */
403 /* pixlemap file with alpha channel. */
404 /* */
405 /* INPUT */
406 /* */
407 /* context Drawing context */
408 /* xpos x-coord of top-left draw point*/
409 /* ypos y-coord of top-left draw point*/
410 /* pixelmap Pointer to GX_PIXELMAP struct */
411 /* */
412 /* OUTPUT */
413 /* */
414 /* None */
415 /* */
416 /* CALLS */
417 /* */
418 /* None */
419 /* */
420 /* CALLED BY */
421 /* */
422 /* GUIX Internal Code */
423 /* */
424 /* RELEASE HISTORY */
425 /* */
426 /* DATE NAME DESCRIPTION */
427 /* */
428 /* 02-02-2021 Kenneth Maxwell Initial Version 6.1.4 */
429 /* */
430 /**************************************************************************/
_gx_display_driver_8bpp_rotated_pixelmap_compressed_transparent_write(GX_DRAW_CONTEXT * context,INT xpos,INT ypos,GX_PIXELMAP * pixelmap)431 static VOID _gx_display_driver_8bpp_rotated_pixelmap_compressed_transparent_write(GX_DRAW_CONTEXT *context,
432 INT xpos, INT ypos, GX_PIXELMAP *pixelmap)
433 {
434 INT yval;
435 INT xval;
436 GX_CONST GX_UBYTE *get;
437 GX_UBYTE *put;
438 GX_UBYTE *putrow;
439 GX_UBYTE count;
440 GX_UBYTE pixel = 0;
441 GX_RECTANGLE *clip = context -> gx_draw_context_clip;
442 GX_RECTANGLE rotated_clip;
443
444 GX_SWAP_VALS(xpos, ypos);
445
446 if (context -> gx_draw_context_display -> gx_display_rotation_angle == GX_SCREEN_ROTATION_CW)
447 {
448 rotated_clip.gx_rectangle_left = clip -> gx_rectangle_top;
449 rotated_clip.gx_rectangle_right = clip -> gx_rectangle_bottom;
450 rotated_clip.gx_rectangle_top = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_right - 1);
451 rotated_clip.gx_rectangle_bottom = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_x_resolution - clip -> gx_rectangle_left - 1);
452 ypos = (context -> gx_draw_context_canvas -> gx_canvas_x_resolution - ypos - pixelmap -> gx_pixelmap_width);
453 }
454 else
455 {
456 rotated_clip.gx_rectangle_left = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_bottom - 1);
457 rotated_clip.gx_rectangle_right = (GX_VALUE)(context -> gx_draw_context_canvas -> gx_canvas_y_resolution - clip -> gx_rectangle_top - 1);
458 rotated_clip.gx_rectangle_top = clip -> gx_rectangle_left;
459 rotated_clip.gx_rectangle_bottom = clip -> gx_rectangle_right;
460 xpos = (context -> gx_draw_context_canvas -> gx_canvas_y_resolution - xpos - pixelmap -> gx_pixelmap_height);
461 }
462
463 get = (GX_CONST GX_UBYTE *)pixelmap -> gx_pixelmap_data;
464
465 /* First, skip to the starting row. */
466 for (yval = ypos; yval < rotated_clip.gx_rectangle_top; yval++)
467 {
468 xval = 0;
469 while (xval < pixelmap -> gx_pixelmap_height)
470 {
471 count = *get++;
472
473 if (count & 0x80)
474 {
475 count = (GX_UBYTE)((count & 0x7f) + 1);
476
477 /* Skip repeated pixel value. */
478 get++;
479 }
480 else
481 {
482 count++;
483
484 /* Skip raw pixel values. */
485 get += count;
486 }
487 xval += count;
488 }
489 }
490
491 /* Now we are on the first visible row, copy pixels until we get
492 to the end of the last visible row. */
493 putrow = (GX_UBYTE *)context -> gx_draw_context_memory;
494 putrow += yval * context -> gx_draw_context_pitch;
495 putrow += xpos;
496
497 while (yval <= rotated_clip.gx_rectangle_bottom)
498 {
499 put = putrow;
500 xval = xpos;
501 while (xval < (xpos + pixelmap -> gx_pixelmap_height))
502 {
503 count = *get++;
504
505 if (count & 0x80)
506 {
507
508 /* Repeated value. */
509 count = (GX_UBYTE)((count & 0x7f) + 1);
510 pixel = *get++;
511
512 if (pixel == pixelmap -> gx_pixelmap_transparent_color)
513 {
514 put += count;
515 xval += count;
516 }
517 else
518 {
519 while (count--)
520 {
521 if (xval >= rotated_clip.gx_rectangle_left &&
522 xval <= rotated_clip.gx_rectangle_right)
523 {
524 *put = pixel;
525 }
526 put++;
527 xval++;
528 }
529 }
530 }
531 else
532 {
533
534 /* String of non-repeated values. */
535 count++;
536
537 while (count--)
538 {
539 pixel = *get++;
540
541 if (xval >= rotated_clip.gx_rectangle_left &&
542 xval <= rotated_clip.gx_rectangle_right &&
543 pixel != pixelmap -> gx_pixelmap_transparent_color)
544 {
545 *put = pixel;
546 }
547 put++;
548 xval++;
549 }
550 }
551 }
552 putrow += context -> gx_draw_context_pitch;
553 yval++;
554 }
555 }
556
557 /**************************************************************************/
558 /* */
559 /* FUNCTION RELEASE */
560 /* */
561 /* _gx_display_driver_8bpp_rotated_pixelmap_draw PORTABLE C */
562 /* 6.1.4 */
563 /* AUTHOR */
564 /* */
565 /* Kenneth Maxwell, Microsoft Corporation */
566 /* */
567 /* DESCRIPTION */
568 /* */
569 /* 8bit screen driver pixelmap drawing function that handles */
570 /* compressed or uncompress, with or without alpha channel. */
571 /* */
572 /* INPUT */
573 /* */
574 /* context Drawing context */
575 /* xpos x-coord of top-left draw point*/
576 /* ypos y-coord of top-left draw point*/
577 /* pixelmap Pointer to GX_PIXELMAP struct */
578 /* */
579 /* OUTPUT */
580 /* */
581 /* None */
582 /* */
583 /* CALLS */
584 /* */
585 /* _gx_display_driver_8bit_rotated_pixelmap_compressed_write */
586 /* _gx_display_driver_8bit_rotated_pixelmap_compressed_transparent_ */
587 /* write */
588 /* _gx_display_driver_8bit_rotated_pixelmap_transparent_write */
589 /* _gx_display_driver_8bit_rotated_pixelmap_raw_write */
590 /* */
591 /* CALLED BY */
592 /* */
593 /* GUIX Internal Code */
594 /* */
595 /* RELEASE HISTORY */
596 /* */
597 /* DATE NAME DESCRIPTION */
598 /* */
599 /* 02-02-2021 Kenneth Maxwell Initial Version 6.1.4 */
600 /* */
601 /**************************************************************************/
_gx_display_driver_8bpp_rotated_pixelmap_draw(GX_DRAW_CONTEXT * context,INT xpos,INT ypos,GX_PIXELMAP * pixelmap)602 VOID _gx_display_driver_8bpp_rotated_pixelmap_draw(GX_DRAW_CONTEXT *context,
603 INT xpos, INT ypos, GX_PIXELMAP *pixelmap)
604 {
605
606 if (pixelmap -> gx_pixelmap_format != GX_COLOR_FORMAT_8BIT_PALETTE ||
607 (pixelmap -> gx_pixelmap_flags & GX_PIXELMAP_ALPHA))
608 {
609
610 /* Wrong color format for this driver. */
611 return;
612 }
613
614 if (pixelmap -> gx_pixelmap_flags & GX_PIXELMAP_TRANSPARENT)
615 {
616 if (pixelmap -> gx_pixelmap_flags & GX_PIXELMAP_COMPRESSED)
617 {
618
619 /* Has both compression and transparent. */
620 _gx_display_driver_8bpp_rotated_pixelmap_compressed_transparent_write(context, xpos, ypos, pixelmap);
621 }
622 else
623 {
624
625 /* Transparent, no compression. */
626 _gx_display_driver_8bpp_rotated_pixelmap_transparent_write(context, xpos, ypos, pixelmap);
627 }
628 }
629 else
630 {
631 if (pixelmap -> gx_pixelmap_flags & GX_PIXELMAP_COMPRESSED)
632 {
633
634 /* Compressed with no transparency. */
635 _gx_display_driver_8bpp_rotated_pixelmap_compressed_write(context, xpos, ypos, pixelmap);
636 }
637 else
638 {
639
640 /* No compression or transaprency. */
641 _gx_display_driver_8bpp_rotated_pixelmap_raw_write(context, xpos, ypos, pixelmap);
642 }
643 }
644 }
645
646
