reactos/dll/win32/gdi32/objects/bitmap.c

   1 #include "precomp.h"
   2
   3 #define NDEBUG
   4 #include <debug.h>
   5
   6 /*
   7  *           DIB_BitmapInfoSize
   8  *
   9  * Return the size of the bitmap info structure including color table.
  10  * 11/16/1999 (RJJ) lifted from wine
  11  */
  12
  13 INT FASTCALL DIB_BitmapInfoSize(const BITMAPINFO * info, WORD coloruse)
  14 {
  15     unsigned int colors, size, masks = 0;
  16
  17     if (info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
  18     {
  19         const BITMAPCOREHEADER *core = (const BITMAPCOREHEADER *)info;
  20         colors = (core->bcBitCount <= 8) ? 1 << core->bcBitCount : 0;
  21         return sizeof(BITMAPCOREHEADER) + colors *
  22                ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBTRIPLE) : sizeof(WORD));
  23     }
  24     else  /* assume BITMAPINFOHEADER */
  25     {
  26         colors = info->bmiHeader.biClrUsed;
  27         if (colors > 256) colors = 256;
  28         if (!colors && (info->bmiHeader.biBitCount <= 8))
  29             colors = 1 << info->bmiHeader.biBitCount;
  30         if (info->bmiHeader.biCompression == BI_BITFIELDS) masks = 3;
  31         size = max( info->bmiHeader.biSize, sizeof(BITMAPINFOHEADER) + masks * sizeof(DWORD) );
  32         return size + colors * ((coloruse == DIB_RGB_COLORS) ? sizeof(RGBQUAD) : sizeof(WORD));
  33     }
  34 }
  35
  36 /*
  37  * Return the full scan size for a bitmap.
  38  *
  39  * Based on Wine, Utils.c and Windows Graphics Prog pg 595, SDK amvideo.h.
  40  */
  41 UINT
  42 FASTCALL
  43 DIB_BitmapMaxBitsSize( PBITMAPINFO Info, UINT ScanLines )
  44 {
  45     UINT MaxBits = 0;
  46
  47     if (!Info) return 0;
  48
  49     if (Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
  50     {
  51         PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info;
  52         MaxBits = Core->bcBitCount * Core->bcPlanes * Core->bcWidth;
  53     }
  54     else  /* assume BITMAPINFOHEADER */
  55     {
  56         if ((Info->bmiHeader.biCompression) && (Info->bmiHeader.biCompression != BI_BITFIELDS))
  57             return Info->bmiHeader.biSizeImage;
  58         // Planes are over looked by Yuan. I guess assumed always 1.
  59         MaxBits = Info->bmiHeader.biBitCount * Info->bmiHeader.biPlanes * Info->bmiHeader.biWidth;
  60     }
  61     MaxBits = ((MaxBits + 31) & ~31 ) / 8; // From Yuan, ScanLineSize = (Width * bitcount + 31)/32
  62     return (MaxBits * ScanLines);  // ret the full Size.
  63 }
  64
  65 UINT
  66 FASTCALL
  67 DIB_BitmapBitsSize( CONST BITMAPINFO* Info )
  68 {
  69     UINT Ret;
  70
  71     if (!Info) return 0;
  72
  73     if ( Info->bmiHeader.biSize == sizeof(BITMAPCOREHEADER))
  74     {
  75         PBITMAPCOREHEADER Core = (PBITMAPCOREHEADER)Info;
  76         Ret = Core->bcHeight *
  77               ((Core->bcWidth * Core->bcPlanes * Core->bcBitCount  + 31) & ~31 ) / 8;
  78     }
  79     else /* assume BITMAPINFOHEADER */
  80     {
  81         if ((Info->bmiHeader.biCompression) &&
  82                 (Info->bmiHeader.biCompression != BI_BITFIELDS))
  83             return Info->bmiHeader.biSizeImage;
  84         // Make Height positive always....
  85         Ret = abs(Info->bmiHeader.biHeight) *
  86               ((Info->bmiHeader.biWidth * Info->bmiHeader.biPlanes * Info->bmiHeader.biBitCount + 31) & ~31 ) / 8;
  87     }
  88     return Ret;
  89 }
  90
  91
  92 /*
  93  * DIB_GetBitmapInfo is complete copy of wine cvs 2/9-2006
  94  * from file dib.c from gdi32.dll or orginal version
  95  * did not calc the info right for some headers.
  96  */
  97 INT
  98 WINAPI
  99 DIB_GetBitmapInfo(const BITMAPINFOHEADER *header,
 100                   PLONG width,
 101                   PLONG height,
 102                   PWORD planes,
 103                   PWORD bpp,
 104                   PLONG compr,
 105                   PLONG size )
 106 {
 107     if (header->biSize == sizeof(BITMAPCOREHEADER))
 108     {
 109         BITMAPCOREHEADER *core = (BITMAPCOREHEADER *)header;
 110         *width  = core->bcWidth;
 111         *height = core->bcHeight;
 112         *planes = core->bcPlanes;
 113         *bpp    = core->bcBitCount;
 114         *compr  = 0;
 115         *size   = 0;
 116         return 0;
 117     }
 118
 119     if (header->biSize == sizeof(BITMAPINFOHEADER))
 120     {
 121         *width  = header->biWidth;
 122         *height = header->biHeight;
 123         *planes = header->biPlanes;
 124         *bpp    = header->biBitCount;
 125         *compr  = header->biCompression;
 126         *size   = header->biSizeImage;
 127         return 1;
 128     }
 129
 130     if (header->biSize == sizeof(BITMAPV4HEADER))
 131     {
 132         BITMAPV4HEADER *v4hdr = (BITMAPV4HEADER *)header;
 133         *width  = v4hdr->bV4Width;
 134         *height = v4hdr->bV4Height;
 135         *planes = v4hdr->bV4Planes;
 136         *bpp    = v4hdr->bV4BitCount;
 137         *compr  = v4hdr->bV4V4Compression;
 138         *size   = v4hdr->bV4SizeImage;
 139         return 4;
 140     }
 141
 142     if (header->biSize == sizeof(BITMAPV5HEADER))
 143     {
 144         BITMAPV5HEADER *v5hdr = (BITMAPV5HEADER *)header;
 145         *width  = v5hdr->bV5Width;
 146         *height = v5hdr->bV5Height;
 147         *planes = v5hdr->bV5Planes;
 148         *bpp    = v5hdr->bV5BitCount;
 149         *compr  = v5hdr->bV5Compression;
 150         *size   = v5hdr->bV5SizeImage;
 151         return 5;
 152     }
 153     DPRINT("(%ld): wrong size for header\n", header->biSize );
 154     return -1;
 155 }
 156
 157 /*
 158  * @implemented
 159  */
 160 int
 161 WINAPI
 162 GdiGetBitmapBitsSize(BITMAPINFO *lpbmi)
 163 {
 164     int retSize;
 165
 166     if (lpbmi->bmiHeader.biSize == FIELD_OFFSET(BITMAPINFOHEADER, biPlanes))
 167     {
 168         /* Calc the bits Size and align it*/
 169         retSize = HIWORD(lpbmi->bmiHeader.biWidth) * ((LOWORD(lpbmi->bmiHeader.biWidth) *
 170                   LOWORD(lpbmi->bmiHeader.biHeight) * HIWORD(lpbmi->bmiHeader.biHeight) + 31)
 171                   & -32) / 8;
 172     }
 173     else
 174     {
 175         if ( (lpbmi->bmiHeader.biCompression == BI_BITFIELDS) ||
 176                 (lpbmi->bmiHeader.biCompression == BI_RGB))
 177         {
 178             if (lpbmi->bmiHeader.biHeight >=0 )
 179             {
 180                 /* Calc the bits Size and align it*/
 181                 retSize = lpbmi->bmiHeader.biHeight * ((lpbmi->bmiHeader.biWidth *
 182                                                         lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8;
 183             }
 184             else
 185             {
 186                 /* Make height postiive if it negitve then calc the bits Size and align it*/
 187                 retSize = (-lpbmi->bmiHeader.biHeight) * ((lpbmi->bmiHeader.biWidth *
 188                           lpbmi->bmiHeader.biPlanes * lpbmi->bmiHeader.biBitCount + 31) & -32) / 8;
 189             }
 190         }
 191         else
 192         {
 193             retSize = lpbmi->bmiHeader.biSizeImage;
 194         }
 195     }
 196     return retSize;
 197 }
 198
 199 /*
 200  * @implemented
 201  */
 202 HBITMAP WINAPI
 203 CreateDIBSection(
 204     HDC hDC,
 205     CONST BITMAPINFO *BitmapInfo,
 206     UINT Usage,
 207     VOID **Bits,
 208     HANDLE hSection,
 209     DWORD dwOffset)
 210 {
 211     PBITMAPINFO pConvertedInfo;
 212     UINT ConvertedInfoSize;
 213     HBITMAP hBitmap = NULL;
 214     PVOID  bmBits = NULL;
 215
 216     pConvertedInfo = ConvertBitmapInfo(BitmapInfo, Usage,
 217                                        &ConvertedInfoSize, FALSE);
 218     if (pConvertedInfo)
 219     {
 220         // Verify header due to converted may == info.
 221         if ( pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
 222         {
 223             if ( pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
 224                     pConvertedInfo->bmiHeader.biCompression  == BI_PNG )
 225             {
 226                 SetLastError(ERROR_INVALID_PARAMETER);
 227                 return NULL;
 228             }
 229         }
 230         bmBits = Bits;
 231         hBitmap = NtGdiCreateDIBSection( hDC,
 232                                          hSection,
 233                                          dwOffset,
 234                                          pConvertedInfo,
 235                                          Usage,
 236                                          0,
 237                                          0,
 238                                          0,
 239                                          &bmBits);
 240         if (BitmapInfo != pConvertedInfo)
 241             RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
 242
 243         if (!hBitmap)
 244         {
 245             bmBits = NULL;
 246         }
 247     }
 248
 249     if (Bits) *Bits = bmBits;
 250
 251     return hBitmap;
 252 }
 253
 254
 255 /*
 256  * @implemented
 257  */
 258 BOOL
 259 WINAPI
 260 BitBlt(HDC hdcDest,      /* handle to destination DC */
 261        int nXOriginDest, /* x-coord of destination upper-left corner */
 262        int nYOriginDest, /* y-coord of destination upper-left corner */
 263        int nWidthDest,   /* width of destination rectangle */
 264        int nHeightDest,  /* height of destination rectangle */
 265        HDC hdcSrc,       /* handle to source DC */
 266        int nXSrc,        /* x-coordinate of source upper-left corner */
 267        int nYSrc,        /* y-coordinate of source upper-left corner */
 268        DWORD dwRop)      /* raster operation code */
 269 {
 270     /* use patBlt for no source blt  Like windows does */
 271     if (!ROP_USES_SOURCE(dwRop))
 272     {
 273         return PatBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest, nHeightDest, dwRop);
 274     }
 275
 276     return NtGdiBitBlt(hdcDest,
 277                        nXOriginDest,
 278                        nYOriginDest,
 279                        nWidthDest,
 280                        nHeightDest,
 281                        hdcSrc,
 282                        nXSrc,
 283                        nYSrc,
 284                        dwRop,
 285                        0,
 286                        0);
 287 }
 288
 289 /*
 290  * @implemented
 291  */
 292 BOOL WINAPI
 293 StretchBlt(
 294     HDC hdcDest,      /* handle to destination DC */
 295     int nXOriginDest, /* x-coord of destination upper-left corner */
 296     int nYOriginDest, /* y-coord of destination upper-left corner */
 297     int nWidthDest,   /* width of destination rectangle */
 298     int nHeightDest,  /* height of destination rectangle */
 299     HDC hdcSrc,       /* handle to source DC */
 300     int nXOriginSrc,  /* x-coord of source upper-left corner */
 301     int nYOriginSrc,  /* y-coord of source upper-left corner */
 302     int nWidthSrc,    /* width of source rectangle */
 303     int nHeightSrc,   /* height of source rectangle */
 304     DWORD dwRop)      /* raster operation code */
 305
 306 {
 307     if ((nWidthDest != nWidthSrc) || (nHeightDest != nHeightSrc))
 308     {
 309         return NtGdiStretchBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
 310                                nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc,
 311                                nWidthSrc, nHeightSrc, dwRop, 0);
 312     }
 313
 314     return NtGdiBitBlt(hdcDest, nXOriginDest, nYOriginDest, nWidthDest,
 315                        nHeightDest, hdcSrc, nXOriginSrc, nYOriginSrc, dwRop, 0, 0);
 316 }
 317
 318 /*
 319  * @unimplemented
 320  */
 321 HBITMAP WINAPI
 322 CreateBitmap(INT  Width,
 323              INT  Height,
 324              UINT  Planes,
 325              UINT  BitsPixel,
 326              CONST VOID* pUnsafeBits)
 327 {
 328     /* FIXME some part should be done in user mode */
 329     if (Width && Height)
 330     {
 331         return NtGdiCreateBitmap(Width, Height, Planes, BitsPixel, (LPBYTE) pUnsafeBits);
 332     }
 333     else
 334     {
 335         /* Return 1x1 bitmap */
 336         return GetStockObject(DEFAULT_BITMAP);
 337     }
 338 }
 339
 340 /*
 341  * @implemented
 342  */
 343 HBITMAP WINAPI
 344 CreateBitmapIndirect(const BITMAP *pbm)
 345 {
 346     HBITMAP bitmap = NULL;
 347
 348     /* Note windows xp/2003 does not check if pbm is NULL or not */
 349     if ( (pbm->bmWidthBytes != 0) &&
 350             (!(pbm->bmWidthBytes & 1)) )
 351
 352     {
 353
 354         bitmap = CreateBitmap(pbm->bmWidth,
 355                               pbm->bmHeight,
 356                               pbm->bmPlanes,
 357                               pbm->bmBitsPixel,
 358                               pbm->bmBits);
 359     }
 360     else
 361     {
 362         SetLastError(ERROR_INVALID_PARAMETER);
 363     }
 364
 365     return bitmap;
 366 }
 367
 368 HBITMAP WINAPI
 369 CreateDiscardableBitmap(
 370     HDC  hDC,
 371     INT  Width,
 372     INT  Height)
 373 {
 374     return  CreateCompatibleBitmap(hDC, Width, Height);
 375 }
 376
 377
 378 HBITMAP WINAPI
 379 CreateCompatibleBitmap(
 380     HDC  hDC,
 381     INT  Width,
 382     INT  Height)
 383 {
 384     PDC_ATTR pDc_Attr;
 385     HBITMAP hBmp = NULL;
 386     DIBSECTION dibs;
 387
 388     if (!GdiGetHandleUserData(hDC, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
 389         return NULL;
 390
 391     if ( !Width || !Height )
 392         return GetStockObject(DEFAULT_BITMAP);
 393
 394     if (!(pDc_Attr->ulDirty_ & DC_DIBSECTION))
 395     {
 396         return  NtGdiCreateCompatibleBitmap(hDC, Width, Height);
 397     }
 398
 399     hBmp = NtGdiGetDCObject(hDC, GDI_OBJECT_TYPE_BITMAP);
 400
 401     if ( GetObjectA(hBmp, sizeof(DIBSECTION), &dibs) != sizeof(DIBSECTION) )
 402         return NULL;
 403
 404     if ( dibs.dsBm.bmBitsPixel <= 8 )
 405         GetDIBColorTable(hDC, 0, 256, (RGBQUAD *)&dibs.dsBitfields);
 406
 407     dibs.dsBmih.biWidth = Width;
 408     dibs.dsBmih.biHeight = Height;
 409
 410     return CreateDIBSection(hDC, (CONST BITMAPINFO *)&dibs.dsBmih, 0, NULL, NULL, 0);
 411 }
 412
 413
 414 INT
 415 WINAPI
 416 GetDIBits(
 417     HDC hDC,
 418     HBITMAP hbmp,
 419     UINT uStartScan,
 420     UINT cScanLines,
 421     LPVOID lpvBits,
 422     LPBITMAPINFO lpbmi,
 423     UINT uUsage)
 424 {
 425     UINT cjBmpScanSize;
 426     UINT cjInfoSize;
 427
 428     if (!hDC || !GdiIsHandleValid((HGDIOBJ)hDC) || !lpbmi)
 429     {
 430         GdiSetLastError(ERROR_INVALID_PARAMETER);
 431         return 0;
 432     }
 433
 434     cjBmpScanSize = DIB_BitmapMaxBitsSize(lpbmi, cScanLines);
 435     cjInfoSize = DIB_BitmapInfoSize(lpbmi, uUsage);
 436
 437     if ( lpvBits )
 438     {
 439         if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
 440         {
 441             if ( lpbmi->bmiHeader.biCompression == BI_JPEG ||
 442                     lpbmi->bmiHeader.biCompression == BI_PNG )
 443             {
 444                 SetLastError(ERROR_INVALID_PARAMETER);
 445                 return 0;
 446             }
 447         }
 448     }
 449
 450     return NtGdiGetDIBitsInternal(hDC,
 451                                   hbmp,
 452                                   uStartScan,
 453                                   cScanLines,
 454                                   lpvBits,
 455                                   lpbmi,
 456                                   uUsage,
 457                                   cjBmpScanSize,
 458                                   cjInfoSize);
 459 }
 460
 461 /*
 462  * @implemented
 463  */
 464 HBITMAP
 465 WINAPI
 466 CreateDIBitmap( HDC hDC,
 467                 const BITMAPINFOHEADER *Header,
 468                 DWORD Init,
 469                 LPCVOID Bits,
 470                 const BITMAPINFO *Data,
 471                 UINT ColorUse)
 472 {
 473     LONG width, height, compr, dibsize;
 474     WORD planes, bpp;
 475 //  PDC_ATTR pDc_Attr;
 476     UINT InfoSize = 0;
 477     UINT cjBmpScanSize = 0;
 478     HBITMAP hBmp;
 479     NTSTATUS Status = STATUS_SUCCESS;
 480
 481     if (!Header) return 0;
 482
 483     if (DIB_GetBitmapInfo(Header, &width, &height, &planes, &bpp, &compr, &dibsize) == -1)
 484     {
 485         GdiSetLastError(ERROR_INVALID_PARAMETER);
 486         return NULL;
 487     }
 488
 489 // For Icm support.
 490 // GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
 491
 492     if(Data)
 493     {
 494         _SEH2_TRY
 495         {
 496             cjBmpScanSize = DIB_BitmapBitsSize(Data);
 497             CalculateColorTableSize(&Data->bmiHeader, &ColorUse, &InfoSize);
 498             InfoSize += Data->bmiHeader.biSize;
 499         }
 500         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 501         {
 502             Status = _SEH2_GetExceptionCode();
 503         }
 504         _SEH2_END
 505     }
 506
 507     if(!NT_SUCCESS(Status))
 508     {
 509         GdiSetLastError(ERROR_INVALID_PARAMETER);
 510         return NULL;
 511     }
 512
 513     DPRINT("pBMI %x, Size bpp %d, dibsize %d, Conv %d, BSS %d\n", Data,bpp,dibsize,InfoSize,cjBmpScanSize);
 514
 515     if ( !width || !height )
 516         hBmp = GetStockObject(DEFAULT_BITMAP);
 517     else
 518     {
 519         hBmp = NtGdiCreateDIBitmapInternal(hDC,
 520                                            width,
 521                                            height,
 522                                            Init,
 523                                            (LPBYTE)Bits,
 524                                            (LPBITMAPINFO)Data,
 525                                            ColorUse,
 526                                            InfoSize,
 527                                            cjBmpScanSize,
 528                                            0,
 529                                            0);
 530     }
 531     return hBmp;
 532 }
 533
 534 /*
 535  * @implemented
 536  */
 537 INT
 538 WINAPI
 539 SetDIBits(HDC hDC,
 540           HBITMAP hBitmap,
 541           UINT uStartScan,
 542           UINT cScanLines,
 543           CONST VOID *lpvBits,
 544           CONST BITMAPINFO *lpbmi,
 545           UINT fuColorUse)
 546 {
 547     HDC hDCc, SavehDC, nhDC;
 548     DWORD dwWidth, dwHeight;
 549     HGDIOBJ hOldBitmap;
 550     HPALETTE hPal = NULL;
 551     INT LinesCopied = 0;
 552     BOOL newDC = FALSE;
 553
 554     if ( !lpvBits || (GDI_HANDLE_GET_TYPE(hBitmap) != GDI_OBJECT_TYPE_BITMAP) )
 555         return 0;
 556
 557     if ( lpbmi )
 558     {
 559         if ( lpbmi->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER) )
 560         {
 561             if ( lpbmi->bmiHeader.biCompression == BI_JPEG || lpbmi->bmiHeader.biCompression == BI_PNG )
 562             {
 563                 SetLastError(ERROR_INVALID_PARAMETER);
 564                 return 0;
 565             }
 566         }
 567     }
 568
 569     hDCc = NtGdiGetDCforBitmap(hBitmap);
 570     SavehDC = hDCc;
 571     if ( !hDCc )
 572     {
 573         nhDC = CreateCompatibleDC(hDC);
 574         if ( !nhDC ) return 0;
 575         newDC = TRUE;
 576         SavehDC = nhDC;
 577     }
 578     else if ( !SaveDC(hDCc) )
 579         return 0;
 580
 581     hOldBitmap = SelectObject(SavehDC, hBitmap);
 582
 583     if ( hOldBitmap )
 584     {
 585         if ( hDC )
 586             hPal = SelectPalette(SavehDC, (HPALETTE)GetDCObject(hDC, GDI_OBJECT_TYPE_PALETTE), FALSE);
 587
 588         if ( lpbmi->bmiHeader.biSize < sizeof(BITMAPINFOHEADER))
 589         {
 590             PBITMAPCOREINFO pbci = (PBITMAPCOREINFO) lpbmi;
 591             dwWidth = pbci->bmciHeader.bcWidth;
 592             dwHeight = pbci->bmciHeader.bcHeight;
 593         }
 594         else
 595         {
 596             dwWidth = lpbmi->bmiHeader.biWidth;
 597             dwHeight = abs(lpbmi->bmiHeader.biHeight);
 598         }
 599
 600         LinesCopied = SetDIBitsToDevice(SavehDC,
 601                                         0,
 602                                         0,
 603                                         dwWidth,
 604                                         dwHeight,
 605                                         0,
 606                                         0,
 607                                         uStartScan,
 608                                         cScanLines,
 609                                         (void *)lpvBits,
 610                                         (LPBITMAPINFO)lpbmi,
 611                                         fuColorUse);
 612
 613         if ( hDC ) SelectPalette(SavehDC, hPal, FALSE);
 614
 615         SelectObject(SavehDC, hOldBitmap);
 616     }
 617
 618     if ( newDC )
 619         DeleteDC(SavehDC);
 620     else
 621         RestoreDC(SavehDC, -1);
 622
 623     return LinesCopied;
 624 }
 625
 626 /*
 627  * @implemented
 628  *
 629  */
 630 INT
 631 WINAPI
 632 SetDIBitsToDevice(
 633     HDC hdc,
 634     int XDest,
 635     int YDest,
 636     DWORD Width,
 637     DWORD Height,
 638     int XSrc,
 639     int YSrc,
 640     UINT StartScan,
 641     UINT ScanLines,
 642     CONST VOID *Bits,
 643     CONST BITMAPINFO *lpbmi,
 644     UINT ColorUse)
 645 {
 646     PDC_ATTR pDc_Attr;
 647     PBITMAPINFO pConvertedInfo;
 648     UINT ConvertedInfoSize;
 649     INT LinesCopied = 0;
 650     UINT cjBmpScanSize = 0;
 651     PVOID pvSafeBits = (PVOID)Bits;
 652
 653     if ( !ScanLines || !lpbmi || !Bits )
 654         return 0;
 655
 656     if ( ColorUse && ColorUse != DIB_PAL_COLORS && ColorUse != DIB_PAL_COLORS+1 )
 657         return 0;
 658
 659     pConvertedInfo = ConvertBitmapInfo(lpbmi, ColorUse,
 660                                        &ConvertedInfoSize, FALSE);
 661     if (!pConvertedInfo)
 662         return 0;
 663
 664 #if 0
 665 // Handle something other than a normal dc object.
 666     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 667     {
 668         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 669             return MFDRV_SetDIBitsToDevice( hdc,
 670                                             XDest,
 671                                             YDest,
 672                                             Width,
 673                                             Height,
 674                                             XSrc,
 675                                             YSrc,
 676                                             StartScan,
 677                                             ScanLines,
 678                                             Bits,
 679                                             lpbmi,
 680                                             ColorUse);
 681         else
 682         {
 683             PLDC pLDC = GdiGetLDC(hdc);
 684             if ( !pLDC )
 685             {
 686                 SetLastError(ERROR_INVALID_HANDLE);
 687                 return 0;
 688             }
 689             if (pLDC->iType == LDC_EMFLDC)
 690             {
 691                 return EMFDRV_SetDIBitsToDevice(hdc,
 692                                                 XDest,
 693                                                 YDest,
 694                                                 Width,
 695                                                 Height,
 696                                                 XSrc,
 697                                                 YSrc,
 698                                                 StartScan,
 699                                                 ScanLines,
 700                                                 Bits,
 701                                                 lpbmi,
 702                                                 ColorUse);
 703             }
 704             return 0;
 705         }
 706     }
 707 #endif
 708     cjBmpScanSize = DIB_BitmapMaxBitsSize((LPBITMAPINFO)lpbmi, ScanLines);
 709
 710     if ( Bits )
 711     {
 712         pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
 713         if (pvSafeBits)
 714             RtlCopyMemory( pvSafeBits, Bits, cjBmpScanSize);
 715     }
 716
 717     if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
 718     {
 719         SetLastError(ERROR_INVALID_PARAMETER);
 720         return 0;
 721     }
 722     /*
 723       if ( !pDc_Attr ||
 724            ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
 725            (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
 726             pConvertedInfo->bmiHeader.biCompression  == BI_PNG )) )*/
 727     {
 728         LinesCopied = NtGdiSetDIBitsToDeviceInternal( hdc,
 729                       XDest,
 730                       YDest,
 731                       Width,
 732                       Height,
 733                       XSrc,
 734                       YSrc,
 735                       StartScan,
 736                       ScanLines,
 737                       (LPBYTE)pvSafeBits,
 738                       (LPBITMAPINFO)pConvertedInfo,
 739                       ColorUse,
 740                       cjBmpScanSize,
 741                       ConvertedInfoSize,
 742                       TRUE,
 743                       NULL);
 744     }
 745     if ( Bits != pvSafeBits)
 746         RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
 747     if (lpbmi != pConvertedInfo)
 748         RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
 749
 750     return LinesCopied;
 751 }
 752
 753
 754 /*
 755  * @unimplemented
 756  */
 757 int
 758 WINAPI
 759 StretchDIBits(HDC hdc,
 760               int XDest,
 761               int YDest,
 762               int nDestWidth,
 763               int nDestHeight,
 764               int XSrc,
 765               int YSrc,
 766               int nSrcWidth,
 767               int nSrcHeight,
 768               CONST VOID *lpBits,
 769               CONST BITMAPINFO *lpBitsInfo,
 770               UINT iUsage,
 771               DWORD dwRop)
 772
 773 {
 774     PDC_ATTR pDc_Attr;
 775     PBITMAPINFO pConvertedInfo = NULL;
 776     UINT ConvertedInfoSize = 0;
 777     INT LinesCopied = 0;
 778     UINT cjBmpScanSize = 0;
 779     PVOID pvSafeBits = NULL;
 780     BOOL Hit = FALSE;
 781
 782     DPRINT("StretchDIBits %x : %x : %d\n", lpBits, lpBitsInfo, iUsage);
 783 #if 0
 784 // Handle something other than a normal dc object.
 785     if (GDI_HANDLE_GET_TYPE(hdc) != GDI_OBJECT_TYPE_DC)
 786     {
 787         if (GDI_HANDLE_GET_TYPE(hdc) == GDI_OBJECT_TYPE_METADC)
 788             return MFDRV_StretchBlt( hdc,
 789                                      XDest,
 790                                      YDest,
 791                                      nDestWidth,
 792                                      nDestHeight,
 793                                      XSrc,
 794                                      YSrc,
 795                                      nSrcWidth,
 796                                      nSrcHeight,
 797                                      lpBits,
 798                                      lpBitsInfo,
 799                                      iUsage,
 800                                      dwRop);
 801         else
 802         {
 803             PLDC pLDC = GdiGetLDC(hdc);
 804             if ( !pLDC )
 805             {
 806                 SetLastError(ERROR_INVALID_HANDLE);
 807                 return 0;
 808             }
 809             if (pLDC->iType == LDC_EMFLDC)
 810             {
 811                 return EMFDRV_StretchBlt(hdc,
 812                                          XDest,
 813                                          YDest,
 814                                          nDestWidth,
 815                                          nDestHeight,
 816                                          XSrc,
 817                                          YSrc,
 818                                          nSrcWidth,
 819                                          nSrcHeight,
 820                                          lpBits,
 821                                          lpBitsInfo,
 822                                          iUsage,
 823                                          dwRop);
 824             }
 825             return 0;
 826         }
 827     }
 828 #endif
 829     pConvertedInfo = ConvertBitmapInfo(lpBitsInfo, iUsage,
 830                                        &ConvertedInfoSize, FALSE);
 831     if (!pConvertedInfo)
 832     {
 833         return 0;
 834     }
 835
 836     cjBmpScanSize = DIB_BitmapBitsSize((LPBITMAPINFO)pConvertedInfo);
 837
 838     if ( lpBits )
 839     {
 840         pvSafeBits = RtlAllocateHeap(GetProcessHeap(), 0, cjBmpScanSize);
 841         if (pvSafeBits)
 842         {
 843             _SEH2_TRY
 844             {
 845                 RtlCopyMemory( pvSafeBits, lpBits, cjBmpScanSize );
 846             }
 847             _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 848             {
 849                 Hit = TRUE;
 850             }
 851             _SEH2_END
 852
 853             if (Hit)
 854             {
 855                 // We don't die, we continue on with a allocated safe pointer to kernel
 856                 // space.....
 857                 DPRINT1("StretchDIBits fail to read BitMapInfo: %x or Bits: %x & Size: %d\n",pConvertedInfo,lpBits,cjBmpScanSize);
 858             }
 859             DPRINT("StretchDIBits Allocate Bits %d!!!\n", cjBmpScanSize);
 860         }
 861     }
 862
 863     if (!GdiGetHandleUserData(hdc, GDI_OBJECT_TYPE_DC, (PVOID)&pDc_Attr))
 864     {
 865         SetLastError(ERROR_INVALID_PARAMETER);
 866         return 0;
 867     }
 868     /*
 869       if ( !pDc_Attr ||
 870            ((pConvertedInfo->bmiHeader.biSize >= sizeof(BITMAPINFOHEADER)) &&
 871            (pConvertedInfo->bmiHeader.biCompression == BI_JPEG ||
 872             pConvertedInfo->bmiHeader.biCompression  == BI_PNG )) )*/
 873     {
 874         LinesCopied = NtGdiStretchDIBitsInternal( hdc,
 875                       XDest,
 876                       YDest,
 877                       nDestWidth,
 878                       nDestHeight,
 879                       XSrc,
 880                       YSrc,
 881                       nSrcWidth,
 882                       nSrcHeight,
 883                       pvSafeBits,
 884                       pConvertedInfo,
 885                       (DWORD)iUsage,
 886                       dwRop,
 887                       ConvertedInfoSize,
 888                       cjBmpScanSize,
 889                       NULL);
 890     }
 891     if ( pvSafeBits )
 892         RtlFreeHeap(RtlGetProcessHeap(), 0, pvSafeBits);
 893     if (lpBitsInfo != pConvertedInfo)
 894         RtlFreeHeap(RtlGetProcessHeap(), 0, pConvertedInfo);
 895
 896     return LinesCopied;
 897 }
 898