← Back to branch summary

~itmages/itmages/itmages-windows-extension

« back to all changes in this revision

Viewing changes to imagefunc.c

  • Committer: Dmitry
  • Date: 2012-03-11 07:56:24 UTC
  • Revision ID: git-v1:d5a30bf1fe74b46641b08d0151d39dba15b67f0e
Migrate from launchpad

Show diffs side-by-side

added added

removed removed

Lines of Context:
imagefunc.c
 
1
/*
 
2
    ITmages  upload client for Windows
 
3
    Copyright (C) 2011 Dmitriy Simbiriatin <slpiv@mail.ru>
 
4
 
 
5
    This program is free software; you can redistribute it and/or
 
6
    modify it under the terms of the GNU General Public License
 
7
    as published by the Free Software Foundation; either version 2
 
8
    of the License, or (at your option) any later version.
 
9
 
 
10
    This program is distributed in the hope that it will be useful,
 
11
    but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
    GNU General Public License for more details.
 
14
 
 
15
    You should have received a copy of the GNU General Public License
 
16
    along with this program; if not, write to the Free Software
 
17
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 
18
 */
 
19
 
 
20
#include <windows.h>
 
21
#include <wchar.h>
 
22
#include <wctype.h>
 
23
#include <FreeImage.h>
 
24
#include "imagefunc.h"
 
25
#include "enconv.h"
 
26
#include "errorshandler.h"
 
27
 
 
28
void SetExtToLower(wchar_t *ext)
 
29
{
 
30
    size_t i;
 
31
 
 
32
    for (i = 0; i < wcslen(ext); ++i) {
 
33
        ext[i] = towlower(ext[i]);
 
34
    }
 
35
}
 
36
 
 
37
size_t GetFilterType(size_t filter_index)
 
38
{
 
39
    size_t filter_type;
 
40
 
 
41
    switch (filter_index) {
 
42
    case 0:
 
43
        filter_type = FILTER_LANCZOS3; // Lanczos filter
 
44
        break;
 
45
    case 1:
 
46
        filter_type = FILTER_BOX; // Box filter
 
47
        break;
 
48
    case 2:
 
49
        filter_type = FILTER_BILINEAR; // Bilinear filter
 
50
        break;
 
51
    case 3:
 
52
        filter_type = FILTER_BSPLINE; // B-Spline filter
 
53
        break;
 
54
    }
 
55
    return filter_type;
 
56
}
 
57
 
 
58
int GetImageInfo(
 
59
        wchar_t *image_path,
 
60
        wchar_t *basename,
 
61
        wchar_t *ext,
 
62
        ItmagesImageInfo *imageInfo)
 
63
{
 
64
    FIBITMAP *image = NULL;
 
65
 
 
66
    size_t image_type = FreeImage_GetFileTypeU(image_path, 0);
 
67
 
 
68
    image = FreeImage_LoadU(image_type, image_path, 0);
 
69
    if (image == NULL) {
 
70
        return -1;
 
71
    }
 
72
    
 
73
    imageInfo->mime = (char*) FreeImage_GetFIFMimeType(image_type);
 
74
    imageInfo->fullname = GetImageFullname(basename, ext);
 
75
    imageInfo->width = FreeImage_GetWidth(image);
 
76
    imageInfo->height = FreeImage_GetHeight(image);
 
77
    imageInfo->size = GetImageSize(image_path);
 
78
 
 
79
    if (image) {
 
80
        FreeImage_Unload(image);
 
81
    }
 
82
    return 0;
 
83
}
 
84
 
 
85
void FreeImageInfo(ItmagesImageInfo *imageInfo)
 
86
{
 
87
    if (imageInfo->fullname != NULL) {
 
88
        free(imageInfo->fullname);
 
89
        imageInfo->fullname = NULL;
 
90
    }
 
91
    if (imageInfo->mime != NULL) {
 
92
        imageInfo->mime = NULL;
 
93
    }
 
94
    imageInfo->width = 0;
 
95
    imageInfo->height = 0;
 
96
    imageInfo->size = 0;
 
97
}
 
98
 
 
99
int ResizeImageTo(
 
100
        wchar_t *image_path,
 
101
        size_t new_width,
 
102
        size_t filter_index)
 
103
{
 
104
    FIBITMAP *image = NULL;
 
105
    FIBITMAP *resized_image = NULL;
 
106
 
 
107
    float width, height, ratio;
 
108
    size_t new_height;
 
109
 
 
110
    size_t image_type = FreeImage_GetFileTypeU(image_path, 0);
 
111
 
 
112
    image = FreeImage_LoadU(image_type, image_path, 0);
 
113
    if (image == NULL) {
 
114
        return -1;
 
115
    }
 
116
    width = FreeImage_GetWidth(image);
 
117
    height = FreeImage_GetHeight(image);
 
118
 
 
119
    ratio = width / new_width;
 
120
    new_height = height / ratio;
 
121
        
 
122
        if (new_width < 1) {
 
123
                new_width = 1;
 
124
        }
 
125
    if (new_height < 1) {
 
126
        new_height = 1;
 
127
    }
 
128
 
 
129
    if (new_height > height) {
 
130
        if (image) FreeImage_Unload(image);
 
131
        return -1;
 
132
    }
 
133
 
 
134
    size_t filter_type = GetFilterType(filter_index);
 
135
    resized_image = FreeImage_Rescale(image, new_width, new_height, filter_type);
 
136
    if (resized_image == NULL) {
 
137
        if (image) FreeImage_Unload(image);
 
138
        return -1;
 
139
    }
 
140
    FreeImage_SaveU(image_type, resized_image, image_path, 0);
 
141
 
 
142
    if (resized_image) {
 
143
        FreeImage_Unload(resized_image);
 
144
    }
 
145
 
 
146
    if (image) {
 
147
        FreeImage_Unload(image);
 
148
    }
 
149
 
 
150
    return 0;
 
151
}
 
152
 
 
153
int RotateImageTo(wchar_t *image_path, int angle)
 
154
{
 
155
    FIBITMAP *image = NULL;
 
156
    FIBITMAP *rotated_image = NULL;
 
157
 
 
158
    size_t image_type = FreeImage_GetFileTypeU(image_path, 0);
 
159
 
 
160
    image = FreeImage_LoadU(image_type, image_path, 0);
 
161
    if (image == NULL) {
 
162
        return -1;
 
163
    }
 
164
 
 
165
    rotated_image = FreeImage_Rotate(image, angle, NULL);
 
166
    if (rotated_image == NULL) {
 
167
        if (image) FreeImage_Unload(image);
 
168
        return -1;
 
169
    }
 
170
    FreeImage_SaveU(image_type, rotated_image, image_path, 0);
 
171
 
 
172
    if (rotated_image) {
 
173
        FreeImage_Unload(rotated_image);
 
174
    }
 
175
 
 
176
    if (image) {
 
177
        FreeImage_Unload(image);
 
178
    }
 
179
 
 
180
    return 0;
 
181
}
 
182
 
 
183
HBITMAP HBITMAPFromFile(
 
184
        HWND image_wnd,
 
185
        wchar_t *image_path,
 
186
        size_t max_width,
 
187
        size_t max_height)
 
188
{
 
189
    FIBITMAP *image = NULL;
 
190
    FIBITMAP *resized_image = NULL;
 
191
 
 
192
    size_t width, height, new_width, new_height;
 
193
 
 
194
    size_t image_type = FreeImage_GetFileTypeU(image_path, 0);
 
195
 
 
196
    image = FreeImage_LoadU(image_type, image_path, 0);
 
197
    if (image == NULL) {
 
198
        return NULL;
 
199
    }
 
200
        
 
201
    width = FreeImage_GetWidth(image);
 
202
    height = FreeImage_GetHeight(image);
 
203
 
 
204
    if (width <= max_width) {
 
205
        new_width = width;
 
206
    } else {
 
207
        new_width = max_width;
 
208
    }
 
209
    if (height <= max_height) {
 
210
        new_height = height;
 
211
    } else {
 
212
        new_height = max_height;
 
213
    }
 
214
 
 
215
    resized_image = FreeImage_Rescale(image, new_width, new_height, FILTER_BOX);
 
216
    if (resized_image == NULL) {
 
217
        if (image) FreeImage_Unload(image);
 
218
        return NULL;
 
219
    }
 
220
 
 
221
    HBITMAP bitmap;
 
222
    HDC image_dc;
 
223
 
 
224
    image_dc = GetDC(image_wnd);
 
225
    bitmap = CreateDIBitmap(
 
226
            image_dc,
 
227
            FreeImage_GetInfoHeader(resized_image),
 
228
            CBM_INIT,
 
229
            FreeImage_GetBits(resized_image),
 
230
            FreeImage_GetInfo(resized_image),
 
231
            DIB_RGB_COLORS);
 
232
    DeleteDC(image_dc);
 
233
    ReleaseDC(image_wnd, image_dc);
 
234
 
 
235
    if (resized_image) {
 
236
        FreeImage_Unload(resized_image);
 
237
    }
 
238
 
 
239
    if (image) {
 
240
        FreeImage_Unload(image);
 
241
    }
 
242
 
 
243
    return bitmap;
 
244
}
 
245
 
 
246
int CheckImageExtension(wchar_t *ext)
 
247
{
 
248
    if (
 
249
            wmemcmp(ext, L".jpg", 5) != 0 &&
 
250
            wmemcmp(ext, L".jpeg", 6) != 0 &&
 
251
            wmemcmp(ext, L".png", 5) != 0 &&
 
252
            wmemcmp(ext, L".gif", 5) != 0
 
253
            ) {
 
254
        return -1;
 
255
    }
 
256
    return 0;
 
257
}
 
258
 
 
259
int GetImageSize(wchar_t *image_path)
 
260
{
 
261
    struct _stat image;
 
262
 
 
263
    _wstat(image_path, &image);
 
264
    if (image.st_size > MAX_IMAGE_SIZE) {
 
265
        return -1;
 
266
    } else {
 
267
        return image.st_size;
 
268
    }
 
269
}
 
270
 
 
271
char *GetImageFullname(wchar_t *basename, wchar_t *ext)
 
272
{
 
273
    size_t base_len = wcslen(basename);
 
274
    size_t ext_len = wcslen(ext);
 
275
 
 
276
    wchar_t *fullname = (wchar_t*) malloc((base_len + ext_len + 1) * sizeof (wchar_t));
 
277
    if (fullname == NULL) {
 
278
        ErrorsHandler(ERROR_MEMALLOC);
 
279
        exit(EXIT_FAILURE);
 
280
    }
 
281
 
 
282
    wmemcpy(fullname, basename, base_len + 1);
 
283
    wmemcpy(fullname + base_len, ext, ext_len + 1);
 
284
 
 
285
    char *fullname_mb = WideToUtf8(fullname);
 
286
    free(fullname);
 
287
        
 
288
    return fullname_mb;
 
289
}
 
 
b'\\ No newline at end of file'