2 * Copyright (C) 2007 Google (Evan Stade)
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.
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.
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
21 #define NONAMELESSUNION
36 #include "gdiplus_private.h"
37 #include "wine/debug.h"
39 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus
);
41 #define PIXELFORMATBPP(x) ((x) ? ((x) >> 8) & 255 : 24)
43 static INT
ipicture_pixel_height(IPicture
*pic
)
48 IPicture_get_Height(pic
, &y
);
52 y
= MulDiv(y
, GetDeviceCaps(hdcref
, LOGPIXELSY
), INCH_HIMETRIC
);
58 static INT
ipicture_pixel_width(IPicture
*pic
)
63 IPicture_get_Width(pic
, &x
);
67 x
= MulDiv(x
, GetDeviceCaps(hdcref
, LOGPIXELSX
), INCH_HIMETRIC
);
74 GpStatus WINGDIPAPI
GdipBitmapApplyEffect(GpBitmap
* bitmap
, CGpEffect
* effect
,
75 RECT
* roi
, BOOL useAuxData
, VOID
** auxData
, INT
* auxDataSize
)
77 FIXME("(%p %p %p %d %p %p): stub\n", bitmap
, effect
, roi
, useAuxData
, auxData
, auxDataSize
);
79 * Note: According to Jose Roca's GDI+ docs, this function is not
80 * implemented in Windows's GDI+.
82 return NotImplemented
;
85 GpStatus WINGDIPAPI
GdipBitmapCreateApplyEffect(GpBitmap
** inputBitmaps
,
86 INT numInputs
, CGpEffect
* effect
, RECT
* roi
, RECT
* outputRect
,
87 GpBitmap
** outputBitmap
, BOOL useAuxData
, VOID
** auxData
, INT
* auxDataSize
)
89 FIXME("(%p %d %p %p %p %p %d %p %p): stub\n", inputBitmaps
, numInputs
, effect
, roi
, outputRect
, outputBitmap
, useAuxData
, auxData
, auxDataSize
);
91 * Note: According to Jose Roca's GDI+ docs, this function is not
92 * implemented in Windows's GDI+.
94 return NotImplemented
;
97 static inline void getpixel_1bppIndexed(BYTE
*index
, const BYTE
*row
, UINT x
)
99 *index
= (row
[x
/8]>>(7-x
%8)) & 1;
102 static inline void getpixel_4bppIndexed(BYTE
*index
, const BYTE
*row
, UINT x
)
105 *index
= row
[x
/2]&0xf;
107 *index
= row
[x
/2]>>4;
110 static inline void getpixel_8bppIndexed(BYTE
*index
, const BYTE
*row
, UINT x
)
115 static inline void getpixel_16bppGrayScale(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
116 const BYTE
*row
, UINT x
)
118 *r
= *g
= *b
= row
[x
*2+1];
122 static inline void getpixel_16bppRGB555(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
123 const BYTE
*row
, UINT x
)
125 WORD pixel
= *((const WORD
*)(row
)+x
);
126 *r
= (pixel
>>7&0xf8)|(pixel
>>12&0x7);
127 *g
= (pixel
>>2&0xf8)|(pixel
>>6&0x7);
128 *b
= (pixel
<<3&0xf8)|(pixel
>>2&0x7);
132 static inline void getpixel_16bppRGB565(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
133 const BYTE
*row
, UINT x
)
135 WORD pixel
= *((const WORD
*)(row
)+x
);
136 *r
= (pixel
>>8&0xf8)|(pixel
>>13&0x7);
137 *g
= (pixel
>>3&0xfc)|(pixel
>>9&0x3);
138 *b
= (pixel
<<3&0xf8)|(pixel
>>2&0x7);
142 static inline void getpixel_16bppARGB1555(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
143 const BYTE
*row
, UINT x
)
145 WORD pixel
= *((const WORD
*)(row
)+x
);
146 *r
= (pixel
>>7&0xf8)|(pixel
>>12&0x7);
147 *g
= (pixel
>>2&0xf8)|(pixel
>>6&0x7);
148 *b
= (pixel
<<3&0xf8)|(pixel
>>2&0x7);
149 if ((pixel
&0x8000) == 0x8000)
155 static inline void getpixel_24bppRGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
156 const BYTE
*row
, UINT x
)
164 static inline void getpixel_32bppRGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
165 const BYTE
*row
, UINT x
)
173 static inline void getpixel_32bppARGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
174 const BYTE
*row
, UINT x
)
182 static inline void getpixel_32bppPARGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
183 const BYTE
*row
, UINT x
)
190 *r
= row
[x
*4+2] * 255 / *a
;
191 *g
= row
[x
*4+1] * 255 / *a
;
192 *b
= row
[x
*4] * 255 / *a
;
196 static inline void getpixel_48bppRGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
197 const BYTE
*row
, UINT x
)
205 static inline void getpixel_64bppARGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
206 const BYTE
*row
, UINT x
)
214 static inline void getpixel_64bppPARGB(BYTE
*r
, BYTE
*g
, BYTE
*b
, BYTE
*a
,
215 const BYTE
*row
, UINT x
)
222 *r
= row
[x
*8+5] * 255 / *a
;
223 *g
= row
[x
*8+3] * 255 / *a
;
224 *b
= row
[x
*8+1] * 255 / *a
;
228 GpStatus WINGDIPAPI
GdipBitmapGetPixel(GpBitmap
* bitmap
, INT x
, INT y
,
234 TRACE("%p %d %d %p\n", bitmap
, x
, y
, color
);
236 if(!bitmap
|| !color
||
237 x
< 0 || y
< 0 || x
>= bitmap
->width
|| y
>= bitmap
->height
)
238 return InvalidParameter
;
240 row
= bitmap
->bits
+bitmap
->stride
*y
;
242 switch (bitmap
->format
)
244 case PixelFormat1bppIndexed
:
245 getpixel_1bppIndexed(&index
,row
,x
);
247 case PixelFormat4bppIndexed
:
248 getpixel_4bppIndexed(&index
,row
,x
);
250 case PixelFormat8bppIndexed
:
251 getpixel_8bppIndexed(&index
,row
,x
);
253 case PixelFormat16bppGrayScale
:
254 getpixel_16bppGrayScale(&r
,&g
,&b
,&a
,row
,x
);
256 case PixelFormat16bppRGB555
:
257 getpixel_16bppRGB555(&r
,&g
,&b
,&a
,row
,x
);
259 case PixelFormat16bppRGB565
:
260 getpixel_16bppRGB565(&r
,&g
,&b
,&a
,row
,x
);
262 case PixelFormat16bppARGB1555
:
263 getpixel_16bppARGB1555(&r
,&g
,&b
,&a
,row
,x
);
265 case PixelFormat24bppRGB
:
266 getpixel_24bppRGB(&r
,&g
,&b
,&a
,row
,x
);
268 case PixelFormat32bppRGB
:
269 getpixel_32bppRGB(&r
,&g
,&b
,&a
,row
,x
);
271 case PixelFormat32bppARGB
:
272 getpixel_32bppARGB(&r
,&g
,&b
,&a
,row
,x
);
274 case PixelFormat32bppPARGB
:
275 getpixel_32bppPARGB(&r
,&g
,&b
,&a
,row
,x
);
277 case PixelFormat48bppRGB
:
278 getpixel_48bppRGB(&r
,&g
,&b
,&a
,row
,x
);
280 case PixelFormat64bppARGB
:
281 getpixel_64bppARGB(&r
,&g
,&b
,&a
,row
,x
);
283 case PixelFormat64bppPARGB
:
284 getpixel_64bppPARGB(&r
,&g
,&b
,&a
,row
,x
);
287 FIXME("not implemented for format 0x%x\n", bitmap
->format
);
288 return NotImplemented
;
291 if (bitmap
->format
& PixelFormatIndexed
)
292 *color
= bitmap
->image
.palette_entries
[index
];
294 *color
= a
<<24|r
<<16|g
<<8|b
;
299 static inline void setpixel_16bppGrayScale(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
302 *((WORD
*)(row
)+x
) = (r
+g
+b
)*85;
305 static inline void setpixel_16bppRGB555(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
308 *((WORD
*)(row
)+x
) = (r
<<7&0x7c00)|
313 static inline void setpixel_16bppRGB565(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
316 *((WORD
*)(row
)+x
) = (r
<<8&0xf800)|
321 static inline void setpixel_16bppARGB1555(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
324 *((WORD
*)(row
)+x
) = (a
<<8&0x8000)|
330 static inline void setpixel_24bppRGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
338 static inline void setpixel_32bppRGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
341 *((DWORD
*)(row
)+x
) = (r
<<16)|(g
<<8)|b
;
344 static inline void setpixel_32bppARGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
347 *((DWORD
*)(row
)+x
) = (a
<<24)|(r
<<16)|(g
<<8)|b
;
350 static inline void setpixel_32bppPARGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
356 *((DWORD
*)(row
)+x
) = (a
<<24)|(r
<<16)|(g
<<8)|b
;
359 static inline void setpixel_48bppRGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
362 row
[x
*6+5] = row
[x
*6+4] = r
;
363 row
[x
*6+3] = row
[x
*6+2] = g
;
364 row
[x
*6+1] = row
[x
*6] = b
;
367 static inline void setpixel_64bppARGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
370 UINT64 a64
=a
, r64
=r
, g64
=g
, b64
=b
;
371 *((UINT64
*)(row
)+x
) = (a64
<<56)|(a64
<<48)|(r64
<<40)|(r64
<<32)|(g64
<<24)|(g64
<<16)|(b64
<<8)|b64
;
374 static inline void setpixel_64bppPARGB(BYTE r
, BYTE g
, BYTE b
, BYTE a
,
377 UINT64 a64
, r64
, g64
, b64
;
382 *((UINT64
*)(row
)+x
) = (a64
<<48)|(r64
<<32)|(g64
<<16)|b64
;
385 GpStatus WINGDIPAPI
GdipBitmapSetPixel(GpBitmap
* bitmap
, INT x
, INT y
,
390 TRACE("bitmap:%p, x:%d, y:%d, color:%08x\n", bitmap
, x
, y
, color
);
392 if(!bitmap
|| x
< 0 || y
< 0 || x
>= bitmap
->width
|| y
>= bitmap
->height
)
393 return InvalidParameter
;
400 row
= bitmap
->bits
+ bitmap
->stride
* y
;
402 switch (bitmap
->format
)
404 case PixelFormat16bppGrayScale
:
405 setpixel_16bppGrayScale(r
,g
,b
,a
,row
,x
);
407 case PixelFormat16bppRGB555
:
408 setpixel_16bppRGB555(r
,g
,b
,a
,row
,x
);
410 case PixelFormat16bppRGB565
:
411 setpixel_16bppRGB565(r
,g
,b
,a
,row
,x
);
413 case PixelFormat16bppARGB1555
:
414 setpixel_16bppARGB1555(r
,g
,b
,a
,row
,x
);
416 case PixelFormat24bppRGB
:
417 setpixel_24bppRGB(r
,g
,b
,a
,row
,x
);
419 case PixelFormat32bppRGB
:
420 setpixel_32bppRGB(r
,g
,b
,a
,row
,x
);
422 case PixelFormat32bppARGB
:
423 setpixel_32bppARGB(r
,g
,b
,a
,row
,x
);
425 case PixelFormat32bppPARGB
:
426 setpixel_32bppPARGB(r
,g
,b
,a
,row
,x
);
428 case PixelFormat48bppRGB
:
429 setpixel_48bppRGB(r
,g
,b
,a
,row
,x
);
431 case PixelFormat64bppARGB
:
432 setpixel_64bppARGB(r
,g
,b
,a
,row
,x
);
434 case PixelFormat64bppPARGB
:
435 setpixel_64bppPARGB(r
,g
,b
,a
,row
,x
);
438 FIXME("not implemented for format 0x%x\n", bitmap
->format
);
439 return NotImplemented
;
445 GpStatus
convert_pixels(UINT width
, UINT height
,
446 INT dst_stride
, BYTE
*dst_bits
, PixelFormat dst_format
,
447 INT src_stride
, const BYTE
*src_bits
, PixelFormat src_format
, ARGB
*src_palette
)
451 if (src_format
== dst_format
||
452 (dst_format
== PixelFormat32bppRGB
&& PIXELFORMATBPP(src_format
) == 32))
454 UINT widthbytes
= PIXELFORMATBPP(src_format
) * width
/ 8;
455 for (y
=0; y
<height
; y
++)
456 memcpy(dst_bits
+dst_stride
*y
, src_bits
+src_stride
*y
, widthbytes
);
460 #define convert_indexed_to_rgb(getpixel_function, setpixel_function) do { \
461 for (x=0; x<width; x++) \
462 for (y=0; y<height; y++) { \
465 getpixel_function(&index, src_bits+src_stride*y, x); \
466 color = (BYTE*)(&src_palette[index]); \
467 setpixel_function(color[2], color[1], color[0], color[3], dst_bits+dst_stride*y, x); \
472 #define convert_rgb_to_rgb(getpixel_function, setpixel_function) do { \
473 for (x=0; x<width; x++) \
474 for (y=0; y<height; y++) { \
476 getpixel_function(&r, &g, &b, &a, src_bits+src_stride*y, x); \
477 setpixel_function(r, g, b, a, dst_bits+dst_stride*y, x); \
484 case PixelFormat1bppIndexed
:
487 case PixelFormat16bppGrayScale
:
488 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_16bppGrayScale
);
489 case PixelFormat16bppRGB555
:
490 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_16bppRGB555
);
491 case PixelFormat16bppRGB565
:
492 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_16bppRGB565
);
493 case PixelFormat16bppARGB1555
:
494 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_16bppARGB1555
);
495 case PixelFormat24bppRGB
:
496 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_24bppRGB
);
497 case PixelFormat32bppRGB
:
498 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_32bppRGB
);
499 case PixelFormat32bppARGB
:
500 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_32bppARGB
);
501 case PixelFormat32bppPARGB
:
502 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_32bppPARGB
);
503 case PixelFormat48bppRGB
:
504 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_48bppRGB
);
505 case PixelFormat64bppARGB
:
506 convert_indexed_to_rgb(getpixel_1bppIndexed
, setpixel_64bppARGB
);
511 case PixelFormat4bppIndexed
:
514 case PixelFormat16bppGrayScale
:
515 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_16bppGrayScale
);
516 case PixelFormat16bppRGB555
:
517 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_16bppRGB555
);
518 case PixelFormat16bppRGB565
:
519 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_16bppRGB565
);
520 case PixelFormat16bppARGB1555
:
521 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_16bppARGB1555
);
522 case PixelFormat24bppRGB
:
523 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_24bppRGB
);
524 case PixelFormat32bppRGB
:
525 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_32bppRGB
);
526 case PixelFormat32bppARGB
:
527 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_32bppARGB
);
528 case PixelFormat32bppPARGB
:
529 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_32bppPARGB
);
530 case PixelFormat48bppRGB
:
531 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_48bppRGB
);
532 case PixelFormat64bppARGB
:
533 convert_indexed_to_rgb(getpixel_4bppIndexed
, setpixel_64bppARGB
);
538 case PixelFormat8bppIndexed
:
541 case PixelFormat16bppGrayScale
:
542 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_16bppGrayScale
);
543 case PixelFormat16bppRGB555
:
544 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_16bppRGB555
);
545 case PixelFormat16bppRGB565
:
546 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_16bppRGB565
);
547 case PixelFormat16bppARGB1555
:
548 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_16bppARGB1555
);
549 case PixelFormat24bppRGB
:
550 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_24bppRGB
);
551 case PixelFormat32bppRGB
:
552 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_32bppRGB
);
553 case PixelFormat32bppARGB
:
554 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_32bppARGB
);
555 case PixelFormat32bppPARGB
:
556 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_32bppPARGB
);
557 case PixelFormat48bppRGB
:
558 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_48bppRGB
);
559 case PixelFormat64bppARGB
:
560 convert_indexed_to_rgb(getpixel_8bppIndexed
, setpixel_64bppARGB
);
565 case PixelFormat16bppGrayScale
:
568 case PixelFormat16bppRGB555
:
569 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_16bppRGB555
);
570 case PixelFormat16bppRGB565
:
571 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_16bppRGB565
);
572 case PixelFormat16bppARGB1555
:
573 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_16bppARGB1555
);
574 case PixelFormat24bppRGB
:
575 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_24bppRGB
);
576 case PixelFormat32bppRGB
:
577 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_32bppRGB
);
578 case PixelFormat32bppARGB
:
579 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_32bppARGB
);
580 case PixelFormat32bppPARGB
:
581 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_32bppPARGB
);
582 case PixelFormat48bppRGB
:
583 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_48bppRGB
);
584 case PixelFormat64bppARGB
:
585 convert_rgb_to_rgb(getpixel_16bppGrayScale
, setpixel_64bppARGB
);
590 case PixelFormat16bppRGB555
:
593 case PixelFormat16bppGrayScale
:
594 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_16bppGrayScale
);
595 case PixelFormat16bppRGB565
:
596 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_16bppRGB565
);
597 case PixelFormat16bppARGB1555
:
598 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_16bppARGB1555
);
599 case PixelFormat24bppRGB
:
600 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_24bppRGB
);
601 case PixelFormat32bppRGB
:
602 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_32bppRGB
);
603 case PixelFormat32bppARGB
:
604 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_32bppARGB
);
605 case PixelFormat32bppPARGB
:
606 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_32bppPARGB
);
607 case PixelFormat48bppRGB
:
608 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_48bppRGB
);
609 case PixelFormat64bppARGB
:
610 convert_rgb_to_rgb(getpixel_16bppRGB555
, setpixel_64bppARGB
);
615 case PixelFormat16bppRGB565
:
618 case PixelFormat16bppGrayScale
:
619 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_16bppGrayScale
);
620 case PixelFormat16bppRGB555
:
621 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_16bppRGB555
);
622 case PixelFormat16bppARGB1555
:
623 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_16bppARGB1555
);
624 case PixelFormat24bppRGB
:
625 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_24bppRGB
);
626 case PixelFormat32bppRGB
:
627 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_32bppRGB
);
628 case PixelFormat32bppARGB
:
629 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_32bppARGB
);
630 case PixelFormat32bppPARGB
:
631 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_32bppPARGB
);
632 case PixelFormat48bppRGB
:
633 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_48bppRGB
);
634 case PixelFormat64bppARGB
:
635 convert_rgb_to_rgb(getpixel_16bppRGB565
, setpixel_64bppARGB
);
640 case PixelFormat16bppARGB1555
:
643 case PixelFormat16bppGrayScale
:
644 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_16bppGrayScale
);
645 case PixelFormat16bppRGB555
:
646 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_16bppRGB555
);
647 case PixelFormat16bppRGB565
:
648 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_16bppRGB565
);
649 case PixelFormat24bppRGB
:
650 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_24bppRGB
);
651 case PixelFormat32bppRGB
:
652 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_32bppRGB
);
653 case PixelFormat32bppARGB
:
654 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_32bppARGB
);
655 case PixelFormat32bppPARGB
:
656 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_32bppPARGB
);
657 case PixelFormat48bppRGB
:
658 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_48bppRGB
);
659 case PixelFormat64bppARGB
:
660 convert_rgb_to_rgb(getpixel_16bppARGB1555
, setpixel_64bppARGB
);
665 case PixelFormat24bppRGB
:
668 case PixelFormat16bppGrayScale
:
669 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_16bppGrayScale
);
670 case PixelFormat16bppRGB555
:
671 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_16bppRGB555
);
672 case PixelFormat16bppRGB565
:
673 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_16bppRGB565
);
674 case PixelFormat16bppARGB1555
:
675 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_16bppARGB1555
);
676 case PixelFormat32bppRGB
:
677 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_32bppRGB
);
678 case PixelFormat32bppARGB
:
679 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_32bppARGB
);
680 case PixelFormat32bppPARGB
:
681 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_32bppPARGB
);
682 case PixelFormat48bppRGB
:
683 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_48bppRGB
);
684 case PixelFormat64bppARGB
:
685 convert_rgb_to_rgb(getpixel_24bppRGB
, setpixel_64bppARGB
);
690 case PixelFormat32bppRGB
:
693 case PixelFormat16bppGrayScale
:
694 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_16bppGrayScale
);
695 case PixelFormat16bppRGB555
:
696 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_16bppRGB555
);
697 case PixelFormat16bppRGB565
:
698 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_16bppRGB565
);
699 case PixelFormat16bppARGB1555
:
700 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_16bppARGB1555
);
701 case PixelFormat24bppRGB
:
702 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_24bppRGB
);
703 case PixelFormat32bppARGB
:
704 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_32bppARGB
);
705 case PixelFormat32bppPARGB
:
706 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_32bppPARGB
);
707 case PixelFormat48bppRGB
:
708 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_48bppRGB
);
709 case PixelFormat64bppARGB
:
710 convert_rgb_to_rgb(getpixel_32bppRGB
, setpixel_64bppARGB
);
715 case PixelFormat32bppARGB
:
718 case PixelFormat16bppGrayScale
:
719 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_16bppGrayScale
);
720 case PixelFormat16bppRGB555
:
721 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_16bppRGB555
);
722 case PixelFormat16bppRGB565
:
723 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_16bppRGB565
);
724 case PixelFormat16bppARGB1555
:
725 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_16bppARGB1555
);
726 case PixelFormat24bppRGB
:
727 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_24bppRGB
);
728 case PixelFormat32bppPARGB
:
729 convert_32bppARGB_to_32bppPARGB(width
, height
, dst_bits
, dst_stride
, src_bits
, src_stride
);
731 case PixelFormat48bppRGB
:
732 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_48bppRGB
);
733 case PixelFormat64bppARGB
:
734 convert_rgb_to_rgb(getpixel_32bppARGB
, setpixel_64bppARGB
);
739 case PixelFormat32bppPARGB
:
742 case PixelFormat16bppGrayScale
:
743 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_16bppGrayScale
);
744 case PixelFormat16bppRGB555
:
745 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_16bppRGB555
);
746 case PixelFormat16bppRGB565
:
747 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_16bppRGB565
);
748 case PixelFormat16bppARGB1555
:
749 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_16bppARGB1555
);
750 case PixelFormat24bppRGB
:
751 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_24bppRGB
);
752 case PixelFormat32bppRGB
:
753 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_32bppRGB
);
754 case PixelFormat32bppARGB
:
755 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_32bppARGB
);
756 case PixelFormat48bppRGB
:
757 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_48bppRGB
);
758 case PixelFormat64bppARGB
:
759 convert_rgb_to_rgb(getpixel_32bppPARGB
, setpixel_64bppARGB
);
764 case PixelFormat48bppRGB
:
767 case PixelFormat16bppGrayScale
:
768 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_16bppGrayScale
);
769 case PixelFormat16bppRGB555
:
770 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_16bppRGB555
);
771 case PixelFormat16bppRGB565
:
772 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_16bppRGB565
);
773 case PixelFormat16bppARGB1555
:
774 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_16bppARGB1555
);
775 case PixelFormat24bppRGB
:
776 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_24bppRGB
);
777 case PixelFormat32bppRGB
:
778 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_32bppRGB
);
779 case PixelFormat32bppARGB
:
780 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_32bppARGB
);
781 case PixelFormat32bppPARGB
:
782 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_32bppPARGB
);
783 case PixelFormat64bppARGB
:
784 convert_rgb_to_rgb(getpixel_48bppRGB
, setpixel_64bppARGB
);
789 case PixelFormat64bppARGB
:
792 case PixelFormat16bppGrayScale
:
793 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_16bppGrayScale
);
794 case PixelFormat16bppRGB555
:
795 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_16bppRGB555
);
796 case PixelFormat16bppRGB565
:
797 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_16bppRGB565
);
798 case PixelFormat16bppARGB1555
:
799 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_16bppARGB1555
);
800 case PixelFormat24bppRGB
:
801 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_24bppRGB
);
802 case PixelFormat32bppRGB
:
803 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_32bppRGB
);
804 case PixelFormat32bppARGB
:
805 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_32bppARGB
);
806 case PixelFormat32bppPARGB
:
807 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_32bppPARGB
);
808 case PixelFormat48bppRGB
:
809 convert_rgb_to_rgb(getpixel_64bppARGB
, setpixel_48bppRGB
);
814 case PixelFormat64bppPARGB
:
817 case PixelFormat16bppGrayScale
:
818 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_16bppGrayScale
);
819 case PixelFormat16bppRGB555
:
820 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_16bppRGB555
);
821 case PixelFormat16bppRGB565
:
822 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_16bppRGB565
);
823 case PixelFormat16bppARGB1555
:
824 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_16bppARGB1555
);
825 case PixelFormat24bppRGB
:
826 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_24bppRGB
);
827 case PixelFormat32bppRGB
:
828 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_32bppRGB
);
829 case PixelFormat32bppARGB
:
830 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_32bppARGB
);
831 case PixelFormat32bppPARGB
:
832 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_32bppPARGB
);
833 case PixelFormat48bppRGB
:
834 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_48bppRGB
);
835 case PixelFormat64bppARGB
:
836 convert_rgb_to_rgb(getpixel_64bppPARGB
, setpixel_64bppARGB
);
845 #undef convert_indexed_to_rgb
846 #undef convert_rgb_to_rgb
848 return NotImplemented
;
851 /* This function returns a pointer to an array of pixels that represents the
852 * bitmap. The *entire* bitmap is locked according to the lock mode specified by
853 * flags. It is correct behavior that a user who calls this function with write
854 * privileges can write to the whole bitmap (not just the area in rect).
856 * FIXME: only used portion of format is bits per pixel. */
857 GpStatus WINGDIPAPI
GdipBitmapLockBits(GpBitmap
* bitmap
, GDIPCONST GpRect
* rect
,
858 UINT flags
, PixelFormat format
, BitmapData
* lockeddata
)
860 INT stride
, bitspp
= PIXELFORMATBPP(format
);
863 GpRect act_rect
; /* actual rect to be used */
866 TRACE("%p %p %d 0x%x %p\n", bitmap
, rect
, flags
, format
, lockeddata
);
868 if(!lockeddata
|| !bitmap
)
869 return InvalidParameter
;
872 if(rect
->X
< 0 || rect
->Y
< 0 || (rect
->X
+ rect
->Width
> bitmap
->width
) ||
873 (rect
->Y
+ rect
->Height
> bitmap
->height
) || !flags
)
874 return InvalidParameter
;
879 act_rect
.X
= act_rect
.Y
= 0;
880 act_rect
.Width
= bitmap
->width
;
881 act_rect
.Height
= bitmap
->height
;
884 if(flags
& ImageLockModeUserInputBuf
)
887 if (!fixme
++) FIXME("ImageLockModeUserInputBuf not implemented\n");
888 return NotImplemented
;
893 WARN("bitmap is already locked and cannot be locked again\n");
897 if (bitmap
->bits
&& bitmap
->format
== format
)
899 /* no conversion is necessary; just use the bits directly */
900 lockeddata
->Width
= act_rect
.Width
;
901 lockeddata
->Height
= act_rect
.Height
;
902 lockeddata
->PixelFormat
= format
;
903 lockeddata
->Reserved
= flags
;
904 lockeddata
->Stride
= bitmap
->stride
;
905 lockeddata
->Scan0
= bitmap
->bits
+ (bitspp
/ 8) * act_rect
.X
+
906 bitmap
->stride
* act_rect
.Y
;
908 bitmap
->lockmode
= flags
;
914 /* Make sure we can convert to the requested format. */
915 stat
= convert_pixels(0, 0, 0, NULL
, format
, 0, NULL
, bitmap
->format
, NULL
);
916 if (stat
== NotImplemented
)
918 FIXME("cannot read bitmap from %x to %x\n", bitmap
->format
, format
);
919 return NotImplemented
;
922 /* If we're opening for writing, make sure we'll be able to write back in
923 * the original format. */
924 if (flags
& ImageLockModeWrite
)
926 stat
= convert_pixels(0, 0, 0, NULL
, bitmap
->format
, 0, NULL
, format
, NULL
);
927 if (stat
== NotImplemented
)
929 FIXME("cannot write bitmap from %x to %x\n", format
, bitmap
->format
);
930 return NotImplemented
;
934 abs_height
= bitmap
->height
;
935 stride
= (bitmap
->width
* bitspp
+ 7) / 8;
936 stride
= (stride
+ 3) & ~3;
938 buff
= GdipAlloc(stride
* abs_height
);
940 if (!buff
) return OutOfMemory
;
942 stat
= convert_pixels(bitmap
->width
, bitmap
->height
,
943 stride
, buff
, format
,
944 bitmap
->stride
, bitmap
->bits
, bitmap
->format
, bitmap
->image
.palette_entries
);
952 lockeddata
->Width
= act_rect
.Width
;
953 lockeddata
->Height
= act_rect
.Height
;
954 lockeddata
->PixelFormat
= format
;
955 lockeddata
->Reserved
= flags
;
956 lockeddata
->Stride
= stride
;
957 lockeddata
->Scan0
= buff
+ (bitspp
/ 8) * act_rect
.X
+ stride
* act_rect
.Y
;
959 bitmap
->lockmode
= flags
;
961 bitmap
->bitmapbits
= buff
;
966 GpStatus WINGDIPAPI
GdipBitmapSetResolution(GpBitmap
* bitmap
, REAL xdpi
, REAL ydpi
)
968 TRACE("(%p, %.2f, %.2f)\n", bitmap
, xdpi
, ydpi
);
970 if (!bitmap
|| xdpi
== 0.0 || ydpi
== 0.0)
971 return InvalidParameter
;
973 bitmap
->image
.xres
= xdpi
;
974 bitmap
->image
.yres
= ydpi
;
979 GpStatus WINGDIPAPI
GdipBitmapUnlockBits(GpBitmap
* bitmap
,
980 BitmapData
* lockeddata
)
984 TRACE("(%p,%p)\n", bitmap
, lockeddata
);
986 if(!bitmap
|| !lockeddata
)
987 return InvalidParameter
;
989 if(!bitmap
->lockmode
)
992 if(lockeddata
->Reserved
& ImageLockModeUserInputBuf
)
993 return NotImplemented
;
995 if(lockeddata
->Reserved
& ImageLockModeRead
){
996 if(!(--bitmap
->numlocks
))
997 bitmap
->lockmode
= 0;
999 GdipFree(bitmap
->bitmapbits
);
1000 bitmap
->bitmapbits
= NULL
;
1004 if (!bitmap
->bitmapbits
)
1006 /* we passed a direct reference; no need to do anything */
1007 bitmap
->lockmode
= 0;
1008 bitmap
->numlocks
= 0;
1012 stat
= convert_pixels(bitmap
->width
, bitmap
->height
,
1013 bitmap
->stride
, bitmap
->bits
, bitmap
->format
,
1014 lockeddata
->Stride
, bitmap
->bitmapbits
, lockeddata
->PixelFormat
, NULL
);
1018 ERR("failed to convert pixels; this should never happen\n");
1021 GdipFree(bitmap
->bitmapbits
);
1022 bitmap
->bitmapbits
= NULL
;
1023 bitmap
->lockmode
= 0;
1024 bitmap
->numlocks
= 0;
1029 GpStatus WINGDIPAPI
GdipCloneBitmapArea(REAL x
, REAL y
, REAL width
, REAL height
,
1030 PixelFormat format
, GpBitmap
* srcBitmap
, GpBitmap
** dstBitmap
)
1032 BitmapData lockeddata_src
, lockeddata_dst
;
1038 TRACE("(%f,%f,%f,%f,0x%x,%p,%p)\n", x
, y
, width
, height
, format
, srcBitmap
, dstBitmap
);
1040 if (!srcBitmap
|| !dstBitmap
|| srcBitmap
->image
.type
!= ImageTypeBitmap
||
1042 x
+ width
> srcBitmap
->width
|| y
+ height
> srcBitmap
->height
)
1044 TRACE("<-- InvalidParameter\n");
1045 return InvalidParameter
;
1048 if (format
== PixelFormatDontCare
)
1049 format
= srcBitmap
->format
;
1053 area
.Width
= roundr(width
);
1054 area
.Height
= roundr(height
);
1056 stat
= GdipBitmapLockBits(srcBitmap
, &area
, ImageLockModeRead
, format
,
1058 if (stat
!= Ok
) return stat
;
1060 stat
= GdipCreateBitmapFromScan0(lockeddata_src
.Width
, lockeddata_src
.Height
,
1061 0, lockeddata_src
.PixelFormat
, NULL
, dstBitmap
);
1064 stat
= GdipBitmapLockBits(*dstBitmap
, NULL
, ImageLockModeWrite
,
1065 lockeddata_src
.PixelFormat
, &lockeddata_dst
);
1069 /* copy the image data */
1070 row_size
= (lockeddata_src
.Width
* PIXELFORMATBPP(lockeddata_src
.PixelFormat
) +7)/8;
1071 for (i
=0; i
<lockeddata_src
.Height
; i
++)
1072 memcpy((BYTE
*)lockeddata_dst
.Scan0
+lockeddata_dst
.Stride
*i
,
1073 (BYTE
*)lockeddata_src
.Scan0
+lockeddata_src
.Stride
*i
,
1076 GdipBitmapUnlockBits(*dstBitmap
, &lockeddata_dst
);
1080 GdipDisposeImage((GpImage
*)*dstBitmap
);
1083 GdipBitmapUnlockBits(srcBitmap
, &lockeddata_src
);
1093 GpStatus WINGDIPAPI
GdipCloneBitmapAreaI(INT x
, INT y
, INT width
, INT height
,
1094 PixelFormat format
, GpBitmap
* srcBitmap
, GpBitmap
** dstBitmap
)
1096 TRACE("(%i,%i,%i,%i,0x%x,%p,%p)\n", x
, y
, width
, height
, format
, srcBitmap
, dstBitmap
);
1098 return GdipCloneBitmapArea(x
, y
, width
, height
, format
, srcBitmap
, dstBitmap
);
1101 GpStatus WINGDIPAPI
GdipCloneImage(GpImage
*image
, GpImage
**cloneImage
)
1103 GpStatus stat
= GenericError
;
1105 TRACE("%p, %p\n", image
, cloneImage
);
1107 if (!image
|| !cloneImage
)
1108 return InvalidParameter
;
1117 hr
= CreateStreamOnHGlobal(0, TRUE
, &stream
);
1119 return GenericError
;
1121 hr
= IPicture_SaveAsFile(image
->picture
, stream
, FALSE
, &size
);
1124 WARN("Failed to save image on stream\n");
1128 /* Set seek pointer back to the beginning of the picture */
1130 hr
= IStream_Seek(stream
, move
, STREAM_SEEK_SET
, NULL
);
1134 stat
= GdipLoadImageFromStream(stream
, cloneImage
);
1135 if (stat
!= Ok
) WARN("Failed to load image from stream\n");
1138 IStream_Release(stream
);
1141 else if (image
->type
== ImageTypeBitmap
)
1143 GpBitmap
*bitmap
= (GpBitmap
*)image
;
1144 BitmapData lockeddata_src
, lockeddata_dst
;
1148 stat
= GdipBitmapLockBits(bitmap
, NULL
, ImageLockModeRead
, bitmap
->format
,
1150 if (stat
!= Ok
) return stat
;
1152 stat
= GdipCreateBitmapFromScan0(lockeddata_src
.Width
, lockeddata_src
.Height
,
1153 0, lockeddata_src
.PixelFormat
, NULL
, (GpBitmap
**)cloneImage
);
1156 stat
= GdipBitmapLockBits((GpBitmap
*)*cloneImage
, NULL
, ImageLockModeWrite
,
1157 lockeddata_src
.PixelFormat
, &lockeddata_dst
);
1161 /* copy the image data */
1162 row_size
= (lockeddata_src
.Width
* PIXELFORMATBPP(lockeddata_src
.PixelFormat
) +7)/8;
1163 for (i
=0; i
<lockeddata_src
.Height
; i
++)
1164 memcpy((BYTE
*)lockeddata_dst
.Scan0
+lockeddata_dst
.Stride
*i
,
1165 (BYTE
*)lockeddata_src
.Scan0
+lockeddata_src
.Stride
*i
,
1168 GdipBitmapUnlockBits((GpBitmap
*)*cloneImage
, &lockeddata_dst
);
1172 GdipDisposeImage(*cloneImage
);
1175 GdipBitmapUnlockBits(bitmap
, &lockeddata_src
);
1181 else memcpy(&(*cloneImage
)->format
, &image
->format
, sizeof(GUID
));
1187 ERR("GpImage with no IPicture or bitmap?!\n");
1188 return NotImplemented
;
1192 GpStatus WINGDIPAPI
GdipCreateBitmapFromFile(GDIPCONST WCHAR
* filename
,
1198 TRACE("(%s) %p\n", debugstr_w(filename
), bitmap
);
1200 if(!filename
|| !bitmap
)
1201 return InvalidParameter
;
1203 stat
= GdipCreateStreamOnFile(filename
, GENERIC_READ
, &stream
);
1208 stat
= GdipCreateBitmapFromStream(stream
, bitmap
);
1210 IStream_Release(stream
);
1215 GpStatus WINGDIPAPI
GdipCreateBitmapFromGdiDib(GDIPCONST BITMAPINFO
* info
,
1216 VOID
*bits
, GpBitmap
**bitmap
)
1218 DWORD height
, stride
;
1221 FIXME("(%p, %p, %p) - partially implemented\n", info
, bits
, bitmap
);
1223 height
= abs(info
->bmiHeader
.biHeight
);
1224 stride
= ((info
->bmiHeader
.biWidth
* info
->bmiHeader
.biBitCount
+ 31) >> 3) & ~3;
1226 if(info
->bmiHeader
.biHeight
> 0) /* bottom-up */
1228 bits
= (BYTE
*)bits
+ (height
- 1) * stride
;
1232 switch(info
->bmiHeader
.biBitCount
) {
1234 format
= PixelFormat1bppIndexed
;
1237 format
= PixelFormat4bppIndexed
;
1240 format
= PixelFormat8bppIndexed
;
1243 format
= PixelFormat24bppRGB
;
1246 FIXME("don't know how to handle %d bpp\n", info
->bmiHeader
.biBitCount
);
1248 return InvalidParameter
;
1251 return GdipCreateBitmapFromScan0(info
->bmiHeader
.biWidth
, height
, stride
, format
,
1257 GpStatus WINGDIPAPI
GdipCreateBitmapFromFileICM(GDIPCONST WCHAR
* filename
,
1260 TRACE("(%s) %p\n", debugstr_w(filename
), bitmap
);
1262 return GdipCreateBitmapFromFile(filename
, bitmap
);
1265 GpStatus WINGDIPAPI
GdipCreateBitmapFromResource(HINSTANCE hInstance
,
1266 GDIPCONST WCHAR
* lpBitmapName
, GpBitmap
** bitmap
)
1269 GpStatus stat
= InvalidParameter
;
1271 TRACE("%p (%s) %p\n", hInstance
, debugstr_w(lpBitmapName
), bitmap
);
1273 if(!lpBitmapName
|| !bitmap
)
1274 return InvalidParameter
;
1277 hbm
= LoadImageW(hInstance
, lpBitmapName
, IMAGE_BITMAP
, 0, 0,
1278 LR_CREATEDIBSECTION
);
1281 stat
= GdipCreateBitmapFromHBITMAP(hbm
, NULL
, bitmap
);
1288 GpStatus WINGDIPAPI
GdipCreateHBITMAPFromBitmap(GpBitmap
* bitmap
,
1289 HBITMAP
* hbmReturn
, ARGB background
)
1292 HBITMAP result
, oldbitmap
;
1295 GpGraphics
*graphics
;
1296 BITMAPINFOHEADER bih
;
1298 TRACE("(%p,%p,%x)\n", bitmap
, hbmReturn
, background
);
1300 if (!bitmap
|| !hbmReturn
) return InvalidParameter
;
1302 GdipGetImageWidth((GpImage
*)bitmap
, &width
);
1303 GdipGetImageHeight((GpImage
*)bitmap
, &height
);
1305 bih
.biSize
= sizeof(bih
);
1306 bih
.biWidth
= width
;
1307 bih
.biHeight
= height
;
1309 bih
.biBitCount
= 32;
1310 bih
.biCompression
= BI_RGB
;
1311 bih
.biSizeImage
= 0;
1312 bih
.biXPelsPerMeter
= 0;
1313 bih
.biYPelsPerMeter
= 0;
1315 bih
.biClrImportant
= 0;
1317 hdc
= CreateCompatibleDC(NULL
);
1318 if (!hdc
) return GenericError
;
1320 result
= CreateDIBSection(hdc
, (BITMAPINFO
*)&bih
, DIB_RGB_COLORS
, &bits
,
1325 oldbitmap
= SelectObject(hdc
, result
);
1327 stat
= GdipCreateFromHDC(hdc
, &graphics
);
1330 stat
= GdipGraphicsClear(graphics
, background
);
1333 stat
= GdipDrawImage(graphics
, (GpImage
*)bitmap
, 0, 0);
1335 GdipDeleteGraphics(graphics
);
1338 SelectObject(hdc
, oldbitmap
);
1341 stat
= GenericError
;
1345 if (stat
!= Ok
&& result
)
1347 DeleteObject(result
);
1351 *hbmReturn
= result
;
1356 GpStatus WINGDIPAPI
GdipConvertToEmfPlus(const GpGraphics
* ref
,
1357 GpMetafile
* metafile
, BOOL
* succ
, EmfType emfType
,
1358 const WCHAR
* description
, GpMetafile
** out_metafile
)
1362 TRACE("(%p,%p,%p,%u,%s,%p)\n", ref
, metafile
, succ
, emfType
,
1363 debugstr_w(description
), out_metafile
);
1365 if(!ref
|| !metafile
|| !out_metafile
)
1366 return InvalidParameter
;
1369 *out_metafile
= NULL
;
1372 FIXME("not implemented\n");
1374 return NotImplemented
;
1377 /* FIXME: this should create a bitmap in the given size with the attributes
1378 * (resolution etc.) of the graphics object */
1379 GpStatus WINGDIPAPI
GdipCreateBitmapFromGraphics(INT width
, INT height
,
1380 GpGraphics
* target
, GpBitmap
** bitmap
)
1385 if(!target
|| !bitmap
)
1386 return InvalidParameter
;
1389 FIXME("hacked stub\n");
1391 ret
= GdipCreateBitmapFromScan0(width
, height
, 0, PixelFormat24bppRGB
,
1397 GpStatus WINGDIPAPI
GdipCreateBitmapFromHICON(HICON hicon
, GpBitmap
** bitmap
)
1405 BitmapData lockeddata
;
1410 BITMAPINFOHEADER bih
;
1415 TRACE("%p, %p\n", hicon
, bitmap
);
1417 if(!bitmap
|| !GetIconInfo(hicon
, &iinfo
))
1418 return InvalidParameter
;
1420 /* get the size of the icon */
1421 ret
= GetObjectA(iinfo
.hbmColor
? iinfo
.hbmColor
: iinfo
.hbmMask
, sizeof(bm
), &bm
);
1423 DeleteObject(iinfo
.hbmColor
);
1424 DeleteObject(iinfo
.hbmMask
);
1425 return GenericError
;
1431 height
= abs(bm
.bmHeight
);
1432 else /* combined bitmap + mask */
1433 height
= abs(bm
.bmHeight
) / 2;
1435 bits
= HeapAlloc(GetProcessHeap(), 0, 4*width
*height
);
1437 DeleteObject(iinfo
.hbmColor
);
1438 DeleteObject(iinfo
.hbmMask
);
1442 stat
= GdipCreateBitmapFromScan0(width
, height
, 0, PixelFormat32bppARGB
, NULL
, bitmap
);
1444 DeleteObject(iinfo
.hbmColor
);
1445 DeleteObject(iinfo
.hbmMask
);
1446 HeapFree(GetProcessHeap(), 0, bits
);
1453 rect
.Height
= height
;
1455 stat
= GdipBitmapLockBits(*bitmap
, &rect
, ImageLockModeWrite
, PixelFormat32bppARGB
, &lockeddata
);
1457 DeleteObject(iinfo
.hbmColor
);
1458 DeleteObject(iinfo
.hbmMask
);
1459 HeapFree(GetProcessHeap(), 0, bits
);
1460 GdipDisposeImage((GpImage
*)*bitmap
);
1464 bih
.biSize
= sizeof(bih
);
1465 bih
.biWidth
= width
;
1466 bih
.biHeight
= -height
;
1468 bih
.biBitCount
= 32;
1469 bih
.biCompression
= BI_RGB
;
1470 bih
.biSizeImage
= 0;
1471 bih
.biXPelsPerMeter
= 0;
1472 bih
.biYPelsPerMeter
= 0;
1474 bih
.biClrImportant
= 0;
1476 screendc
= GetDC(0);
1479 GetDIBits(screendc
, iinfo
.hbmColor
, 0, height
, bits
, (BITMAPINFO
*)&bih
, DIB_RGB_COLORS
);
1481 if (bm
.bmBitsPixel
== 32)
1485 /* If any pixel has a non-zero alpha, ignore hbmMask */
1487 for (x
=0; x
<width
&& !has_alpha
; x
++)
1488 for (y
=0; y
<height
&& !has_alpha
; y
++)
1489 if ((*src
++ & 0xff000000) != 0)
1492 else has_alpha
= FALSE
;
1496 GetDIBits(screendc
, iinfo
.hbmMask
, 0, height
, bits
, (BITMAPINFO
*)&bih
, DIB_RGB_COLORS
);
1500 /* copy the image data to the Bitmap */
1502 dst_row
= lockeddata
.Scan0
;
1503 for (y
=0; y
<height
; y
++)
1505 memcpy(dst_row
, src
, width
*4);
1507 dst_row
+= lockeddata
.Stride
;
1514 /* read alpha data from the mask */
1516 GetDIBits(screendc
, iinfo
.hbmMask
, 0, height
, bits
, (BITMAPINFO
*)&bih
, DIB_RGB_COLORS
);
1518 GetDIBits(screendc
, iinfo
.hbmMask
, height
, height
, bits
, (BITMAPINFO
*)&bih
, DIB_RGB_COLORS
);
1521 dst_row
= lockeddata
.Scan0
;
1522 for (y
=0; y
<height
; y
++)
1524 dst
= (DWORD
*)dst_row
;
1525 for (x
=0; x
<height
; x
++)
1527 DWORD src_value
= *src
++;
1531 *dst
++ |= 0xff000000;
1533 dst_row
+= lockeddata
.Stride
;
1538 /* set constant alpha of 255 */
1540 for (y
=0; y
<height
; y
++)
1542 dst
= (DWORD
*)dst_row
;
1543 for (x
=0; x
<height
; x
++)
1544 *dst
++ |= 0xff000000;
1545 dst_row
+= lockeddata
.Stride
;
1550 ReleaseDC(0, screendc
);
1552 DeleteObject(iinfo
.hbmColor
);
1553 DeleteObject(iinfo
.hbmMask
);
1555 GdipBitmapUnlockBits(*bitmap
, &lockeddata
);
1557 HeapFree(GetProcessHeap(), 0, bits
);
1562 static void generate_halftone_palette(ARGB
*entries
, UINT count
)
1564 static const BYTE halftone_values
[6]={0x00,0x33,0x66,0x99,0xcc,0xff};
1567 for (i
=0; i
<8 && i
<count
; i
++)
1569 entries
[i
] = 0xff000000;
1570 if (i
&1) entries
[i
] |= 0x800000;
1571 if (i
&2) entries
[i
] |= 0x8000;
1572 if (i
&4) entries
[i
] |= 0x80;
1576 entries
[i
] = 0xffc0c0c0;
1578 for (i
=9; i
<16 && i
<count
; i
++)
1580 entries
[i
] = 0xff000000;
1581 if (i
&1) entries
[i
] |= 0xff0000;
1582 if (i
&2) entries
[i
] |= 0xff00;
1583 if (i
&4) entries
[i
] |= 0xff;
1586 for (i
=16; i
<40 && i
<count
; i
++)
1591 for (i
=40; i
<256 && i
<count
; i
++)
1593 entries
[i
] = 0xff000000;
1594 entries
[i
] |= halftone_values
[(i
-40)%6];
1595 entries
[i
] |= halftone_values
[((i
-40)/6)%6] << 8;
1596 entries
[i
] |= halftone_values
[((i
-40)/36)%6] << 16;
1600 static GpStatus
get_screen_resolution(REAL
*xres
, REAL
*yres
)
1602 HDC screendc
= GetDC(0);
1604 if (!screendc
) return GenericError
;
1606 *xres
= (REAL
)GetDeviceCaps(screendc
, LOGPIXELSX
);
1607 *yres
= (REAL
)GetDeviceCaps(screendc
, LOGPIXELSY
);
1609 ReleaseDC(0, screendc
);
1614 GpStatus WINGDIPAPI
GdipCreateBitmapFromScan0(INT width
, INT height
, INT stride
,
1615 PixelFormat format
, BYTE
* scan0
, GpBitmap
** bitmap
)
1619 INT row_size
, dib_stride
;
1626 TRACE("%d %d %d 0x%x %p %p\n", width
, height
, stride
, format
, scan0
, bitmap
);
1628 if (!bitmap
) return InvalidParameter
;
1630 if(width
<= 0 || height
<= 0 || (scan0
&& (stride
% 4))){
1632 return InvalidParameter
;
1635 if(scan0
&& !stride
)
1636 return InvalidParameter
;
1638 stat
= get_screen_resolution(&xres
, &yres
);
1639 if (stat
!= Ok
) return stat
;
1641 row_size
= (width
* PIXELFORMATBPP(format
)+7) / 8;
1642 dib_stride
= (row_size
+ 3) & ~3;
1645 stride
= dib_stride
;
1647 pbmi
= GdipAlloc(sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
));
1651 pbmi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
1652 pbmi
->bmiHeader
.biWidth
= width
;
1653 pbmi
->bmiHeader
.biHeight
= -height
;
1654 pbmi
->bmiHeader
.biPlanes
= 1;
1655 /* FIXME: use the rest of the data from format */
1656 pbmi
->bmiHeader
.biBitCount
= PIXELFORMATBPP(format
);
1657 pbmi
->bmiHeader
.biCompression
= BI_RGB
;
1658 pbmi
->bmiHeader
.biSizeImage
= 0;
1659 pbmi
->bmiHeader
.biXPelsPerMeter
= 0;
1660 pbmi
->bmiHeader
.biYPelsPerMeter
= 0;
1661 pbmi
->bmiHeader
.biClrUsed
= 0;
1662 pbmi
->bmiHeader
.biClrImportant
= 0;
1664 hdc
= CreateCompatibleDC(NULL
);
1667 return GenericError
;
1670 hbitmap
= CreateDIBSection(hdc
, pbmi
, DIB_RGB_COLORS
, (void**)&bits
, NULL
, 0);
1675 if (!hbitmap
) return GenericError
;
1677 /* copy bits to the dib if necessary */
1678 /* FIXME: should reference the bits instead of copying them */
1680 for (i
=0; i
<height
; i
++)
1681 memcpy(bits
+i
*dib_stride
, scan0
+i
*stride
, row_size
);
1683 *bitmap
= GdipAlloc(sizeof(GpBitmap
));
1686 DeleteObject(hbitmap
);
1690 (*bitmap
)->image
.type
= ImageTypeBitmap
;
1691 memcpy(&(*bitmap
)->image
.format
, &ImageFormatMemoryBMP
, sizeof(GUID
));
1692 (*bitmap
)->image
.flags
= ImageFlagsNone
;
1693 (*bitmap
)->image
.palette_flags
= 0;
1694 (*bitmap
)->image
.palette_count
= 0;
1695 (*bitmap
)->image
.palette_size
= 0;
1696 (*bitmap
)->image
.palette_entries
= NULL
;
1697 (*bitmap
)->image
.xres
= xres
;
1698 (*bitmap
)->image
.yres
= yres
;
1699 (*bitmap
)->width
= width
;
1700 (*bitmap
)->height
= height
;
1701 (*bitmap
)->format
= format
;
1702 (*bitmap
)->image
.picture
= NULL
;
1703 (*bitmap
)->hbitmap
= hbitmap
;
1704 (*bitmap
)->hdc
= NULL
;
1705 (*bitmap
)->bits
= bits
;
1706 (*bitmap
)->stride
= dib_stride
;
1708 if (format
== PixelFormat1bppIndexed
||
1709 format
== PixelFormat4bppIndexed
||
1710 format
== PixelFormat8bppIndexed
)
1712 (*bitmap
)->image
.palette_size
= (*bitmap
)->image
.palette_count
= 1 << PIXELFORMATBPP(format
);
1713 (*bitmap
)->image
.palette_entries
= GdipAlloc(sizeof(ARGB
) * ((*bitmap
)->image
.palette_size
));
1715 if (!(*bitmap
)->image
.palette_entries
)
1717 GdipDisposeImage(&(*bitmap
)->image
);
1722 if (format
== PixelFormat1bppIndexed
)
1724 (*bitmap
)->image
.palette_flags
= PaletteFlagsGrayScale
;
1725 (*bitmap
)->image
.palette_entries
[0] = 0xff000000;
1726 (*bitmap
)->image
.palette_entries
[1] = 0xffffffff;
1730 if (format
== PixelFormat8bppIndexed
)
1731 (*bitmap
)->image
.palette_flags
= PaletteFlagsHalftone
;
1733 generate_halftone_palette((*bitmap
)->image
.palette_entries
,
1734 (*bitmap
)->image
.palette_count
);
1738 TRACE("<-- %p\n", *bitmap
);
1743 GpStatus WINGDIPAPI
GdipCreateBitmapFromStream(IStream
* stream
,
1748 TRACE("%p %p\n", stream
, bitmap
);
1750 stat
= GdipLoadImageFromStream(stream
, (GpImage
**) bitmap
);
1755 if((*bitmap
)->image
.type
!= ImageTypeBitmap
){
1756 GdipDisposeImage(&(*bitmap
)->image
);
1758 return GenericError
; /* FIXME: what error to return? */
1765 GpStatus WINGDIPAPI
GdipCreateBitmapFromStreamICM(IStream
* stream
,
1768 TRACE("%p %p\n", stream
, bitmap
);
1770 return GdipCreateBitmapFromStream(stream
, bitmap
);
1773 GpStatus WINGDIPAPI
GdipCreateCachedBitmap(GpBitmap
*bitmap
, GpGraphics
*graphics
,
1774 GpCachedBitmap
**cachedbmp
)
1778 TRACE("%p %p %p\n", bitmap
, graphics
, cachedbmp
);
1780 if(!bitmap
|| !graphics
|| !cachedbmp
)
1781 return InvalidParameter
;
1783 *cachedbmp
= GdipAlloc(sizeof(GpCachedBitmap
));
1787 stat
= GdipCloneImage(&(bitmap
->image
), &(*cachedbmp
)->image
);
1789 GdipFree(*cachedbmp
);
1796 GpStatus WINGDIPAPI
GdipCreateHICONFromBitmap(GpBitmap
*bitmap
, HICON
*hicon
)
1798 FIXME("(%p, %p)\n", bitmap
, hicon
);
1800 return NotImplemented
;
1803 GpStatus WINGDIPAPI
GdipDeleteCachedBitmap(GpCachedBitmap
*cachedbmp
)
1805 TRACE("%p\n", cachedbmp
);
1808 return InvalidParameter
;
1810 GdipDisposeImage(cachedbmp
->image
);
1811 GdipFree(cachedbmp
);
1816 GpStatus WINGDIPAPI
GdipDrawCachedBitmap(GpGraphics
*graphics
,
1817 GpCachedBitmap
*cachedbmp
, INT x
, INT y
)
1819 TRACE("%p %p %d %d\n", graphics
, cachedbmp
, x
, y
);
1821 if(!graphics
|| !cachedbmp
)
1822 return InvalidParameter
;
1824 return GdipDrawImage(graphics
, cachedbmp
->image
, (REAL
)x
, (REAL
)y
);
1827 GpStatus WINGDIPAPI
GdipEmfToWmfBits(HENHMETAFILE hemf
, UINT cbData16
,
1828 LPBYTE pData16
, INT iMapMode
, INT eFlags
)
1830 FIXME("(%p, %d, %p, %d, %d): stub\n", hemf
, cbData16
, pData16
, iMapMode
, eFlags
);
1831 return NotImplemented
;
1834 /* Internal utility function: Replace the image data of dst with that of src,
1836 static void move_bitmap(GpBitmap
*dst
, GpBitmap
*src
, BOOL clobber_palette
)
1838 GdipFree(dst
->bitmapbits
);
1840 DeleteObject(dst
->hbitmap
);
1842 if (clobber_palette
)
1844 GdipFree(dst
->image
.palette_entries
);
1845 dst
->image
.palette_flags
= src
->image
.palette_flags
;
1846 dst
->image
.palette_count
= src
->image
.palette_count
;
1847 dst
->image
.palette_entries
= src
->image
.palette_entries
;
1850 GdipFree(src
->image
.palette_entries
);
1852 dst
->image
.xres
= src
->image
.xres
;
1853 dst
->image
.yres
= src
->image
.yres
;
1854 dst
->width
= src
->width
;
1855 dst
->height
= src
->height
;
1856 dst
->format
= src
->format
;
1857 dst
->hbitmap
= src
->hbitmap
;
1858 dst
->hdc
= src
->hdc
;
1859 dst
->bits
= src
->bits
;
1860 dst
->stride
= src
->stride
;
1865 GpStatus WINGDIPAPI
GdipDisposeImage(GpImage
*image
)
1867 TRACE("%p\n", image
);
1870 return InvalidParameter
;
1873 IPicture_Release(image
->picture
);
1874 if (image
->type
== ImageTypeBitmap
)
1876 GdipFree(((GpBitmap
*)image
)->bitmapbits
);
1877 DeleteDC(((GpBitmap
*)image
)->hdc
);
1878 DeleteObject(((GpBitmap
*)image
)->hbitmap
);
1880 GdipFree(image
->palette_entries
);
1886 GpStatus WINGDIPAPI
GdipFindFirstImageItem(GpImage
*image
, ImageItemData
* item
)
1890 TRACE("(%p,%p)\n", image
, item
);
1893 return InvalidParameter
;
1896 FIXME("not implemented\n");
1898 return NotImplemented
;
1901 GpStatus WINGDIPAPI
GdipGetImageItemData(GpImage
*image
, ImageItemData
*item
)
1905 TRACE("(%p,%p)\n", image
, item
);
1908 FIXME("not implemented\n");
1910 return NotImplemented
;
1913 GpStatus WINGDIPAPI
GdipGetImageBounds(GpImage
*image
, GpRectF
*srcRect
,
1916 TRACE("%p %p %p\n", image
, srcRect
, srcUnit
);
1918 if(!image
|| !srcRect
|| !srcUnit
)
1919 return InvalidParameter
;
1920 if(image
->type
== ImageTypeMetafile
){
1921 *srcRect
= ((GpMetafile
*)image
)->bounds
;
1922 *srcUnit
= ((GpMetafile
*)image
)->unit
;
1924 else if(image
->type
== ImageTypeBitmap
){
1925 srcRect
->X
= srcRect
->Y
= 0.0;
1926 srcRect
->Width
= (REAL
) ((GpBitmap
*)image
)->width
;
1927 srcRect
->Height
= (REAL
) ((GpBitmap
*)image
)->height
;
1928 *srcUnit
= UnitPixel
;
1931 srcRect
->X
= srcRect
->Y
= 0.0;
1932 srcRect
->Width
= ipicture_pixel_width(image
->picture
);
1933 srcRect
->Height
= ipicture_pixel_height(image
->picture
);
1934 *srcUnit
= UnitPixel
;
1937 TRACE("returning (%f, %f) (%f, %f) unit type %d\n", srcRect
->X
, srcRect
->Y
,
1938 srcRect
->Width
, srcRect
->Height
, *srcUnit
);
1943 GpStatus WINGDIPAPI
GdipGetImageDimension(GpImage
*image
, REAL
*width
,
1946 TRACE("%p %p %p\n", image
, width
, height
);
1948 if(!image
|| !height
|| !width
)
1949 return InvalidParameter
;
1951 if(image
->type
== ImageTypeMetafile
){
1954 *height
= convert_unit(hdc
, ((GpMetafile
*)image
)->unit
) *
1955 ((GpMetafile
*)image
)->bounds
.Height
;
1957 *width
= convert_unit(hdc
, ((GpMetafile
*)image
)->unit
) *
1958 ((GpMetafile
*)image
)->bounds
.Width
;
1963 else if(image
->type
== ImageTypeBitmap
){
1964 *height
= ((GpBitmap
*)image
)->height
;
1965 *width
= ((GpBitmap
*)image
)->width
;
1968 *height
= ipicture_pixel_height(image
->picture
);
1969 *width
= ipicture_pixel_width(image
->picture
);
1972 TRACE("returning (%f, %f)\n", *height
, *width
);
1976 GpStatus WINGDIPAPI
GdipGetImageGraphicsContext(GpImage
*image
,
1977 GpGraphics
**graphics
)
1982 TRACE("%p %p\n", image
, graphics
);
1984 if(!image
|| !graphics
)
1985 return InvalidParameter
;
1987 if(image
->type
!= ImageTypeBitmap
){
1988 FIXME("not implemented for image type %d\n", image
->type
);
1989 return NotImplemented
;
1992 hdc
= ((GpBitmap
*)image
)->hdc
;
1995 hdc
= CreateCompatibleDC(0);
1996 SelectObject(hdc
, ((GpBitmap
*)image
)->hbitmap
);
1997 ((GpBitmap
*)image
)->hdc
= hdc
;
2000 stat
= GdipCreateFromHDC(hdc
, graphics
);
2003 (*graphics
)->image
= image
;
2008 GpStatus WINGDIPAPI
GdipGetImageHeight(GpImage
*image
, UINT
*height
)
2010 TRACE("%p %p\n", image
, height
);
2012 if(!image
|| !height
)
2013 return InvalidParameter
;
2015 if(image
->type
== ImageTypeMetafile
){
2018 *height
= roundr(convert_unit(hdc
, ((GpMetafile
*)image
)->unit
) *
2019 ((GpMetafile
*)image
)->bounds
.Height
);
2023 else if(image
->type
== ImageTypeBitmap
)
2024 *height
= ((GpBitmap
*)image
)->height
;
2026 *height
= ipicture_pixel_height(image
->picture
);
2028 TRACE("returning %d\n", *height
);
2033 GpStatus WINGDIPAPI
GdipGetImageHorizontalResolution(GpImage
*image
, REAL
*res
)
2036 return InvalidParameter
;
2040 TRACE("(%p) <-- %0.2f\n", image
, *res
);
2045 GpStatus WINGDIPAPI
GdipGetImagePaletteSize(GpImage
*image
, INT
*size
)
2047 TRACE("%p %p\n", image
, size
);
2050 return InvalidParameter
;
2052 if (image
->palette_count
== 0)
2053 *size
= sizeof(ColorPalette
);
2055 *size
= sizeof(UINT
)*2 + sizeof(ARGB
)*image
->palette_count
;
2057 TRACE("<-- %u\n", *size
);
2062 /* FIXME: test this function for non-bitmap types */
2063 GpStatus WINGDIPAPI
GdipGetImagePixelFormat(GpImage
*image
, PixelFormat
*format
)
2065 TRACE("%p %p\n", image
, format
);
2067 if(!image
|| !format
)
2068 return InvalidParameter
;
2070 if(image
->type
!= ImageTypeBitmap
)
2071 *format
= PixelFormat24bppRGB
;
2073 *format
= ((GpBitmap
*) image
)->format
;
2078 GpStatus WINGDIPAPI
GdipGetImageRawFormat(GpImage
*image
, GUID
*format
)
2080 if(!image
|| !format
)
2081 return InvalidParameter
;
2083 memcpy(format
, &image
->format
, sizeof(GUID
));
2088 GpStatus WINGDIPAPI
GdipGetImageType(GpImage
*image
, ImageType
*type
)
2090 TRACE("%p %p\n", image
, type
);
2093 return InvalidParameter
;
2095 *type
= image
->type
;
2100 GpStatus WINGDIPAPI
GdipGetImageVerticalResolution(GpImage
*image
, REAL
*res
)
2103 return InvalidParameter
;
2107 TRACE("(%p) <-- %0.2f\n", image
, *res
);
2112 GpStatus WINGDIPAPI
GdipGetImageWidth(GpImage
*image
, UINT
*width
)
2114 TRACE("%p %p\n", image
, width
);
2116 if(!image
|| !width
)
2117 return InvalidParameter
;
2119 if(image
->type
== ImageTypeMetafile
){
2122 *width
= roundr(convert_unit(hdc
, ((GpMetafile
*)image
)->unit
) *
2123 ((GpMetafile
*)image
)->bounds
.Width
);
2127 else if(image
->type
== ImageTypeBitmap
)
2128 *width
= ((GpBitmap
*)image
)->width
;
2130 *width
= ipicture_pixel_width(image
->picture
);
2132 TRACE("returning %d\n", *width
);
2137 GpStatus WINGDIPAPI
GdipGetMetafileHeaderFromMetafile(GpMetafile
* metafile
,
2138 MetafileHeader
* header
)
2142 if(!metafile
|| !header
)
2143 return InvalidParameter
;
2146 FIXME("not implemented\n");
2148 memset(header
, 0, sizeof(MetafileHeader
));
2153 GpStatus WINGDIPAPI
GdipGetAllPropertyItems(GpImage
*image
, UINT size
,
2154 UINT num
, PropertyItem
* items
)
2159 FIXME("not implemented\n");
2161 return InvalidParameter
;
2164 GpStatus WINGDIPAPI
GdipGetPropertyCount(GpImage
*image
, UINT
* num
)
2169 FIXME("not implemented\n");
2171 return InvalidParameter
;
2174 GpStatus WINGDIPAPI
GdipGetPropertyIdList(GpImage
*image
, UINT num
, PROPID
* list
)
2179 FIXME("not implemented\n");
2181 return InvalidParameter
;
2184 GpStatus WINGDIPAPI
GdipGetPropertyItem(GpImage
*image
, PROPID id
, UINT size
,
2185 PropertyItem
* buffer
)
2190 FIXME("not implemented\n");
2192 return InvalidParameter
;
2195 GpStatus WINGDIPAPI
GdipGetPropertyItemSize(GpImage
*image
, PROPID pid
,
2200 TRACE("%p %x %p\n", image
, pid
, size
);
2203 return InvalidParameter
;
2206 FIXME("not implemented\n");
2208 return NotImplemented
;
2211 GpStatus WINGDIPAPI
GdipGetPropertySize(GpImage
*image
, UINT
* size
, UINT
* num
)
2215 TRACE("(%p,%p,%p)\n", image
, size
, num
);
2218 FIXME("not implemented\n");
2220 return InvalidParameter
;
2223 struct image_format_dimension
2226 const GUID
*dimension
;
2229 struct image_format_dimension image_format_dimensions
[] =
2231 {&ImageFormatGIF
, &FrameDimensionTime
},
2232 {&ImageFormatIcon
, &FrameDimensionResolution
},
2236 /* FIXME: Need to handle multi-framed images */
2237 GpStatus WINGDIPAPI
GdipImageGetFrameCount(GpImage
*image
,
2238 GDIPCONST GUID
* dimensionID
, UINT
* count
)
2242 TRACE("(%p,%s,%p)\n", image
, debugstr_guid(dimensionID
), count
);
2244 if(!image
|| !count
)
2245 return InvalidParameter
;
2248 FIXME("returning frame count of 1\n");
2255 GpStatus WINGDIPAPI
GdipImageGetFrameDimensionsCount(GpImage
*image
,
2258 /* Native gdiplus 1.1 does not yet support multiple frame dimensions. */
2260 if(!image
|| !count
)
2261 return InvalidParameter
;
2268 GpStatus WINGDIPAPI
GdipImageGetFrameDimensionsList(GpImage
* image
,
2269 GUID
* dimensionIDs
, UINT count
)
2272 const GUID
*result
=NULL
;
2274 TRACE("(%p,%p,%u)\n", image
, dimensionIDs
, count
);
2276 if(!image
|| !dimensionIDs
|| count
!= 1)
2277 return InvalidParameter
;
2279 for (i
=0; image_format_dimensions
[i
].format
; i
++)
2281 if (IsEqualGUID(&image
->format
, image_format_dimensions
[i
].format
))
2283 result
= image_format_dimensions
[i
].dimension
;
2289 result
= &FrameDimensionPage
;
2291 memcpy(dimensionIDs
, result
, sizeof(GUID
));
2296 GpStatus WINGDIPAPI
GdipImageSelectActiveFrame(GpImage
*image
,
2297 GDIPCONST GUID
* dimensionID
, UINT frameidx
)
2301 if(!image
|| !dimensionID
)
2302 return InvalidParameter
;
2305 FIXME("not implemented\n");
2310 GpStatus WINGDIPAPI
GdipLoadImageFromFile(GDIPCONST WCHAR
* filename
,
2316 TRACE("(%s) %p\n", debugstr_w(filename
), image
);
2318 if (!filename
|| !image
)
2319 return InvalidParameter
;
2321 stat
= GdipCreateStreamOnFile(filename
, GENERIC_READ
, &stream
);
2326 stat
= GdipLoadImageFromStream(stream
, image
);
2328 IStream_Release(stream
);
2333 /* FIXME: no icm handling */
2334 GpStatus WINGDIPAPI
GdipLoadImageFromFileICM(GDIPCONST WCHAR
* filename
,GpImage
**image
)
2336 TRACE("(%s) %p\n", debugstr_w(filename
), image
);
2338 return GdipLoadImageFromFile(filename
, image
);
2341 static const WICPixelFormatGUID
*wic_pixel_formats
[] = {
2342 &GUID_WICPixelFormat16bppBGR555
,
2343 &GUID_WICPixelFormat24bppBGR
,
2344 &GUID_WICPixelFormat32bppBGR
,
2345 &GUID_WICPixelFormat32bppBGRA
,
2346 &GUID_WICPixelFormat32bppPBGRA
,
2350 static const PixelFormat wic_gdip_formats
[] = {
2351 PixelFormat16bppRGB555
,
2352 PixelFormat24bppRGB
,
2353 PixelFormat32bppRGB
,
2354 PixelFormat32bppARGB
,
2355 PixelFormat32bppPARGB
,
2358 static GpStatus
decode_image_wic(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2363 IWICBitmapDecoder
*decoder
;
2364 IWICBitmapFrameDecode
*frame
;
2365 IWICBitmapSource
*source
=NULL
;
2366 WICPixelFormatGUID wic_format
;
2367 PixelFormat gdip_format
=0;
2370 BitmapData lockeddata
;
2374 initresult
= CoInitialize(NULL
);
2376 hr
= CoCreateInstance(clsid
, NULL
, CLSCTX_INPROC_SERVER
,
2377 &IID_IWICBitmapDecoder
, (void**)&decoder
);
2378 if (FAILED(hr
)) goto end
;
2380 hr
= IWICBitmapDecoder_Initialize(decoder
, (IStream
*)stream
, WICDecodeMetadataCacheOnLoad
);
2382 hr
= IWICBitmapDecoder_GetFrame(decoder
, 0, &frame
);
2384 if (SUCCEEDED(hr
)) /* got frame */
2386 hr
= IWICBitmapFrameDecode_GetPixelFormat(frame
, &wic_format
);
2390 for (i
=0; wic_pixel_formats
[i
]; i
++)
2392 if (IsEqualGUID(&wic_format
, wic_pixel_formats
[i
]))
2394 source
= (IWICBitmapSource
*)frame
;
2395 IWICBitmapSource_AddRef(source
);
2396 gdip_format
= wic_gdip_formats
[i
];
2402 /* unknown format; fall back on 32bppARGB */
2403 hr
= WICConvertBitmapSource(&GUID_WICPixelFormat32bppBGRA
, (IWICBitmapSource
*)frame
, &source
);
2404 gdip_format
= PixelFormat32bppARGB
;
2408 if (SUCCEEDED(hr
)) /* got source */
2410 hr
= IWICBitmapSource_GetSize(source
, &width
, &height
);
2413 status
= GdipCreateBitmapFromScan0(width
, height
, 0, gdip_format
,
2416 if (SUCCEEDED(hr
) && status
== Ok
) /* created bitmap */
2418 status
= GdipBitmapLockBits(bitmap
, NULL
, ImageLockModeWrite
,
2419 gdip_format
, &lockeddata
);
2420 if (status
== Ok
) /* locked bitmap */
2425 for (i
=0; i
<height
; i
++)
2428 hr
= IWICBitmapSource_CopyPixels(source
, &wrc
, abs(lockeddata
.Stride
),
2429 abs(lockeddata
.Stride
), (BYTE
*)lockeddata
.Scan0
+lockeddata
.Stride
*i
);
2430 if (FAILED(hr
)) break;
2433 GdipBitmapUnlockBits(bitmap
, &lockeddata
);
2436 if (SUCCEEDED(hr
) && status
== Ok
)
2437 *image
= (GpImage
*)bitmap
;
2441 GdipDisposeImage((GpImage
*)bitmap
);
2445 IWICBitmapSource_Release(source
);
2448 IWICBitmapFrameDecode_Release(frame
);
2451 IWICBitmapDecoder_Release(decoder
);
2454 if (SUCCEEDED(initresult
)) CoUninitialize();
2456 if (FAILED(hr
) && status
== Ok
) status
= hresult_to_status(hr
);
2461 static GpStatus
decode_image_icon(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2463 return decode_image_wic(stream
, &CLSID_WICIcoDecoder
, image
);
2466 static GpStatus
decode_image_bmp(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2471 status
= decode_image_wic(stream
, &CLSID_WICBmpDecoder
, image
);
2473 bitmap
= (GpBitmap
*)*image
;
2475 if (status
== Ok
&& bitmap
->format
== PixelFormat32bppARGB
)
2477 /* WIC supports bmp files with alpha, but gdiplus does not */
2478 bitmap
->format
= PixelFormat32bppRGB
;
2484 static GpStatus
decode_image_jpeg(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2486 return decode_image_wic(stream
, &CLSID_WICJpegDecoder
, image
);
2489 static GpStatus
decode_image_png(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2491 return decode_image_wic(stream
, &CLSID_WICPngDecoder
, image
);
2494 static GpStatus
decode_image_gif(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2496 return decode_image_wic(stream
, &CLSID_WICGifDecoder
, image
);
2499 static GpStatus
decode_image_tiff(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2501 return decode_image_wic(stream
, &CLSID_WICTiffDecoder
, image
);
2504 static GpStatus
decode_image_olepicture_metafile(IStream
* stream
, REFCLSID clsid
, GpImage
**image
)
2508 TRACE("%p %p\n", stream
, image
);
2510 if(!stream
|| !image
)
2511 return InvalidParameter
;
2513 if(OleLoadPicture(stream
, 0, FALSE
, &IID_IPicture
,
2514 (LPVOID
*) &pic
) != S_OK
){
2515 TRACE("Could not load picture\n");
2516 return GenericError
;
2519 /* FIXME: missing initialization code */
2520 *image
= GdipAlloc(sizeof(GpMetafile
));
2521 if(!*image
) return OutOfMemory
;
2522 (*image
)->type
= ImageTypeMetafile
;
2523 (*image
)->picture
= pic
;
2524 (*image
)->flags
= ImageFlagsNone
;
2525 (*image
)->palette_flags
= 0;
2526 (*image
)->palette_count
= 0;
2527 (*image
)->palette_size
= 0;
2528 (*image
)->palette_entries
= NULL
;
2530 TRACE("<-- %p\n", *image
);
2535 typedef GpStatus (*encode_image_func
)(GpImage
*image
, IStream
* stream
,
2536 GDIPCONST CLSID
* clsid
, GDIPCONST EncoderParameters
* params
);
2538 typedef GpStatus (*decode_image_func
)(IStream
*stream
, REFCLSID clsid
, GpImage
** image
);
2540 typedef struct image_codec
{
2541 ImageCodecInfo info
;
2542 encode_image_func encode_func
;
2543 decode_image_func decode_func
;
2558 static const struct image_codec codecs
[NUM_CODECS
];
2560 static GpStatus
get_decoder_info(IStream
* stream
, const struct image_codec
**result
)
2563 const BYTE
*pattern
, *mask
;
2569 /* seek to the start of the stream */
2571 hr
= IStream_Seek(stream
, seek
, STREAM_SEEK_SET
, NULL
);
2572 if (FAILED(hr
)) return hresult_to_status(hr
);
2574 /* read the first 8 bytes */
2575 /* FIXME: This assumes all codecs have signatures <= 8 bytes in length */
2576 hr
= IStream_Read(stream
, signature
, 8, &bytesread
);
2577 if (FAILED(hr
)) return hresult_to_status(hr
);
2578 if (hr
== S_FALSE
|| bytesread
== 0) return GenericError
;
2580 for (i
= 0; i
< NUM_CODECS
; i
++) {
2581 if ((codecs
[i
].info
.Flags
& ImageCodecFlagsDecoder
) &&
2582 bytesread
>= codecs
[i
].info
.SigSize
)
2584 for (sig
=0; sig
<codecs
[i
].info
.SigCount
; sig
++)
2586 pattern
= &codecs
[i
].info
.SigPattern
[codecs
[i
].info
.SigSize
*sig
];
2587 mask
= &codecs
[i
].info
.SigMask
[codecs
[i
].info
.SigSize
*sig
];
2588 for (j
=0; j
<codecs
[i
].info
.SigSize
; j
++)
2589 if ((signature
[j
] & mask
[j
]) != pattern
[j
])
2591 if (j
== codecs
[i
].info
.SigSize
)
2593 *result
= &codecs
[i
];
2600 TRACE("no match for %i byte signature %x %x %x %x %x %x %x %x\n", bytesread
,
2601 signature
[0],signature
[1],signature
[2],signature
[3],
2602 signature
[4],signature
[5],signature
[6],signature
[7]);
2604 return GenericError
;
2607 GpStatus WINGDIPAPI
GdipLoadImageFromStream(IStream
* stream
, GpImage
**image
)
2612 const struct image_codec
*codec
=NULL
;
2614 /* choose an appropriate image decoder */
2615 stat
= get_decoder_info(stream
, &codec
);
2616 if (stat
!= Ok
) return stat
;
2618 /* seek to the start of the stream */
2620 hr
= IStream_Seek(stream
, seek
, STREAM_SEEK_SET
, NULL
);
2621 if (FAILED(hr
)) return hresult_to_status(hr
);
2623 /* call on the image decoder to do the real work */
2624 stat
= codec
->decode_func(stream
, &codec
->info
.Clsid
, image
);
2626 /* take note of the original data format */
2629 memcpy(&(*image
)->format
, &codec
->info
.FormatID
, sizeof(GUID
));
2636 GpStatus WINGDIPAPI
GdipLoadImageFromStreamICM(IStream
* stream
, GpImage
**image
)
2638 TRACE("%p %p\n", stream
, image
);
2640 return GdipLoadImageFromStream(stream
, image
);
2643 GpStatus WINGDIPAPI
GdipRemovePropertyItem(GpImage
*image
, PROPID propId
)
2647 TRACE("(%p,%u)\n", image
, propId
);
2650 return InvalidParameter
;
2653 FIXME("not implemented\n");
2655 return NotImplemented
;
2658 GpStatus WINGDIPAPI
GdipSetPropertyItem(GpImage
*image
, GDIPCONST PropertyItem
* item
)
2662 TRACE("(%p,%p)\n", image
, item
);
2665 FIXME("not implemented\n");
2667 return NotImplemented
;
2670 GpStatus WINGDIPAPI
GdipSaveImageToFile(GpImage
*image
, GDIPCONST WCHAR
* filename
,
2671 GDIPCONST CLSID
*clsidEncoder
,
2672 GDIPCONST EncoderParameters
*encoderParams
)
2677 TRACE("%p (%s) %p %p\n", image
, debugstr_w(filename
), clsidEncoder
, encoderParams
);
2679 if (!image
|| !filename
|| !clsidEncoder
)
2680 return InvalidParameter
;
2682 stat
= GdipCreateStreamOnFile(filename
, GENERIC_WRITE
, &stream
);
2684 return GenericError
;
2686 stat
= GdipSaveImageToStream(image
, stream
, clsidEncoder
, encoderParams
);
2688 IStream_Release(stream
);
2692 /*************************************************************************
2693 * Encoding functions -
2694 * These functions encode an image in different image file formats.
2696 #define BITMAP_FORMAT_BMP 0x4d42 /* "BM" */
2697 #define BITMAP_FORMAT_JPEG 0xd8ff
2698 #define BITMAP_FORMAT_GIF 0x4947
2699 #define BITMAP_FORMAT_PNG 0x5089
2700 #define BITMAP_FORMAT_APM 0xcdd7
2702 static GpStatus
encode_image_WIC(GpImage
*image
, IStream
* stream
,
2703 GDIPCONST CLSID
* clsid
, GDIPCONST EncoderParameters
* params
)
2707 IWICBitmapEncoder
*encoder
;
2708 IWICBitmapFrameEncode
*frameencode
;
2709 IPropertyBag2
*encoderoptions
;
2712 PixelFormat gdipformat
=0;
2713 WICPixelFormatGUID wicformat
;
2715 BitmapData lockeddata
;
2719 if (image
->type
!= ImageTypeBitmap
)
2720 return GenericError
;
2722 bitmap
= (GpBitmap
*)image
;
2724 GdipGetImageWidth(image
, &width
);
2725 GdipGetImageHeight(image
, &height
);
2732 initresult
= CoInitialize(NULL
);
2734 hr
= CoCreateInstance(clsid
, NULL
, CLSCTX_INPROC_SERVER
,
2735 &IID_IWICBitmapEncoder
, (void**)&encoder
);
2738 if (SUCCEEDED(initresult
)) CoUninitialize();
2739 return hresult_to_status(hr
);
2742 hr
= IWICBitmapEncoder_Initialize(encoder
, stream
, WICBitmapEncoderNoCache
);
2746 hr
= IWICBitmapEncoder_CreateNewFrame(encoder
, &frameencode
, &encoderoptions
);
2749 if (SUCCEEDED(hr
)) /* created frame */
2751 hr
= IWICBitmapFrameEncode_Initialize(frameencode
, encoderoptions
);
2754 hr
= IWICBitmapFrameEncode_SetSize(frameencode
, width
, height
);
2757 /* FIXME: use the resolution from the image */
2758 hr
= IWICBitmapFrameEncode_SetResolution(frameencode
, 96.0, 96.0);
2762 for (i
=0; wic_pixel_formats
[i
]; i
++)
2764 if (wic_gdip_formats
[i
] == bitmap
->format
)
2767 if (wic_pixel_formats
[i
])
2768 memcpy(&wicformat
, wic_pixel_formats
[i
], sizeof(GUID
));
2770 memcpy(&wicformat
, &GUID_WICPixelFormat32bppBGRA
, sizeof(GUID
));
2772 hr
= IWICBitmapFrameEncode_SetPixelFormat(frameencode
, &wicformat
);
2774 for (i
=0; wic_pixel_formats
[i
]; i
++)
2776 if (IsEqualGUID(&wicformat
, wic_pixel_formats
[i
]))
2779 if (wic_pixel_formats
[i
])
2780 gdipformat
= wic_gdip_formats
[i
];
2783 ERR("cannot provide pixel format %s\n", debugstr_guid(&wicformat
));
2790 stat
= GdipBitmapLockBits(bitmap
, &rc
, ImageLockModeRead
, gdipformat
,
2795 UINT row_size
= (lockeddata
.Width
* PIXELFORMATBPP(gdipformat
) + 7)/8;
2798 /* write one row at a time in case stride is negative */
2799 row
= lockeddata
.Scan0
;
2800 for (i
=0; i
<lockeddata
.Height
; i
++)
2802 hr
= IWICBitmapFrameEncode_WritePixels(frameencode
, 1, row_size
, row_size
, row
);
2803 if (FAILED(hr
)) break;
2804 row
+= lockeddata
.Stride
;
2807 GdipBitmapUnlockBits(bitmap
, &lockeddata
);
2814 hr
= IWICBitmapFrameEncode_Commit(frameencode
);
2816 IWICBitmapFrameEncode_Release(frameencode
);
2817 IPropertyBag2_Release(encoderoptions
);
2821 hr
= IWICBitmapEncoder_Commit(encoder
);
2823 IWICBitmapEncoder_Release(encoder
);
2825 if (SUCCEEDED(initresult
)) CoUninitialize();
2827 return hresult_to_status(hr
);
2830 static GpStatus
encode_image_BMP(GpImage
*image
, IStream
* stream
,
2831 GDIPCONST CLSID
* clsid
, GDIPCONST EncoderParameters
* params
)
2833 return encode_image_WIC(image
, stream
, &CLSID_WICBmpEncoder
, params
);
2836 static GpStatus
encode_image_png(GpImage
*image
, IStream
* stream
,
2837 GDIPCONST CLSID
* clsid
, GDIPCONST EncoderParameters
* params
)
2839 return encode_image_WIC(image
, stream
, &CLSID_WICPngEncoder
, params
);
2842 /*****************************************************************************
2843 * GdipSaveImageToStream [GDIPLUS.@]
2845 GpStatus WINGDIPAPI
GdipSaveImageToStream(GpImage
*image
, IStream
* stream
,
2846 GDIPCONST CLSID
* clsid
, GDIPCONST EncoderParameters
* params
)
2849 encode_image_func encode_image
;
2852 TRACE("%p %p %p %p\n", image
, stream
, clsid
, params
);
2854 if(!image
|| !stream
)
2855 return InvalidParameter
;
2857 /* select correct encoder */
2858 encode_image
= NULL
;
2859 for (i
= 0; i
< NUM_CODECS
; i
++) {
2860 if ((codecs
[i
].info
.Flags
& ImageCodecFlagsEncoder
) &&
2861 IsEqualCLSID(clsid
, &codecs
[i
].info
.Clsid
))
2862 encode_image
= codecs
[i
].encode_func
;
2864 if (encode_image
== NULL
)
2865 return UnknownImageFormat
;
2867 stat
= encode_image(image
, stream
, clsid
, params
);
2872 /*****************************************************************************
2873 * GdipGetImagePalette [GDIPLUS.@]
2875 GpStatus WINGDIPAPI
GdipGetImagePalette(GpImage
*image
, ColorPalette
*palette
, INT size
)
2877 TRACE("(%p,%p,%i)\n", image
, palette
, size
);
2879 if (!image
|| !palette
)
2880 return InvalidParameter
;
2882 if (size
< (sizeof(UINT
)*2+sizeof(ARGB
)*image
->palette_count
))
2884 TRACE("<-- InsufficientBuffer\n");
2885 return InsufficientBuffer
;
2888 palette
->Flags
= image
->palette_flags
;
2889 palette
->Count
= image
->palette_count
;
2890 memcpy(palette
->Entries
, image
->palette_entries
, sizeof(ARGB
)*image
->palette_count
);
2895 /*****************************************************************************
2896 * GdipSetImagePalette [GDIPLUS.@]
2898 GpStatus WINGDIPAPI
GdipSetImagePalette(GpImage
*image
,
2899 GDIPCONST ColorPalette
*palette
)
2901 TRACE("(%p,%p)\n", image
, palette
);
2903 if(!image
|| !palette
|| palette
->Count
> 256)
2904 return InvalidParameter
;
2906 if (palette
->Count
> image
->palette_size
)
2910 new_palette
= GdipAlloc(sizeof(ARGB
) * palette
->Count
);
2911 if (!new_palette
) return OutOfMemory
;
2913 GdipFree(image
->palette_entries
);
2914 image
->palette_entries
= new_palette
;
2915 image
->palette_size
= palette
->Count
;
2918 image
->palette_flags
= palette
->Flags
;
2919 image
->palette_count
= palette
->Count
;
2920 memcpy(image
->palette_entries
, palette
->Entries
, sizeof(ARGB
)*palette
->Count
);
2925 /*************************************************************************
2927 * Structures that represent which formats we support for encoding.
2930 /* ImageCodecInfo creation routines taken from libgdiplus */
2931 static const WCHAR bmp_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'B', 'M', 'P', 0}; /* Built-in BMP */
2932 static const WCHAR bmp_extension
[] = {'*','.','B', 'M', 'P',';', '*','.', 'D','I', 'B',';', '*','.', 'R', 'L', 'E',0}; /* *.BMP;*.DIB;*.RLE */
2933 static const WCHAR bmp_mimetype
[] = {'i', 'm', 'a','g', 'e', '/', 'b', 'm', 'p', 0}; /* image/bmp */
2934 static const WCHAR bmp_format
[] = {'B', 'M', 'P', 0}; /* BMP */
2935 static const BYTE bmp_sig_pattern
[] = { 0x42, 0x4D };
2936 static const BYTE bmp_sig_mask
[] = { 0xFF, 0xFF };
2938 static const WCHAR jpeg_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'J','P','E','G', 0};
2939 static const WCHAR jpeg_extension
[] = {'*','.','J','P','G',';', '*','.','J','P','E','G',';', '*','.','J','P','E',';', '*','.','J','F','I','F',0};
2940 static const WCHAR jpeg_mimetype
[] = {'i','m','a','g','e','/','j','p','e','g', 0};
2941 static const WCHAR jpeg_format
[] = {'J','P','E','G',0};
2942 static const BYTE jpeg_sig_pattern
[] = { 0xFF, 0xD8 };
2943 static const BYTE jpeg_sig_mask
[] = { 0xFF, 0xFF };
2945 static const WCHAR gif_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'G','I','F', 0};
2946 static const WCHAR gif_extension
[] = {'*','.','G','I','F',0};
2947 static const WCHAR gif_mimetype
[] = {'i','m','a','g','e','/','g','i','f', 0};
2948 static const WCHAR gif_format
[] = {'G','I','F',0};
2949 static const BYTE gif_sig_pattern
[4] = "GIF8";
2950 static const BYTE gif_sig_mask
[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2952 static const WCHAR tiff_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'T','I','F','F', 0};
2953 static const WCHAR tiff_extension
[] = {'*','.','T','I','F','F',';','*','.','T','I','F',0};
2954 static const WCHAR tiff_mimetype
[] = {'i','m','a','g','e','/','t','i','f','f', 0};
2955 static const WCHAR tiff_format
[] = {'T','I','F','F',0};
2956 static const BYTE tiff_sig_pattern
[] = {0x49,0x49,42,0,0x4d,0x4d,0,42};
2957 static const BYTE tiff_sig_mask
[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2959 static const WCHAR emf_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'E','M','F', 0};
2960 static const WCHAR emf_extension
[] = {'*','.','E','M','F',0};
2961 static const WCHAR emf_mimetype
[] = {'i','m','a','g','e','/','x','-','e','m','f', 0};
2962 static const WCHAR emf_format
[] = {'E','M','F',0};
2963 static const BYTE emf_sig_pattern
[] = { 0x01, 0x00, 0x00, 0x00 };
2964 static const BYTE emf_sig_mask
[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2966 static const WCHAR wmf_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'W','M','F', 0};
2967 static const WCHAR wmf_extension
[] = {'*','.','W','M','F',0};
2968 static const WCHAR wmf_mimetype
[] = {'i','m','a','g','e','/','x','-','w','m','f', 0};
2969 static const WCHAR wmf_format
[] = {'W','M','F',0};
2970 static const BYTE wmf_sig_pattern
[] = { 0xd7, 0xcd };
2971 static const BYTE wmf_sig_mask
[] = { 0xFF, 0xFF };
2973 static const WCHAR png_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'P','N','G', 0};
2974 static const WCHAR png_extension
[] = {'*','.','P','N','G',0};
2975 static const WCHAR png_mimetype
[] = {'i','m','a','g','e','/','p','n','g', 0};
2976 static const WCHAR png_format
[] = {'P','N','G',0};
2977 static const BYTE png_sig_pattern
[] = { 137, 80, 78, 71, 13, 10, 26, 10, };
2978 static const BYTE png_sig_mask
[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
2980 static const WCHAR ico_codecname
[] = {'B', 'u', 'i','l', 't', '-','i', 'n', ' ', 'I','C','O', 0};
2981 static const WCHAR ico_extension
[] = {'*','.','I','C','O',0};
2982 static const WCHAR ico_mimetype
[] = {'i','m','a','g','e','/','x','-','i','c','o','n', 0};
2983 static const WCHAR ico_format
[] = {'I','C','O',0};
2984 static const BYTE ico_sig_pattern
[] = { 0x00, 0x00, 0x01, 0x00 };
2985 static const BYTE ico_sig_mask
[] = { 0xFF, 0xFF, 0xFF, 0xFF };
2987 static const struct image_codec codecs
[NUM_CODECS
] = {
2990 /* Clsid */ { 0x557cf400, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
2991 /* FormatID */ { 0xb96b3cabU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
2992 /* CodecName */ bmp_codecname
,
2994 /* FormatDescription */ bmp_format
,
2995 /* FilenameExtension */ bmp_extension
,
2996 /* MimeType */ bmp_mimetype
,
2997 /* Flags */ ImageCodecFlagsEncoder
| ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3001 /* SigPattern */ bmp_sig_pattern
,
3002 /* SigMask */ bmp_sig_mask
,
3009 /* Clsid */ { 0x557cf401, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3010 /* FormatID */ { 0xb96b3caeU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3011 /* CodecName */ jpeg_codecname
,
3013 /* FormatDescription */ jpeg_format
,
3014 /* FilenameExtension */ jpeg_extension
,
3015 /* MimeType */ jpeg_mimetype
,
3016 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3020 /* SigPattern */ jpeg_sig_pattern
,
3021 /* SigMask */ jpeg_sig_mask
,
3028 /* Clsid */ { 0x557cf402, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3029 /* FormatID */ { 0xb96b3cb0U
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3030 /* CodecName */ gif_codecname
,
3032 /* FormatDescription */ gif_format
,
3033 /* FilenameExtension */ gif_extension
,
3034 /* MimeType */ gif_mimetype
,
3035 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3039 /* SigPattern */ gif_sig_pattern
,
3040 /* SigMask */ gif_sig_mask
,
3047 /* Clsid */ { 0x557cf405, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3048 /* FormatID */ { 0xb96b3cb1U
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3049 /* CodecName */ tiff_codecname
,
3051 /* FormatDescription */ tiff_format
,
3052 /* FilenameExtension */ tiff_extension
,
3053 /* MimeType */ tiff_mimetype
,
3054 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3058 /* SigPattern */ tiff_sig_pattern
,
3059 /* SigMask */ tiff_sig_mask
,
3066 /* Clsid */ { 0x557cf403, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3067 /* FormatID */ { 0xb96b3cacU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3068 /* CodecName */ emf_codecname
,
3070 /* FormatDescription */ emf_format
,
3071 /* FilenameExtension */ emf_extension
,
3072 /* MimeType */ emf_mimetype
,
3073 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportVector
| ImageCodecFlagsBuiltin
,
3077 /* SigPattern */ emf_sig_pattern
,
3078 /* SigMask */ emf_sig_mask
,
3081 decode_image_olepicture_metafile
3085 /* Clsid */ { 0x557cf404, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3086 /* FormatID */ { 0xb96b3cadU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3087 /* CodecName */ wmf_codecname
,
3089 /* FormatDescription */ wmf_format
,
3090 /* FilenameExtension */ wmf_extension
,
3091 /* MimeType */ wmf_mimetype
,
3092 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportVector
| ImageCodecFlagsBuiltin
,
3096 /* SigPattern */ wmf_sig_pattern
,
3097 /* SigMask */ wmf_sig_mask
,
3100 decode_image_olepicture_metafile
3104 /* Clsid */ { 0x557cf406, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3105 /* FormatID */ { 0xb96b3cafU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3106 /* CodecName */ png_codecname
,
3108 /* FormatDescription */ png_format
,
3109 /* FilenameExtension */ png_extension
,
3110 /* MimeType */ png_mimetype
,
3111 /* Flags */ ImageCodecFlagsEncoder
| ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3115 /* SigPattern */ png_sig_pattern
,
3116 /* SigMask */ png_sig_mask
,
3123 /* Clsid */ { 0x557cf407, 0x1a04, 0x11d3, { 0x9a, 0x73, 0x0, 0x0, 0xf8, 0x1e, 0xf3, 0x2e } },
3124 /* FormatID */ { 0xb96b3cabU
, 0x0728U
, 0x11d3U
, {0x9d, 0x7b, 0x00, 0x00, 0xf8, 0x1e, 0xf3, 0x2e} },
3125 /* CodecName */ ico_codecname
,
3127 /* FormatDescription */ ico_format
,
3128 /* FilenameExtension */ ico_extension
,
3129 /* MimeType */ ico_mimetype
,
3130 /* Flags */ ImageCodecFlagsDecoder
| ImageCodecFlagsSupportBitmap
| ImageCodecFlagsBuiltin
,
3134 /* SigPattern */ ico_sig_pattern
,
3135 /* SigMask */ ico_sig_mask
,
3142 /*****************************************************************************
3143 * GdipGetImageDecodersSize [GDIPLUS.@]
3145 GpStatus WINGDIPAPI
GdipGetImageDecodersSize(UINT
*numDecoders
, UINT
*size
)
3147 int decoder_count
=0;
3149 TRACE("%p %p\n", numDecoders
, size
);
3151 if (!numDecoders
|| !size
)
3152 return InvalidParameter
;
3154 for (i
=0; i
<NUM_CODECS
; i
++)
3156 if (codecs
[i
].info
.Flags
& ImageCodecFlagsDecoder
)
3160 *numDecoders
= decoder_count
;
3161 *size
= decoder_count
* sizeof(ImageCodecInfo
);
3166 /*****************************************************************************
3167 * GdipGetImageDecoders [GDIPLUS.@]
3169 GpStatus WINGDIPAPI
GdipGetImageDecoders(UINT numDecoders
, UINT size
, ImageCodecInfo
*decoders
)
3171 int i
, decoder_count
=0;
3172 TRACE("%u %u %p\n", numDecoders
, size
, decoders
);
3175 size
!= numDecoders
* sizeof(ImageCodecInfo
))
3176 return GenericError
;
3178 for (i
=0; i
<NUM_CODECS
; i
++)
3180 if (codecs
[i
].info
.Flags
& ImageCodecFlagsDecoder
)
3182 if (decoder_count
== numDecoders
) return GenericError
;
3183 memcpy(&decoders
[decoder_count
], &codecs
[i
].info
, sizeof(ImageCodecInfo
));
3188 if (decoder_count
< numDecoders
) return GenericError
;
3193 /*****************************************************************************
3194 * GdipGetImageEncodersSize [GDIPLUS.@]
3196 GpStatus WINGDIPAPI
GdipGetImageEncodersSize(UINT
*numEncoders
, UINT
*size
)
3198 int encoder_count
=0;
3200 TRACE("%p %p\n", numEncoders
, size
);
3202 if (!numEncoders
|| !size
)
3203 return InvalidParameter
;
3205 for (i
=0; i
<NUM_CODECS
; i
++)
3207 if (codecs
[i
].info
.Flags
& ImageCodecFlagsEncoder
)
3211 *numEncoders
= encoder_count
;
3212 *size
= encoder_count
* sizeof(ImageCodecInfo
);
3217 /*****************************************************************************
3218 * GdipGetImageEncoders [GDIPLUS.@]
3220 GpStatus WINGDIPAPI
GdipGetImageEncoders(UINT numEncoders
, UINT size
, ImageCodecInfo
*encoders
)
3222 int i
, encoder_count
=0;
3223 TRACE("%u %u %p\n", numEncoders
, size
, encoders
);
3226 size
!= numEncoders
* sizeof(ImageCodecInfo
))
3227 return GenericError
;
3229 for (i
=0; i
<NUM_CODECS
; i
++)
3231 if (codecs
[i
].info
.Flags
& ImageCodecFlagsEncoder
)
3233 if (encoder_count
== numEncoders
) return GenericError
;
3234 memcpy(&encoders
[encoder_count
], &codecs
[i
].info
, sizeof(ImageCodecInfo
));
3239 if (encoder_count
< numEncoders
) return GenericError
;
3244 /*****************************************************************************
3245 * GdipCreateBitmapFromHBITMAP [GDIPLUS.@]
3247 GpStatus WINGDIPAPI
GdipCreateBitmapFromHBITMAP(HBITMAP hbm
, HPALETTE hpal
, GpBitmap
** bitmap
)
3252 BitmapData lockeddata
;
3255 TRACE("%p %p %p\n", hbm
, hpal
, bitmap
);
3258 return InvalidParameter
;
3260 /* TODO: Support for device-dependent bitmaps */
3262 FIXME("no support for device-dependent bitmaps\n");
3263 return NotImplemented
;
3266 if (GetObjectA(hbm
, sizeof(bm
), &bm
) != sizeof(bm
))
3267 return InvalidParameter
;
3269 /* TODO: Figure out the correct format for 16, 32, 64 bpp */
3270 switch(bm
.bmBitsPixel
) {
3272 format
= PixelFormat1bppIndexed
;
3275 format
= PixelFormat4bppIndexed
;
3278 format
= PixelFormat8bppIndexed
;
3281 format
= PixelFormat24bppRGB
;
3284 format
= PixelFormat32bppRGB
;
3287 format
= PixelFormat48bppRGB
;
3290 FIXME("don't know how to handle %d bpp\n", bm
.bmBitsPixel
);
3291 return InvalidParameter
;
3294 retval
= GdipCreateBitmapFromScan0(bm
.bmWidth
, bm
.bmHeight
, 0,
3295 format
, NULL
, bitmap
);
3299 retval
= GdipBitmapLockBits(*bitmap
, NULL
, ImageLockModeWrite
,
3300 format
, &lockeddata
);
3305 for (y
=0; y
<bm
.bmHeight
; y
++)
3307 memcpy((BYTE
*)lockeddata
.Scan0
+lockeddata
.Stride
*y
,
3308 (BYTE
*)bm
.bmBits
+bm
.bmWidthBytes
*(bm
.bmHeight
-1-y
),
3317 INT src_height
, dst_stride
;
3320 hdc
= CreateCompatibleDC(NULL
);
3321 oldhbm
= SelectObject(hdc
, hbm
);
3323 pbmi
= GdipAlloc(sizeof(BITMAPINFOHEADER
) + 256 * sizeof(RGBQUAD
));
3327 pbmi
->bmiHeader
.biSize
= sizeof(BITMAPINFOHEADER
);
3328 pbmi
->bmiHeader
.biBitCount
= 0;
3330 GetDIBits(hdc
, hbm
, 0, 0, NULL
, pbmi
, DIB_RGB_COLORS
);
3332 src_height
= abs(pbmi
->bmiHeader
.biHeight
);
3334 if (pbmi
->bmiHeader
.biHeight
> 0)
3336 dst_bits
= (BYTE
*)lockeddata
.Scan0
+lockeddata
.Stride
*(src_height
-1);
3337 dst_stride
= -lockeddata
.Stride
;
3341 dst_bits
= lockeddata
.Scan0
;
3342 dst_stride
= lockeddata
.Stride
;
3345 for (y
=0; y
<src_height
; y
++)
3347 GetDIBits(hdc
, hbm
, y
, 1, dst_bits
+dst_stride
*y
,
3348 pbmi
, DIB_RGB_COLORS
);
3354 retval
= OutOfMemory
;
3356 SelectObject(hdc
, oldhbm
);
3360 GdipBitmapUnlockBits(*bitmap
, &lockeddata
);
3367 GpStatus WINGDIPAPI
GdipDeleteEffect(CGpEffect
*effect
)
3369 FIXME("(%p): stub\n", effect
);
3370 /* note: According to Jose Roca's GDI+ Docs, this is not implemented
3371 * in Windows's gdiplus */
3372 return NotImplemented
;
3375 /*****************************************************************************
3376 * GdipSetEffectParameters [GDIPLUS.@]
3378 GpStatus WINGDIPAPI
GdipSetEffectParameters(CGpEffect
*effect
,
3379 const VOID
*params
, const UINT size
)
3383 TRACE("(%p,%p,%u)\n", effect
, params
, size
);
3386 FIXME("not implemented\n");
3388 return NotImplemented
;
3391 /*****************************************************************************
3392 * GdipGetImageFlags [GDIPLUS.@]
3394 GpStatus WINGDIPAPI
GdipGetImageFlags(GpImage
*image
, UINT
*flags
)
3396 TRACE("%p %p\n", image
, flags
);
3398 if(!image
|| !flags
)
3399 return InvalidParameter
;
3401 *flags
= image
->flags
;
3406 GpStatus WINGDIPAPI
GdipTestControl(GpTestControlEnum control
, void *param
)
3408 TRACE("(%d, %p)\n", control
, param
);
3411 case TestControlForceBilinear
:
3413 FIXME("TestControlForceBilinear not handled\n");
3415 case TestControlNoICM
:
3417 FIXME("TestControlNoICM not handled\n");
3419 case TestControlGetBuildNumber
:
3420 *((DWORD
*)param
) = 3102;
3427 GpStatus WINGDIPAPI
GdipRecordMetafileFileName(GDIPCONST WCHAR
* fileName
,
3428 HDC hdc
, EmfType type
, GDIPCONST GpRectF
*pFrameRect
,
3429 MetafileFrameUnit frameUnit
, GDIPCONST WCHAR
*desc
,
3430 GpMetafile
**metafile
)
3432 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName
), hdc
, type
, pFrameRect
,
3433 frameUnit
, debugstr_w(desc
), metafile
);
3435 return NotImplemented
;
3438 GpStatus WINGDIPAPI
GdipRecordMetafileFileNameI(GDIPCONST WCHAR
* fileName
, HDC hdc
, EmfType type
,
3439 GDIPCONST GpRect
*pFrameRect
, MetafileFrameUnit frameUnit
,
3440 GDIPCONST WCHAR
*desc
, GpMetafile
**metafile
)
3442 FIXME("%s %p %d %p %d %s %p stub!\n", debugstr_w(fileName
), hdc
, type
, pFrameRect
,
3443 frameUnit
, debugstr_w(desc
), metafile
);
3445 return NotImplemented
;
3448 GpStatus WINGDIPAPI
GdipImageForceValidation(GpImage
*image
)
3450 FIXME("%p\n", image
);
3455 /*****************************************************************************
3456 * GdipGetImageThumbnail [GDIPLUS.@]
3458 GpStatus WINGDIPAPI
GdipGetImageThumbnail(GpImage
*image
, UINT width
, UINT height
,
3459 GpImage
**ret_image
, GetThumbnailImageAbort cb
,
3462 FIXME("(%p %u %u %p %p %p) stub\n",
3463 image
, width
, height
, ret_image
, cb
, cb_data
);
3464 return NotImplemented
;
3467 /*****************************************************************************
3468 * GdipImageRotateFlip [GDIPLUS.@]
3470 GpStatus WINGDIPAPI
GdipImageRotateFlip(GpImage
*image
, RotateFlipType type
)
3472 GpBitmap
*new_bitmap
;
3474 int bpp
, bytesperpixel
;
3475 int rotate_90
, flip_x
, flip_y
;
3476 int src_x_offset
, src_y_offset
;
3478 UINT x
, y
, width
, height
;
3479 BitmapData src_lock
, dst_lock
;
3482 TRACE("(%p, %u)\n", image
, type
);
3485 flip_x
= (type
&6) == 2 || (type
&6) == 4;
3486 flip_y
= (type
&3) == 1 || (type
&3) == 2;
3488 if (image
->type
!= ImageTypeBitmap
)
3490 FIXME("Not implemented for type %i\n", image
->type
);
3491 return NotImplemented
;
3494 bitmap
= (GpBitmap
*)image
;
3495 bpp
= PIXELFORMATBPP(bitmap
->format
);
3499 FIXME("Not implemented for %i bit images\n", bpp
);
3500 return NotImplemented
;
3505 width
= bitmap
->height
;
3506 height
= bitmap
->width
;
3510 width
= bitmap
->width
;
3511 height
= bitmap
->height
;
3514 bytesperpixel
= bpp
/8;
3516 stat
= GdipCreateBitmapFromScan0(width
, height
, 0, bitmap
->format
, NULL
, &new_bitmap
);
3521 stat
= GdipBitmapLockBits(bitmap
, NULL
, ImageLockModeRead
, bitmap
->format
, &src_lock
);
3525 stat
= GdipBitmapLockBits(new_bitmap
, NULL
, ImageLockModeWrite
, bitmap
->format
, &dst_lock
);
3529 LPBYTE src_row
, src_pixel
;
3530 LPBYTE dst_row
, dst_pixel
;
3532 src_origin
= src_lock
.Scan0
;
3533 if (flip_x
) src_origin
+= bytesperpixel
* (bitmap
->width
- 1);
3534 if (flip_y
) src_origin
+= src_lock
.Stride
* (bitmap
->height
- 1);
3538 if (flip_y
) src_x_offset
= -src_lock
.Stride
;
3539 else src_x_offset
= src_lock
.Stride
;
3540 if (flip_x
) src_y_offset
= -bytesperpixel
;
3541 else src_y_offset
= bytesperpixel
;
3545 if (flip_x
) src_x_offset
= -bytesperpixel
;
3546 else src_x_offset
= bytesperpixel
;
3547 if (flip_y
) src_y_offset
= -src_lock
.Stride
;
3548 else src_y_offset
= src_lock
.Stride
;
3551 src_row
= src_origin
;
3552 dst_row
= dst_lock
.Scan0
;
3553 for (y
=0; y
<height
; y
++)
3555 src_pixel
= src_row
;
3556 dst_pixel
= dst_row
;
3557 for (x
=0; x
<width
; x
++)
3559 /* FIXME: This could probably be faster without memcpy. */
3560 memcpy(dst_pixel
, src_pixel
, bytesperpixel
);
3561 dst_pixel
+= bytesperpixel
;
3562 src_pixel
+= src_x_offset
;
3564 src_row
+= src_y_offset
;
3565 dst_row
+= dst_lock
.Stride
;
3568 GdipBitmapUnlockBits(new_bitmap
, &dst_lock
);
3571 GdipBitmapUnlockBits(bitmap
, &src_lock
);
3575 move_bitmap(bitmap
, new_bitmap
, FALSE
);
3577 GdipDisposeImage((GpImage
*)new_bitmap
);