msi/tests: Return INVALID_FILE_SIZE from get_pf_file_size if the file can't be opened.
[wine] / dlls / gphoto2.ds / ds_image.c
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 = 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 = (UINT_PTR)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