Qt 4.8
qmemrotate.cpp
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the QtGui module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #include "private/qmemrotate_p.h"
43 
45 
46 #if QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
47 static const int tileSize = 32;
48 #endif
49 
50 #if Q_BYTE_ORDER == Q_BIG_ENDIAN
51 #if QT_ROTATION_ALGORITHM == QT_ROTATION_PACKED || QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
52 #error Big endian version not implemented for the transformed driver!
53 #endif
54 #endif
55 
56 template <class DST, class SRC>
57 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_cachedRead(const SRC *src, int w, int h,
58  int sstride,
59  DST *dest, int dstride)
60 {
61  const char *s = reinterpret_cast<const char*>(src);
62  char *d = reinterpret_cast<char*>(dest);
63  for (int y = 0; y < h; ++y) {
64  for (int x = w - 1; x >= 0; --x) {
65  DST *destline = reinterpret_cast<DST*>(d + (w - x - 1) * dstride);
66  destline[y] = qt_colorConvert<DST,SRC>(src[x], 0);
67  }
68  s += sstride;
69  src = reinterpret_cast<const SRC*>(s);
70  }
71 }
72 
73 template <class DST, class SRC>
74 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_cachedRead(const SRC *src, int w, int h,
75  int sstride,
76  DST *dest, int dstride)
77 {
78  const char *s = reinterpret_cast<const char*>(src);
79  char *d = reinterpret_cast<char*>(dest);
80  s += (h - 1) * sstride;
81  for (int y = h - 1; y >= 0; --y) {
82  src = reinterpret_cast<const SRC*>(s);
83  for (int x = 0; x < w; ++x) {
84  DST *destline = reinterpret_cast<DST*>(d + x * dstride);
85  destline[h - y - 1] = qt_colorConvert<DST,SRC>(src[x], 0);
86  }
87  s -= sstride;
88  }
89 }
90 
91 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
92 
93 template <class DST, class SRC>
94 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_cachedWrite(const SRC *src, int w, int h,
95  int sstride,
96  DST *dest, int dstride)
97 {
98  for (int x = w - 1; x >= 0; --x) {
99  DST *d = dest + (w - x - 1) * dstride;
100  for (int y = 0; y < h; ++y) {
101  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
102  }
103  }
104 
105 }
106 
107 template <class DST, class SRC>
108 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_cachedWrite(const SRC *src, int w, int h,
109  int sstride,
110  DST *dest, int dstride)
111 {
112  for (int x = 0; x < w; ++x) {
113  DST *d = dest + x * dstride;
114  for (int y = h - 1; y >= 0; --y) {
115  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
116  }
117  }
118 }
119 
120 #endif // QT_ROTATION_CACHEDWRITE
121 
122 #if QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
123 
124 // TODO: packing algorithms should probably be modified on 64-bit architectures
125 
126 template <class DST, class SRC>
127 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_packing(const SRC *src, int w, int h,
128  int sstride,
129  DST *dest, int dstride)
130 {
131  sstride /= sizeof(SRC);
132  dstride /= sizeof(DST);
133 
134  const int pack = sizeof(quint32) / sizeof(DST);
135  const int unaligned = int((long(dest) & (sizeof(quint32)-1))) / sizeof(DST);
136 
137  for (int x = w - 1; x >= 0; --x) {
138  int y = 0;
139 
140  for (int i = 0; i < unaligned; ++i) {
141  dest[(w - x - 1) * dstride + y]
142  = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
143  ++y;
144  }
145 
146  quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride
147  + unaligned);
148  const int rest = (h - unaligned) % pack;
149  while (y < h - rest) {
150  quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
151  for (int i = 1; i < pack; ++i) {
152  c |= qt_colorConvert<DST,SRC>(src[(y + i) * sstride + x], 0)
153  << (sizeof(int) * 8 / pack * i);
154  }
155  *d++ = c;
156  y += pack;
157  }
158 
159  while (y < h) {
160  dest[(w - x - 1) * dstride + y]
161  = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
162  ++y;
163  }
164  }
165 }
166 
167 template <class DST, class SRC>
168 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_packing(const SRC *src, int w, int h,
169  int sstride,
170  DST *dest, int dstride)
171 {
172  sstride /= sizeof(SRC);
173  dstride /= sizeof(DST);
174 
175  const int pack = sizeof(quint32) / sizeof(DST);
176  const int unaligned = int((long(dest) & (sizeof(quint32)-1))) / sizeof(DST);
177 
178  for (int x = 0; x < w; ++x) {
179  int y = h - 1;
180 
181  for (int i = 0; i < unaligned; ++i) {
182  dest[x * dstride + h - y - 1]
183  = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
184  --y;
185  }
186 
187  quint32 *d = reinterpret_cast<quint32*>(dest + x * dstride
188  + unaligned);
189  const int rest = (h - unaligned) % pack;
190  while (y > rest) {
191  quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
192  for (int i = 1; i < pack; ++i) {
193  c |= qt_colorConvert<DST,SRC>(src[(y - i) * sstride + x], 0)
194  << (sizeof(int) * 8 / pack * i);
195  }
196  *d++ = c;
197  y -= pack;
198  }
199  while (y >= 0) {
200  dest[x * dstride + h - y - 1]
201  = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
202  --y;
203  }
204  }
205 }
206 
207 #endif // QT_ROTATION_PACKING
208 
209 #if QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
210 template <class DST, class SRC>
211 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_tiled(const SRC *src, int w, int h,
212  int sstride,
213  DST *dest, int dstride)
214 {
215  sstride /= sizeof(SRC);
216  dstride /= sizeof(DST);
217 
218  const int pack = sizeof(quint32) / sizeof(DST);
219  const int unaligned =
220  qMin(uint((quintptr(dest) & (sizeof(quint32)-1)) / sizeof(DST)), uint(h));
221  const int restX = w % tileSize;
222  const int restY = (h - unaligned) % tileSize;
223  const int unoptimizedY = restY % pack;
224  const int numTilesX = w / tileSize + (restX > 0);
225  const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
226 
227  for (int tx = 0; tx < numTilesX; ++tx) {
228  const int startx = w - tx * tileSize - 1;
229  const int stopx = qMax(startx - tileSize, 0);
230 
231  if (unaligned) {
232  for (int x = startx; x >= stopx; --x) {
233  DST *d = dest + (w - x - 1) * dstride;
234  for (int y = 0; y < unaligned; ++y) {
235  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
236  }
237  }
238  }
239 
240  for (int ty = 0; ty < numTilesY; ++ty) {
241  const int starty = ty * tileSize + unaligned;
242  const int stopy = qMin(starty + tileSize, h - unoptimizedY);
243 
244  for (int x = startx; x >= stopx; --x) {
245  quint32 *d = reinterpret_cast<quint32*>(dest + (w - x - 1) * dstride + starty);
246  for (int y = starty; y < stopy; y += pack) {
247  quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
248  for (int i = 1; i < pack; ++i) {
249  const int shift = (sizeof(int) * 8 / pack * i);
250  const DST color = qt_colorConvert<DST,SRC>(src[(y + i) * sstride + x], 0);
251  c |= color << shift;
252  }
253  *d++ = c;
254  }
255  }
256  }
257 
258  if (unoptimizedY) {
259  const int starty = h - unoptimizedY;
260  for (int x = startx; x >= stopx; --x) {
261  DST *d = dest + (w - x - 1) * dstride + starty;
262  for (int y = starty; y < h; ++y) {
263  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
264  }
265  }
266  }
267  }
268 }
269 
270 template <class DST, class SRC>
271 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate90_tiled_unpacked(const SRC *src, int w, int h,
272  int sstride,
273  DST *dest, int dstride)
274 {
275  const int numTilesX = (w + tileSize - 1) / tileSize;
276  const int numTilesY = (h + tileSize - 1) / tileSize;
277 
278  for (int tx = 0; tx < numTilesX; ++tx) {
279  const int startx = w - tx * tileSize - 1;
280  const int stopx = qMax(startx - tileSize, 0);
281 
282  for (int ty = 0; ty < numTilesY; ++ty) {
283  const int starty = ty * tileSize;
284  const int stopy = qMin(starty + tileSize, h);
285 
286  for (int x = startx; x >= stopx; --x) {
287  DST *d = (DST*)((char*)dest + (w - x - 1) * dstride) + starty;
288  const char *s = (const char*)(src + x) + starty * sstride;
289  for (int y = starty; y < stopy; ++y) {
290  *d++ = qt_colorConvert<DST,SRC>(*(const SRC*)(s), 0);
291  s += sstride;
292  }
293  }
294  }
295  }
296 }
297 
298 template <class DST, class SRC>
299 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_tiled(const SRC *src, int w, int h,
300  int sstride,
301  DST *dest, int dstride)
302 {
303  sstride /= sizeof(SRC);
304  dstride /= sizeof(DST);
305 
306  const int pack = sizeof(quint32) / sizeof(DST);
307  const int unaligned =
308  qMin(uint((long(dest) & (sizeof(quint32)-1)) / sizeof(DST)), uint(h));
309  const int restX = w % tileSize;
310  const int restY = (h - unaligned) % tileSize;
311  const int unoptimizedY = restY % pack;
312  const int numTilesX = w / tileSize + (restX > 0);
313  const int numTilesY = (h - unaligned) / tileSize + (restY >= pack);
314 
315  for (int tx = 0; tx < numTilesX; ++tx) {
316  const int startx = tx * tileSize;
317  const int stopx = qMin(startx + tileSize, w);
318 
319  if (unaligned) {
320  for (int x = startx; x < stopx; ++x) {
321  DST *d = dest + x * dstride;
322  for (int y = h - 1; y >= h - unaligned; --y) {
323  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
324  }
325  }
326  }
327 
328  for (int ty = 0; ty < numTilesY; ++ty) {
329  const int starty = h - 1 - unaligned - ty * tileSize;
330  const int stopy = qMax(starty - tileSize, unoptimizedY);
331 
332  for (int x = startx; x < stopx; ++x) {
333  quint32 *d = reinterpret_cast<quint32*>(dest + x * dstride
334  + h - 1 - starty);
335  for (int y = starty; y > stopy; y -= pack) {
336  quint32 c = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
337  for (int i = 1; i < pack; ++i) {
338  const int shift = (sizeof(int) * 8 / pack * i);
339  const DST color = qt_colorConvert<DST,SRC>(src[(y - i) * sstride + x], 0);
340  c |= color << shift;
341  }
342  *d++ = c;
343  }
344  }
345  }
346  if (unoptimizedY) {
347  const int starty = unoptimizedY - 1;
348  for (int x = startx; x < stopx; ++x) {
349  DST *d = dest + x * dstride + h - 1 - starty;
350  for (int y = starty; y >= 0; --y) {
351  *d++ = qt_colorConvert<DST,SRC>(src[y * sstride + x], 0);
352  }
353  }
354  }
355  }
356 }
357 
358 template <class DST, class SRC>
359 Q_STATIC_TEMPLATE_FUNCTION inline void qt_memrotate270_tiled_unpacked(const SRC *src, int w, int h,
360  int sstride,
361  DST *dest, int dstride)
362 {
363  const int numTilesX = (w + tileSize - 1) / tileSize;
364  const int numTilesY = (h + tileSize - 1) / tileSize;
365 
366  for (int tx = 0; tx < numTilesX; ++tx) {
367  const int startx = tx * tileSize;
368  const int stopx = qMin(startx + tileSize, w);
369 
370  for (int ty = 0; ty < numTilesY; ++ty) {
371  const int starty = h - 1 - ty * tileSize;
372  const int stopy = qMax(starty - tileSize, 0);
373 
374  for (int x = startx; x < stopx; ++x) {
375  DST *d = (DST*)((char*)dest + x * dstride) + h - 1 - starty;
376  const char *s = (const char*)(src + x) + starty * sstride;
377  for (int y = starty; y >= stopy; --y) {
378  *d++ = qt_colorConvert<DST,SRC>(*(const SRC*)s, 0);
379  s -= sstride;
380  }
381  }
382  }
383  }
384 }
385 
386 #endif // QT_ROTATION_ALGORITHM
387 
388 template <class DST, class SRC>
390  int srcWidth, int srcHeight, int srcStride,
391  DST *dest, int dstStride)
392 {
393 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
394  qt_memrotate90_cachedRead<DST,SRC>(src, srcWidth, srcHeight, srcStride,
395  dest, dstStride);
396 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
397  qt_memrotate90_cachedWrite<DST,SRC>(src, srcWidth, srcHeight, srcStride,
398  dest, dstStride);
399 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
400  qt_memrotate90_packing<DST,SRC>(src, srcWidth, srcHeight, srcStride,
401  dest, dstStride);
402 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
403  qt_memrotate90_tiled<DST,SRC>(src, srcWidth, srcHeight, srcStride,
404  dest, dstStride);
405 #endif
406 }
407 
408 template <class DST, class SRC>
410  int w, int h, int sstride,
411  DST *dest, int dstride)
412 {
413  const char *s = (const char*)(src) + (h - 1) * sstride;
414  for (int y = h - 1; y >= 0; --y) {
415  DST *d = reinterpret_cast<DST*>((char *)(dest) + (h - y - 1) * dstride);
416  src = reinterpret_cast<const SRC*>(s);
417  for (int x = w - 1; x >= 0; --x) {
418  d[w - x - 1] = qt_colorConvert<DST,SRC>(src[x], 0);
419  }
420  s -= sstride;
421  }
422 }
423 
424 template <class DST, class SRC>
426  int srcWidth, int srcHeight, int srcStride,
427  DST *dest, int dstStride)
428 {
429 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
430  qt_memrotate270_cachedRead<DST,SRC>(src, srcWidth, srcHeight, srcStride,
431  dest, dstStride);
432 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
433  qt_memrotate270_cachedWrite<DST,SRC>(src, srcWidth, srcHeight, srcStride,
434  dest, dstStride);
435 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
436  qt_memrotate270_packing<DST,SRC>(src, srcWidth, srcHeight, srcStride,
437  dest, dstStride);
438 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
439  qt_memrotate270_tiled_unpacked<DST,SRC>(src, srcWidth, srcHeight,
440  srcStride,
441  dest, dstStride);
442 #endif
443 }
444 
445 template <>
448  int srcWidth, int srcHeight, int srcStride,
449  quint24 *dest, int dstStride)
450 {
451 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
452  qt_memrotate90_cachedRead<quint24,quint24>(src, srcWidth, srcHeight,
453  srcStride, dest, dstStride);
454 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
455  qt_memrotate90_cachedWrite<quint24,quint24>(src, srcWidth, srcHeight,
456  srcStride, dest, dstStride);
457 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
458  // packed algorithm not implemented
459  qt_memrotate90_cachedRead<quint24,quint24>(src, srcWidth, srcHeight,
460  srcStride, dest, dstStride);
461 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
462  // packed algorithm not implemented
463  qt_memrotate90_tiled_unpacked<quint24,quint24>(src, srcWidth, srcHeight,
464  srcStride, dest, dstStride);
465 #endif
466 }
467 
468 template <>
471  int srcWidth, int srcHeight, int srcStride,
472  quint24 *dest, int dstStride)
473 {
474 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
475  qt_memrotate90_cachedRead<quint24,quint32>(src, srcWidth, srcHeight,
476  srcStride, dest, dstStride);
477 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
478  qt_memrotate90_cachedWrite<quint24,quint32>(src, srcWidth, srcHeight,
479  srcStride, dest, dstStride);
480 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
481  // packed algorithm not implemented
482  qt_memrotate90_cachedRead<quint24,quint32>(src, srcWidth, srcHeight,
483  srcStride, dest, dstStride);
484 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
485  // packed algorithm not implemented
486  qt_memrotate90_tiled_unpacked<quint24,quint32>(src, srcWidth, srcHeight,
487  srcStride, dest, dstStride);
488 #endif
489 }
490 
491 template <>
494  int srcWidth, int srcHeight, int srcStride,
495  quint18 *dest, int dstStride)
496 {
497 #if QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDREAD
498  qt_memrotate90_cachedRead<quint18,quint32>(src, srcWidth, srcHeight,
499  srcStride, dest, dstStride);
500 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_CACHEDWRITE
501  qt_memrotate90_cachedWrite<quint18,quint32>(src, srcWidth, srcHeight,
502  srcStride, dest, dstStride);
503 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_PACKING
504  // packed algorithm not implemented
505  qt_memrotate90_cachedRead<quint18,quint32>(src, srcWidth, srcHeight,
506  srcStride, dest, dstStride);
507 #elif QT_ROTATION_ALGORITHM == QT_ROTATION_TILED
508  // packed algorithm not implemented
509  qt_memrotate90_tiled_unpacked<quint18,quint32>(src, srcWidth, srcHeight,
510  srcStride, dest, dstStride);
511 #endif
512 }
513 
514 #define QT_IMPL_MEMROTATE(srctype, desttype) \
515 void qt_memrotate90(const srctype *src, int w, int h, int sstride, \
516  desttype *dest, int dstride) \
517 { \
518  qt_memrotate90_template(src, w, h, sstride, dest, dstride); \
519 } \
520 void qt_memrotate180(const srctype *src, int w, int h, int sstride, \
521  desttype *dest, int dstride) \
522 { \
523  qt_memrotate180_template(src, w, h, sstride, dest, dstride); \
524 } \
525 void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
526  desttype *dest, int dstride) \
527 { \
528  qt_memrotate270_template(src, w, h, sstride, dest, dstride); \
529 }
530 
531 #define QT_IMPL_SIMPLE_MEMROTATE(srctype, desttype) \
532 void qt_memrotate90(const srctype *src, int w, int h, int sstride, \
533  desttype *dest, int dstride) \
534 { \
535  qt_memrotate90_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
536 } \
537 void qt_memrotate180(const srctype *src, int w, int h, int sstride, \
538  desttype *dest, int dstride) \
539 { \
540  qt_memrotate180_template(src, w, h, sstride, dest, dstride); \
541 } \
542 void qt_memrotate270(const srctype *src, int w, int h, int sstride, \
543  desttype *dest, int dstride) \
544 { \
545  qt_memrotate270_tiled_unpacked<desttype,srctype>(src, w, h, sstride, dest, dstride); \
546 }
547 
548 
549 
550 
562 
563 #if defined(QT_QWS_ROTATE_BGR)
568 #endif
569 
570 #ifdef QT_QWS_DEPTH_GENERIC
571 QT_IMPL_MEMROTATE(quint32, qrgb_generic16)
572 QT_IMPL_MEMROTATE(quint16, qrgb_generic16)
573 #endif
574 
576 {
577 public:
578  inline qrgb_gl_rgba(quint32 v) {
579  if (QSysInfo::ByteOrder == QSysInfo::LittleEndian)
580  data = ((v << 16) & 0xff0000) | ((v >> 16) & 0xff) | (v & 0xff00ff00);
581  else
582  data = (v << 8) | ((v >> 24) & 0xff);
583  }
584 
585  inline operator quint32() const { return data; }
586 
587 private:
589 } Q_PACKED;
590 
591 void Q_GUI_EXPORT qt_memrotate90_gl(const quint32 *src, int srcWidth, int srcHeight, int srcStride,
592  quint32 *dest, int dstStride)
593 {
594  qt_memrotate90_template(src, srcWidth, srcHeight, srcStride, reinterpret_cast<qrgb_gl_rgba *>(dest), dstStride);
595 }
596 
597 void qt_memrotate90_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
598 {
599  qt_memrotate90((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
600 }
601 
602 void qt_memrotate180_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
603 {
604  qt_memrotate180((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
605 }
606 
607 void qt_memrotate270_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
608 {
609  qt_memrotate270((const ushort *)srcPixels, w, h, sbpl, (ushort *)destPixels, dbpl);
610 }
611 
612 void qt_memrotate90_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
613 {
614  qt_memrotate90((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
615 }
616 
617 void qt_memrotate180_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
618 {
619  qt_memrotate180((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
620 }
621 
622 void qt_memrotate270_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
623 {
624  qt_memrotate270((const uint *)srcPixels, w, h, sbpl, (uint *)destPixels, dbpl);
625 }
626 
627 MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3] =
628 // 90, 180, 270
629 {
630  { 0, 0, 0 }, // Format_Invalid,
631  { 0, 0, 0 }, // Format_Mono,
632  { 0, 0, 0 }, // Format_MonoLSB,
633  { 0, 0, 0 }, // Format_Indexed8,
635  { qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 }, // Format_ARGB32,
636  { qt_memrotate90_32, qt_memrotate180_32, qt_memrotate270_32 }, // Format_ARGB32_Premultiplied,
638  { 0, 0, 0 }, // Format_ARGB8565_Premultiplied,
639  { 0, 0, 0 }, // Format_RGB666,
640  { 0, 0, 0 }, // Format_ARGB6666_Premultiplied,
641  { 0, 0, 0 }, // Format_RGB555,
642  { 0, 0, 0 }, // Format_ARGB8555_Premultiplied,
643  { 0, 0, 0 }, // Format_RGB888,
644  { 0, 0, 0 }, // Format_RGB444,
645  { 0, 0, 0 } // Format_ARGB4444_Premultiplied,
646 };
647 
double d
Definition: qnumeric_p.h:62
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_tiled_unpacked(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:271
static ShiftResult shift(const QBezier *orig, QBezier *shifted, qreal offset, qreal threshold)
Definition: qbezier.cpp:289
QIntegerForSizeof< void * >::Unsigned quintptr
Definition: qglobal.h:986
unsigned char c[8]
Definition: qnumeric_p.h:62
Q_DECL_CONSTEXPR const T & qMin(const T &a, const T &b)
Definition: qglobal.h:1215
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_tiled(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:211
void qt_memrotate90_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:597
#define QT_IMPL_MEMROTATE(srctype, desttype)
Definition: qmemrotate.cpp:514
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_cachedWrite(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:108
#define Q_GUI_EXPORT
Definition: qglobal.h:1450
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_tiled_unpacked(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:359
Q_STATIC_TEMPLATE_SPECIALIZATION void qt_memrotate90_template< quint24, quint32 >(const quint32 *src, int srcWidth, int srcHeight, int srcStride, quint24 *dest, int dstStride)
Definition: qmemrotate.cpp:470
void qt_memrotate180_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:602
struct qrgb_gl_rgba Q_PACKED
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate180_template(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:409
Q_STATIC_TEMPLATE_SPECIALIZATION void qt_memrotate90_template< quint24, quint24 >(const quint24 *src, int srcWidth, int srcHeight, int srcStride, quint24 *dest, int dstStride)
Definition: qmemrotate.cpp:447
unsigned char quint8
Definition: qglobal.h:934
#define Q_STATIC_TEMPLATE_FUNCTION
Definition: qdrawhelper_p.h:85
void Q_GUI_QWS_EXPORT qt_memrotate180(const quint32 *, int, int, int, quint32 *, int)
void Q_GUI_EXPORT qt_memrotate90_gl(const quint32 *src, int srcWidth, int srcHeight, int srcStride, quint32 *dest, int dstStride)
Definition: qmemrotate.cpp:591
void Q_GUI_EXPORT qt_memrotate90(const quint32 *, int, int, int, quint32 *, int)
Q_STATIC_TEMPLATE_SPECIALIZATION void qt_memrotate90_template< quint18, quint32 >(const quint32 *src, int srcWidth, int srcHeight, int srcStride, quint18 *dest, int dstStride)
Definition: qmemrotate.cpp:493
#define QT_IMPL_SIMPLE_MEMROTATE(srctype, desttype)
Definition: qmemrotate.cpp:531
Q_DECL_CONSTEXPR const T & qMax(const T &a, const T &b)
Definition: qglobal.h:1217
void qt_memrotate90_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:612
unsigned char uchar
Definition: qglobal.h:994
#define Q_STATIC_TEMPLATE_SPECIALIZATION
Definition: qdrawhelper_p.h:77
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
void qt_memrotate270_16(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:607
unsigned short quint16
Definition: qglobal.h:936
unsigned int uint
Definition: qglobal.h:996
qrgb_gl_rgba(quint32 v)
Definition: qmemrotate.cpp:578
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_cachedWrite(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:94
unsigned short ushort
Definition: qglobal.h:995
void Q_GUI_QWS_EXPORT qt_memrotate270(const quint32 *, int, int, int, quint32 *, int)
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_cachedRead(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:74
quint32 data
Definition: qmemrotate.cpp:588
unsigned int quint32
Definition: qglobal.h:938
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_cachedRead(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:57
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_template(const SRC *src, int srcWidth, int srcHeight, int srcStride, DST *dest, int dstStride)
Definition: qmemrotate.cpp:389
MemRotateFunc qMemRotateFunctions[QImage::NImageFormats][3]
Definition: qmemrotate.cpp:627
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_template(const SRC *src, int srcWidth, int srcHeight, int srcStride, DST *dest, int dstStride)
Definition: qmemrotate.cpp:425
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_packing(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:168
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate270_tiled(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:299
void qt_memrotate270_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:622
static const int tileSize
Definition: qmemrotate.cpp:47
void(* MemRotateFunc)(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
void qt_memrotate180_32(const uchar *srcPixels, int w, int h, int sbpl, uchar *destPixels, int dbpl)
Definition: qmemrotate.cpp:617
Q_STATIC_TEMPLATE_FUNCTION void qt_memrotate90_packing(const SRC *src, int w, int h, int sstride, DST *dest, int dstride)
Definition: qmemrotate.cpp:127