- Fix registered guids for IPortMidi
[reactos.git] / reactos / dll / win32 / gdiplus / image.c
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #include <stdarg.h>
20
21 #include "windef.h"
22 #include "winbase.h"
23 #include "winuser.h"
24 #include "wingdi.h"
25
26 #define COBJMACROS
27 #include "objbase.h"
28 #include "olectl.h"
29 #include "ole2.h"
30
31 #include "initguid.h"
32 #include "gdiplus.h"
33 #include "gdiplus_private.h"
34 #include "wine/debug.h"
35
36 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
37
38 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
39
40 static INT ipicture_pixel_height(IPicture *pic)
41 {
42 HDC hdcref;
43 OLE_YSIZE_HIMETRIC y;
44
45 IPicture_get_Height(pic, &y);
46
47 hdcref = GetDC(0);
48
49 y = MulDiv(y, GetDeviceCaps(hdcref, LOGPIXELSY), INCH_HIMETRIC);
50 ReleaseDC(0, hdcref);
51
52 return y;
53 }
54
55 static INT ipicture_pixel_width(IPicture *pic)
56 {
57 HDC hdcref;
58 OLE_XSIZE_HIMETRIC x;
59
60 IPicture_get_Width(pic, &x);
61
62 hdcref = GetDC(0);
63
64 x = MulDiv(x, GetDeviceCaps(hdcref, LOGPIXELSX), INCH_HIMETRIC);
65
66 ReleaseDC(0, hdcref);
67
68 return x;
69 }
70
71 GpStatus WINGDIPAPI GdipBitmapGetPixel(GpBitmap* bitmap, INT x, INT y,
72 ARGB *color)
73 {
74 static int calls;
75 TRACE("%p %d %d %p\n", bitmap, x, y, color);
76
77 if(!bitmap || !color)
78 return InvalidParameter;
79
80 if(!(calls++))
81 FIXME("not implemented\n");
82
83 *color = 0xdeadbeef;
84
85 return NotImplemented;
86 }
87
88 /* This function returns a pointer to an array of pixels that represents the
89 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
90 * flags. It is correct behavior that a user who calls this function with write
91 * privileges can write to the whole bitmap (not just the area in rect).
92 *
93 * FIXME: only used portion of format is bits per pixel. */
94 GpStatus WINGDIPAPI GdipBitmapLockBits(GpBitmap* bitmap, GDIPCONST GpRect* rect,
95 UINT flags, PixelFormat format, BitmapData* lockeddata)
96 {
97 BOOL bm_is_selected;
98 INT stride, bitspp = PIXELFORMATBPP(format);
99 HDC hdc;
100 HBITMAP hbm, old = NULL;
101 BITMAPINFO *pbmi;
102 BYTE *buff = NULL;
103 UINT abs_height;
104 GpRect act_rect; /* actual rect to be used */
105
106 TRACE("%p %p %d %d %p\n", bitmap, rect, flags, format, lockeddata);
107
108 if(!lockeddata || !bitmap)
109 return InvalidParameter;
110
111 if(rect){
112 if(rect->X < 0 || rect->Y < 0 || (rect->X + rect->Width > bitmap->width) ||
113 (rect->Y + rect->Height > bitmap->height) || !flags)
114 return InvalidParameter;
115
116 act_rect = *rect;
117 }
118 else{
119 act_rect.X = act_rect.Y = 0;
120 act_rect.Width = bitmap->width;
121 act_rect.Height = bitmap->height;
122 }
123
124 if(flags & ImageLockModeUserInputBuf)
125 return NotImplemented;
126
127 if(bitmap->lockmode)
128 return WrongState;
129
130 IPicture_get_Handle(bitmap->image.picture, (OLE_HANDLE*)&hbm);
131 IPicture_get_CurDC(bitmap->image.picture, &hdc);
132 bm_is_selected = (hdc != 0);
133
134 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
135 if (!pbmi)
136 return OutOfMemory;
137 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
138 pbmi->bmiHeader.biBitCount = 0;
139
140 if(!bm_is_selected){
141 hdc = CreateCompatibleDC(0);
142 old = SelectObject(hdc, hbm);
143 }
144
145 /* fill out bmi */
146 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
147
148 abs_height = abs(pbmi->bmiHeader.biHeight);
149 stride = pbmi->bmiHeader.biWidth * bitspp / 8;
150 stride = (stride + 3) & ~3;
151
152 buff = GdipAlloc(stride * abs_height);
153
154 pbmi->bmiHeader.biBitCount = bitspp;
155
156 if(buff)
157 GetDIBits(hdc, hbm, 0, abs_height, buff, pbmi, DIB_RGB_COLORS);
158
159 if(!bm_is_selected){
160 SelectObject(hdc, old);
161 DeleteDC(hdc);
162 }
163
164 if(!buff){
165 GdipFree(pbmi);
166 return OutOfMemory;
167 }
168
169 lockeddata->Width = act_rect.Width;
170 lockeddata->Height = act_rect.Height;
171 lockeddata->PixelFormat = format;
172 lockeddata->Reserved = flags;
173
174 if(pbmi->bmiHeader.biHeight > 0){
175 lockeddata->Stride = -stride;
176 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X +
177 stride * (abs_height - 1 - act_rect.Y);
178 }
179 else{
180 lockeddata->Stride = stride;
181 lockeddata->Scan0 = buff + (bitspp / 8) * act_rect.X + stride * act_rect.Y;
182 }
183
184 bitmap->lockmode = flags;
185 bitmap->numlocks++;
186
187 bitmap->bitmapbits = buff;
188
189 GdipFree(pbmi);
190 return Ok;
191 }
192
193 GpStatus WINGDIPAPI GdipBitmapUnlockBits(GpBitmap* bitmap,
194 BitmapData* lockeddata)
195 {
196 HDC hdc;
197 HBITMAP hbm, old = NULL;
198 BOOL bm_is_selected;
199 BITMAPINFO *pbmi;
200
201 if(!bitmap || !lockeddata)
202 return InvalidParameter;
203
204 if(!bitmap->lockmode)
205 return WrongState;
206
207 if(lockeddata->Reserved & ImageLockModeUserInputBuf)
208 return NotImplemented;
209
210 if(lockeddata->Reserved & ImageLockModeRead){
211 if(!(--bitmap->numlocks))
212 bitmap->lockmode = 0;
213
214 GdipFree(bitmap->bitmapbits);
215 bitmap->bitmapbits = NULL;
216 return Ok;
217 }
218
219 IPicture_get_Handle(bitmap->image.picture, (OLE_HANDLE*)&hbm);
220 IPicture_get_CurDC(bitmap->image.picture, &hdc);
221 bm_is_selected = (hdc != 0);
222
223 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
224 pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
225 pbmi->bmiHeader.biBitCount = 0;
226
227 if(!bm_is_selected){
228 hdc = CreateCompatibleDC(0);
229 old = SelectObject(hdc, hbm);
230 }
231
232 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
233 pbmi->bmiHeader.biBitCount = PIXELFORMATBPP(lockeddata->PixelFormat);
234 SetDIBits(hdc, hbm, 0, abs(pbmi->bmiHeader.biHeight),
235 bitmap->bitmapbits, pbmi, DIB_RGB_COLORS);
236
237 if(!bm_is_selected){
238 SelectObject(hdc, old);
239 DeleteDC(hdc);
240 }
241
242 GdipFree(pbmi);
243 GdipFree(bitmap->bitmapbits);
244 bitmap->bitmapbits = NULL;
245 bitmap->lockmode = 0;
246
247 return Ok;
248 }
249
250 GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
251 {
252 IStream* stream;
253 HRESULT hr;
254 INT size;
255 LARGE_INTEGER move;
256 GpStatus stat = GenericError;
257
258 TRACE("%p, %p\n", image, cloneImage);
259
260 if (!image || !cloneImage)
261 return InvalidParameter;
262
263 hr = CreateStreamOnHGlobal(0, TRUE, &stream);
264 if (FAILED(hr))
265 return GenericError;
266
267 hr = IPicture_SaveAsFile(image->picture, stream, FALSE, &size);
268 if(FAILED(hr))
269 {
270 WARN("Failed to save image on stream\n");
271 goto out;
272 }
273
274 /* Set seek pointer back to the beginning of the picture */
275 move.QuadPart = 0;
276 hr = IStream_Seek(stream, move, STREAM_SEEK_SET, NULL);
277 if (FAILED(hr))
278 goto out;
279
280 stat = GdipLoadImageFromStream(stream, cloneImage);
281 if (stat != Ok) WARN("Failed to load image from stream\n");
282
283 out:
284 IStream_Release(stream);
285 return stat;
286 }
287
288 GpStatus WINGDIPAPI GdipCreateBitmapFromFile(GDIPCONST WCHAR* filename,
289 GpBitmap **bitmap)
290 {
291 GpStatus stat;
292 IStream *stream;
293
294 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
295
296 if(!filename || !bitmap)
297 return InvalidParameter;
298
299 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
300
301 if(stat != Ok)
302 return stat;
303
304 stat = GdipCreateBitmapFromStream(stream, bitmap);
305
306 IStream_Release(stream);
307
308 return stat;
309 }
310
311 GpStatus WINGDIPAPI GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO* info,
312 VOID *bits, GpBitmap **bitmap)
313 {
314 DWORD height, stride;
315 PixelFormat format;
316
317 FIXME("(%p, %p, %p) - partially implemented\n", info, bits, bitmap);
318
319 height = abs(info->bmiHeader.biHeight);
320 stride = ((info->bmiHeader.biWidth * info->bmiHeader.biBitCount + 31) >> 3) & ~3;
321
322 if(info->bmiHeader.biHeight > 0) /* bottom-up */
323 {
324 bits = (BYTE*)bits + (height - 1) * stride;
325 stride = -stride;
326 }
327
328 switch(info->bmiHeader.biBitCount) {
329 case 1:
330 format = PixelFormat1bppIndexed;
331 break;
332 case 4:
333 format = PixelFormat4bppIndexed;
334 break;
335 case 8:
336 format = PixelFormat8bppIndexed;
337 break;
338 case 24:
339 format = PixelFormat24bppRGB;
340 break;
341 default:
342 FIXME("don't know how to handle %d bpp\n", info->bmiHeader.biBitCount);
343 *bitmap = NULL;
344 return InvalidParameter;
345 }
346
347 return GdipCreateBitmapFromScan0(info->bmiHeader.biWidth, height, stride, format,
348 bits, bitmap);
349
350 }
351
352 /* FIXME: no icm */
353 GpStatus WINGDIPAPI GdipCreateBitmapFromFileICM(GDIPCONST WCHAR* filename,
354 GpBitmap **bitmap)
355 {
356 TRACE("(%s) %p\n", debugstr_w(filename), bitmap);
357
358 return GdipCreateBitmapFromFile(filename, bitmap);
359 }
360
361 GpStatus WINGDIPAPI GdipCreateBitmapFromResource(HINSTANCE hInstance,
362 GDIPCONST WCHAR* lpBitmapName, GpBitmap** bitmap)
363 {
364 HBITMAP hbm;
365 GpStatus stat = InvalidParameter;
366
367 TRACE("%p (%s) %p\n", hInstance, debugstr_w(lpBitmapName), bitmap);
368
369 if(!lpBitmapName || !bitmap)
370 return InvalidParameter;
371
372 /* load DIB */
373 hbm = LoadImageW(hInstance, lpBitmapName, IMAGE_BITMAP, 0, 0,
374 LR_CREATEDIBSECTION);
375
376 if(hbm){
377 stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, bitmap);
378 DeleteObject(hbm);
379 }
380
381 return stat;
382 }
383
384 GpStatus WINGDIPAPI GdipCreateHBITMAPFromBitmap(GpBitmap* bitmap,
385 HBITMAP* hbmReturn, ARGB background)
386 {
387 FIXME("stub\n");
388
389 hbmReturn = NULL;
390
391 return NotImplemented;
392 }
393
394 GpStatus WINGDIPAPI GdipConvertToEmfPlus(const GpGraphics* ref,
395 GpMetafile* metafile, BOOL* succ, EmfType emfType,
396 const WCHAR* description, GpMetafile** out_metafile)
397 {
398 static int calls;
399
400 if(!ref || !metafile || !out_metafile)
401 return InvalidParameter;
402
403 *succ = FALSE;
404 *out_metafile = NULL;
405
406 if(!(calls++))
407 FIXME("not implemented\n");
408
409 return NotImplemented;
410 }
411
412 /* FIXME: this should create a bitmap in the given size with the attributes
413 * (resolution etc.) of the graphics object */
414 GpStatus WINGDIPAPI GdipCreateBitmapFromGraphics(INT width, INT height,
415 GpGraphics* target, GpBitmap** bitmap)
416 {
417 static int calls;
418 GpStatus ret;
419
420 if(!target || !bitmap)
421 return InvalidParameter;
422
423 if(!(calls++))
424 FIXME("hacked stub\n");
425
426 ret = GdipCreateBitmapFromScan0(width, height, 0, PixelFormat24bppRGB,
427 NULL, bitmap);
428
429 return ret;
430 }
431
432 GpStatus WINGDIPAPI GdipCreateBitmapFromScan0(INT width, INT height, INT stride,
433 PixelFormat format, BYTE* scan0, GpBitmap** bitmap)
434 {
435 BITMAPFILEHEADER *bmfh;
436 BITMAPINFOHEADER *bmih;
437 BYTE *buff;
438 INT datalen, size;
439 IStream *stream;
440
441 TRACE("%d %d %d %d %p %p\n", width, height, stride, format, scan0, bitmap);
442
443 if (!bitmap) return InvalidParameter;
444
445 if(width <= 0 || height <= 0 || (scan0 && (stride % 4))){
446 *bitmap = NULL;
447 return InvalidParameter;
448 }
449
450 if(scan0 && !stride)
451 return InvalidParameter;
452
453 /* FIXME: windows allows negative stride (reads backwards from scan0) */
454 if(stride < 0){
455 FIXME("negative stride\n");
456 return InvalidParameter;
457 }
458
459 *bitmap = GdipAlloc(sizeof(GpBitmap));
460 if(!*bitmap) return OutOfMemory;
461
462 if(stride == 0){
463 stride = width * (PIXELFORMATBPP(format) / 8);
464 stride = (stride + 3) & ~3;
465 }
466
467 datalen = abs(stride * height);
468 size = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + datalen;
469 buff = GdipAlloc(size);
470 if(!buff){
471 GdipFree(*bitmap);
472 return OutOfMemory;
473 }
474
475 bmfh = (BITMAPFILEHEADER*) buff;
476 bmih = (BITMAPINFOHEADER*) (bmfh + 1);
477
478 bmfh->bfType = (((WORD)'M') << 8) + (WORD)'B';
479 bmfh->bfSize = size;
480 bmfh->bfOffBits = size - datalen;
481
482 bmih->biSize = sizeof(BITMAPINFOHEADER);
483 bmih->biWidth = width;
484 bmih->biHeight = -height;
485 /* FIXME: use the rest of the data from format */
486 bmih->biBitCount = PIXELFORMATBPP(format);
487 bmih->biCompression = BI_RGB;
488 bmih->biSizeImage = datalen;
489
490 if(scan0)
491 memcpy(bmih + 1, scan0, datalen);
492 else
493 memset(bmih + 1, 0, datalen);
494
495 if(CreateStreamOnHGlobal(buff, TRUE, &stream) != S_OK){
496 ERR("could not make stream\n");
497 GdipFree(*bitmap);
498 GdipFree(buff);
499 return GenericError;
500 }
501
502 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
503 (LPVOID*) &((*bitmap)->image.picture)) != S_OK){
504 TRACE("Could not load picture\n");
505 IStream_Release(stream);
506 GdipFree(*bitmap);
507 GdipFree(buff);
508 return GenericError;
509 }
510
511 (*bitmap)->image.type = ImageTypeBitmap;
512 (*bitmap)->image.flags = ImageFlagsNone;
513 (*bitmap)->width = width;
514 (*bitmap)->height = height;
515 (*bitmap)->format = format;
516
517 return Ok;
518 }
519
520 GpStatus WINGDIPAPI GdipCreateBitmapFromStream(IStream* stream,
521 GpBitmap **bitmap)
522 {
523 GpStatus stat;
524
525 TRACE("%p %p\n", stream, bitmap);
526
527 stat = GdipLoadImageFromStream(stream, (GpImage**) bitmap);
528
529 if(stat != Ok)
530 return stat;
531
532 if((*bitmap)->image.type != ImageTypeBitmap){
533 IPicture_Release((*bitmap)->image.picture);
534 GdipFree(bitmap);
535 return GenericError; /* FIXME: what error to return? */
536 }
537
538 return Ok;
539 }
540
541 /* FIXME: no icm */
542 GpStatus WINGDIPAPI GdipCreateBitmapFromStreamICM(IStream* stream,
543 GpBitmap **bitmap)
544 {
545 TRACE("%p %p\n", stream, bitmap);
546
547 return GdipCreateBitmapFromStream(stream, bitmap);
548 }
549
550 GpStatus WINGDIPAPI GdipCreateCachedBitmap(GpBitmap *bitmap, GpGraphics *graphics,
551 GpCachedBitmap **cachedbmp)
552 {
553 GpStatus stat;
554
555 TRACE("%p %p %p\n", bitmap, graphics, cachedbmp);
556
557 if(!bitmap || !graphics || !cachedbmp)
558 return InvalidParameter;
559
560 *cachedbmp = GdipAlloc(sizeof(GpCachedBitmap));
561 if(!*cachedbmp)
562 return OutOfMemory;
563
564 stat = GdipCloneImage(&(bitmap->image), &(*cachedbmp)->image);
565 if(stat != Ok){
566 GdipFree(*cachedbmp);
567 return stat;
568 }
569
570 return Ok;
571 }
572
573 GpStatus WINGDIPAPI GdipDeleteCachedBitmap(GpCachedBitmap *cachedbmp)
574 {
575 TRACE("%p\n", cachedbmp);
576
577 if(!cachedbmp)
578 return InvalidParameter;
579
580 GdipDisposeImage(cachedbmp->image);
581 GdipFree(cachedbmp);
582
583 return Ok;
584 }
585
586 GpStatus WINGDIPAPI GdipDrawCachedBitmap(GpGraphics *graphics,
587 GpCachedBitmap *cachedbmp, INT x, INT y)
588 {
589 TRACE("%p %p %d %d\n", graphics, cachedbmp, x, y);
590
591 if(!graphics || !cachedbmp)
592 return InvalidParameter;
593
594 return GdipDrawImage(graphics, cachedbmp->image, (REAL)x, (REAL)y);
595 }
596
597 GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
598 {
599 HDC hdc;
600
601 TRACE("%p\n", image);
602
603 if(!image)
604 return InvalidParameter;
605
606 IPicture_get_CurDC(image->picture, &hdc);
607 DeleteDC(hdc);
608 IPicture_Release(image->picture);
609 if (image->type == ImageTypeBitmap)
610 GdipFree(((GpBitmap*)image)->bitmapbits);
611 GdipFree(image);
612
613 return Ok;
614 }
615
616 GpStatus WINGDIPAPI GdipFindFirstImageItem(GpImage *image, ImageItemData* item)
617 {
618 if(!image || !item)
619 return InvalidParameter;
620
621 return NotImplemented;
622 }
623
624 GpStatus WINGDIPAPI GdipGetImageBounds(GpImage *image, GpRectF *srcRect,
625 GpUnit *srcUnit)
626 {
627 TRACE("%p %p %p\n", image, srcRect, srcUnit);
628
629 if(!image || !srcRect || !srcUnit)
630 return InvalidParameter;
631 if(image->type == ImageTypeMetafile){
632 *srcRect = ((GpMetafile*)image)->bounds;
633 *srcUnit = ((GpMetafile*)image)->unit;
634 }
635 else if(image->type == ImageTypeBitmap){
636 srcRect->X = srcRect->Y = 0.0;
637 srcRect->Width = (REAL) ((GpBitmap*)image)->width;
638 srcRect->Height = (REAL) ((GpBitmap*)image)->height;
639 *srcUnit = UnitPixel;
640 }
641 else{
642 srcRect->X = srcRect->Y = 0.0;
643 srcRect->Width = ipicture_pixel_width(image->picture);
644 srcRect->Height = ipicture_pixel_height(image->picture);
645 *srcUnit = UnitPixel;
646 }
647
648 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect->X, srcRect->Y,
649 srcRect->Width, srcRect->Height, *srcUnit);
650
651 return Ok;
652 }
653
654 GpStatus WINGDIPAPI GdipGetImageDimension(GpImage *image, REAL *width,
655 REAL *height)
656 {
657 TRACE("%p %p %p\n", image, width, height);
658
659 if(!image || !height || !width)
660 return InvalidParameter;
661
662 if(image->type == ImageTypeMetafile){
663 HDC hdc = GetDC(0);
664
665 *height = convert_unit(hdc, ((GpMetafile*)image)->unit) *
666 ((GpMetafile*)image)->bounds.Height;
667
668 *width = convert_unit(hdc, ((GpMetafile*)image)->unit) *
669 ((GpMetafile*)image)->bounds.Width;
670
671 ReleaseDC(0, hdc);
672 }
673
674 else if(image->type == ImageTypeBitmap){
675 *height = ((GpBitmap*)image)->height;
676 *width = ((GpBitmap*)image)->width;
677 }
678 else{
679 *height = ipicture_pixel_height(image->picture);
680 *width = ipicture_pixel_width(image->picture);
681 }
682
683 TRACE("returning (%f, %f)\n", *height, *width);
684 return Ok;
685 }
686
687 GpStatus WINGDIPAPI GdipGetImageGraphicsContext(GpImage *image,
688 GpGraphics **graphics)
689 {
690 HDC hdc;
691
692 TRACE("%p %p\n", image, graphics);
693
694 if(!image || !graphics)
695 return InvalidParameter;
696
697 if(image->type != ImageTypeBitmap){
698 FIXME("not implemented for image type %d\n", image->type);
699 return NotImplemented;
700 }
701
702 IPicture_get_CurDC(image->picture, &hdc);
703
704 if(!hdc){
705 hdc = CreateCompatibleDC(0);
706 IPicture_SelectPicture(image->picture, hdc, NULL, NULL);
707 }
708
709 return GdipCreateFromHDC(hdc, graphics);
710 }
711
712 GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
713 {
714 TRACE("%p %p\n", image, height);
715
716 if(!image || !height)
717 return InvalidParameter;
718
719 if(image->type == ImageTypeMetafile){
720 HDC hdc = GetDC(0);
721
722 *height = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
723 ((GpMetafile*)image)->bounds.Height);
724
725 ReleaseDC(0, hdc);
726 }
727 else if(image->type == ImageTypeBitmap)
728 *height = ((GpBitmap*)image)->height;
729 else
730 *height = ipicture_pixel_height(image->picture);
731
732 TRACE("returning %d\n", *height);
733
734 return Ok;
735 }
736
737 GpStatus WINGDIPAPI GdipGetImageHorizontalResolution(GpImage *image, REAL *res)
738 {
739 static int calls;
740
741 if(!image || !res)
742 return InvalidParameter;
743
744 if(!(calls++))
745 FIXME("not implemented\n");
746
747 return NotImplemented;
748 }
749
750 GpStatus WINGDIPAPI GdipGetImagePaletteSize(GpImage *image, INT *size)
751 {
752 FIXME("%p %p\n", image, size);
753
754 if(!image || !size)
755 return InvalidParameter;
756
757 return NotImplemented;
758 }
759
760 /* FIXME: test this function for non-bitmap types */
761 GpStatus WINGDIPAPI GdipGetImagePixelFormat(GpImage *image, PixelFormat *format)
762 {
763 TRACE("%p %p\n", image, format);
764
765 if(!image || !format)
766 return InvalidParameter;
767
768 if(image->type != ImageTypeBitmap)
769 *format = PixelFormat24bppRGB;
770 else
771 *format = ((GpBitmap*) image)->format;
772
773 return Ok;
774 }
775
776 GpStatus WINGDIPAPI GdipGetImageRawFormat(GpImage *image, GUID *format)
777 {
778 static int calls;
779
780 if(!image || !format)
781 return InvalidParameter;
782
783 if(!(calls++))
784 FIXME("stub\n");
785
786 /* FIXME: should be detected from embedded picture or stored separately */
787 switch (image->type)
788 {
789 case ImageTypeBitmap: *format = ImageFormatBMP; break;
790 case ImageTypeMetafile: *format = ImageFormatEMF; break;
791 default:
792 WARN("unknown type %u\n", image->type);
793 *format = ImageFormatUndefined;
794 }
795 return Ok;
796 }
797
798 GpStatus WINGDIPAPI GdipGetImageType(GpImage *image, ImageType *type)
799 {
800 TRACE("%p %p\n", image, type);
801
802 if(!image || !type)
803 return InvalidParameter;
804
805 *type = image->type;
806
807 return Ok;
808 }
809
810 GpStatus WINGDIPAPI GdipGetImageVerticalResolution(GpImage *image, REAL *res)
811 {
812 static int calls;
813
814 if(!image || !res)
815 return InvalidParameter;
816
817 if(!(calls++))
818 FIXME("not implemented\n");
819
820 return NotImplemented;
821 }
822
823 GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
824 {
825 TRACE("%p %p\n", image, width);
826
827 if(!image || !width)
828 return InvalidParameter;
829
830 if(image->type == ImageTypeMetafile){
831 HDC hdc = GetDC(0);
832
833 *width = roundr(convert_unit(hdc, ((GpMetafile*)image)->unit) *
834 ((GpMetafile*)image)->bounds.Width);
835
836 ReleaseDC(0, hdc);
837 }
838 else if(image->type == ImageTypeBitmap)
839 *width = ((GpBitmap*)image)->width;
840 else
841 *width = ipicture_pixel_width(image->picture);
842
843 TRACE("returning %d\n", *width);
844
845 return Ok;
846 }
847
848 GpStatus WINGDIPAPI GdipGetMetafileHeaderFromMetafile(GpMetafile * metafile,
849 MetafileHeader * header)
850 {
851 static int calls;
852
853 if(!metafile || !header)
854 return InvalidParameter;
855
856 if(!(calls++))
857 FIXME("not implemented\n");
858
859 return Ok;
860 }
861
862 GpStatus WINGDIPAPI GdipGetAllPropertyItems(GpImage *image, UINT size,
863 UINT num, PropertyItem* items)
864 {
865 static int calls;
866
867 if(!(calls++))
868 FIXME("not implemented\n");
869
870 return InvalidParameter;
871 }
872
873 GpStatus WINGDIPAPI GdipGetPropertyCount(GpImage *image, UINT* num)
874 {
875 static int calls;
876
877 if(!(calls++))
878 FIXME("not implemented\n");
879
880 return InvalidParameter;
881 }
882
883 GpStatus WINGDIPAPI GdipGetPropertyIdList(GpImage *image, UINT num, PROPID* list)
884 {
885 static int calls;
886
887 if(!(calls++))
888 FIXME("not implemented\n");
889
890 return InvalidParameter;
891 }
892
893 GpStatus WINGDIPAPI GdipGetPropertyItem(GpImage *image, PROPID id, UINT size,
894 PropertyItem* buffer)
895 {
896 static int calls;
897
898 if(!(calls++))
899 FIXME("not implemented\n");
900
901 return InvalidParameter;
902 }
903
904 GpStatus WINGDIPAPI GdipGetPropertyItemSize(GpImage *image, PROPID pid,
905 UINT* size)
906 {
907 static int calls;
908
909 TRACE("%p %x %p\n", image, pid, size);
910
911 if(!size || !image)
912 return InvalidParameter;
913
914 if(!(calls++))
915 FIXME("not implemented\n");
916
917 return NotImplemented;
918 }
919
920 GpStatus WINGDIPAPI GdipGetPropertySize(GpImage *image, UINT* size, UINT* num)
921 {
922 static int calls;
923
924 if(!(calls++))
925 FIXME("not implemented\n");
926
927 return InvalidParameter;
928 }
929
930 GpStatus WINGDIPAPI GdipImageGetFrameCount(GpImage *image,
931 GDIPCONST GUID* dimensionID, UINT* count)
932 {
933 static int calls;
934
935 if(!image || !dimensionID || !count)
936 return InvalidParameter;
937
938 if(!(calls++))
939 FIXME("not implemented\n");
940
941 return NotImplemented;
942 }
943
944 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsCount(GpImage *image,
945 UINT* count)
946 {
947 if(!image || !count)
948 return InvalidParameter;
949
950 *count = 1;
951
952 FIXME("stub\n");
953
954 return Ok;
955 }
956
957 GpStatus WINGDIPAPI GdipImageGetFrameDimensionsList(GpImage* image,
958 GUID* dimensionIDs, UINT count)
959 {
960 static int calls;
961
962 if(!image || !dimensionIDs)
963 return InvalidParameter;
964
965 if(!(calls++))
966 FIXME("not implemented\n");
967
968 return Ok;
969 }
970
971 GpStatus WINGDIPAPI GdipImageSelectActiveFrame(GpImage *image,
972 GDIPCONST GUID* dimensionID, UINT frameidx)
973 {
974 static int calls;
975
976 if(!image || !dimensionID)
977 return InvalidParameter;
978
979 if(!(calls++))
980 FIXME("not implemented\n");
981
982 return Ok;
983 }
984
985 GpStatus WINGDIPAPI GdipLoadImageFromFile(GDIPCONST WCHAR* filename,
986 GpImage **image)
987 {
988 GpStatus stat;
989 IStream *stream;
990
991 TRACE("(%s) %p\n", debugstr_w(filename), image);
992
993 if (!filename || !image)
994 return InvalidParameter;
995
996 stat = GdipCreateStreamOnFile(filename, GENERIC_READ, &stream);
997
998 if (stat != Ok)
999 return stat;
1000
1001 stat = GdipLoadImageFromStream(stream, image);
1002
1003 IStream_Release(stream);
1004
1005 return stat;
1006 }
1007
1008 /* FIXME: no icm handling */
1009 GpStatus WINGDIPAPI GdipLoadImageFromFileICM(GDIPCONST WCHAR* filename,GpImage **image)
1010 {
1011 TRACE("(%s) %p\n", debugstr_w(filename), image);
1012
1013 return GdipLoadImageFromFile(filename, image);
1014 }
1015
1016 GpStatus WINGDIPAPI GdipLoadImageFromStream(IStream* stream, GpImage **image)
1017 {
1018 IPicture *pic;
1019 short type;
1020
1021 TRACE("%p %p\n", stream, image);
1022
1023 if(!stream || !image)
1024 return InvalidParameter;
1025
1026 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1027 (LPVOID*) &pic) != S_OK){
1028 TRACE("Could not load picture\n");
1029 return GenericError;
1030 }
1031
1032 IPicture_get_Type(pic, &type);
1033
1034 if(type == PICTYPE_BITMAP){
1035 BITMAPINFO *pbmi;
1036 BITMAPCOREHEADER* bmch;
1037 HBITMAP hbm;
1038 HDC hdc;
1039
1040 pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
1041 if (!pbmi)
1042 return OutOfMemory;
1043 *image = GdipAlloc(sizeof(GpBitmap));
1044 if(!*image){
1045 GdipFree(pbmi);
1046 return OutOfMemory;
1047 }
1048 (*image)->type = ImageTypeBitmap;
1049
1050 (*((GpBitmap**) image))->width = ipicture_pixel_width(pic);
1051 (*((GpBitmap**) image))->height = ipicture_pixel_height(pic);
1052
1053 /* get the pixel format */
1054 IPicture_get_Handle(pic, (OLE_HANDLE*)&hbm);
1055 IPicture_get_CurDC(pic, &hdc);
1056
1057 bmch = (BITMAPCOREHEADER*) (&pbmi->bmiHeader);
1058 bmch->bcSize = sizeof(BITMAPCOREHEADER);
1059
1060 if(!hdc){
1061 HBITMAP old;
1062 hdc = CreateCompatibleDC(0);
1063 old = SelectObject(hdc, hbm);
1064 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1065 SelectObject(hdc, old);
1066 DeleteDC(hdc);
1067 }
1068 else
1069 GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
1070
1071 (*((GpBitmap**) image))->format = (bmch->bcBitCount << 8) | PixelFormatGDI;
1072 GdipFree(pbmi);
1073 }
1074 else if(type == PICTYPE_METAFILE || type == PICTYPE_ENHMETAFILE){
1075 /* FIXME: missing initialization code */
1076 *image = GdipAlloc(sizeof(GpMetafile));
1077 if(!*image) return OutOfMemory;
1078 (*image)->type = ImageTypeMetafile;
1079 }
1080 else{
1081 *image = GdipAlloc(sizeof(GpImage));
1082 if(!*image) return OutOfMemory;
1083 (*image)->type = ImageTypeUnknown;
1084 }
1085
1086 (*image)->picture = pic;
1087 (*image)->flags = ImageFlagsNone;
1088
1089 return Ok;
1090 }
1091
1092 /* FIXME: no ICM */
1093 GpStatus WINGDIPAPI GdipLoadImageFromStreamICM(IStream* stream, GpImage **image)
1094 {
1095 TRACE("%p %p\n", stream, image);
1096
1097 return GdipLoadImageFromStream(stream, image);
1098 }
1099
1100 GpStatus WINGDIPAPI GdipRemovePropertyItem(GpImage *image, PROPID propId)
1101 {
1102 static int calls;
1103
1104 if(!image)
1105 return InvalidParameter;
1106
1107 if(!(calls++))
1108 FIXME("not implemented\n");
1109
1110 return NotImplemented;
1111 }
1112
1113 GpStatus WINGDIPAPI GdipSetPropertyItem(GpImage *image, GDIPCONST PropertyItem* item)
1114 {
1115 static int calls;
1116
1117 if(!(calls++))
1118 FIXME("not implemented\n");
1119
1120 return NotImplemented;
1121 }
1122
1123 GpStatus WINGDIPAPI GdipSaveImageToFile(GpImage *image, GDIPCONST WCHAR* filename,
1124 GDIPCONST CLSID *clsidEncoder,
1125 GDIPCONST EncoderParameters *encoderParams)
1126 {
1127 GpStatus stat;
1128 IStream *stream;
1129
1130 TRACE("%p (%s) %p %p\n", image, debugstr_w(filename), clsidEncoder, encoderParams);
1131
1132 if (!image || !filename|| !clsidEncoder)
1133 return InvalidParameter;
1134
1135 if (!(image->picture))
1136 return InvalidParameter;
1137
1138 stat = GdipCreateStreamOnFile(filename, GENERIC_WRITE, &stream);
1139 if (stat != Ok)
1140 return GenericError;
1141
1142 stat = GdipSaveImageToStream(image, stream, clsidEncoder, encoderParams);
1143
1144 IStream_Release(stream);
1145 return stat;
1146 }
1147
1148 /*************************************************************************
1149 * Encoding functions -
1150 * These functions encode an image in different image file formats.
1151 */
1152 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
1153 #define BITMAP_FORMAT_JPEG 0xd8ff
1154 #define BITMAP_FORMAT_GIF 0x4947
1155 #define BITMAP_FORMAT_PNG 0x5089
1156 #define BITMAP_FORMAT_APM 0xcdd7
1157
1158 static GpStatus encode_image_BMP(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1159 void **output, unsigned int *output_size)
1160 {
1161 int num_palette_entries;
1162 BITMAPFILEHEADER *bmp_file_hdr;
1163 BITMAPINFO *bmp_info_hdr;
1164
1165 if (bitmap_info->bmiHeader.biClrUsed) {
1166 num_palette_entries = bitmap_info->bmiHeader.biClrUsed;
1167 if (num_palette_entries > 256) num_palette_entries = 256;
1168 } else {
1169 if (bitmap_info->bmiHeader.biBitCount <= 8)
1170 num_palette_entries = 1 << bitmap_info->bmiHeader.biBitCount;
1171 else
1172 num_palette_entries = 0;
1173 }
1174
1175 *output_size =
1176 sizeof(BITMAPFILEHEADER) +
1177 sizeof(BITMAPINFOHEADER) +
1178 num_palette_entries * sizeof(RGBQUAD) +
1179 bitmap_info->bmiHeader.biSizeImage;
1180
1181 *output = GdipAlloc(*output_size);
1182
1183 bmp_file_hdr = (BITMAPFILEHEADER*) *output;
1184 bmp_file_hdr->bfType = BITMAP_FORMAT_BMP;
1185 bmp_file_hdr->bfSize = *output_size;
1186 bmp_file_hdr->bfOffBits =
1187 sizeof(BITMAPFILEHEADER) +
1188 sizeof(BITMAPINFOHEADER) +
1189 num_palette_entries * sizeof (RGBQUAD);
1190
1191 bmp_info_hdr = (BITMAPINFO*) ((unsigned char*)(*output) + sizeof(BITMAPFILEHEADER));
1192 memcpy(bmp_info_hdr, bitmap_info, sizeof(BITMAPINFOHEADER) + num_palette_entries * sizeof(RGBQUAD));
1193 memcpy((unsigned char *)(*output) +
1194 sizeof(BITMAPFILEHEADER) +
1195 sizeof(BITMAPINFOHEADER) +
1196 num_palette_entries * sizeof(RGBQUAD),
1197 bitmap_bits, bitmap_info->bmiHeader.biSizeImage);
1198
1199 return Ok;
1200 }
1201
1202 typedef GpStatus encode_image_func(LPVOID bitmap_bits, LPBITMAPINFO bitmap_info,
1203 void **output, unsigned int *output_size);
1204
1205 typedef enum {
1206 BMP,
1207 NUM_ENCODERS_SUPPORTED
1208 } ImageFormat;
1209
1210 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED];
1211 static encode_image_func *const encode_image_funcs[NUM_ENCODERS_SUPPORTED] = {
1212 encode_image_BMP,
1213 };
1214
1215 /*****************************************************************************
1216 * GdipSaveImageToStream [GDIPLUS.@]
1217 */
1218 GpStatus WINGDIPAPI GdipSaveImageToStream(GpImage *image, IStream* stream,
1219 GDIPCONST CLSID* clsid, GDIPCONST EncoderParameters* params)
1220 {
1221 GpStatus stat;
1222 HRESULT hr;
1223 short type;
1224 HBITMAP hbmp;
1225 HBITMAP old_hbmp;
1226 HDC hdc;
1227 int bm_is_selected;
1228 BITMAPINFO bmp_info;
1229 LPVOID bmp_bits;
1230 encode_image_func* encode_image;
1231 LPVOID output;
1232 unsigned int output_size;
1233 unsigned int dummy;
1234 int i;
1235
1236 old_hbmp = 0;
1237 output = NULL;
1238 output_size = 0;
1239
1240 TRACE("%p %p %p %p\n", image, stream, clsid, params);
1241
1242 if(!image || !stream)
1243 return InvalidParameter;
1244
1245 if (!image->picture)
1246 return GenericError;
1247
1248 hr = IPicture_get_Type(image->picture, &type);
1249 if (FAILED(hr) || type != PICTYPE_BITMAP)
1250 return GenericError;
1251
1252 /* select correct encoder */
1253 encode_image = NULL;
1254 for (i = 0; i < NUM_ENCODERS_SUPPORTED; i++) {
1255 if (IsEqualCLSID(clsid, &codecs[i].Clsid))
1256 encode_image = encode_image_funcs[i];
1257 }
1258 if (encode_image == NULL)
1259 return UnknownImageFormat;
1260
1261 /* extract underlying hbitmap representation from the IPicture */
1262 hr = IPicture_get_Handle(image->picture, (OLE_HANDLE*)&hbmp);
1263 if (FAILED(hr) || !hbmp)
1264 return GenericError;
1265 hr = IPicture_get_CurDC(image->picture, &hdc);
1266 if (FAILED(hr))
1267 return GenericError;
1268 bm_is_selected = (hdc != 0);
1269 if (!bm_is_selected) {
1270 hdc = CreateCompatibleDC(0);
1271 old_hbmp = SelectObject(hdc, hbmp);
1272 }
1273
1274 /* get bits from HBITMAP */
1275 bmp_info.bmiHeader.biSize = sizeof(bmp_info.bmiHeader);
1276 bmp_info.bmiHeader.biBitCount = 0;
1277 GetDIBits(hdc, hbmp, 0, 0, NULL, &bmp_info, DIB_RGB_COLORS);
1278
1279 bmp_bits = GdipAlloc(bmp_info.bmiHeader.biSizeImage);
1280
1281 if (bmp_bits)
1282 GetDIBits(hdc, hbmp, 0, abs(bmp_info.bmiHeader.biHeight), bmp_bits, &bmp_info, DIB_RGB_COLORS);
1283
1284 if (!bm_is_selected) {
1285 SelectObject(hdc, old_hbmp);
1286 DeleteDC(hdc);
1287 }
1288
1289 if (!bmp_bits)
1290 return OutOfMemory;
1291
1292 stat = encode_image(bmp_bits, &bmp_info, &output, &output_size);
1293 if (stat == Ok)
1294 IStream_Write(stream, output, output_size, &dummy);
1295
1296 GdipFree(output);
1297 GdipFree(bmp_bits);
1298
1299 return stat;
1300 }
1301
1302 /*****************************************************************************
1303 * GdipSetImagePalette [GDIPLUS.@]
1304 */
1305 GpStatus WINGDIPAPI GdipSetImagePalette(GpImage *image,
1306 GDIPCONST ColorPalette *palette)
1307 {
1308 static int calls;
1309
1310 if(!image || !palette)
1311 return InvalidParameter;
1312
1313 if(!(calls++))
1314 FIXME("not implemented\n");
1315
1316 return NotImplemented;
1317 }
1318
1319 /*************************************************************************
1320 * Encoders -
1321 * Structures that represent which formats we support for encoding.
1322 */
1323
1324 /* ImageCodecInfo creation routines taken from libgdiplus */
1325 static const WCHAR bmp_codecname[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
1326 static const WCHAR bmp_extension[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
1327 static const WCHAR bmp_mimetype[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
1328 static const WCHAR bmp_format[] = {'B', 'M', 'P', 0}; /* BMP */
1329 static const BYTE bmp_sig_pattern[] = { 0x42, 0x4D };
1330 static const BYTE bmp_sig_mask[] = { 0xFF, 0xFF };
1331
1332 static const ImageCodecInfo codecs[NUM_ENCODERS_SUPPORTED] =
1333 {
1334 { /* BMP */
1335 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
1336 /* FormatID */ { 0xb96b3cabU, 0x0728U, 0x11d3U, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
1337 /* CodecName */ bmp_codecname,
1338 /* DllName */ NULL,
1339 /* FormatDescription */ bmp_format,
1340 /* FilenameExtension */ bmp_extension,
1341 /* MimeType */ bmp_mimetype,
1342 /* Flags */ ImageCodecFlagsEncoder | ImageCodecFlagsDecoder | ImageCodecFlagsSupportBitmap | ImageCodecFlagsBuiltin,
1343 /* Version */ 1,
1344 /* SigCount */ 1,
1345 /* SigSize */ 2,
1346 /* SigPattern */ bmp_sig_pattern,
1347 /* SigMask */ bmp_sig_mask,
1348 },
1349 };
1350
1351 /*****************************************************************************
1352 * GdipGetImageDecodersSize [GDIPLUS.@]
1353 */
1354 GpStatus WINGDIPAPI GdipGetImageDecodersSize(UINT *numDecoders, UINT *size)
1355 {
1356 FIXME("%p %p stub!\n", numDecoders, size);
1357
1358 if (!numDecoders || !size)
1359 return InvalidParameter;
1360
1361 *numDecoders = 0;
1362 *size = 0;
1363
1364 return Ok;
1365 }
1366
1367 /*****************************************************************************
1368 * GdipGetImageDecoders [GDIPLUS.@]
1369 */
1370 GpStatus WINGDIPAPI GdipGetImageDecoders(UINT numDecoders, UINT size, ImageCodecInfo *decoders)
1371 {
1372 FIXME("%u %u %p stub!\n", numDecoders, size, decoders);
1373
1374 if (!decoders)
1375 return GenericError;
1376
1377 return NotImplemented;
1378 }
1379
1380 /*****************************************************************************
1381 * GdipGetImageEncodersSize [GDIPLUS.@]
1382 */
1383 GpStatus WINGDIPAPI GdipGetImageEncodersSize(UINT *numEncoders, UINT *size)
1384 {
1385 TRACE("%p %p\n", numEncoders, size);
1386
1387 if (!numEncoders || !size)
1388 return InvalidParameter;
1389
1390 *numEncoders = NUM_ENCODERS_SUPPORTED;
1391 *size = sizeof (codecs);
1392
1393 return Ok;
1394 }
1395
1396 /*****************************************************************************
1397 * GdipGetImageEncoders [GDIPLUS.@]
1398 */
1399 GpStatus WINGDIPAPI GdipGetImageEncoders(UINT numEncoders, UINT size, ImageCodecInfo *encoders)
1400 {
1401 TRACE("%u %u %p\n", numEncoders, size, encoders);
1402
1403 if (!encoders ||
1404 (numEncoders != NUM_ENCODERS_SUPPORTED) ||
1405 (size != sizeof (codecs)))
1406 return GenericError;
1407
1408 memcpy(encoders, codecs, sizeof (codecs));
1409
1410 return Ok;
1411 }
1412
1413 /*****************************************************************************
1414 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
1415 */
1416 GpStatus WINGDIPAPI GdipCreateBitmapFromHBITMAP(HBITMAP hbm, HPALETTE hpal, GpBitmap** bitmap)
1417 {
1418 BITMAP bm;
1419 GpStatus retval;
1420 PixelFormat format;
1421
1422 TRACE("%p %p %p\n", hbm, hpal, bitmap);
1423
1424 if(!hbm || !bitmap)
1425 return InvalidParameter;
1426
1427 /* TODO: Support for device-dependent bitmaps */
1428 if(hpal){
1429 FIXME("no support for device-dependent bitmaps\n");
1430 return NotImplemented;
1431 }
1432
1433 if (GetObjectA(hbm, sizeof(bm), &bm) != sizeof(bm))
1434 return InvalidParameter;
1435
1436 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
1437 switch(bm.bmBitsPixel) {
1438 case 1:
1439 format = PixelFormat1bppIndexed;
1440 break;
1441 case 4:
1442 format = PixelFormat4bppIndexed;
1443 break;
1444 case 8:
1445 format = PixelFormat8bppIndexed;
1446 break;
1447 case 24:
1448 format = PixelFormat24bppRGB;
1449 break;
1450 case 32:
1451 format = PixelFormat32bppRGB;
1452 break;
1453 case 48:
1454 format = PixelFormat48bppRGB;
1455 break;
1456 default:
1457 FIXME("don't know how to handle %d bpp\n", bm.bmBitsPixel);
1458 return InvalidParameter;
1459 }
1460
1461 retval = GdipCreateBitmapFromScan0(bm.bmWidth, bm.bmHeight, bm.bmWidthBytes,
1462 format, bm.bmBits, bitmap);
1463
1464 return retval;
1465 }
1466
1467 /*****************************************************************************
1468 * GdipSetEffectParameters [GDIPLUS.@]
1469 */
1470 GpStatus WINGDIPAPI GdipSetEffectParameters(CGpEffect *effect,
1471 const VOID *params, const UINT size)
1472 {
1473 static int calls;
1474
1475 if(!(calls++))
1476 FIXME("not implemented\n");
1477
1478 return NotImplemented;
1479 }
1480
1481 /*****************************************************************************
1482 * GdipGetImageFlags [GDIPLUS.@]
1483 */
1484 GpStatus WINGDIPAPI GdipGetImageFlags(GpImage *image, UINT *flags)
1485 {
1486 TRACE("%p %p\n", image, flags);
1487
1488 if(!image || !flags)
1489 return InvalidParameter;
1490
1491 *flags = image->flags;
1492
1493 return Ok;
1494 }
1495
1496 GpStatus WINGDIPAPI GdipTestControl(GpTestControlEnum control, void *param)
1497 {
1498 TRACE("(%d, %p)\n", control, param);
1499
1500 switch(control){
1501 case TestControlForceBilinear:
1502 if(param)
1503 FIXME("TestControlForceBilinear not handled\n");
1504 break;
1505 case TestControlNoICM:
1506 if(param)
1507 FIXME("TestControlNoICM not handled\n");
1508 break;
1509 case TestControlGetBuildNumber:
1510 *((DWORD*)param) = 3102;
1511 break;
1512 }
1513
1514 return Ok;
1515 }
1516
1517 GpStatus WINGDIPAPI GdipRecordMetafileFileName(GDIPCONST WCHAR* fileName,
1518 HDC hdc, EmfType type, GDIPCONST GpRectF *pFrameRect,
1519 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc,
1520 GpMetafile **metafile)
1521 {
1522 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1523 frameUnit, debugstr_w(desc), metafile);
1524
1525 return NotImplemented;
1526 }
1527
1528 GpStatus WINGDIPAPI GdipRecordMetafileFileNameI(GDIPCONST WCHAR* fileName, HDC hdc, EmfType type,
1529 GDIPCONST GpRect *pFrameRect, MetafileFrameUnit frameUnit,
1530 GDIPCONST WCHAR *desc, GpMetafile **metafile)
1531 {
1532 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName), hdc, type, pFrameRect,
1533 frameUnit, debugstr_w(desc), metafile);
1534
1535 return NotImplemented;
1536 }
1537
1538 GpStatus WINGDIPAPI GdipImageForceValidation(GpImage *image)
1539 {
1540 FIXME("%p\n", image);
1541
1542 return Ok;
1543 }