1 /*
2 * Copyright 2000 Corel Corporation
3 * Copyright 2006 Marcus Meissner
4 * Copyright 2006 CodeWeavers, Aric Stewart
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include "config.h"
22 #include "wine/port.h"
23 #include "wine/library.h"
24
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "wingdi.h"
31 #include "winuser.h"
32 #include "twain.h"
33 #include "gphoto2_i.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(twain);
37
38 #ifdef HAVE_GPHOTO2
39 static void *libjpeg_handle;
40 #define MAKE_FUNCPTR(f) static typeof(f) * p##f
41 MAKE_FUNCPTR(jpeg_std_error);
42 MAKE_FUNCPTR(jpeg_CreateDecompress);
43 MAKE_FUNCPTR(jpeg_read_header);
44 MAKE_FUNCPTR(jpeg_start_decompress);
45 MAKE_FUNCPTR(jpeg_read_scanlines);
46 MAKE_FUNCPTR(jpeg_finish_decompress);
47 MAKE_FUNCPTR(jpeg_destroy_decompress);
48 #undef MAKE_FUNCPTR
49
50 static void *load_libjpeg(void)
51 {
52 if((libjpeg_handle = wine_dlopen(SONAME_LIBJPEG, RTLD_NOW, NULL, 0)) != NULL) {
53
54 #define LOAD_FUNCPTR(f) \
55 if((p##f = wine_dlsym(libjpeg_handle, #f, NULL, 0)) == NULL) { \
56 libjpeg_handle = NULL; \
57 return NULL; \
58 }
59
60 LOAD_FUNCPTR(jpeg_std_error);
61 LOAD_FUNCPTR(jpeg_CreateDecompress);
62 LOAD_FUNCPTR(jpeg_read_header);
63 LOAD_FUNCPTR(jpeg_start_decompress);
64 LOAD_FUNCPTR(jpeg_read_scanlines);
65 LOAD_FUNCPTR(jpeg_finish_decompress);
66 LOAD_FUNCPTR(jpeg_destroy_decompress);
67 #undef LOAD_FUNCPTR
68 }
69 return libjpeg_handle;
70 }
71
72
73 /* for the jpeg decompressor source manager. */
74 static void _jpeg_init_source(j_decompress_ptr cinfo) { }
75
76 static boolean _jpeg_fill_input_buffer(j_decompress_ptr cinfo) {
77 ERR("(), should not get here.\n");
78 return FALSE;
79 }
80
81 static void _jpeg_skip_input_data(j_decompress_ptr cinfo,long num_bytes) {
82 TRACE("Skipping %ld bytes...\n", num_bytes);
83 cinfo->src->next_input_byte += num_bytes;
84 cinfo->src->bytes_in_buffer -= num_bytes;
85 }
86
87 static boolean _jpeg_resync_to_restart(j_decompress_ptr cinfo, int desired) {
88 ERR("(desired=%d), should not get here.\n",desired);
89 return FALSE;
90 }
91 static void _jpeg_term_source(j_decompress_ptr cinfo) { }
92 #endif
93
94 /* DG_IMAGE/DAT_CIECOLOR/MSG_GET */
95 TW_UINT16 GPHOTO2_CIEColorGet (pTW_IDENTITY pOrigin,
96 TW_MEMREF pData)
97 {
98 FIXME ("stub!\n");
99
100 return TWRC_FAILURE;
101 }
102
103 /* DG_IMAGE/DAT_EXTIMAGEINFO/MSG_GET */
104 TW_UINT16 GPHOTO2_ExtImageInfoGet (pTW_IDENTITY pOrigin,
105 TW_MEMREF pData)
106 {
107 FIXME ("stub!\n");
108
109 return TWRC_FAILURE;
110 }
111
112 /* DG_IMAGE/DAT_GRAYRESPONSE/MSG_RESET */
113 TW_UINT16 GPHOTO2_GrayResponseReset (pTW_IDENTITY pOrigin,
114 TW_MEMREF pData)
115 {
116 FIXME ("stub!\n");
117
118 return TWRC_FAILURE;
119 }
120
121 /* DG_IMAGE/DAT_GRAYRESPONSE/MSG_SET */
122 TW_UINT16 GPHOTO2_GrayResponseSet (pTW_IDENTITY pOrigin,
123 TW_MEMREF pData)
124 {
125 FIXME ("stub!\n");
126
127 return TWRC_FAILURE;
128 }
129
130 /* DG_IMAGE/DAT_IMAGEFILEXFER/MSG_GET */
131 TW_UINT16 GPHOTO2_ImageFileXferGet (pTW_IDENTITY pOrigin,
132 TW_MEMREF pData)
133 {
134 FIXME ("stub!\n");
135
136 return TWRC_FAILURE;
137 }
138
139 #ifdef HAVE_GPHOTO2
140 static TW_UINT16 _get_image_and_startup_jpeg(void) {
141 const char *folder = NULL, *filename = NULL;
142 struct gphoto2_file *file;
143 const unsigned char *filedata;
144 unsigned long filesize;
145 int ret;
146
147 if (activeDS.file) /* Already loaded. */
148 return TWRC_SUCCESS;
149
150 if(!libjpeg_handle) {
151 if(!load_libjpeg()) {
152 FIXME("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG);
153 filedata = NULL;
154 return TWRC_FAILURE;
155 }
156 }
157
158 LIST_FOR_EACH_ENTRY( file, &activeDS.files, struct gphoto2_file, entry ) {
159 if (strstr(file->filename,".JPG") || strstr(file->filename,".jpg")) {
160 filename = file->filename;
161 folder = file->folder;
162 TRACE("downloading %s/%s\n", folder, filename);
163 if (file->download) {
164 file->download = FALSE; /* mark as done */
165 break;
166 }
167 }
168 }
169 gp_file_new (&activeDS.file);
170 ret = gp_camera_file_get(activeDS.camera, folder, filename, GP_FILE_TYPE_NORMAL,
171 activeDS.file, activeDS.context);
172 if (ret < GP_OK) {
173 FIXME("Failed to get file?\n");
174 activeDS.twCC = TWCC_SEQERROR;
175 return TWRC_FAILURE;
176 }
177 ret = gp_file_get_data_and_size (activeDS.file, (const char**)&filedata, &filesize);
178 if (ret < GP_OK) {
179 FIXME("Failed to get file data?\n");
180 activeDS.twCC = TWCC_SEQERROR;
181 return TWRC_FAILURE;
182 }
183
184 /* This is basically so we can use in-memory data for jpeg decompression.
185 * We need to have all the functions.
186 */
187 activeDS.xjsm.next_input_byte = filedata;
188 activeDS.xjsm.bytes_in_buffer = filesize;
189 activeDS.xjsm.init_source = _jpeg_init_source;
190 activeDS.xjsm.fill_input_buffer = _jpeg_fill_input_buffer;
191 activeDS.xjsm.skip_input_data = _jpeg_skip_input_data;
192 activeDS.xjsm.resync_to_restart = _jpeg_resync_to_restart;
193 activeDS.xjsm.term_source = _jpeg_term_source;
194
195 activeDS.jd.err = pjpeg_std_error(&activeDS.jerr);
196 /* jpeg_create_decompress is a macro that expands to jpeg_CreateDecompress - see jpeglib.h
197 * jpeg_create_decompress(&jd); */
198 pjpeg_CreateDecompress(&activeDS.jd, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct));
199 activeDS.jd.src = &activeDS.xjsm;
200 ret=pjpeg_read_header(&activeDS.jd,TRUE);
201 activeDS.jd.out_color_space = JCS_RGB;
202 pjpeg_start_decompress(&activeDS.jd);
203 if (ret != JPEG_HEADER_OK) {
204 ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
205 gp_file_unref (activeDS.file);
206 activeDS.file = NULL;
207 return TWRC_FAILURE;
208 }
209 return TWRC_SUCCESS;
210 }
211 #endif
212
213 /* DG_IMAGE/DAT_IMAGEINFO/MSG_GET */
214 TW_UINT16 GPHOTO2_ImageInfoGet (pTW_IDENTITY pOrigin,
215 TW_MEMREF pData)
216 {
217 #ifdef HAVE_GPHOTO2
218 pTW_IMAGEINFO pImageInfo = (pTW_IMAGEINFO) pData;
219
220 TRACE("DG_IMAGE/DAT_IMAGEINFO/MSG_GET\n");
221
222 if (activeDS.currentState != 6 && activeDS.currentState != 7) {
223 activeDS.twCC = TWCC_SEQERROR;
224 return TWRC_FAILURE;
225 }
226 if (TWRC_SUCCESS != _get_image_and_startup_jpeg()) {
227 FIXME("Failed to get an image\n");
228 activeDS.twCC = TWCC_SEQERROR;
229 return TWRC_FAILURE;
230 }
231 if (activeDS.currentState == 6)
232 {
233 /* return general image description information about the image about to be transferred */
234 TRACE("Getting parameters\n");
235 }
236 TRACE("activeDS.jd.output_width = %d\n", activeDS.jd.output_width);
237 TRACE("activeDS.jd.output_height = %d\n", activeDS.jd.output_height);
238 pImageInfo->Compression = TWCP_NONE;
239 pImageInfo->SamplesPerPixel = 3;
240 pImageInfo->BitsPerSample[0]= 8;
241 pImageInfo->BitsPerSample[1]= 8;
242 pImageInfo->BitsPerSample[2]= 8;
243 pImageInfo->PixelType = TWPT_RGB;
244 pImageInfo->Planar = FALSE; /* R-G-B is chunky! */
245 pImageInfo->XResolution.Whole = -1;
246 pImageInfo->XResolution.Frac = 0;
247 pImageInfo->YResolution.Whole = -1;
248 pImageInfo->YResolution.Frac = 0;
249 pImageInfo->ImageWidth = activeDS.jd.output_width;
250 pImageInfo->ImageLength = activeDS.jd.output_height;
251 pImageInfo->BitsPerPixel = 24;
252 return TWRC_SUCCESS;
253 #else
254 return TWRC_FAILURE;
255 #endif
256 }
257
258 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_GET */
259 TW_UINT16 GPHOTO2_ImageLayoutGet (pTW_IDENTITY pOrigin,
260 TW_MEMREF pData)
261 {
262 FIXME ("stub!\n");
263
264 return TWRC_FAILURE;
265 }
266
267 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_GETDEFAULT */
268 TW_UINT16 GPHOTO2_ImageLayoutGetDefault (pTW_IDENTITY pOrigin,
269 TW_MEMREF pData)
270 {
271 FIXME ("stub!\n");
272
273 return TWRC_FAILURE;
274 }
275
276 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_RESET */
277 TW_UINT16 GPHOTO2_ImageLayoutReset (pTW_IDENTITY pOrigin,
278 TW_MEMREF pData)
279 {
280 FIXME ("stub!\n");
281
282 return TWRC_FAILURE;
283 }
284
285 /* DG_IMAGE/DAT_IMAGELAYOUT/MSG_SET */
286 TW_UINT16 GPHOTO2_ImageLayoutSet (pTW_IDENTITY pOrigin,
287 TW_MEMREF pData)
288 {
289 FIXME ("stub!\n");
290
291 return TWRC_FAILURE;
292 }
293
294 /* DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET */
295 TW_UINT16 GPHOTO2_ImageMemXferGet (pTW_IDENTITY pOrigin,
296 TW_MEMREF pData)
297 {
298 #ifdef HAVE_GPHOTO2
299 TW_UINT16 twRC = TWRC_SUCCESS;
300 pTW_IMAGEMEMXFER pImageMemXfer = (pTW_IMAGEMEMXFER) pData;
301 LPBYTE buffer;
302 int readrows;
303 unsigned int curoff;
304
305 TRACE ("DG_IMAGE/DAT_IMAGEMEMXFER/MSG_GET\n");
306 if (activeDS.currentState < 6 || activeDS.currentState > 7) {
307 activeDS.twCC = TWCC_SEQERROR;
308 return TWRC_FAILURE;
309 }
310 TRACE("pImageMemXfer.Compression is %d\n", pImageMemXfer->Compression);
311 if (activeDS.currentState == 6) {
312 if (TWRC_SUCCESS != _get_image_and_startup_jpeg()) {
313 FIXME("Failed to get an image\n");
314 activeDS.twCC = TWCC_SEQERROR;
315 return TWRC_FAILURE;
316 }
317
318 if (!activeDS.progressWnd)
319 activeDS.progressWnd = TransferringDialogBox(NULL,0);
320 TransferringDialogBox(activeDS.progressWnd,0);
321
322 activeDS.currentState = 7;
323 } else {
324 if (!activeDS.file) {
325 activeDS.twCC = TWRC_SUCCESS;
326 return TWRC_XFERDONE;
327 }
328 }
329
330 if (pImageMemXfer->Memory.Flags & TWMF_HANDLE) {
331 FIXME("Memory Handle, may not be locked correctly\n");
332 buffer = LocalLock(pImageMemXfer->Memory.TheMem);
333 } else
334 buffer = pImageMemXfer->Memory.TheMem;
335
336 memset(buffer,0,pImageMemXfer->Memory.Length);
337 curoff = 0; readrows = 0;
338 pImageMemXfer->YOffset = activeDS.jd.output_scanline;
339 pImageMemXfer->XOffset = 0; /* we do whole strips */
340 while ((activeDS.jd.output_scanline<activeDS.jd.output_height) &&
341 ((pImageMemXfer->Memory.Length - curoff) > activeDS.jd.output_width*activeDS.jd.output_components)
342 ) {
343 JSAMPROW row = buffer+curoff;
344 int x = pjpeg_read_scanlines(&activeDS.jd,&row,1);
345 if (x != 1) {
346 FIXME("failed to read current scanline?\n");
347 break;
348 }
349 readrows++;
350 curoff += activeDS.jd.output_width*activeDS.jd.output_components;
351 }
352 pImageMemXfer->Compression = TWCP_NONE;
353 pImageMemXfer->BytesPerRow = activeDS.jd.output_components * activeDS.jd.output_width;
354 pImageMemXfer->Rows = readrows;
355 pImageMemXfer->Columns = activeDS.jd.output_width; /* we do whole strips */
356 pImageMemXfer->BytesWritten = curoff;
357
358 TransferringDialogBox(activeDS.progressWnd,0);
359
360 if (activeDS.jd.output_scanline == activeDS.jd.output_height) {
361 pjpeg_finish_decompress(&activeDS.jd);
362 pjpeg_destroy_decompress(&activeDS.jd);
363 gp_file_unref (activeDS.file);
364 activeDS.file = NULL;
365 TRACE("xfer is done!\n");
366
367 /*TransferringDialogBox(activeDS.progressWnd, -1);*/
368 twRC = TWRC_XFERDONE;
369 }
370 activeDS.twCC = TWRC_SUCCESS;
371 if (pImageMemXfer->Memory.Flags & TWMF_HANDLE)
372 LocalUnlock(pImageMemXfer->Memory.TheMem);
373 return twRC;
374 #else
375 return TWRC_FAILURE;
376 #endif
377 }
378
379 /* DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET */
380 TW_UINT16 GPHOTO2_ImageNativeXferGet (pTW_IDENTITY pOrigin,
381 TW_MEMREF pData)
382 {
383 #ifdef HAVE_GPHOTO2
384 pTW_UINT32 pHandle = (pTW_UINT32) pData;
385 HBITMAP hDIB;
386 BITMAPINFO bmpInfo;
387 LPBYTE bits, oldbits;
388 JSAMPROW samprow, oldsamprow;
389 HDC dc;
390
391 FIXME("DG_IMAGE/DAT_IMAGENATIVEXFER/MSG_GET: implemented, but expect program crash due to DIB.\n");
392
393 /* NOTE NOTE NOTE NOTE NOTE NOTE NOTE
394 *
395 * While this is a mandatory transfer mode and this function
396 * is correctly implemented and fully works, the calling program
397 * will likely crash after calling.
398 *
399 * Reason is that there is a lot of example code that does:
400 * bmpinfo = (LPBITMAPINFOHEADER)GlobalLock(hBITMAP); ... pointer access to bmpinfo
401 *
402 * Our current HBITMAP handles do not support getting GlobalLocked -> App Crash
403 *
404 * This needs a GDI Handle rewrite, at least for DIB sections.
405 * - Marcus
406 */
407 if (activeDS.currentState != 6) {
408 activeDS.twCC = TWCC_SEQERROR;
409 return TWRC_FAILURE;
410 }
411 if (TWRC_SUCCESS != _get_image_and_startup_jpeg()) {
412 FIXME("Failed to get an image\n");
413 activeDS.twCC = TWCC_OPERATIONERROR;
414 return TWRC_FAILURE;
415 }
416 TRACE("Acquiring image %dx%dx%d bits from gphoto.\n",
417 activeDS.jd.output_width, activeDS.jd.output_height,
418 activeDS.jd.output_components*8);
419 ZeroMemory (&bmpInfo, sizeof (BITMAPINFO));
420 bmpInfo.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
421 bmpInfo.bmiHeader.biWidth = activeDS.jd.output_width;
422 bmpInfo.bmiHeader.biHeight = -activeDS.jd.output_height;
423 bmpInfo.bmiHeader.biPlanes = 1;
424 bmpInfo.bmiHeader.biBitCount = activeDS.jd.output_components*8;
425 bmpInfo.bmiHeader.biCompression = BI_RGB;
426 bmpInfo.bmiHeader.biSizeImage = 0;
427 bmpInfo.bmiHeader.biXPelsPerMeter = 0;
428 bmpInfo.bmiHeader.biYPelsPerMeter = 0;
429 bmpInfo.bmiHeader.biClrUsed = 0;
430 bmpInfo.bmiHeader.biClrImportant = 0;
431 hDIB = CreateDIBSection ((dc = GetDC(activeDS.hwndOwner)), &bmpInfo,
432 DIB_RGB_COLORS, (LPVOID)&bits, 0, 0);
433 if (!hDIB) {
434 FIXME("Failed creating DIB.\n");
435 gp_file_unref (activeDS.file);
436 activeDS.file = NULL;
437 activeDS.twCC = TWCC_LOWMEMORY;
438 return TWRC_FAILURE;
439 }
440 samprow = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,activeDS.jd.output_width*activeDS.jd.output_components);
441 oldbits = bits;
442 oldsamprow = samprow;
443 while ( activeDS.jd.output_scanline<activeDS.jd.output_height ) {
444 int i, x = pjpeg_read_scanlines(&activeDS.jd,&samprow,1);
445 if (x != 1) {
446 FIXME("failed to read current scanline?\n");
447 break;
448 }
449 /* We have to convert from RGB to BGR, see MSDN/ BITMAPINFOHEADER */
450 for(i=0;i<activeDS.jd.output_width;i++,samprow+=activeDS.jd.output_components) {
451 *(bits++) = *(samprow+2);
452 *(bits++) = *(samprow+1);
453 *(bits++) = *(samprow);
454 }
455 bits = (LPBYTE)(((UINT_PTR)bits + 3) & ~3);
456 samprow = oldsamprow;
457 }
458 bits = oldbits;
459 HeapFree (GetProcessHeap(), 0, samprow);
460 gp_file_unref (activeDS.file);
461 activeDS.file = NULL;
462 ReleaseDC (activeDS.hwndOwner, dc);
463 *pHandle = (TW_UINT32)hDIB;
464 activeDS.twCC = TWCC_SUCCESS;
465 activeDS.currentState = 7;
466 return TWRC_XFERDONE;
467 #else
468 return TWRC_FAILURE;
469 #endif
470 }
471
472 /* DG_IMAGE/DAT_JPEGCOMPRESSION/MSG_GET */
473 TW_UINT16 GPHOTO2_JPEGCompressionGet (pTW_IDENTITY pOrigin,
474 TW_MEMREF pData)
475 {
476 FIXME ("stub!\n");
477
478 return TWRC_FAILURE;
479 }
480
481 /* DG_IMAGE/DAT_JPEGCOMPRESSION/MSG_GETDEFAULT */
482 TW_UINT16 GPHOTO2_JPEGCompressionGetDefault (pTW_IDENTITY pOrigin,
483
484 TW_MEMREF pData)
485 {
486 FIXME ("stub!\n");
487
488 return TWRC_FAILURE;
489 }
490
491 /* DG_IMAGE/DAT_JPEGCOMPRESSION/MSG_RESET */
492 TW_UINT16 GPHOTO2_JPEGCompressionReset (pTW_IDENTITY pOrigin,
493 TW_MEMREF pData)
494 {
495 FIXME ("stub!\n");
496
497 return TWRC_FAILURE;
498 }
499
500 /* DG_IMAGE/DAT_JPEGCOMPRESSION/MSG_SET */
501 TW_UINT16 GPHOTO2_JPEGCompressionSet (pTW_IDENTITY pOrigin,
502 TW_MEMREF pData)
503 {
504 FIXME ("stub!\n");
505
506 return TWRC_FAILURE;
507 }
508
509 /* DG_IMAGE/DAT_PALETTE8/MSG_GET */
510 TW_UINT16 GPHOTO2_Palette8Get (pTW_IDENTITY pOrigin,
511 TW_MEMREF pData)
512 {
513 FIXME ("stub!\n");
514
515 return TWRC_FAILURE;
516 }
517
518 /* DG_IMAGE/DAT_PALETTE8/MSG_GETDEFAULT */
519 TW_UINT16 GPHOTO2_Palette8GetDefault (pTW_IDENTITY pOrigin,
520 TW_MEMREF pData)
521 {
522 FIXME ("stub!\n");
523
524 return TWRC_FAILURE;
525 }
526
527 /* DG_IMAGE/DAT_PALETTE8/MSG_RESET */
528 TW_UINT16 GPHOTO2_Palette8Reset (pTW_IDENTITY pOrigin,
529 TW_MEMREF pData)
530 {
531 FIXME ("stub!\n");
532
533 return TWRC_FAILURE;
534 }
535
536 /* DG_IMAGE/DAT_PALETTE8/MSG_SET */
537 TW_UINT16 GPHOTO2_Palette8Set (pTW_IDENTITY pOrigin,
538 TW_MEMREF pData)
539 {
540 FIXME ("stub!\n");
541
542 return TWRC_FAILURE;
543 }
544
545 /* DG_IMAGE/DAT_RGBRESPONSE/MSG_RESET */
546 TW_UINT16 GPHOTO2_RGBResponseReset (pTW_IDENTITY pOrigin,
547 TW_MEMREF pData)
548 {
549 FIXME ("stub!\n");
550
551 return TWRC_FAILURE;
552 }
553
554 /* DG_IMAGE/DAT_RGBRESPONSE/MSG_SET */
555 TW_UINT16 GPHOTO2_RGBResponseSet (pTW_IDENTITY pOrigin,
556 TW_MEMREF pData)
557 {
558 FIXME ("stub!\n");
559
560 return TWRC_FAILURE;
561 }
562
563 #ifdef HAVE_GPHOTO2
564 TW_UINT16
565 _get_gphoto2_file_as_DIB(
566 const char *folder, const char *filename, CameraFileType type,
567 HWND hwnd, HBITMAP *hDIB
568 ) {
569 const unsigned char *filedata;
570 unsigned long filesize;
571 int ret;
572 CameraFile *file;
573 struct jpeg_source_mgr xjsm;
574 struct jpeg_decompress_struct jd;
575 struct jpeg_error_mgr jerr;
576 HDC dc;
577 BITMAPINFO bmpInfo;
578 LPBYTE bits, oldbits;
579 JSAMPROW samprow, oldsamprow;
580
581 if(!libjpeg_handle) {
582 if(!load_libjpeg()) {
583 FIXME("Failed reading JPEG because unable to find %s\n", SONAME_LIBJPEG);
584 filedata = NULL;
585 return TWRC_FAILURE;
586 }
587 }
588
589 gp_file_new (&file);
590 ret = gp_camera_file_get(activeDS.camera, folder, filename, type, file, activeDS.context);
591 if (ret < GP_OK) {
592 FIXME("Failed to get file?\n");
593 gp_file_unref (file);
594 return TWRC_FAILURE;
595 }
596 ret = gp_file_get_data_and_size (file, (const char**)&filedata, &filesize);
597 if (ret < GP_OK) {
598 FIXME("Failed to get file data?\n");
599 return TWRC_FAILURE;
600 }
601
602 /* FIXME: Actually we might get other types than JPEG ... But only handle JPEG for now */
603 if (filedata[0] != 0xff) {
604 ERR("File %s/%s might not be JPEG, cannot decode!\n", folder, filename);
605 }
606
607 /* This is basically so we can use in-memory data for jpeg decompression.
608 * We need to have all the functions.
609 */
610 xjsm.next_input_byte = filedata;
611 xjsm.bytes_in_buffer = filesize;
612 xjsm.init_source = _jpeg_init_source;
613 xjsm.fill_input_buffer = _jpeg_fill_input_buffer;
614 xjsm.skip_input_data = _jpeg_skip_input_data;
615 xjsm.resync_to_restart = _jpeg_resync_to_restart;
616 xjsm.term_source = _jpeg_term_source;
617
618 jd.err = pjpeg_std_error(&jerr);
619 /* jpeg_create_decompress is a macro that expands to jpeg_CreateDecompress - see jpeglib.h
620 * jpeg_create_decompress(&jd); */
621 pjpeg_CreateDecompress(&jd, JPEG_LIB_VERSION, (size_t) sizeof(struct jpeg_decompress_struct));
622 jd.src = &xjsm;
623 ret=pjpeg_read_header(&jd,TRUE);
624 jd.out_color_space = JCS_RGB;
625 pjpeg_start_decompress(&jd);
626 if (ret != JPEG_HEADER_OK) {
627 ERR("Jpeg image in stream has bad format, read header returned %d.\n",ret);
628 gp_file_unref (file);
629 return TWRC_FAILURE;
630 }
631
632 ZeroMemory (&bmpInfo, sizeof (BITMAPINFO));
633 bmpInfo.bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
634 bmpInfo.bmiHeader.biWidth = jd.output_width;
635 bmpInfo.bmiHeader.biHeight = -jd.output_height;
636 bmpInfo.bmiHeader.biPlanes = 1;
637 bmpInfo.bmiHeader.biBitCount = jd.output_components*8;
638 bmpInfo.bmiHeader.biCompression = BI_RGB;
639 bmpInfo.bmiHeader.biSizeImage = 0;
640 bmpInfo.bmiHeader.biXPelsPerMeter = 0;
641 bmpInfo.bmiHeader.biYPelsPerMeter = 0;
642 bmpInfo.bmiHeader.biClrUsed = 0;
643 bmpInfo.bmiHeader.biClrImportant = 0;
644 *hDIB = CreateDIBSection ((dc = GetDC(hwnd)), &bmpInfo, DIB_RGB_COLORS, (LPVOID)&bits, 0, 0);
645 if (!*hDIB) {
646 FIXME("Failed creating DIB.\n");
647 gp_file_unref (file);
648 return TWRC_FAILURE;
649 }
650 samprow = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,jd.output_width*jd.output_components);
651 oldbits = bits;
652 oldsamprow = samprow;
653 while ( jd.output_scanline<jd.output_height ) {
654 int i, x = pjpeg_read_scanlines(&jd,&samprow,1);
655 if (x != 1) {
656 FIXME("failed to read current scanline?\n");
657 break;
658 }
659 /* We have to convert from RGB to BGR, see MSDN/ BITMAPINFOHEADER */
660 for(i=0;i<jd.output_width;i++,samprow+=jd.output_components) {
661 *(bits++) = *(samprow+2);
662 *(bits++) = *(samprow+1);
663 *(bits++) = *(samprow);
664 }
665 bits = (LPBYTE)(((UINT_PTR)bits + 3) & ~3);
666 samprow = oldsamprow;
667 }
668 if (hwnd) ReleaseDC (hwnd, dc);
669 HeapFree (GetProcessHeap(), 0, samprow);
670 gp_file_unref (file);
671 return TWRC_SUCCESS;
672 }
673 #endif
674
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.