Arm-2D  
2D Image Processing Library for Cortex-M Processors
 
Loading...
Searching...
No Matches
arm_2d_tile.h
1/*
2 * Copyright (C) 2010-2022 Arm Limited or its affiliates. All rights reserved.
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Licensed under the Apache License, Version 2.0 (the License); you may
7 * not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
14 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19/* ----------------------------------------------------------------------
20 * Project: Arm-2D Library
21 * Title: arm_2d_tile.h
22 * Description: Public header file to contain the basic tile operations
23 *
24 * $Date: 12. May 2025
25 * $Revision: V.1.5.1
26 *
27 * Target Processor: Cortex-M cores
28 * -------------------------------------------------------------------- */
29
30#ifndef __ARM_2D_TILE_H__
31#define __ARM_2D_TILE_H__
32
33/*============================ INCLUDES ======================================*/
34#include "arm_2d_types.h"
35
36#ifdef __cplusplus
37extern "C" {
38#endif
39
40
41
42/*============================ MACROS ========================================*/
43
44/*!
45 * \addtogroup Deprecated
46 * @{
47 */
48#define arm_2d_c8bit_tile_copy_with_colour_masking \
49 arm_2d_c8bit_tile_copy_with_colour_keying
50
51#define arm_2d_rgb16_tile_copy_with_colour_masking \
52 arm_2d_rgb16_tile_copy_with_colour_keying
53
54#define arm_2d_rgb32_tile_copy_with_colour_masking \
55 arm_2d_rgb32_tile_copy_with_colour_keying
56/*! @} */
57
58/*!
59 * \addtogroup Tile 2 Tile Operations
60 * @{
61 */
62/*============================ MACROFIED FUNCTIONS ===========================*/
63
64#define arm_2d_c8bit_tile_copy( __SRC_ADDR, /* source tile address */ \
65 __DES_ADDR, /* target tile address */ \
66 __DES_REGION_ADDR, /* target region address*/\
67 __MODE) /* mode */ \
68 arm_2dp_c8bit_tile_copy(NULL, \
69 (__SRC_ADDR), \
70 (__DES_ADDR), \
71 (__DES_REGION_ADDR), \
72 (__MODE))
73
74#define arm_2d_rgb16_tile_copy( __SRC_ADDR, /* source tile address */ \
75 __DES_ADDR, /* target tile address */ \
76 __DES_REGION_ADDR, /* target region address*/\
77 __MODE) /* mode */ \
78 arm_2dp_rgb16_tile_copy(NULL, \
79 (__SRC_ADDR), \
80 (__DES_ADDR), \
81 (__DES_REGION_ADDR), \
82 (__MODE))
83
84#define arm_2d_rgb32_tile_copy( __SRC_ADDR, /* source tile address */ \
85 __DES_ADDR, /* target tile address */ \
86 __DES_REGION_ADDR, /* target region address*/\
87 __MODE) /* mode */ \
88 arm_2dp_rgb32_tile_copy(NULL, \
89 (__SRC_ADDR), \
90 (__DES_ADDR), \
91 (__DES_REGION_ADDR), \
92 (__MODE))
93
94#define arm_2d_c8bit_tile_copy_only( \
95 __SRC_ADDR, /* source tile address */ \
96 __DES_ADDR, /* target tile address */ \
97 __DES_REGION_ADDR) /* target region address*/\
98 arm_2dp_c8bit_tile_copy_only(NULL, \
99 (__SRC_ADDR), \
100 (__DES_ADDR), \
101 (__DES_REGION_ADDR))
102
103#define arm_2d_rgb16_tile_copy_only( \
104 __SRC_ADDR, /* source tile address */ \
105 __DES_ADDR, /* target tile address */ \
106 __DES_REGION_ADDR) /* target region address*/\
107 arm_2dp_rgb16_tile_copy_only(NULL, \
108 (__SRC_ADDR), \
109 (__DES_ADDR), \
110 (__DES_REGION_ADDR))
111
112#define arm_2d_rgb32_tile_copy_only( \
113 __SRC_ADDR, /* source tile address */ \
114 __DES_ADDR, /* target tile address */ \
115 __DES_REGION_ADDR) /* target region address*/\
116 arm_2dp_rgb32_tile_copy_only(NULL, \
117 (__SRC_ADDR), \
118 (__DES_ADDR), \
119 (__DES_REGION_ADDR))
120
121#define arm_2d_c8bit_tile_copy_with_x_mirror( \
122 __SRC_ADDR, /* source tile address */ \
123 __DES_ADDR, /* target tile address */ \
124 __DES_REGION_ADDR) /* target region address*/\
125 arm_2dp_c8bit_tile_copy_with_x_mirror( \
126 NULL, \
127 (__SRC_ADDR), \
128 (__DES_ADDR), \
129 (__DES_REGION_ADDR))
130
131#define arm_2d_rgb16_tile_copy_with_x_mirror( \
132 __SRC_ADDR, /* source tile address */ \
133 __DES_ADDR, /* target tile address */ \
134 __DES_REGION_ADDR) /* target region address*/\
135 arm_2dp_rgb16_tile_copy_with_x_mirror( \
136 NULL, \
137 (__SRC_ADDR), \
138 (__DES_ADDR), \
139 (__DES_REGION_ADDR))
140
141#define arm_2d_rgb32_tile_copy_with_x_mirror( \
142 __SRC_ADDR, /* source tile address */ \
143 __DES_ADDR, /* target tile address */ \
144 __DES_REGION_ADDR) /* target region address*/\
145 arm_2dp_rgb32_tile_copy_with_x_mirror( \
146 NULL, \
147 (__SRC_ADDR), \
148 (__DES_ADDR), \
149 (__DES_REGION_ADDR))
150
151#define arm_2d_c8bit_tile_copy_with_y_mirror( \
152 __SRC_ADDR, /* source tile address */ \
153 __DES_ADDR, /* target tile address */ \
154 __DES_REGION_ADDR) /* target region address*/\
155 arm_2dp_c8bit_tile_copy_with_y_mirror( \
156 NULL, \
157 (__SRC_ADDR), \
158 (__DES_ADDR), \
159 (__DES_REGION_ADDR))
160
161#define arm_2d_rgb16_tile_copy_with_y_mirror( \
162 __SRC_ADDR, /* source tile address */ \
163 __DES_ADDR, /* target tile address */ \
164 __DES_REGION_ADDR) /* target region address*/\
165 arm_2dp_rgb16_tile_copy_with_y_mirror( \
166 NULL, \
167 (__SRC_ADDR), \
168 (__DES_ADDR), \
169 (__DES_REGION_ADDR))
170
171#define arm_2d_rgb32_tile_copy_with_y_mirror( \
172 __SRC_ADDR, /* source tile address */ \
173 __DES_ADDR, /* target tile address */ \
174 __DES_REGION_ADDR) /* target region address*/\
175 arm_2dp_rgb32_tile_copy_with_y_mirror( \
176 NULL, \
177 (__SRC_ADDR), \
178 (__DES_ADDR), \
179 (__DES_REGION_ADDR))
180
181#define arm_2d_c8bit_tile_copy_with_xy_mirror( \
182 __SRC_ADDR, /* source tile address */ \
183 __DES_ADDR, /* target tile address */ \
184 __DES_REGION_ADDR) /* target region address*/\
185 arm_2dp_c8bit_tile_copy_with_xy_mirror( \
186 NULL, \
187 (__SRC_ADDR), \
188 (__DES_ADDR), \
189 (__DES_REGION_ADDR))
190
191#define arm_2d_rgb16_tile_copy_with_xy_mirror( \
192 __SRC_ADDR, /* source tile address */ \
193 __DES_ADDR, /* target tile address */ \
194 __DES_REGION_ADDR) /* target region address*/\
195 arm_2dp_rgb16_tile_copy_with_xy_mirror( \
196 NULL, \
197 (__SRC_ADDR), \
198 (__DES_ADDR), \
199 (__DES_REGION_ADDR))
200
201#define arm_2d_rgb32_tile_copy_with_xy_mirror( \
202 __SRC_ADDR, /* source tile address */ \
203 __DES_ADDR, /* target tile address */ \
204 __DES_REGION_ADDR) /* target region address*/\
205 arm_2dp_rgb32_tile_copy_with_xy_mirror( \
206 NULL, \
207 (__SRC_ADDR), \
208 (__DES_ADDR), \
209 (__DES_REGION_ADDR))
210
211#define arm_2d_c8bit_tile_fill_only( \
212 __SRC_ADDR, /* source tile address */ \
213 __DES_ADDR, /* target tile address */ \
214 __DES_REGION_ADDR) /* target region address*/\
215 arm_2dp_c8bit_tile_fill_only(NULL, \
216 (__SRC_ADDR), \
217 (__DES_ADDR), \
218 (__DES_REGION_ADDR))
219
220#define arm_2d_rgb16_tile_fill_only( \
221 __SRC_ADDR, /* source tile address */ \
222 __DES_ADDR, /* target tile address */ \
223 __DES_REGION_ADDR) /* target region address*/\
224 arm_2dp_rgb16_tile_fill_only(NULL, \
225 (__SRC_ADDR), \
226 (__DES_ADDR), \
227 (__DES_REGION_ADDR))
228
229#define arm_2d_rgb32_tile_fill_only( \
230 __SRC_ADDR, /* source tile address */ \
231 __DES_ADDR, /* target tile address */ \
232 __DES_REGION_ADDR) /* target region address*/\
233 arm_2dp_rgb32_tile_fill_only(NULL, \
234 (__SRC_ADDR), \
235 (__DES_ADDR), \
236 (__DES_REGION_ADDR))
237
238#define arm_2d_c8bit_tile_fill_with_x_mirror( \
239 __SRC_ADDR, /* source tile address */ \
240 __DES_ADDR, /* target tile address */ \
241 __DES_REGION_ADDR) /* target region address*/\
242 arm_2dp_c8bit_tile_fill_with_x_mirror( \
243 NULL, \
244 (__SRC_ADDR), \
245 (__DES_ADDR), \
246 (__DES_REGION_ADDR))
247
248#define arm_2d_rgb16_tile_fill_with_x_mirror( \
249 __SRC_ADDR, /* source tile address */ \
250 __DES_ADDR, /* target tile address */ \
251 __DES_REGION_ADDR) /* target region address*/\
252 arm_2dp_rgb16_tile_fill_with_x_mirror( \
253 NULL, \
254 (__SRC_ADDR), \
255 (__DES_ADDR), \
256 (__DES_REGION_ADDR))
257
258#define arm_2d_rgb32_tile_fill_with_x_mirror( \
259 __SRC_ADDR, /* source tile address */ \
260 __DES_ADDR, /* target tile address */ \
261 __DES_REGION_ADDR) /* target region address*/\
262 arm_2dp_rgb32_tile_fill_with_x_mirror( \
263 NULL, \
264 (__SRC_ADDR), \
265 (__DES_ADDR), \
266 (__DES_REGION_ADDR))
267
268#define arm_2d_c8bit_tile_fill_with_y_mirror( \
269 __SRC_ADDR, /* source tile address */ \
270 __DES_ADDR, /* target tile address */ \
271 __DES_REGION_ADDR) /* target region address*/\
272 arm_2dp_c8bit_tile_fill_with_y_mirror( \
273 NULL, \
274 (__SRC_ADDR), \
275 (__DES_ADDR), \
276 (__DES_REGION_ADDR))
277
278#define arm_2d_rgb16_tile_fill_with_y_mirror( \
279 __SRC_ADDR, /* source tile address */ \
280 __DES_ADDR, /* target tile address */ \
281 __DES_REGION_ADDR) /* target region address*/\
282 arm_2dp_rgb16_tile_fill_with_y_mirror( \
283 NULL, \
284 (__SRC_ADDR), \
285 (__DES_ADDR), \
286 (__DES_REGION_ADDR))
287
288#define arm_2d_rgb32_tile_fill_with_y_mirror( \
289 __SRC_ADDR, /* source tile address */ \
290 __DES_ADDR, /* target tile address */ \
291 __DES_REGION_ADDR) /* target region address*/\
292 arm_2dp_rgb32_tile_fill_with_y_mirror( \
293 NULL, \
294 (__SRC_ADDR), \
295 (__DES_ADDR), \
296 (__DES_REGION_ADDR))
297
298#define arm_2d_c8bit_tile_fill_with_xy_mirror( \
299 __SRC_ADDR, /* source tile address */ \
300 __DES_ADDR, /* target tile address */ \
301 __DES_REGION_ADDR) /* target region address*/\
302 arm_2dp_c8bit_tile_fill_with_xy_mirror( \
303 NULL, \
304 (__SRC_ADDR), \
305 (__DES_ADDR), \
306 (__DES_REGION_ADDR))
307
308#define arm_2d_rgb16_tile_fill_with_xy_mirror( \
309 __SRC_ADDR, /* source tile address */ \
310 __DES_ADDR, /* target tile address */ \
311 __DES_REGION_ADDR) /* target region address*/\
312 arm_2dp_rgb16_tile_fill_with_xy_mirror( \
313 NULL, \
314 (__SRC_ADDR), \
315 (__DES_ADDR), \
316 (__DES_REGION_ADDR))
317
318#define arm_2d_rgb32_tile_fill_with_xy_mirror( \
319 __SRC_ADDR, /* source tile address */ \
320 __DES_ADDR, /* target tile address */ \
321 __DES_REGION_ADDR) /* target region address*/\
322 arm_2dp_rgb32_tile_fill_with_xy_mirror( \
323 NULL, \
324 (__SRC_ADDR), \
325 (__DES_ADDR), \
326 (__DES_REGION_ADDR))
327
328#define arm_2d_c8bit_tile_copy_with_colour_keying( \
329 __SRC_ADDR, /* source tile address */ \
330 __DES_ADDR, /* target tile address */ \
331 __DES_REGION_ADDR, /* target region address*/\
332 __MSK_COLOUR, /* mask(key) colour */ \
333 __MODE) /* mode */ \
334 arm_2dp_c8bit_tile_copy_with_colour_keying( \
335 NULL, \
336 (__SRC_ADDR), \
337 (__DES_ADDR), \
338 (__DES_REGION_ADDR), \
339 (__MSK_COLOUR), \
340 (__MODE))
341
342
343#define arm_2d_rgb16_tile_copy_with_colour_keying( \
344 __SRC_ADDR, /* source tile address */ \
345 __DES_ADDR, /* target tile address */ \
346 __DES_REGION_ADDR, /* target region address*/\
347 __MSK_COLOUR, /* mask(key) colour */ \
348 __MODE) /* mode */ \
349 arm_2dp_rgb16_tile_copy_with_colour_keying( \
350 NULL, \
351 (__SRC_ADDR), \
352 (__DES_ADDR), \
353 (__DES_REGION_ADDR), \
354 (__MSK_COLOUR), \
355 (__MODE))
356
357#define arm_2d_rgb32_tile_copy_with_colour_keying( \
358 __SRC_ADDR, /* source tile address */ \
359 __DES_ADDR, /* target tile address */ \
360 __DES_REGION_ADDR, /* target region address*/\
361 __MSK_COLOUR, /* mask(key) colour */ \
362 __MODE) /* mode */ \
363 arm_2dp_rgb32_tile_copy_with_colour_keying( \
364 NULL, \
365 (__SRC_ADDR), \
366 (__DES_ADDR), \
367 (__DES_REGION_ADDR), \
368 (__MSK_COLOUR), \
369 (__MODE))
370
371#define arm_2d_c8bit_tile_copy_with_colour_keying_only( \
372 __SRC_ADDR, /* source tile address */ \
373 __DES_ADDR, /* target tile address */ \
374 __DES_REGION_ADDR, /* target region address*/\
375 __MSK_COLOUR) /* mask(key) colour */ \
376 arm_2dp_c8bit_tile_copy_with_colour_keying_only( \
377 NULL, \
378 (__SRC_ADDR), \
379 (__DES_ADDR), \
380 (__DES_REGION_ADDR), \
381 (__MSK_COLOUR))
382
383
384#define arm_2d_rgb16_tile_copy_with_colour_keying_only( \
385 __SRC_ADDR, /* source tile address */ \
386 __DES_ADDR, /* target tile address */ \
387 __DES_REGION_ADDR, /* target region address*/\
388 __MSK_COLOUR) /* mask(key) colour */ \
389 arm_2dp_rgb16_tile_copy_with_colour_keying_only( \
390 NULL, \
391 (__SRC_ADDR), \
392 (__DES_ADDR), \
393 (__DES_REGION_ADDR), \
394 (__MSK_COLOUR))
395
396#define arm_2d_rgb32_tile_copy_with_colour_keying_only( \
397 __SRC_ADDR, /* source tile address */ \
398 __DES_ADDR, /* target tile address */ \
399 __DES_REGION_ADDR, /* target region address*/\
400 __MSK_COLOUR) /* mask(key) colour */ \
401 arm_2dp_rgb32_tile_copy_with_colour_keying_only( \
402 NULL, \
403 (__SRC_ADDR), \
404 (__DES_ADDR), \
405 (__DES_REGION_ADDR), \
406 (__MSK_COLOUR))
407
408
409#define arm_2d_c8bit_tile_copy_with_colour_keying_and_x_mirror( \
410 __SRC_ADDR, /* source tile address */ \
411 __DES_ADDR, /* target tile address */ \
412 __DES_REGION_ADDR, /* target region address*/\
413 __MSK_COLOUR) /* mask(key) colour */ \
414 arm_2dp_c8bit_tile_copy_with_colour_keying_and_x_mirror( \
415 NULL, \
416 (__SRC_ADDR), \
417 (__DES_ADDR), \
418 (__DES_REGION_ADDR), \
419 (__MSK_COLOUR))
420
421#define arm_2d_rgb16_tile_copy_with_colour_keying_and_x_mirror( \
422 __SRC_ADDR, /* source tile address */ \
423 __DES_ADDR, /* target tile address */ \
424 __DES_REGION_ADDR, /* target region address*/\
425 __MSK_COLOUR) /* mask(key) colour */ \
426 arm_2dp_rgb16_tile_copy_with_colour_keying_and_x_mirror( \
427 NULL, \
428 (__SRC_ADDR), \
429 (__DES_ADDR), \
430 (__DES_REGION_ADDR), \
431 (__MSK_COLOUR))
432
433#define arm_2d_rgb32_tile_copy_with_colour_keying_and_x_mirror( \
434 __SRC_ADDR, /* source tile address */ \
435 __DES_ADDR, /* target tile address */ \
436 __DES_REGION_ADDR, /* target region address*/\
437 __MSK_COLOUR) /* mask(key) colour */ \
438 arm_2dp_rgb32_tile_copy_with_colour_keying_and_x_mirror( \
439 NULL, \
440 (__SRC_ADDR), \
441 (__DES_ADDR), \
442 (__DES_REGION_ADDR), \
443 (__MSK_COLOUR))
444
445#define arm_2d_c8bit_tile_copy_with_colour_keying_and_y_mirror( \
446 __SRC_ADDR, /* source tile address */ \
447 __DES_ADDR, /* target tile address */ \
448 __DES_REGION_ADDR, /* target region address*/\
449 __MSK_COLOUR) /* mask(key) colour */ \
450 arm_2dp_c8bit_tile_copy_with_colour_keying_and_y_mirror( \
451 NULL, \
452 (__SRC_ADDR), \
453 (__DES_ADDR), \
454 (__DES_REGION_ADDR), \
455 (__MSK_COLOUR))
456
457#define arm_2d_rgb16_tile_copy_with_colour_keying_and_y_mirror( \
458 __SRC_ADDR, /* source tile address */ \
459 __DES_ADDR, /* target tile address */ \
460 __DES_REGION_ADDR, /* target region address*/\
461 __MSK_COLOUR) /* mask(key) colour */ \
462 arm_2dp_rgb16_tile_copy_with_colour_keying_and_y_mirror( \
463 NULL, \
464 (__SRC_ADDR), \
465 (__DES_ADDR), \
466 (__DES_REGION_ADDR), \
467 (__MSK_COLOUR))
468
469#define arm_2d_rgb32_tile_copy_with_colour_keying_and_y_mirror( \
470 __SRC_ADDR, /* source tile address */ \
471 __DES_ADDR, /* target tile address */ \
472 __DES_REGION_ADDR, /* target region address*/\
473 __MSK_COLOUR) /* mask(key) colour */ \
474 arm_2dp_rgb32_tile_copy_with_colour_keying_and_y_mirror( \
475 NULL, \
476 (__SRC_ADDR), \
477 (__DES_ADDR), \
478 (__DES_REGION_ADDR), \
479 (__MSK_COLOUR))
480
481#define arm_2d_c8bit_tile_copy_with_colour_keying_and_xy_mirror( \
482 __SRC_ADDR, /* source tile address */ \
483 __DES_ADDR, /* target tile address */ \
484 __DES_REGION_ADDR, /* target region address*/\
485 __MSK_COLOUR) /* mask(key) colour */ \
486 arm_2dp_c8bit_tile_copy_with_colour_keying_and_xy_mirror( \
487 NULL, \
488 (__SRC_ADDR), \
489 (__DES_ADDR), \
490 (__DES_REGION_ADDR), \
491 (__MSK_COLOUR))
492
493#define arm_2d_rgb16_tile_copy_with_colour_keying_and_xy_mirror( \
494 __SRC_ADDR, /* source tile address */ \
495 __DES_ADDR, /* target tile address */ \
496 __DES_REGION_ADDR, /* target region address*/\
497 __MSK_COLOUR) /* mask(key) colour */ \
498 arm_2dp_rgb16_tile_copy_with_colour_keying_and_xy_mirror( \
499 NULL, \
500 (__SRC_ADDR), \
501 (__DES_ADDR), \
502 (__DES_REGION_ADDR), \
503 (__MSK_COLOUR))
504
505#define arm_2d_rgb32_tile_copy_with_colour_keying_and_xy_mirror( \
506 __SRC_ADDR, /* source tile address */ \
507 __DES_ADDR, /* target tile address */ \
508 __DES_REGION_ADDR, /* target region address*/\
509 __MSK_COLOUR) /* mask(key) colour */ \
510 arm_2dp_rgb32_tile_copy_with_colour_keying_and_xy_mirror( \
511 NULL, \
512 (__SRC_ADDR), \
513 (__DES_ADDR), \
514 (__DES_REGION_ADDR), \
515 (__MSK_COLOUR))
516
517#define arm_2d_c8bit_tile_fill_with_colour_keying_only( \
518 __SRC_ADDR, /* source tile address */ \
519 __DES_ADDR, /* target tile address */ \
520 __DES_REGION_ADDR, /* target region address*/\
521 __MSK_COLOUR) /* mask(key) colour */ \
522 arm_2dp_c8bit_tile_fill_with_colour_keying_only( \
523 NULL, \
524 (__SRC_ADDR), \
525 (__DES_ADDR), \
526 (__DES_REGION_ADDR), \
527 (__MSK_COLOUR))
528
529
530#define arm_2d_rgb16_tile_fill_with_colour_keying_only( \
531 __SRC_ADDR, /* source tile address */ \
532 __DES_ADDR, /* target tile address */ \
533 __DES_REGION_ADDR, /* target region address*/\
534 __MSK_COLOUR) /* mask(key) colour */ \
535 arm_2dp_rgb16_tile_fill_with_colour_keying_only( \
536 NULL, \
537 (__SRC_ADDR), \
538 (__DES_ADDR), \
539 (__DES_REGION_ADDR), \
540 (__MSK_COLOUR))
541
542#define arm_2d_rgb32_tile_fill_with_colour_keying_only( \
543 __SRC_ADDR, /* source tile address */ \
544 __DES_ADDR, /* target tile address */ \
545 __DES_REGION_ADDR, /* target region address*/\
546 __MSK_COLOUR) /* mask(key) colour */ \
547 arm_2dp_rgb32_tile_fill_with_colour_keying_only( \
548 NULL, \
549 (__SRC_ADDR), \
550 (__DES_ADDR), \
551 (__DES_REGION_ADDR), \
552 (__MSK_COLOUR))
553
554
555#define arm_2d_c8bit_tile_fill_with_colour_keying_and_x_mirror( \
556 __SRC_ADDR, /* source tile address */ \
557 __DES_ADDR, /* target tile address */ \
558 __DES_REGION_ADDR, /* target region address*/\
559 __MSK_COLOUR) /* mask(key) colour */ \
560 arm_2dp_c8bit_tile_fill_with_colour_keying_and_x_mirror( \
561 NULL, \
562 (__SRC_ADDR), \
563 (__DES_ADDR), \
564 (__DES_REGION_ADDR), \
565 (__MSK_COLOUR))
566
567#define arm_2d_rgb16_tile_fill_with_colour_keying_and_x_mirror( \
568 __SRC_ADDR, /* source tile address */ \
569 __DES_ADDR, /* target tile address */ \
570 __DES_REGION_ADDR, /* target region address*/\
571 __MSK_COLOUR) /* mask(key) colour */ \
572 arm_2dp_rgb16_tile_fill_with_colour_keying_and_x_mirror( \
573 NULL, \
574 (__SRC_ADDR), \
575 (__DES_ADDR), \
576 (__DES_REGION_ADDR), \
577 (__MSK_COLOUR))
578
579#define arm_2d_rgb32_tile_fill_with_colour_keying_and_x_mirror( \
580 __SRC_ADDR, /* source tile address */ \
581 __DES_ADDR, /* target tile address */ \
582 __DES_REGION_ADDR, /* target region address*/\
583 __MSK_COLOUR) /* mask(key) colour */ \
584 arm_2dp_rgb32_tile_fill_with_colour_keying_and_x_mirror( \
585 NULL, \
586 (__SRC_ADDR), \
587 (__DES_ADDR), \
588 (__DES_REGION_ADDR), \
589 (__MSK_COLOUR))
590
591#define arm_2d_c8bit_tile_fill_with_colour_keying_and_y_mirror( \
592 __SRC_ADDR, /* source tile address */ \
593 __DES_ADDR, /* target tile address */ \
594 __DES_REGION_ADDR, /* target region address*/\
595 __MSK_COLOUR) /* mask(key) colour */ \
596 arm_2dp_c8bit_tile_fill_with_colour_keying_and_y_mirror( \
597 NULL, \
598 (__SRC_ADDR), \
599 (__DES_ADDR), \
600 (__DES_REGION_ADDR), \
601 (__MSK_COLOUR))
602
603#define arm_2d_rgb16_tile_fill_with_colour_keying_and_y_mirror( \
604 __SRC_ADDR, /* source tile address */ \
605 __DES_ADDR, /* target tile address */ \
606 __DES_REGION_ADDR, /* target region address*/\
607 __MSK_COLOUR) /* mask(key) colour */ \
608 arm_2dp_rgb16_tile_fill_with_colour_keying_and_y_mirror( \
609 NULL, \
610 (__SRC_ADDR), \
611 (__DES_ADDR), \
612 (__DES_REGION_ADDR), \
613 (__MSK_COLOUR))
614
615#define arm_2d_rgb32_tile_fill_with_colour_keying_and_y_mirror( \
616 __SRC_ADDR, /* source tile address */ \
617 __DES_ADDR, /* target tile address */ \
618 __DES_REGION_ADDR, /* target region address*/\
619 __MSK_COLOUR) /* mask(key) colour */ \
620 arm_2dp_rgb32_tile_fill_with_colour_keying_and_y_mirror( \
621 NULL, \
622 (__SRC_ADDR), \
623 (__DES_ADDR), \
624 (__DES_REGION_ADDR), \
625 (__MSK_COLOUR))
626
627#define arm_2d_c8bit_tile_fill_with_colour_keying_and_xy_mirror( \
628 __SRC_ADDR, /* source tile address */ \
629 __DES_ADDR, /* target tile address */ \
630 __DES_REGION_ADDR, /* target region address*/\
631 __MSK_COLOUR) /* mask(key) colour */ \
632 arm_2dp_c8bit_tile_fill_with_colour_keying_and_xy_mirror( \
633 NULL, \
634 (__SRC_ADDR), \
635 (__DES_ADDR), \
636 (__DES_REGION_ADDR), \
637 (__MSK_COLOUR))
638
639#define arm_2d_rgb16_tile_fill_with_colour_keying_and_xy_mirror( \
640 __SRC_ADDR, /* source tile address */ \
641 __DES_ADDR, /* target tile address */ \
642 __DES_REGION_ADDR, /* target region address*/\
643 __MSK_COLOUR) /* mask(key) colour */ \
644 arm_2dp_rgb16_tile_fill_with_colour_keying_and_xy_mirror( \
645 NULL, \
646 (__SRC_ADDR), \
647 (__DES_ADDR), \
648 (__DES_REGION_ADDR), \
649 (__MSK_COLOUR))
650
651#define arm_2d_rgb32_tile_fill_with_colour_keying_and_xy_mirror( \
652 __SRC_ADDR, /* source tile address */ \
653 __DES_ADDR, /* target tile address */ \
654 __DES_REGION_ADDR, /* target region address*/\
655 __MSK_COLOUR) /* mask(key) colour */ \
656 arm_2dp_rgb32_tile_fill_with_colour_keying_and_xy_mirror( \
657 NULL, \
658 (__SRC_ADDR), \
659 (__DES_ADDR), \
660 (__DES_REGION_ADDR), \
661 (__MSK_COLOUR))
662
663
664
665
666
667/*
668 calculate the start address
669 HOW IT WORKS:
670
671 Base Address
672 +------------------------------------------------------------------------+
673 | |
674 |<------------------------------- iWidth ------------------------------->|
675 | |
676 | |
677 | Start Address = Base Address + iX + iY * iWidth |
678 | (iX,iY) |
679 |<-------- iX --------->+------------------------------+ |
680 | | | |
681 | | Valid Region | |
682 | | | |
683 | +------------------------------+ |
684 ... ...
685 | |
686 +------------------------------------------------------------------------+
687 */
688
689#define __arm_2d_get_address_and_region_from_tile( __TILE_PTR, \
690 __VALID_REGION_NAME, \
691 __LOCATION_OFFSET_PTR, \
692 __TYPE, \
693 __BUF_PTR_NAME) \
694 arm_2d_region_t __VALID_REGION_NAME; \
695 assert(NULL != (__TILE_PTR)); \
696 __TYPE *(__BUF_PTR_NAME) = NULL; \
697 \
698 (__TILE_PTR) = arm_2d_tile_get_root((__TILE_PTR), \
699 &__VALID_REGION_NAME, \
700 __LOCATION_OFFSET_PTR); \
701 \
702 if (NULL != (__TILE_PTR)) { \
703 (__BUF_PTR_NAME) = ((__TYPE *)((__TILE_PTR)->pchBuffer)) \
704 + (__TILE_PTR)->tRegion.tSize.iWidth * \
705 __VALID_REGION_NAME.tLocation.iY \
706 + __VALID_REGION_NAME.tLocation.iX; \
707 }
708
709
710#define arm_2d_get_address_and_region_from_tile(__TILE_PTR, \
711 __VALID_REGION_NAME, \
712 __LOCATION_OFFSET_PTR, \
713 __TYPE, \
714 __BUF_PTR_NAME) \
715 __arm_2d_get_address_and_region_from_tile( __TILE_PTR, \
716 __VALID_REGION_NAME, \
717 __LOCATION_OFFSET_PTR, \
718 __TYPE, \
719 __BUF_PTR_NAME)
720
721
722#define __arm_2d_get_address_and_region_from_tile_with_mirroring( \
723 __TILE_PTR, \
724 __VALID_REGION_NAME, \
725 __LOCATION_OFFSET_PTR, \
726 __TYPE, \
727 __BUF_PTR_NAME, \
728 __MODE) \
729 arm_2d_region_t __VALID_REGION_NAME; \
730 assert(NULL != (__TILE_PTR)); \
731 __TYPE *(__BUF_PTR_NAME) = NULL; \
732 \
733 (__TILE_PTR) = arm_2d_tile_get_root((__TILE_PTR), \
734 &__VALID_REGION_NAME, \
735 __LOCATION_OFFSET_PTR); \
736 \
737 if (NULL != (__TILE_PTR)) { \
738 arm_2d_location_t tOffset = __VALID_REGION_NAME.tLocation; \
739 if ((__MODE) & ARM_2D_CP_MODE_X_MIRROR) { \
740 tOffset.iX = 0; \
741 } \
742 if ((__MODE) & ARM_2D_CP_MODE_Y_MIRROR) { \
743 tOffset.iY = 0; \
744 } \
745 (__BUF_PTR_NAME) = ((__TYPE *)((__TILE_PTR)->pchBuffer)) \
746 + (__TILE_PTR)->tRegion.tSize.iWidth * tOffset.iY \
747 + tOffset.iX; \
748 }
749
750
751#define arm_2d_get_address_and_region_from_tile_with_mirroring( \
752 __TILE_PTR, \
753 __VALID_REGION_NAME, \
754 __LOCATION_OFFSET_PTR, \
755 __TYPE, \
756 __BUF_PTR_NAME, \
757 __MODE) \
758 __arm_2d_get_address_and_region_from_tile_with_mirroring( \
759 __TILE_PTR, \
760 __VALID_REGION_NAME, \
761 __LOCATION_OFFSET_PTR, \
762 __TYPE, \
763 __BUF_PTR_NAME, \
764 (__MODE))
765
766/*============================ TYPES =========================================*/
767
768typedef arm_2d_op_src_t arm_2d_op_cp_t;
769
770/*! \note arm_2d_op_cp_cl_key_t inherits from arm_2d_op_src_t explicitly
771 */
772typedef struct arm_2d_op_cp_cl_key_t {
773 inherit(arm_2d_op_core_t); //!< base
774 struct {
775 const arm_2d_tile_t *ptTile; //!< target tile
776 const arm_2d_region_t *ptRegion; //!< target region
777 } Target;
778 struct {
779 const arm_2d_tile_t *ptTile; //!< source tile
780 }Source;
781 uint32_t wMode; //!< copy mode
782 union {
783 uint8_t chColour; //!< 8bit colour
784 uint16_t hwColour; //!< 16bit colour
785 uint32_t wColour; //!< 32bit colour
786 };
787} arm_2d_op_cp_cl_key_t;
788
789/*============================ GLOBAL VARIABLES ==============================*/
790/*============================ PROTOTYPES ====================================*/
791
792
793/*----------------------------------------------------------------------------*
794 * Tile Operations *
795 *----------------------------------------------------------------------------*/
796
797/*!
798 * \brief check whether a given tile is root or not
799 * \param[in] ptTile the target tile
800 * \retval true the target tile is a root tile
801 * \retval false the target tile is a child tile
802 */
803ARM_NONNULL(1)
804__STATIC_INLINE bool arm_2d_is_root_tile(const arm_2d_tile_t *ptTile)
805{
806 return ptTile->tInfo.bIsRoot;
807}
808
809
810/*!
811 * \brief intersect two regions and find the overlapped region
812 * \param[in] ptRegionIn0 the input region 0
813 * \param[in] ptRegionIn1 the input region 1
814 * \param[out] ptRegionOut the overlapped region
815 * \retval false the two regions do not overlap
816 * \retval true the two regions overlap
817 *
818 * \code
819
820 HOW IT WORKS:
821
822 Input Region 0
823 +------------------------------------------------------+
824 | |
825 | |
826 | |
827 | +------------------------------+---------+
828 | | |/////////|
829 | | Output Region |/////////|
830 | | |/////////|
831 +-----------------------+------------------------------+/////////|
832 |////////////////////////////////////////|
833 |////////////////////////////////////////|
834 +----------------------------------------+
835 Input Region 1
836 * \endcode
837 */
838extern
839ARM_NONNULL(1,2)
840bool arm_2d_region_intersect( const arm_2d_region_t *ptRegionIn0,
841 const arm_2d_region_t *ptRegionIn1,
842 arm_2d_region_t *ptRegionOut);
843
844
845/*!
846 * \brief get the minimal enclosure region for the given two regions
847 * \param[in] ptRegionIn0 the input region 0
848 * \param[in] ptRegionIn1 the input region 1
849 * \param[out] ptRegionOut the enclosure region
850 * \return arm_2d_region_t * the enclosure region
851 *
852 * \code
853
854 HOW IT WORKS:
855
856 Output Region
857 +------------------------------------------------------+---------+
858 | Input Region 0 |/////////|
859 | |/////////|
860 | |/////////|
861 | +------------------------------+---------+
862 | | | |
863 | | | |
864 | | | |
865 +-----------------------+------------------------------+ |
866 |///////////////////////| |
867 |///////////////////////| |
868 +-----------------------+----------------------------------------+
869 Input Region 1
870 * \endcode
871 */
872extern
873ARM_NONNULL(1,2,3)
874arm_2d_region_t *arm_2d_region_get_minimal_enclosure(
875 const arm_2d_region_t *ptInput0,
876 const arm_2d_region_t *ptInput1,
877 arm_2d_region_t *ptOutput);
878
879extern
880ARM_NONNULL(1)
881arm_2d_region_t *arm_2d_create_region_from_corner_points(
882 arm_2d_region_t *ptOutput,
883 arm_2d_location_t tPointA,
884 arm_2d_location_t tPointB);
885
886/*!
887 * \brief check whether a point is inside a given region
888 * \param[in] ptRegion the target region
889 * \param[in] ptPoint the target point
890 * \retval true the point is inside the target region
891 * \retval false the point is outside the target region
892 */
893extern
894ARM_NONNULL(1,2)
895bool arm_2d_is_point_inside_region( const arm_2d_region_t *ptRegion,
896 const arm_2d_location_t *ptPoint);
897
898/*!
899 * \brief check whether a given region is inside the target region
900 * \param[in] ptRegion a given region
901 * \param[in] ptTarget the target region used as the reference
902 * \retval 1 the given region is inside the target region
903 * \retval -1 the target region is inside the given region
904 * \return 0 the given region is outside of the target region or
905 * it only partially overlaps with the target region
906 */
907extern
908ARM_NONNULL(1,2)
909int_fast8_t arm_2d_is_region_inside_target(const arm_2d_region_t *ptRegion,
910 const arm_2d_region_t *ptTarget);
911
912/*!
913 * \brief get the root tile and the valid region for a given tile
914 * \param[in] ptTile the target tile
915 * \param[out] ptValidRegion the valid region inside the root tile
916 * \param[out] ptOffset the offsite of the root tile as if the root tile is inside the target tile
917 * \return const arm_2d_tile_t* the root tile
918 *
919 * \code
920 HOW IT WORKS:
921
922 Root Tile (Output Tile)
923 +------------------------------------------------------------------------+
924 | ... ... |
925 | |
926 | Child Tile of Parent Tile |
927 | +------------------------------------+ |
928 | | Child Tile of Parent Tile | |
929 | | +------------------------------+---------+ |
930 | | | |/////////| |
931 | | | Valid Region |/////////| |
932 | | | |/////////| |
933 | +-----+------------------------------+/////////| |
934 | |////////////////////////////////////////| |
935 | |////////////////////////////////////////| |
936 | +----------------------------------------+ |
937 | |
938 +------------------------------------------------------------------------+
939 \endcode
940 */
941extern
942ARM_NONNULL(1)
943const arm_2d_tile_t *arm_2d_tile_get_root( const arm_2d_tile_t *ptTile,
944 arm_2d_region_t *ptValidRegion,
945 arm_2d_location_t *ptOffset);
946
947extern
948ARM_NONNULL(1)
949/*!
950 * \brief get the root tile (and/or the virtual screen tile)
951 *
952 * \param[in] ptTile the target tile
953 * \param[out] ptValidRegion the valid region inside the root tile
954 * \param[out] ptOffset the offsite of the root tile as if the root tile
955 * is inside the target tile
956 * \param[out] ppVirtualScreen the virtual screen tile
957 * \param[in] bQuitWhenFindVirtualScreen whether stop searching when
958 * encounter the virtual screen tile.
959 * \return const arm_2d_tile_t* the root tile or the virtual screen tile
960 * when bQuitWhenFindVirtualScreen is true
961 */
962const arm_2d_tile_t *__arm_2d_tile_get_virtual_screen_or_root(
963 const arm_2d_tile_t *ptTile,
964 arm_2d_region_t *ptValidRegion,
965 arm_2d_location_t *ptOffset,
966 const arm_2d_tile_t **ppVirtualScreen,
967 bool bQuitWhenFindVirtualScreen);
968
969extern
970ARM_NONNULL(1)
971/*!
972 * \brief check whether a given target tile contains the boolean value of
973 * bIsNewFrame, if it is, return the bIsNewFrame value
974 *
975 * \param[in] ptTarget the target tile
976 * \retval ARM_2D_ERR_INVALID_PARAM the target tile is invalid
977 * \retval ARM_2D_RT_TRUE The bIsNewFrame is true, or there is no virtual
978 * screen.
979 * \retval ARM_2D_RT_FALSE The bIsNewFrame is false
980 */
981arm_2d_err_t arm_2d_target_tile_is_new_frame(const arm_2d_tile_t *ptTarget);
982
983/*!
984 * \brief generate a child tile from the target tile with a given region
985 * \param[in] ptTargetTile the target tile
986 * \param[in] ptRegion the target region
987 * \param[out] ptOutput the child tile
988 * \param[in] bClipRegion whether clip the region for the child tile
989 * \note We highly recommend that please DO NOT clip the child tile if
990 * you don't know what you are doing.
991 * \retval non-NULL the child tile
992 * \retval NULL the given region is outside the target tile
993 *
994 * \note If you want to use the child tile generated by
995 * arm_2d_tile_generate_child() as a source tile / mask, please set the
996 * bDerivedResource to true manually, otherwise all mirror related
997 * operation will NOT work correctly.
998 *
999 * \code
1000 HOW IT WORKS:
1001
1002 Parent Tile (NOT necessarily a ROOT tile )
1003 +------------------------------------------------------+
1004 | |
1005 | |
1006 | Target Region |
1007 | +------------------------------+---------+
1008 | | |/////////|
1009 | | New Child Tile (Output) |/////////|
1010 | | |/////////|
1011 +-----------------------+------------------------------+/////////|
1012 |////////////////////////////////////////|
1013 |////////////////////////////////////////|
1014 +----------------------------------------+
1015 \endcode
1016 */
1017extern
1018ARM_NONNULL(1,2,3)
1019arm_2d_tile_t *arm_2d_tile_generate_child(
1020 const arm_2d_tile_t *ptTargetTile,
1021 const arm_2d_region_t *ptRegion,
1022 arm_2d_tile_t *ptOutput,
1023 bool bClipRegion);
1024
1025/*!
1026 * \brief get the absolute location on a specified target tile
1027 *
1028 * \param[in] ptTile the target tile
1029 * \param[in] tLocation the relative location
1030 * \param[in] bOnVirtualScreen whether taking the virtual screen into
1031 * consideration.
1032 *
1033 * \return arm_2d_location_t the absolute location
1034 */
1035extern
1036ARM_NONNULL(1)
1037arm_2d_location_t arm_2d_get_absolute_location( const arm_2d_tile_t *ptTile,
1038 arm_2d_location_t tLocation,
1039 bool bOnVirtualScreen);
1040
1041/*!
1042 * \brief compare the widths of two tiles
1043 * \param[in] ptTarget the target tile
1044 * \param[in] ptReference the reference tile
1045 * \return arm_2d_cmp_t the comparision result
1046 */
1047extern
1048ARM_NONNULL(1,2)
1049arm_2d_cmp_t arm_2d_tile_width_compare( const arm_2d_tile_t *ptTarget,
1050 const arm_2d_tile_t *ptReference);
1051/*!
1052 * \brief compare the heights of two tiles
1053 * \param[in] ptTarget the target tile
1054 * \param[in] ptReference the reference tile
1055 * \return arm_2d_cmp_t the comparision result
1056 */
1057extern
1058ARM_NONNULL(1,2)
1059arm_2d_cmp_t arm_2d_tile_height_compare(const arm_2d_tile_t *ptTarget,
1060 const arm_2d_tile_t *ptReference);
1061
1062/*!
1063 * \brief compare the shape (both widths and heights) of two tiles
1064 * \param[in] ptTarget the target tile
1065 * \param[in] ptReference the reference tile
1066 * \return arm_2d_cmp_t the comparision result
1067 */
1068extern
1069ARM_NONNULL(1,2)
1070arm_2d_cmp_t arm_2d_tile_shape_compare( const arm_2d_tile_t *ptTarget,
1071 const arm_2d_tile_t *ptReference);
1072
1073/*!
1074 * \brief get the absolute location of a given tile
1075 * \param[in] ptTile the target tile
1076 * \param[out] ptLocation the absolute location in the root tile
1077 * \return const arm_2d_tile_t * the root tile
1078 */
1079extern
1080ARM_NONNULL(1,2)
1081const arm_2d_tile_t * arm_2d_tile_get_absolute_location(
1082 const arm_2d_tile_t *ptTile,
1083 arm_2d_location_t *ptLocation);
1084
1085/*!
1086 * \brief calculate the region differences between two tiles
1087 * \param[in] ptTarget the target tile
1088 * \param[in] ptReference the reference tile
1089 * \param[out] ptBuffer the difference stored in a region
1090 * \return arm_2d_region_t * the ptBuffer passed to this function
1091 */
1092extern
1093ARM_NONNULL(1,2,3)
1094arm_2d_region_t *arm_2d_tile_region_diff( const arm_2d_tile_t *ptTarget,
1095 const arm_2d_tile_t *ptReference,
1096 arm_2d_region_t *ptBuffer);
1097
1098extern
1099ARM_NONNULL(1,2)
1100/*!
1101 * \brief generic software tile copy for root tiles.
1102 * \note This API only supports normal tiles but not virtual resources.
1103 *
1104 * \param[in] ptSource the source tile
1105 * \param[in] ptTarget the target tile
1106 * \param[in] ptRegion the target region, NULL means using the region of the
1107 * target tile.
1108 * \param chBytesPerPixel number of bytes in a pixel
1109 */
1110void arm_2d_sw_normal_root_tile_copy( const arm_2d_tile_t *ptSource,
1111 arm_2d_tile_t *ptTarget,
1112 const arm_2d_region_t *ptRegion,
1113 uint_fast8_t chBytesPerPixel);
1114
1115/*----------------------------------------------------------------------------*
1116 * Copy/Fill tile to destination with Mirroring *
1117 *----------------------------------------------------------------------------*/
1118
1119/*!
1120 * \brief tile copy modes
1121 */
1122enum __arm_2d_copy_mode_t {
1123 ARM_2D_CP_MODE_COPY = 0,
1124 ARM_2D_CP_MODE_FILL = _BV(0),
1125 ARM_2D_CP_MODE_Y_MIRROR = _BV(2),
1126 ARM_2D_CP_MODE_X_MIRROR = _BV(3),
1127 ARM_2D_CP_MODE_XY_MIRROR = ARM_2D_CP_MODE_X_MIRROR |
1128 ARM_2D_CP_MODE_Y_MIRROR,
1129};
1130
1131/*!
1132 * \brief tile copy with specified mode
1133 * \param[in] ptOP the control block, NULL means using the default control block
1134 * \param[in] ptSource the source tile
1135 * \param[in] ptTarget the target tile
1136 * \param[in] ptRegion the target region, NULL means using the region of the
1137 * target tile.
1138 * \param[in] wMode the copy mode
1139 * \return arm_fsm_rt_t the operation result
1140 */
1141extern
1142ARM_NONNULL(2,3)
1143arm_fsm_rt_t arm_2dp_c8bit_tile_copy(arm_2d_op_cp_t *ptOP,
1144 const arm_2d_tile_t *ptSource,
1145 const arm_2d_tile_t *ptTarget,
1146 const arm_2d_region_t *ptRegion,
1147 uint32_t wMode);
1148
1149/*!
1150 * \brief tile copy with specified mode
1151 * \param[in] ptOP the control block, NULL means using the default control block
1152 * \param[in] ptSource the source tile
1153 * \param[in] ptTarget the target tile
1154 * \param[in] ptRegion the target region, NULL means using the region of the
1155 * target tile.
1156 * \param[in] wMode the copy mode
1157 * \return arm_fsm_rt_t the operation result
1158 */
1159extern
1160ARM_NONNULL(2,3)
1161arm_fsm_rt_t arm_2dp_rgb16_tile_copy(arm_2d_op_cp_t *ptOP,
1162 const arm_2d_tile_t *ptSource,
1163 const arm_2d_tile_t *ptTarget,
1164 const arm_2d_region_t *ptRegion,
1165 uint32_t wMode);
1166
1167/*!
1168 * \brief tile copy with specified mode
1169 * \param[in] ptOP the control block, NULL means using the default control block
1170 * \param[in] ptSource the source tile
1171 * \param[in] ptTarget the target tile
1172 * \param[in] ptRegion the target region, NULL means using the region of the
1173 * target tile.
1174 * \param[in] wMode the copy mode
1175 * \return arm_fsm_rt_t the operation result
1176 */
1177extern
1178ARM_NONNULL(2,3)
1179arm_fsm_rt_t arm_2dp_rgb32_tile_copy(arm_2d_op_cp_t *ptOP,
1180 const arm_2d_tile_t *ptSource,
1181 const arm_2d_tile_t *ptTarget,
1182 const arm_2d_region_t *ptRegion,
1183 uint32_t wMode);
1184
1185/*----------------------------------------------------------------------------*
1186 * Copy Only *
1187 *----------------------------------------------------------------------------*/
1188/*!
1189 * \brief tile copy only
1190 * \param[in] ptOP the control block, NULL means using the default control block
1191 * \param[in] ptSource the source tile
1192 * \param[in] ptTarget the target tile
1193 * \param[in] ptRegion the target region, NULL means using the region of the
1194 * target tile.
1195 * \return arm_fsm_rt_t the operation result
1196 */
1197extern
1198ARM_NONNULL(2,3)
1199arm_fsm_rt_t arm_2dp_c8bit_tile_copy_only( arm_2d_op_cp_t *ptOP,
1200 const arm_2d_tile_t *ptSource,
1201 const arm_2d_tile_t *ptTarget,
1202 const arm_2d_region_t *ptRegion);
1203
1204/*!
1205 * \brief tile copy only
1206 * \param[in] ptOP the control block, NULL means using the default control block
1207 * \param[in] ptSource the source tile
1208 * \param[in] ptTarget the target tile
1209 * \param[in] ptRegion the target region, NULL means using the region of the
1210 * target tile.
1211 * \return arm_fsm_rt_t the operation result
1212 */
1213extern
1214ARM_NONNULL(2,3)
1215arm_fsm_rt_t arm_2dp_rgb16_tile_copy_only( arm_2d_op_cp_t *ptOP,
1216 const arm_2d_tile_t *ptSource,
1217 const arm_2d_tile_t *ptTarget,
1218 const arm_2d_region_t *ptRegion);
1219
1220/*!
1221 * \brief tile copy only
1222 * \param[in] ptOP the control block, NULL means using the default control block
1223 * \param[in] ptSource the source tile
1224 * \param[in] ptTarget the target tile
1225 * \param[in] ptRegion the target region, NULL means using the region of the
1226 * target tile.
1227 * \return arm_fsm_rt_t the operation result
1228 */
1229extern
1230ARM_NONNULL(2,3)
1231arm_fsm_rt_t arm_2dp_rgb32_tile_copy_only( arm_2d_op_cp_t *ptOP,
1232 const arm_2d_tile_t *ptSource,
1233 const arm_2d_tile_t *ptTarget,
1234 const arm_2d_region_t *ptRegion);
1235
1236/*----------------------------------------------------------------------------*
1237 * Copy with X mirroring *
1238 *----------------------------------------------------------------------------*/
1239/*!
1240 * \brief tile copy with x-mirroring
1241 * \param[in] ptOP the control block, NULL means using the default control block
1242 * \param[in] ptSource the source tile
1243 * \param[in] ptTarget the target tile
1244 * \param[in] ptRegion the target region, NULL means using the region of the
1245 * target tile.
1246 * \return arm_fsm_rt_t the operation result
1247 */
1248extern
1249ARM_NONNULL(2,3)
1250arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_x_mirror(
1251 arm_2d_op_cp_t *ptOP,
1252 const arm_2d_tile_t *ptSource,
1253 const arm_2d_tile_t *ptTarget,
1254 const arm_2d_region_t *ptRegion);
1255
1256/*!
1257 * \brief tile copy with x-mirroring
1258 * \param[in] ptOP the control block, NULL means using the default control block
1259 * \param[in] ptSource the source tile
1260 * \param[in] ptTarget the target tile
1261 * \param[in] ptRegion the target region, NULL means using the region of the
1262 * target tile.
1263 * \return arm_fsm_rt_t the operation result
1264 */
1265extern
1266ARM_NONNULL(2,3)
1267arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_x_mirror(
1268 arm_2d_op_cp_t *ptOP,
1269 const arm_2d_tile_t *ptSource,
1270 const arm_2d_tile_t *ptTarget,
1271 const arm_2d_region_t *ptRegion);
1272
1273/*!
1274 * \brief tile copy with x-mirroring
1275 * \param[in] ptOP the control block, NULL means using the default control block
1276 * \param[in] ptSource the source tile
1277 * \param[in] ptTarget the target tile
1278 * \param[in] ptRegion the target region, NULL means using the region of the
1279 * target tile.
1280 * \return arm_fsm_rt_t the operation result
1281 */
1282extern
1283ARM_NONNULL(2,3)
1284arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_x_mirror(
1285 arm_2d_op_cp_t *ptOP,
1286 const arm_2d_tile_t *ptSource,
1287 const arm_2d_tile_t *ptTarget,
1288 const arm_2d_region_t *ptRegion);
1289
1290/*----------------------------------------------------------------------------*
1291 * Copy with Y mirroring *
1292 *----------------------------------------------------------------------------*/
1293
1294/*!
1295 * \brief tile copy with y-mirroring
1296 * \param[in] ptOP the control block, NULL means using the default control block
1297 * \param[in] ptSource the source tile
1298 * \param[in] ptTarget the target tile
1299 * \param[in] ptRegion the target region, NULL means using the region of the
1300 * target tile.
1301 * \return arm_fsm_rt_t the operation result
1302 */
1303extern
1304ARM_NONNULL(2,3)
1305arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_y_mirror(
1306 arm_2d_op_cp_t *ptOP,
1307 const arm_2d_tile_t *ptSource,
1308 const arm_2d_tile_t *ptTarget,
1309 const arm_2d_region_t *ptRegion);
1310
1311/*!
1312 * \brief tile copy with y-mirroring
1313 * \param[in] ptOP the control block, NULL means using the default control block
1314 * \param[in] ptSource the source tile
1315 * \param[in] ptTarget the target tile
1316 * \param[in] ptRegion the target region, NULL means using the region of the
1317 * target tile.
1318 * \return arm_fsm_rt_t the operation result
1319 */
1320extern
1321ARM_NONNULL(2,3)
1322arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_y_mirror(
1323 arm_2d_op_cp_t *ptOP,
1324 const arm_2d_tile_t *ptSource,
1325 const arm_2d_tile_t *ptTarget,
1326 const arm_2d_region_t *ptRegion);
1327
1328/*!
1329 * \brief tile copy with y-mirroring
1330 * \param[in] ptOP the control block, NULL means using the default control block
1331 * \param[in] ptSource the source tile
1332 * \param[in] ptTarget the target tile
1333 * \param[in] ptRegion the target region, NULL means using the region of the
1334 * target tile.
1335 * \return arm_fsm_rt_t the operation result
1336 */
1337extern
1338ARM_NONNULL(2,3)
1339arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_y_mirror(
1340 arm_2d_op_cp_t *ptOP,
1341 const arm_2d_tile_t *ptSource,
1342 const arm_2d_tile_t *ptTarget,
1343 const arm_2d_region_t *ptRegion);
1344
1345/*----------------------------------------------------------------------------*
1346 * Copy with XY mirroring *
1347 *----------------------------------------------------------------------------*/
1348
1349/*!
1350 * \brief tile copy with xy-mirroring
1351 * \param[in] ptOP the control block, NULL means using the default control block
1352 * \param[in] ptSource the source tile
1353 * \param[in] ptTarget the target tile
1354 * \param[in] ptRegion the target region, NULL means using the region of the
1355 * target tile.
1356 * \return arm_fsm_rt_t the operation result
1357 */
1358extern
1359ARM_NONNULL(2,3)
1360arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_xy_mirror(
1361 arm_2d_op_cp_t *ptOP,
1362 const arm_2d_tile_t *ptSource,
1363 const arm_2d_tile_t *ptTarget,
1364 const arm_2d_region_t *ptRegion);
1365
1366/*!
1367 * \brief tile copy with xy-mirroring
1368 * \param[in] ptOP the control block, NULL means using the default control block
1369 * \param[in] ptSource the source tile
1370 * \param[in] ptTarget the target tile
1371 * \param[in] ptRegion the target region, NULL means using the region of the
1372 * target tile.
1373 * \return arm_fsm_rt_t the operation result
1374 */
1375extern
1376ARM_NONNULL(2,3)
1377arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_xy_mirror(
1378 arm_2d_op_cp_t *ptOP,
1379 const arm_2d_tile_t *ptSource,
1380 const arm_2d_tile_t *ptTarget,
1381 const arm_2d_region_t *ptRegion);
1382
1383/*!
1384 * \brief tile copy with xy-mirroring
1385 * \param[in] ptOP the control block, NULL means using the default control block
1386 * \param[in] ptSource the source tile
1387 * \param[in] ptTarget the target tile
1388 * \param[in] ptRegion the target region, NULL means using the region of the
1389 * target tile.
1390 * \return arm_fsm_rt_t the operation result
1391 */
1392extern
1393ARM_NONNULL(2,3)
1394arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_xy_mirror(
1395 arm_2d_op_cp_t *ptOP,
1396 const arm_2d_tile_t *ptSource,
1397 const arm_2d_tile_t *ptTarget,
1398 const arm_2d_region_t *ptRegion);
1399
1400/*----------------------------------------------------------------------------*
1401 * Fill Only *
1402 *----------------------------------------------------------------------------*/
1403
1404/*!
1405 * \brief Tiling only
1406 * \param[in] ptOP the control block, NULL means using the default control block
1407 * \param[in] ptSource the source tile
1408 * \param[in] ptTarget the target tile
1409 * \param[in] ptRegion the target region, NULL means using the region of the
1410 * target tile.
1411 * \return arm_fsm_rt_t the operation result
1412 */
1413extern
1414ARM_NONNULL(2,3)
1415arm_fsm_rt_t arm_2dp_c8bit_tile_fill_only( arm_2d_op_cp_t *ptOP,
1416 const arm_2d_tile_t *ptSource,
1417 const arm_2d_tile_t *ptTarget,
1418 const arm_2d_region_t *ptRegion);
1419
1420/*!
1421 * \brief Tiling only
1422 * \param[in] ptOP the control block, NULL means using the default control block
1423 * \param[in] ptSource the source tile
1424 * \param[in] ptTarget the target tile
1425 * \param[in] ptRegion the target region, NULL means using the region of the
1426 * target tile.
1427 * \return arm_fsm_rt_t the operation result
1428 */
1429extern
1430ARM_NONNULL(2,3)
1431arm_fsm_rt_t arm_2dp_rgb16_tile_fill_only( arm_2d_op_cp_t *ptOP,
1432 const arm_2d_tile_t *ptSource,
1433 const arm_2d_tile_t *ptTarget,
1434 const arm_2d_region_t *ptRegion);
1435
1436/*!
1437 * \brief Tiling only
1438 * \param[in] ptOP the control block, NULL means using the default control block
1439 * \param[in] ptSource the source tile
1440 * \param[in] ptTarget the target tile
1441 * \param[in] ptRegion the target region, NULL means using the region of the
1442 * target tile.
1443 * \return arm_fsm_rt_t the operation result
1444 */
1445extern
1446ARM_NONNULL(2,3)
1447arm_fsm_rt_t arm_2dp_rgb32_tile_fill_only( arm_2d_op_cp_t *ptOP,
1448 const arm_2d_tile_t *ptSource,
1449 const arm_2d_tile_t *ptTarget,
1450 const arm_2d_region_t *ptRegion);
1451
1452/*----------------------------------------------------------------------------*
1453 * Fill with X mirroring *
1454 *----------------------------------------------------------------------------*/
1455
1456/*!
1457 * \brief Tiling with x-mirroring
1458 * \param[in] ptOP the control block, NULL means using the default control block
1459 * \param[in] ptSource the source tile
1460 * \param[in] ptTarget the target tile
1461 * \param[in] ptRegion the target region, NULL means using the region of the
1462 * target tile.
1463 * \return arm_fsm_rt_t the operation result
1464 */
1465extern
1466ARM_NONNULL(2,3)
1467arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_x_mirror(
1468 arm_2d_op_cp_t *ptOP,
1469 const arm_2d_tile_t *ptSource,
1470 const arm_2d_tile_t *ptTarget,
1471 const arm_2d_region_t *ptRegion);
1472
1473/*!
1474 * \brief Tiling with x-mirroring
1475 * \param[in] ptOP the control block, NULL means using the default control block
1476 * \param[in] ptSource the source tile
1477 * \param[in] ptTarget the target tile
1478 * \param[in] ptRegion the target region, NULL means using the region of the
1479 * target tile.
1480 * \return arm_fsm_rt_t the operation result
1481 */
1482extern
1483ARM_NONNULL(2,3)
1484arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_x_mirror(
1485 arm_2d_op_cp_t *ptOP,
1486 const arm_2d_tile_t *ptSource,
1487 const arm_2d_tile_t *ptTarget,
1488 const arm_2d_region_t *ptRegion);
1489
1490/*!
1491 * \brief Tiling with x-mirroring
1492 * \param[in] ptOP the control block, NULL means using the default control block
1493 * \param[in] ptSource the source tile
1494 * \param[in] ptTarget the target tile
1495 * \param[in] ptRegion the target region, NULL means using the region of the
1496 * target tile.
1497 * \return arm_fsm_rt_t the operation result
1498 */
1499extern
1500ARM_NONNULL(2,3)
1501arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_x_mirror(
1502 arm_2d_op_cp_t *ptOP,
1503 const arm_2d_tile_t *ptSource,
1504 const arm_2d_tile_t *ptTarget,
1505 const arm_2d_region_t *ptRegion);
1506
1507/*----------------------------------------------------------------------------*
1508 * Fill with Y mirroring *
1509 *----------------------------------------------------------------------------*/
1510
1511/*!
1512 * \brief Tiling with y-mirroring
1513 * \param[in] ptOP the control block, NULL means using the default control block
1514 * \param[in] ptSource the source tile
1515 * \param[in] ptTarget the target tile
1516 * \param[in] ptRegion the target region, NULL means using the region of the
1517 * target tile.
1518 * \return arm_fsm_rt_t the operation result
1519 */
1520extern
1521ARM_NONNULL(2,3)
1522arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_y_mirror(
1523 arm_2d_op_cp_t *ptOP,
1524 const arm_2d_tile_t *ptSource,
1525 const arm_2d_tile_t *ptTarget,
1526 const arm_2d_region_t *ptRegion);
1527
1528/*!
1529 * \brief Tiling with y-mirroring
1530 * \param[in] ptOP the control block, NULL means using the default control block
1531 * \param[in] ptSource the source tile
1532 * \param[in] ptTarget the target tile
1533 * \param[in] ptRegion the target region, NULL means using the region of the
1534 * target tile.
1535 * \return arm_fsm_rt_t the operation result
1536 */
1537extern
1538ARM_NONNULL(2,3)
1539arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_y_mirror(
1540 arm_2d_op_cp_t *ptOP,
1541 const arm_2d_tile_t *ptSource,
1542 const arm_2d_tile_t *ptTarget,
1543 const arm_2d_region_t *ptRegion);
1544
1545/*!
1546 * \brief Tiling with y-mirroring
1547 * \param[in] ptOP the control block, NULL means using the default control block
1548 * \param[in] ptSource the source tile
1549 * \param[in] ptTarget the target tile
1550 * \param[in] ptRegion the target region, NULL means using the region of the
1551 * target tile.
1552 * \return arm_fsm_rt_t the operation result
1553 */
1554extern
1555ARM_NONNULL(2,3)
1556arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_y_mirror(
1557 arm_2d_op_cp_t *ptOP,
1558 const arm_2d_tile_t *ptSource,
1559 const arm_2d_tile_t *ptTarget,
1560 const arm_2d_region_t *ptRegion);
1561
1562/*----------------------------------------------------------------------------*
1563 * Fill with XY mirroring *
1564 *----------------------------------------------------------------------------*/
1565
1566/*!
1567 * \brief Tiling with xy-mirroring
1568 * \param[in] ptOP the control block, NULL means using the default control block
1569 * \param[in] ptSource the source tile
1570 * \param[in] ptTarget the target tile
1571 * \param[in] ptRegion the target region, NULL means using the region of the
1572 * target tile.
1573 * \return arm_fsm_rt_t the operation result
1574 */
1575extern
1576ARM_NONNULL(2,3)
1577arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_xy_mirror(
1578 arm_2d_op_cp_t *ptOP,
1579 const arm_2d_tile_t *ptSource,
1580 const arm_2d_tile_t *ptTarget,
1581 const arm_2d_region_t *ptRegion);
1582
1583/*!
1584 * \brief Tiling with xy-mirroring
1585 * \param[in] ptOP the control block, NULL means using the default control block
1586 * \param[in] ptSource the source tile
1587 * \param[in] ptTarget the target tile
1588 * \param[in] ptRegion the target region, NULL means using the region of the
1589 * target tile.
1590 * \return arm_fsm_rt_t the operation result
1591 */
1592extern
1593ARM_NONNULL(2,3)
1594arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_xy_mirror(
1595 arm_2d_op_cp_t *ptOP,
1596 const arm_2d_tile_t *ptSource,
1597 const arm_2d_tile_t *ptTarget,
1598 const arm_2d_region_t *ptRegion);
1599
1600/*!
1601 * \brief Tiling with xy-mirroring
1602 * \param[in] ptOP the control block, NULL means using the default control block
1603 * \param[in] ptSource the source tile
1604 * \param[in] ptTarget the target tile
1605 * \param[in] ptRegion the target region, NULL means using the region of the
1606 * target tile.
1607 * \return arm_fsm_rt_t the operation result
1608 */
1609extern
1610ARM_NONNULL(2,3)
1611arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_xy_mirror(
1612 arm_2d_op_cp_t *ptOP,
1613 const arm_2d_tile_t *ptSource,
1614 const arm_2d_tile_t *ptTarget,
1615 const arm_2d_region_t *ptRegion);
1616
1617/*----------------------------------------------------------------------------*
1618 * Copy/Fill tile to destination with colour-keying and mirroring *
1619 *----------------------------------------------------------------------------*/
1620
1621/*!
1622 * \brief tile copy with colour-keying and specified mode
1623 * \param[in] ptOP the control block, NULL means using the default control block
1624 * \param[in] ptSource the source tile
1625 * \param[in] ptTarget the target tile
1626 * \param[in] ptRegion the target region, NULL means using the region of the
1627 * target tile.
1628 * \param[in] chMaskColour the key colour in any 8bit colour format
1629 * \param[in] wMode the copy mode
1630 * \return arm_fsm_rt_t the operation result
1631 */
1632extern
1633ARM_NONNULL(2,3)
1634arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_colour_keying(
1635 arm_2d_op_cp_cl_key_t *ptOP,
1636 const arm_2d_tile_t *ptSource,
1637 const arm_2d_tile_t *ptTarget,
1638 const arm_2d_region_t *ptRegion,
1639 uint8_t chMaskColour,
1640 uint32_t wMode);
1641
1642/*!
1643 * \brief tile copy with colour-keying and specified mode
1644 * \param[in] ptOP the control block, NULL means using the default control block
1645 * \param[in] ptSource the source tile
1646 * \param[in] ptTarget the target tile
1647 * \param[in] ptRegion the target region, NULL means using the region of the
1648 * target tile.
1649 * \param[in] hwMaskColour the key colour in any 16bit colour format
1650 * \param[in] wMode the copy mode
1651 * \return arm_fsm_rt_t the operation result
1652 *
1653 * \note alpha channel is not handled, i.e. rgba5551
1654 */
1655extern
1656ARM_NONNULL(2,3)
1657arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_colour_keying(
1658 arm_2d_op_cp_cl_key_t *ptOP,
1659 const arm_2d_tile_t *ptSource,
1660 const arm_2d_tile_t *ptTarget,
1661 const arm_2d_region_t *ptRegion,
1662 uint16_t hwMaskColour,
1663 uint32_t wMode);
1664
1665
1666/*!
1667 * \brief tile copy with colour-keying and specified mode
1668 * \param[in] ptOP the control block, NULL means using the default control block
1669 * \param[in] ptSource the source tile
1670 * \param[in] ptTarget the target tile
1671 * \param[in] ptRegion the target region, NULL means using the region of the
1672 * target tile.
1673 * \param[in] wMaskColour the key colour in any 32bit colour format
1674 * \param[in] wMode the copy mode
1675 * \return arm_fsm_rt_t the operation result
1676 *
1677 * \note alpha channel is not handled
1678 */
1679extern
1680ARM_NONNULL(2,3)
1681arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_colour_keying(
1682 arm_2d_op_cp_cl_key_t *ptOP,
1683 const arm_2d_tile_t *ptSource,
1684 const arm_2d_tile_t *ptTarget,
1685 const arm_2d_region_t *ptRegion,
1686 uint32_t wMaskColour,
1687 uint32_t wMode);
1688
1689
1690/*----------------------------------------------------------------------------*
1691 * Copy tile to destination with colour-keying *
1692 *----------------------------------------------------------------------------*/
1693
1694/*!
1695 * \brief tile copy with colour-keying
1696 * \param[in] ptOP the control block, NULL means using the default control block
1697 * \param[in] ptSource the source tile
1698 * \param[in] ptTarget the target tile
1699 * \param[in] ptRegion the target region, NULL means using the region of the
1700 * target tile.
1701 * \param[in] chMaskColour the key colour in any 8bit colour format
1702 * \return arm_fsm_rt_t the operation result
1703 */
1704extern
1705ARM_NONNULL(2,3)
1706arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_colour_keying_only(
1707 arm_2d_op_cp_cl_key_t *ptOP,
1708 const arm_2d_tile_t *ptSource,
1709 const arm_2d_tile_t *ptTarget,
1710 const arm_2d_region_t *ptRegion,
1711 uint8_t chMaskColour);
1712
1713/*!
1714 * \brief tile copy with colour-keying
1715 * \param[in] ptOP the control block, NULL means using the default control block
1716 * \param[in] ptSource the source tile
1717 * \param[in] ptTarget the target tile
1718 * \param[in] ptRegion the target region, NULL means using the region of the
1719 * target tile.
1720 * \param[in] hwMaskColour the key colour in any 16bit colour format
1721 * \return arm_fsm_rt_t the operation result
1722 *
1723 * \note alpha channel is not handled, i.e. rgba5551
1724 */
1725extern
1726ARM_NONNULL(2,3)
1727arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_colour_keying_only(
1728 arm_2d_op_cp_cl_key_t *ptOP,
1729 const arm_2d_tile_t *ptSource,
1730 const arm_2d_tile_t *ptTarget,
1731 const arm_2d_region_t *ptRegion,
1732 uint16_t hwMaskColour);
1733
1734
1735/*!
1736 * \brief tile copy with colour-keying
1737 * \param[in] ptOP the control block, NULL means using the default control block
1738 * \param[in] ptSource the source tile
1739 * \param[in] ptTarget the target tile
1740 * \param[in] ptRegion the target region, NULL means using the region of the
1741 * target tile.
1742 * \param[in] wMaskColour the key colour in any 32bit colour format
1743 * \return arm_fsm_rt_t the operation result
1744 *
1745 * \note alpha channel is not handled
1746 */
1747extern
1748ARM_NONNULL(2,3)
1749arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_colour_keying_only(
1750 arm_2d_op_cp_cl_key_t *ptOP,
1751 const arm_2d_tile_t *ptSource,
1752 const arm_2d_tile_t *ptTarget,
1753 const arm_2d_region_t *ptRegion,
1754 uint32_t wMaskColour);
1755
1756
1757/*----------------------------------------------------------------------------*
1758 * Copy tile to destination with colour-keying and x-mirroring *
1759 *----------------------------------------------------------------------------*/
1760
1761/*!
1762 * \brief tile copy with colour-keying and x-mirroring
1763 * \param[in] ptOP the control block, NULL means using the default control block
1764 * \param[in] ptSource the source tile
1765 * \param[in] ptTarget the target tile
1766 * \param[in] ptRegion the target region, NULL means using the region of the
1767 * target tile.
1768 * \param[in] chMaskColour the key colour in any 8bit colour format
1769 * \return arm_fsm_rt_t the operation result
1770 */
1771extern
1772ARM_NONNULL(2,3)
1773arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_colour_keying_and_x_mirror(
1774 arm_2d_op_cp_cl_key_t *ptOP,
1775 const arm_2d_tile_t *ptSource,
1776 const arm_2d_tile_t *ptTarget,
1777 const arm_2d_region_t *ptRegion,
1778 uint8_t chMaskColour);
1779
1780/*!
1781 * \brief tile copy with colour-keying and x-mirroring
1782 * \param[in] ptOP the control block, NULL means using the default control block
1783 * \param[in] ptSource the source tile
1784 * \param[in] ptTarget the target tile
1785 * \param[in] ptRegion the target region, NULL means using the region of the
1786 * target tile.
1787 * \param[in] hwMaskColour the key colour in any 16bit colour format
1788 * \return arm_fsm_rt_t the operation result
1789 *
1790 * \note alpha channel is not handled, i.e. rgba5551
1791 */
1792extern
1793ARM_NONNULL(2,3)
1794arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_colour_keying_and_x_mirror(
1795 arm_2d_op_cp_cl_key_t *ptOP,
1796 const arm_2d_tile_t *ptSource,
1797 const arm_2d_tile_t *ptTarget,
1798 const arm_2d_region_t *ptRegion,
1799 uint16_t hwMaskColour);
1800
1801
1802/*!
1803 * \brief tile copy with colour-keying and x-mirroring
1804 * \param[in] ptOP the control block, NULL means using the default control block
1805 * \param[in] ptSource the source tile
1806 * \param[in] ptTarget the target tile
1807 * \param[in] ptRegion the target region, NULL means using the region of the
1808 * target tile.
1809 * \param[in] wMaskColour the key colour in any 32bit colour format
1810 * \return arm_fsm_rt_t the operation result
1811 *
1812 * \note alpha channel is not handled
1813 */
1814extern
1815ARM_NONNULL(2,3)
1816arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_colour_keying_and_x_mirror(
1817 arm_2d_op_cp_cl_key_t *ptOP,
1818 const arm_2d_tile_t *ptSource,
1819 const arm_2d_tile_t *ptTarget,
1820 const arm_2d_region_t *ptRegion,
1821 uint32_t wMaskColour);
1822
1823
1824/*----------------------------------------------------------------------------*
1825 * Copy tile to destination with colour-keying and y-mirroring *
1826 *----------------------------------------------------------------------------*/
1827
1828/*!
1829 * \brief tile copy with colour-keying and y-mirroring
1830 * \param[in] ptOP the control block, NULL means using the default control block
1831 * \param[in] ptSource the source tile
1832 * \param[in] ptTarget the target tile
1833 * \param[in] ptRegion the target region, NULL means using the region of the
1834 * target tile.
1835 * \param[in] chMaskColour the key colour in any 8bit colour format
1836 * \return arm_fsm_rt_t the operation result
1837 */
1838extern
1839ARM_NONNULL(2,3)
1840arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_colour_keying_and_y_mirror(
1841 arm_2d_op_cp_cl_key_t *ptOP,
1842 const arm_2d_tile_t *ptSource,
1843 const arm_2d_tile_t *ptTarget,
1844 const arm_2d_region_t *ptRegion,
1845 uint8_t chMaskColour);
1846
1847/*!
1848 * \brief tile copy with colour-keying and y-mirroring
1849 * \param[in] ptOP the control block, NULL means using the default control block
1850 * \param[in] ptSource the source tile
1851 * \param[in] ptTarget the target tile
1852 * \param[in] ptRegion the target region, NULL means using the region of the
1853 * target tile.
1854 * \param[in] hwMaskColour the key colour in any 16bit colour format
1855 * \return arm_fsm_rt_t the operation result
1856 *
1857 * \note alpha channel is not handled, i.e. rgba5551
1858 */
1859extern
1860ARM_NONNULL(2,3)
1861arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_colour_keying_and_y_mirror(
1862 arm_2d_op_cp_cl_key_t *ptOP,
1863 const arm_2d_tile_t *ptSource,
1864 const arm_2d_tile_t *ptTarget,
1865 const arm_2d_region_t *ptRegion,
1866 uint16_t hwMaskColour);
1867
1868
1869/*!
1870 * \brief tile copy with colour-keying and y-mirroring
1871 * \param[in] ptOP the control block, NULL means using the default control block
1872 * \param[in] ptSource the source tile
1873 * \param[in] ptTarget the target tile
1874 * \param[in] ptRegion the target region, NULL means using the region of the
1875 * target tile.
1876 * \param[in] wMaskColour the key colour in any 32bit colour format
1877 * \return arm_fsm_rt_t the operation result
1878 *
1879 * \note alpha channel is not handled
1880 */
1881extern
1882ARM_NONNULL(2,3)
1883arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_colour_keying_and_y_mirror(
1884 arm_2d_op_cp_cl_key_t *ptOP,
1885 const arm_2d_tile_t *ptSource,
1886 const arm_2d_tile_t *ptTarget,
1887 const arm_2d_region_t *ptRegion,
1888 uint32_t wMaskColour);
1889
1890/*----------------------------------------------------------------------------*
1891 * Copy tile to destination with colour-keying and xy-mirroring *
1892 *----------------------------------------------------------------------------*/
1893
1894/*!
1895 * \brief tile copy with colour-keying and xy-mirroring
1896 * \param[in] ptOP the control block, NULL means using the default control block
1897 * \param[in] ptSource the source tile
1898 * \param[in] ptTarget the target tile
1899 * \param[in] ptRegion the target region, NULL means using the region of the
1900 * target tile.
1901 * \param[in] chMaskColour the key colour in any 8bit colour format
1902 * \return arm_fsm_rt_t the operation result
1903 */
1904extern
1905ARM_NONNULL(2,3)
1906arm_fsm_rt_t arm_2dp_c8bit_tile_copy_with_colour_keying_and_xy_mirror(
1907 arm_2d_op_cp_cl_key_t *ptOP,
1908 const arm_2d_tile_t *ptSource,
1909 const arm_2d_tile_t *ptTarget,
1910 const arm_2d_region_t *ptRegion,
1911 uint8_t chMaskColour);
1912
1913/*!
1914 * \brief tile copy with colour-keying and xy-mirroring
1915 * \param[in] ptOP the control block, NULL means using the default control block
1916 * \param[in] ptSource the source tile
1917 * \param[in] ptTarget the target tile
1918 * \param[in] ptRegion the target region, NULL means using the region of the
1919 * target tile.
1920 * \param[in] hwMaskColour the key colour in any 16bit colour format
1921 * \return arm_fsm_rt_t the operation result
1922 *
1923 * \note alpha channel is not handled, i.e. rgba5551
1924 */
1925extern
1926ARM_NONNULL(2,3)
1927arm_fsm_rt_t arm_2dp_rgb16_tile_copy_with_colour_keying_and_xy_mirror(
1928 arm_2d_op_cp_cl_key_t *ptOP,
1929 const arm_2d_tile_t *ptSource,
1930 const arm_2d_tile_t *ptTarget,
1931 const arm_2d_region_t *ptRegion,
1932 uint16_t hwMaskColour);
1933
1934
1935/*!
1936 * \brief tile copy with colour-keying and xy-mirroring
1937 * \param[in] ptOP the control block, NULL means using the default control block
1938 * \param[in] ptSource the source tile
1939 * \param[in] ptTarget the target tile
1940 * \param[in] ptRegion the target region, NULL means using the region of the
1941 * target tile.
1942 * \param[in] wMaskColour the key colour in any 32bit colour format
1943 * \return arm_fsm_rt_t the operation result
1944 *
1945 * \note alpha channel is not handled
1946 */
1947extern
1948ARM_NONNULL(2,3)
1949arm_fsm_rt_t arm_2dp_rgb32_tile_copy_with_colour_keying_and_xy_mirror(
1950 arm_2d_op_cp_cl_key_t *ptOP,
1951 const arm_2d_tile_t *ptSource,
1952 const arm_2d_tile_t *ptTarget,
1953 const arm_2d_region_t *ptRegion,
1954 uint32_t wMaskColour);
1955
1956
1957/*----------------------------------------------------------------------------*
1958 * Tile filling (tiling) to destination with colour-keying *
1959 *----------------------------------------------------------------------------*/
1960
1961/*!
1962 * \brief tile filling (tiling) with colour-keying
1963 * \param[in] ptOP the control block, NULL means using the default control block
1964 * \param[in] ptSource the source tile
1965 * \param[in] ptTarget the target tile
1966 * \param[in] ptRegion the target region, NULL means using the region of the
1967 * target tile.
1968 * \param[in] chMaskColour the key colour in any 8bit colour format
1969 * \return arm_fsm_rt_t the operation result
1970 */
1971extern
1972ARM_NONNULL(2,3)
1973arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_colour_keying_only(
1974 arm_2d_op_cp_cl_key_t *ptOP,
1975 const arm_2d_tile_t *ptSource,
1976 const arm_2d_tile_t *ptTarget,
1977 const arm_2d_region_t *ptRegion,
1978 uint8_t chMaskColour);
1979
1980/*!
1981 * \brief tile filling (tiling) with colour-keying
1982 * \param[in] ptOP the control block, NULL means using the default control block
1983 * \param[in] ptSource the source tile
1984 * \param[in] ptTarget the target tile
1985 * \param[in] ptRegion the target region, NULL means using the region of the
1986 * target tile.
1987 * \param[in] hwMaskColour the key colour in any 16bit colour format
1988 * \return arm_fsm_rt_t the operation result
1989 *
1990 * \note alpha channel is not handled, i.e. rgba5551
1991 */
1992extern
1993ARM_NONNULL(2,3)
1994arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_colour_keying_only(
1995 arm_2d_op_cp_cl_key_t *ptOP,
1996 const arm_2d_tile_t *ptSource,
1997 const arm_2d_tile_t *ptTarget,
1998 const arm_2d_region_t *ptRegion,
1999 uint16_t hwMaskColour);
2000
2001
2002/*!
2003 * \brief tile filling (tiling) with colour-keying
2004 * \param[in] ptOP the control block, NULL means using the default control block
2005 * \param[in] ptSource the source tile
2006 * \param[in] ptTarget the target tile
2007 * \param[in] ptRegion the target region, NULL means using the region of the
2008 * target tile.
2009 * \param[in] wMaskColour the key colour in any 32bit colour format
2010 * \return arm_fsm_rt_t the operation result
2011 *
2012 * \note alpha channel is not handled
2013 */
2014extern
2015ARM_NONNULL(2,3)
2016arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_colour_keying_only(
2017 arm_2d_op_cp_cl_key_t *ptOP,
2018 const arm_2d_tile_t *ptSource,
2019 const arm_2d_tile_t *ptTarget,
2020 const arm_2d_region_t *ptRegion,
2021 uint32_t wMaskColour);
2022
2023
2024/*----------------------------------------------------------------------------*
2025 * Tile filling (tiling) to destination with colour-keying and x-mirroring *
2026 *----------------------------------------------------------------------------*/
2027
2028/*!
2029 * \brief tile filling (tiling) with colour-keying and x-mirroring
2030 * \param[in] ptOP the control block, NULL means using the default control block
2031 * \param[in] ptSource the source tile
2032 * \param[in] ptTarget the target tile
2033 * \param[in] ptRegion the target region, NULL means using the region of the
2034 * target tile.
2035 * \param[in] chMaskColour the key colour in any 8bit colour format
2036 * \return arm_fsm_rt_t the operation result
2037 */
2038extern
2039ARM_NONNULL(2,3)
2040arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_colour_keying_and_x_mirror(
2041 arm_2d_op_cp_cl_key_t *ptOP,
2042 const arm_2d_tile_t *ptSource,
2043 const arm_2d_tile_t *ptTarget,
2044 const arm_2d_region_t *ptRegion,
2045 uint8_t chMaskColour);
2046
2047/*!
2048 * \brief tile filling (tiling) with colour-keying and x-mirroring
2049 * \param[in] ptOP the control block, NULL means using the default control block
2050 * \param[in] ptSource the source tile
2051 * \param[in] ptTarget the target tile
2052 * \param[in] ptRegion the target region, NULL means using the region of the
2053 * target tile.
2054 * \param[in] hwMaskColour the key colour in any 16bit colour format
2055 * \return arm_fsm_rt_t the operation result
2056 *
2057 * \note alpha channel is not handled, i.e. rgba5551
2058 */
2059extern
2060ARM_NONNULL(2,3)
2061arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_colour_keying_and_x_mirror(
2062 arm_2d_op_cp_cl_key_t *ptOP,
2063 const arm_2d_tile_t *ptSource,
2064 const arm_2d_tile_t *ptTarget,
2065 const arm_2d_region_t *ptRegion,
2066 uint16_t hwMaskColour);
2067
2068
2069/*!
2070 * \brief tile filling (tiling) with colour-keying and x-mirroring
2071 * \param[in] ptOP the control block, NULL means using the default control block
2072 * \param[in] ptSource the source tile
2073 * \param[in] ptTarget the target tile
2074 * \param[in] ptRegion the target region, NULL means using the region of the
2075 * target tile.
2076 * \param[in] wMaskColour the key colour in any 32bit colour format
2077 * \return arm_fsm_rt_t the operation result
2078 *
2079 * \note alpha channel is not handled
2080 */
2081extern
2082ARM_NONNULL(2,3)
2083arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_colour_keying_and_x_mirror(
2084 arm_2d_op_cp_cl_key_t *ptOP,
2085 const arm_2d_tile_t *ptSource,
2086 const arm_2d_tile_t *ptTarget,
2087 const arm_2d_region_t *ptRegion,
2088 uint32_t wMaskColour);
2089
2090
2091/*----------------------------------------------------------------------------*
2092 * Tile filling (tiling) to destination with colour-keying and y-mirroring *
2093 *----------------------------------------------------------------------------*/
2094
2095/*!
2096 * \brief tile filling (tiling) with colour-keying and y-mirroring
2097 * \param[in] ptOP the control block, NULL means using the default control block
2098 * \param[in] ptSource the source tile
2099 * \param[in] ptTarget the target tile
2100 * \param[in] ptRegion the target region, NULL means using the region of the
2101 * target tile.
2102 * \param[in] chMaskColour the key colour in any 8bit colour format
2103 * \return arm_fsm_rt_t the operation result
2104 */
2105extern
2106ARM_NONNULL(2,3)
2107arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_colour_keying_and_y_mirror(
2108 arm_2d_op_cp_cl_key_t *ptOP,
2109 const arm_2d_tile_t *ptSource,
2110 const arm_2d_tile_t *ptTarget,
2111 const arm_2d_region_t *ptRegion,
2112 uint8_t chMaskColour);
2113
2114/*!
2115 * \brief tile filling (tiling) with colour-keying and y-mirroring
2116 * \param[in] ptOP the control block, NULL means using the default control block
2117 * \param[in] ptSource the source tile
2118 * \param[in] ptTarget the target tile
2119 * \param[in] ptRegion the target region, NULL means using the region of the
2120 * target tile.
2121 * \param[in] hwMaskColour the key colour in any 16bit colour format
2122 * \return arm_fsm_rt_t the operation result
2123 *
2124 * \note alpha channel is not handled, i.e. rgba5551
2125 */
2126extern
2127ARM_NONNULL(2,3)
2128arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_colour_keying_and_y_mirror(
2129 arm_2d_op_cp_cl_key_t *ptOP,
2130 const arm_2d_tile_t *ptSource,
2131 const arm_2d_tile_t *ptTarget,
2132 const arm_2d_region_t *ptRegion,
2133 uint16_t hwMaskColour);
2134
2135
2136/*!
2137 * \brief tile filling (tiling) with colour-keying and y-mirroring
2138 * \param[in] ptOP the control block, NULL means using the default control block
2139 * \param[in] ptSource the source tile
2140 * \param[in] ptTarget the target tile
2141 * \param[in] ptRegion the target region, NULL means using the region of the
2142 * target tile.
2143 * \param[in] wMaskColour the key colour in any 32bit colour format
2144 * \return arm_fsm_rt_t the operation result
2145 *
2146 * \note alpha channel is not handled
2147 */
2148extern
2149ARM_NONNULL(2,3)
2150arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_colour_keying_and_y_mirror(
2151 arm_2d_op_cp_cl_key_t *ptOP,
2152 const arm_2d_tile_t *ptSource,
2153 const arm_2d_tile_t *ptTarget,
2154 const arm_2d_region_t *ptRegion,
2155 uint32_t wMaskColour);
2156
2157/*----------------------------------------------------------------------------*
2158 * Tile filling (tiling) to destination with colour-keying and xy-mirroring *
2159 *----------------------------------------------------------------------------*/
2160
2161/*!
2162 * \brief tile filling (tiling) with colour-keying and xy-mirroring
2163 * \param[in] ptOP the control block, NULL means using the default control block
2164 * \param[in] ptSource the source tile
2165 * \param[in] ptTarget the target tile
2166 * \param[in] ptRegion the target region, NULL means using the region of the
2167 * target tile.
2168 * \param[in] chMaskColour the key colour in any 8bit colour format
2169 * \return arm_fsm_rt_t the operation result
2170 */
2171extern
2172ARM_NONNULL(2,3)
2173arm_fsm_rt_t arm_2dp_c8bit_tile_fill_with_colour_keying_and_xy_mirror(
2174 arm_2d_op_cp_cl_key_t *ptOP,
2175 const arm_2d_tile_t *ptSource,
2176 const arm_2d_tile_t *ptTarget,
2177 const arm_2d_region_t *ptRegion,
2178 uint8_t chMaskColour);
2179
2180/*!
2181 * \brief tile filling (tiling) with colour-keying and xy-mirroring
2182 * \param[in] ptOP the control block, NULL means using the default control block
2183 * \param[in] ptSource the source tile
2184 * \param[in] ptTarget the target tile
2185 * \param[in] ptRegion the target region, NULL means using the region of the
2186 * target tile.
2187 * \param[in] hwMaskColour the key colour in any 16bit colour format
2188 * \return arm_fsm_rt_t the operation result
2189 *
2190 * \note alpha channel is not handled, i.e. rgba5551
2191 */
2192extern
2193ARM_NONNULL(2,3)
2194arm_fsm_rt_t arm_2dp_rgb16_tile_fill_with_colour_keying_and_xy_mirror(
2195 arm_2d_op_cp_cl_key_t *ptOP,
2196 const arm_2d_tile_t *ptSource,
2197 const arm_2d_tile_t *ptTarget,
2198 const arm_2d_region_t *ptRegion,
2199 uint16_t hwMaskColour);
2200
2201
2202/*!
2203 * \brief tile filling (tiling) with colour-keying and xy-mirroring
2204 * \param[in] ptOP the control block, NULL means using the default control block
2205 * \param[in] ptSource the source tile
2206 * \param[in] ptTarget the target tile
2207 * \param[in] ptRegion the target region, NULL means using the region of the
2208 * target tile.
2209 * \param[in] wMaskColour the key colour in any 32bit colour format
2210 * \return arm_fsm_rt_t the operation result
2211 *
2212 * \note alpha channel is not handled
2213 */
2214extern
2215ARM_NONNULL(2,3)
2216arm_fsm_rt_t arm_2dp_rgb32_tile_fill_with_colour_keying_and_xy_mirror(
2217 arm_2d_op_cp_cl_key_t *ptOP,
2218 const arm_2d_tile_t *ptSource,
2219 const arm_2d_tile_t *ptTarget,
2220 const arm_2d_region_t *ptRegion,
2221 uint32_t wMaskColour);
2222
2223
2224
2225
2226
2227/*! @} */
2228
2229#ifdef __cplusplus
2230}
2231#endif
2232
2233#endif