1 // ==========================================================
2 // Flipping routines
3 //
4 // Design and implementation by
5 // - Floris van den Berg (flvdberg@wxs.nl)
6 // - Herv� Drolon (drolon@infonie.fr)
7 // - Jim Keir (jimkeir@users.sourceforge.net)
8 //
9 // This file is part of FreeImage 3
10 //
11 // COVERED CODE IS PROVIDED UNDER THIS LICENSE ON AN "AS IS" BASIS, WITHOUT WARRANTY
12 // OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, WITHOUT LIMITATION, WARRANTIES
13 // THAT THE COVERED CODE IS FREE OF DEFECTS, MERCHANTABLE, FIT FOR A PARTICULAR PURPOSE
14 // OR NON-INFRINGING. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE COVERED
15 // CODE IS WITH YOU. SHOULD ANY COVERED CODE PROVE DEFECTIVE IN ANY RESPECT, YOU (NOT
16 // THE INITIAL DEVELOPER OR ANY OTHER CONTRIBUTOR) ASSUME THE COST OF ANY NECESSARY
17 // SERVICING, REPAIR OR CORRECTION. THIS DISCLAIMER OF WARRANTY CONSTITUTES AN ESSENTIAL
18 // PART OF THIS LICENSE. NO USE OF ANY COVERED CODE IS AUTHORIZED HEREUNDER EXCEPT UNDER
19 // THIS DISCLAIMER.
20 //
21 // Use at your own risk!
22 // ==========================================================
23
24 #include "FreeImage.h"
25 #include "Utilities.h"
26
27 /**
28 Flip the image horizontally along the vertical axis.
29 @param src Input image to be processed.
30 @return Returns TRUE if successful, FALSE otherwise.
31 */
32 BOOL DLL_CALLCONV
FreeImage_FlipHorizontal(FIBITMAP * src)33 FreeImage_FlipHorizontal(FIBITMAP *src) {
34 if (!FreeImage_HasPixels(src)) return FALSE;
35
36 unsigned line = FreeImage_GetLine(src);
37 unsigned width = FreeImage_GetWidth(src);
38 unsigned height = FreeImage_GetHeight(src);
39
40 unsigned bytespp = FreeImage_GetLine(src) / FreeImage_GetWidth(src);
41
42 // copy between aligned memories
43 BYTE *new_bits = (BYTE*)FreeImage_Aligned_Malloc(line * sizeof(BYTE), FIBITMAP_ALIGNMENT);
44 if (!new_bits) return FALSE;
45
46 // mirror the buffer
47
48 for (unsigned y = 0; y < height; y++) {
49 BYTE *bits = FreeImage_GetScanLine(src, y);
50 memcpy(new_bits, bits, line);
51
52 switch (FreeImage_GetBPP(src)) {
53 case 1 :
54 {
55 for(unsigned x = 0; x < width; x++) {
56 // get pixel at (x, y)
57 BOOL value = (new_bits[x >> 3] & (0x80 >> (x & 0x07))) != 0;
58 // set pixel at (new_x, y)
59 unsigned new_x = width - 1 - x;
60 value ? bits[new_x >> 3] |= (0x80 >> (new_x & 0x7)) : bits[new_x >> 3] &= (0xff7f >> (new_x & 0x7));
61 }
62 }
63 break;
64
65 case 4 :
66 {
67 for(unsigned c = 0; c < line; c++) {
68 bits[c] = new_bits[line - c - 1];
69
70 BYTE nibble = (bits[c] & 0xF0) >> 4;
71
72 bits[c] = bits[c] << 4;
73 bits[c] |= nibble;
74 }
75 }
76 break;
77
78 case 8:
79 {
80 BYTE *dst_data = (BYTE*) bits;
81 BYTE *src_data = (BYTE*) (new_bits + line - bytespp);
82 for(unsigned c = 0; c < width; c++) {
83 *dst_data++ = *src_data--;
84 }
85 }
86 break;
87
88 case 16:
89 {
90 WORD *dst_data = (WORD*) bits;
91 WORD *src_data = (WORD*) (new_bits + line - bytespp);
92 for(unsigned c = 0; c < width; c++) {
93 *dst_data++ = *src_data--;
94 }
95 }
96 break;
97
98 case 24 :
99 case 32 :
100 case 48:
101 case 64:
102 case 96:
103 case 128:
104 {
105 BYTE *dst_data = (BYTE*) bits;
106 BYTE *src_data = (BYTE*) (new_bits + line - bytespp);
107 for(unsigned c = 0; c < width; c++) {
108 for(unsigned k = 0; k < bytespp; k++) {
109 *dst_data++ = src_data[k];
110 }
111 src_data -= bytespp;
112 }
113 }
114 break;
115
116 }
117 }
118
119 FreeImage_Aligned_Free(new_bits);
120
121 return TRUE;
122 }
123
124
125 /**
126 Flip the image vertically along the horizontal axis.
127 @param src Input image to be processed.
128 @return Returns TRUE if successful, FALSE otherwise.
129 */
130
131 BOOL DLL_CALLCONV
FreeImage_FlipVertical(FIBITMAP * src)132 FreeImage_FlipVertical(FIBITMAP *src) {
133 BYTE *From, *Mid;
134
135 if (!FreeImage_HasPixels(src)) return FALSE;
136
137 // swap the buffer
138
139 unsigned pitch = FreeImage_GetPitch(src);
140 unsigned height = FreeImage_GetHeight(src);
141
142 // copy between aligned memories
143 Mid = (BYTE*)FreeImage_Aligned_Malloc(pitch * sizeof(BYTE), FIBITMAP_ALIGNMENT);
144 if (!Mid) return FALSE;
145
146 From = FreeImage_GetBits(src);
147
148 unsigned line_s = 0;
149 unsigned line_t = (height-1) * pitch;
150
151 for(unsigned y = 0; y < height/2; y++) {
152
153 memcpy(Mid, From + line_s, pitch);
154 memcpy(From + line_s, From + line_t, pitch);
155 memcpy(From + line_t, Mid, pitch);
156
157 line_s += pitch;
158 line_t -= pitch;
159
160 }
161
162 FreeImage_Aligned_Free(Mid);
163
164 return TRUE;
165 }
166
167