Speichern HBITMAP *.bmp Datei mit nur Win32

Habe ich ein HBITMAP in meinem reinen Win32-Projekt (keine externen Bibliotheken verwendet werden). Kann ich es exportieren in eine *.bmp-Datei, die nur mithilfe von Winapi und/oder CRT-Funktionen, so glaube ich nicht, entstehen Ihnen keine zusätzlichen Abhängigkeiten?

InformationsquelleAutor sashoalm | 2014-07-13

  1. 14

    Gibt es keine API zum speichern in die Datei direkt da, in der Regel, dass ein bitmap-handle bedeutet nicht, Sie haben direkten Zugriff auf die bitmap-Daten. Ihre Lösung: kopieren Sie die bitmap in ein anderes bitmap mit Zugang zu den Daten (DIB) und dann mit es-Daten zum schreiben in die Datei.

    Sie in der Regel erstellen Sie entweder ein anderes bitmap mit CreateDIBSection oder Sie bekommen bitmap-Daten mit GetDIBits.

    CreateFile, WriteFile schreibt Daten in die Datei.

    Schreiben Sie: BITMAPFILEHEADER, dann BITMAPINFOHEADER, dann palette (die Sie normalerweise nicht haben, wenn bits/pixel auf 8), dann werden die Daten selbst.

    Siehe auch:

    Den Code

    Dies ist der code aus der MSDN-Artikel (Hinweis, dass Sie brauchen, um zu definieren, die errhandler() - Funktion):

    PBITMAPINFO CreateBitmapInfoStruct(HWND hwnd, HBITMAP hBmp)
{ 
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 

    //Retrieve the bitmap color format, width, and height.  
    if (!GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp)) 
        errhandler("GetObject", hwnd); 

    //Convert the color format to a count of bits.  
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 

    //Allocate memory for the BITMAPINFO structure. (This structure  
    //contains a BITMAPINFOHEADER structure and an array of RGBQUAD  
    //data structures.)  

    if (cClrBits < 24) 
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
        sizeof(BITMAPINFOHEADER) + 
        sizeof(RGBQUAD) * (1<< cClrBits)); 

    //There is no RGBQUAD array for these formats: 24-bit-per-pixel or 32-bit-per-pixel 

    else 
        pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
        sizeof(BITMAPINFOHEADER)); 

    //Initialize the fields in the BITMAPINFO structure.  

    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 

    //If the bitmap is not compressed, set the BI_RGB flag.  
    pbmi->bmiHeader.biCompression = BI_RGB; 

    //Compute the number of bytes in the array of color  
    //indices and store the result in biSizeImage.  
    //The width must be DWORD aligned unless the bitmap is RLE 
    //compressed. 
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
        * pbmi->bmiHeader.biHeight; 
    //Set biClrImportant to 0, indicating that all of the  
    //device colors are important.  
    pbmi->bmiHeader.biClrImportant = 0; 
    return pbmi; 
} 

void CreateBMPFile(HWND hwnd, LPTSTR pszFile, PBITMAPINFO pbi, 
                   HBITMAP hBMP, HDC hDC) 
{ 
    HANDLE hf;                 //file handle  
    BITMAPFILEHEADER hdr;       //bitmap file-header  
    PBITMAPINFOHEADER pbih;     //bitmap info-header  
    LPBYTE lpBits;              //memory pointer  
    DWORD dwTotal;              //total count of bytes  
    DWORD cb;                   //incremental count of bytes  
    BYTE *hp;                   //byte pointer  
    DWORD dwTmp; 

    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);

    if (!lpBits) 
        errhandler("GlobalAlloc", hwnd); 

    //Retrieve the color table (RGBQUAD array) and the bits  
    //(array of palette indices) from the DIB.  
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS)) 
    {
        errhandler("GetDIBits", hwnd); 
    }

    //Create the .BMP file.  
    hf = CreateFile(pszFile, 
        GENERIC_READ | GENERIC_WRITE, 
        (DWORD) 0, 
        NULL, 
        CREATE_ALWAYS, 
        FILE_ATTRIBUTE_NORMAL, 
        (HANDLE) NULL); 
    if (hf == INVALID_HANDLE_VALUE) 
        errhandler("CreateFile", hwnd); 
    hdr.bfType = 0x4d42;        //0x42 = "B" 0x4d = "M"  
    //Compute the size of the entire file.  
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
        pbih->biSize + pbih->biClrUsed 
        * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 

    //Compute the offset to the array of color indices.  
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
        pbih->biSize + pbih->biClrUsed 
        * sizeof (RGBQUAD); 

    //Copy the BITMAPFILEHEADER into the .BMP file.  
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)) 
    {
        errhandler("WriteFile", hwnd); 
    }

    //Copy the BITMAPINFOHEADER and RGBQUAD array into the file.  
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
        + pbih->biClrUsed * sizeof (RGBQUAD), 
        (LPDWORD) &dwTmp, ( NULL)))
        errhandler("WriteFile", hwnd); 

    //Copy the array of color indices into the .BMP file.  
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)) 
        errhandler("WriteFile", hwnd); 

    //Close the .BMP file.  
    if (!CloseHandle(hf)) 
        errhandler("CloseHandle", hwnd); 

    //Free memory.  
    GlobalFree((HGLOBAL)lpBits);
}
    Tatsächlich, Sie kann sparen Sie eine HBITMAP zimmerreserviereung, ohne das Sie manuell konvertieren. Es dauert ein bisschen code zu erstellen Sie einen stream auf eine Datei, erstellen Sie ein encoder, und dann dumping frames hinein. Aber die heavy-lifting erfolgt in IWICImagingFactory::CreateBitmapFromHBITMAP und der IWICBitmapEncoder, so dass Sie nicht haben, um Geige mit bitmap-Header.

    InformationsquelleAutor Roman R.

  2. 5

    Noch eine weitere minimalistische option ist die Verwendung von OLE -IPicture. Es war schon immer rund um, immer noch ein Teil des Win32-API:

    #define _S(exp) (([](HRESULT hr) { if (FAILED(hr)) _com_raise_error(hr); return hr; })(exp));

PICTDESC pictdesc = {};
pictdesc.cbSizeofstruct = sizeof(pictdesc);
pictdesc.picType = PICTYPE_BITMAP;
pictdesc.bmp.hbitmap = hBitmap;

CComPtr<IPicture> picture;
_S( OleCreatePictureIndirect(&pictdesc, __uuidof(IPicture), FALSE, (LPVOID*)&picture) );

//Save to a stream

CComPtr<IStream> stream;
_S( CreateStreamOnHGlobal(NULL, TRUE, &stream) );
LONG cbSize = 0;
_S( picture->SaveAsFile(stream, TRUE, &cbSize) );

//Or save to a file

CComPtr<IPictureDisp> disp;
_S( picture->QueryInterface(&disp) );
_S( OleSavePictureFile(disp, CComBSTR("C:\\Temp\\File.bmp")) );
    Die hBitmap im pictdesc.bmp.hbitmap = hBitmap; scheint schwarzarbeit. Haben Sie eine Idee haben, wie Sie zu beheben?
    ist das, was Sie bereits haben, nach OP ' s Frage, von HBITMAP geben. Dies ist ein Win32-handle auf das bitmap, welche Inhalte Sie möchten, um eine Datei zu speichern.
    Es ist meine Schuld. Habe ich nicht gelesen voll OP ' s Frage. Alles, was er will, ist der Export. Also im Grunde, er hat eine bitmap schon. Danke!

    InformationsquelleAutor noseratio

  3. 4

    lasse ich diese selbst enthalten, proof-of-concept, seit ich hier wahrscheinlich benötigen, um es so Aussehen, bis später, da es nicht offensichtlich ist. Es nimmt einen screenshot des desktop-Fensters und speichert es in bitmap.bmp:

    #include <Windows.h>
#include <stdio.h>
#include <assert.h>

/* forward declarations */
PBITMAPINFO CreateBitmapInfoStruct(HBITMAP);
void CreateBMPFile(LPTSTR pszFile, HBITMAP hBMP); 
int main(int argc, char **argv);

PBITMAPINFO CreateBitmapInfoStruct(HBITMAP hBmp)
{ 
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 

    //Retrieve the bitmap color format, width, and height.  
    assert(GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp)); 

    //Convert the color format to a count of bits.  
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 

    //Allocate memory for the BITMAPINFO structure. (This structure  
    //contains a BITMAPINFOHEADER structure and an array of RGBQUAD  
    //data structures.)  

     if (cClrBits < 24) 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD) * (1<< cClrBits)); 

     //There is no RGBQUAD array for these formats: 24-bit-per-pixel or 32-bit-per-pixel 

     else 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 

    //Initialize the fields in the BITMAPINFO structure.  

    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 

    //If the bitmap is not compressed, set the BI_RGB flag.  
    pbmi->bmiHeader.biCompression = BI_RGB; 

    //Compute the number of bytes in the array of color  
    //indices and store the result in biSizeImage.  
    //The width must be DWORD aligned unless the bitmap is RLE 
    //compressed. 
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
    //Set biClrImportant to 0, indicating that all of the  
    //device colors are important.  
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
 } 

void CreateBMPFile(LPTSTR pszFile, HBITMAP hBMP) 
 { 
     HANDLE hf;                 //file handle  
    BITMAPFILEHEADER hdr;       //bitmap file-header  
    PBITMAPINFOHEADER pbih;     //bitmap info-header  
    LPBYTE lpBits;              //memory pointer  
    DWORD dwTotal;              //total count of bytes  
    DWORD cb;                   //incremental count of bytes  
    BYTE *hp;                   //byte pointer  
    DWORD dwTmp;     
    PBITMAPINFO pbi;
    HDC hDC;

    hDC = CreateCompatibleDC(GetWindowDC(GetDesktopWindow()));
    SelectObject(hDC, hBMP);

    pbi = CreateBitmapInfoStruct(hBMP);

    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);

    assert(lpBits) ;

    //Retrieve the color table (RGBQUAD array) and the bits  
    //(array of palette indices) from the DIB.  
    assert(GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS));

    //Create the .BMP file.  
    hf = CreateFile(pszFile, 
                   GENERIC_READ | GENERIC_WRITE, 
                   (DWORD) 0, 
                    NULL, 
                   CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL); 
    assert(hf != INVALID_HANDLE_VALUE) ;

    hdr.bfType = 0x4d42;        //0x42 = "B" 0x4d = "M"  
    //Compute the size of the entire file.  
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
                 pbih->biSize + pbih->biClrUsed 
                 * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 

    //Compute the offset to the array of color indices.  
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    pbih->biSize + pbih->biClrUsed 
                    * sizeof (RGBQUAD); 

    //Copy the BITMAPFILEHEADER into the .BMP file.  
    assert(WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)); 

    //Copy the BITMAPINFOHEADER and RGBQUAD array into the file.  
    assert(WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
                  + pbih->biClrUsed * sizeof (RGBQUAD), 
                  (LPDWORD) &dwTmp, ( NULL)));

    //Copy the array of color indices into the .BMP file.  
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    assert(WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)); 

    //Close the .BMP file.  
     assert(CloseHandle(hf)); 

    //Free memory.  
    GlobalFree((HGLOBAL)lpBits);
}

int main(int argc, char **argv)
{
    HWND hwnd;
    HDC hdc[2];
    HBITMAP hbitmap;
    RECT rect;

    hwnd = GetDesktopWindow();
    GetClientRect(hwnd, &rect);
    hdc[0] = GetWindowDC(hwnd);
    hbitmap = CreateCompatibleBitmap(hdc[0], rect.right, rect.bottom); 
    hdc[1] = CreateCompatibleDC(hdc[0]);
    SelectObject(hdc[1], hbitmap);    

    BitBlt (    
        hdc[1],
        0,
        0,
        rect.right,
        rect.bottom,
        hdc[0],
        0,
        0,
        SRCCOPY
    );

    CreateBMPFile("bitmap.bmp", hbitmap);
    return 0;
}
    Danke Dimitry, für das schöne Stück code. Sie machte meinen Tag. Prost!
    Speichern bmp-Datei auf Laufwerk " D " verwenden CreateBMPFile("D:\\bitmap.bmp", hbitmap);
    Es ist ein Fehler, der sagt: uninitialized local variable 'bmp' used. Der code bereits deklariert BITMAP bmp. Warum?
    meine Vermutung ist, weil Sie kompilieren Sie c++ - compiler oder eine andere compiler. Ich kann nicht sagen, ohne Ihnen zu sagen, welche Linie der Warnung, aber es ist in der Tat initialisiert mithilfe von GetObject und überprüft, ob GetObject erfolgreich war oder nicht.
    Ich bin mit MSVS C++ - compiler, um diesen code zu kompilieren.

    InformationsquelleAutor Dmitry

  4. 4

    Ja, das ist möglich, mit dem Windows Imaging Component (WIC). WIC bietet integrierte Encoder, so dass Sie nicht haben, um manuell zu schreiben, die bitmap-Header und Daten. Es erlaubt Ihnen auch, wählen Sie einen anderen encoder (z.B. PNG), und ändern Sie so wenig wie eine Zeile code.

    Der Prozess ist ziemlich geradlinig. Es besteht aus den folgenden Schritten:

    1. Abrufen von Eigenschaften aus der Quelle HBITMAP mit GetObject (Abmessungen, bit-Tiefe).
    2. Erstellen Sie eine IWICImagingFactory Instanz.
    3. Erstellen Sie eine IWICBitmap Instanz aus der HBITMAP (IWICImagingFactory::CreateBitmapFromHBITMAP).
    4. Erstellen Sie eine IWICStream Instanz (IWICImagingFactory::CreateStream), und befestigen Sie es an eine mit dem Namen (IWICStream::InitializeFromFilename).
    5. Erstellen Sie eine IWICBitmapEncoder Instanz (IWICImagingFactory::CreateEncoder), und verbinden es mit dem stream (IWICBitmapEncoder::Initialize).
    6. Erstellen Sie eine IWICBitmapFrameEncode Instanz (IWICBitmapEncoder::CreateNewFrame), und initialisieren Sie es in übereinstimmung mit der Quelle HBITMAP (IWICBitmapFrameEncode::Initialize, IWICBitmapFrameEncode::SetSize, IWICBitmapFrameEncode::SetPixelFormat).
    7. Schreiben von bitmap-Daten auf den Rahmen (IWICBitmapFrameEncode::WriteSource).
    8. Commit-frame und Daten-stream (IWICBitmapFrameEncode::Commit, IWICBitmapEncoder::Commit).

    Übersetzt-code:

    #define COBJMACROS

#include <Objbase.h>
#include <wincodec.h>
#include <Windows.h>
#include <Winerror.h>

#pragma comment(lib, "Windowscodecs.lib")

HRESULT WriteBitmap(HBITMAP bitmap, const wchar_t* pathname) {

    HRESULT hr = S_OK;

    //(1) Retrieve properties from the source HBITMAP.
    BITMAP bm_info = { 0 };
    if (!GetObject(bitmap, sizeof(bm_info), &bm_info))
        hr = E_FAIL;

    //(2) Create an IWICImagingFactory instance.
    IWICImagingFactory* factory = NULL;
    if (SUCCEEDED(hr))
        hr = CoCreateInstance(&CLSID_WICImagingFactory, NULL, CLSCTX_INPROC_SERVER,
                              &IID_IWICImagingFactory, &factory);

    //(3) Create an IWICBitmap instance from the HBITMAP.
    IWICBitmap* wic_bitmap = NULL;
    if (SUCCEEDED(hr))
        hr = IWICImagingFactory_CreateBitmapFromHBITMAP(factory, bitmap, NULL,
                                                        WICBitmapIgnoreAlpha,
                                                        &wic_bitmap);

    //(4) Create an IWICStream instance, and attach it to a filename.
    IWICStream* stream = NULL;
    if (SUCCEEDED(hr))
        hr = IWICImagingFactory_CreateStream(factory, &stream);
    if (SUCCEEDED(hr))
        hr = IWICStream_InitializeFromFilename(stream, pathname, GENERIC_WRITE);

    //(5) Create an IWICBitmapEncoder instance, and associate it with the stream.
    IWICBitmapEncoder* encoder = NULL;
    if (SUCCEEDED(hr))
        hr = IWICImagingFactory_CreateEncoder(factory, &GUID_ContainerFormatBmp, NULL,
                                              &encoder);
    if (SUCCEEDED(hr))
        hr = IWICBitmapEncoder_Initialize(encoder, (IStream*)stream,
                                          WICBitmapEncoderNoCache);

    //(6) Create an IWICBitmapFrameEncode instance, and initialize it
    //in compliance with the source HBITMAP.
    IWICBitmapFrameEncode* frame = NULL;
    if (SUCCEEDED(hr))
        hr = IWICBitmapEncoder_CreateNewFrame(encoder, &frame, NULL);
    if (SUCCEEDED(hr))
        hr = IWICBitmapFrameEncode_Initialize(frame, NULL);
    if (SUCCEEDED(hr))
        hr = IWICBitmapFrameEncode_SetSize(frame, bm_info.bmWidth, bm_info.bmHeight);
    if (SUCCEEDED(hr)) {
        GUID pixel_format = GUID_WICPixelFormat24bppBGR;
        hr = IWICBitmapFrameEncode_SetPixelFormat(frame, &pixel_format);
    }

    //(7) Write bitmap data to the frame.
    if (SUCCEEDED(hr))
        hr = IWICBitmapFrameEncode_WriteSource(frame, (IWICBitmapSource*)wic_bitmap,
                                               NULL);

    //(8) Commit frame and data to stream.
    if (SUCCEEDED(hr))
        hr = IWICBitmapFrameEncode_Commit(frame);
    if (SUCCEEDED(hr))
        hr = IWICBitmapEncoder_Commit(encoder);

    //Cleanup
    if (frame)
        IWICBitmapFrameEncode_Release(frame);
    if (encoder)
        IWICBitmapEncoder_Release(encoder);
    if (stream)
        IWICStream_Release(stream);
    if (wic_bitmap)
        IWICBitmap_Release(wic_bitmap);
    if (factory)
        IWICImagingFactory_Release(factory);

    return hr;
}

    Hier ist eine companion-test Anwendung zu präsentieren, die Nutzung. Stellen Sie sicher, dass #define OEMRESOURCE vor jedem system-Header zu ermöglichen, der Nutzung der OBM_ Bilder.

    int wmain(int argc, wchar_t** argv) {

    HRESULT hr = S_OK;
    hr = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    if (FAILED(hr))
        return -1;

    HBITMAP bitmap = LoadImage(NULL, MAKEINTRESOURCE(OBM_ZOOM), IMAGE_BITMAP, 0, 0,
                               LR_DEFAULTCOLOR);

    hr = WriteBitmap(bitmap, argv[1]);

    //Cleanup
    if (bitmap)
        DeleteObject(bitmap);

    CoUninitialize();
    return 0;
}

    Diese laden einen vom system bereitgestellten bitmap und speichern angegebene Pfadname als argument auf der Befehlszeile.

    Einschränkungen:

    • Keine Unterstützung für alpha-Kanäle. Obwohl die bitmaps version 5 alpha-Kanäle unterstützen, ich bin mir nicht bewusst irgendeine Möglichkeit herauszufinden, ob ein HBITMAP bezieht sich auf eine bitmap mit alpha-Kanal, noch würde ich wissen, wie, um zu bestimmen, ob es ein vor-multipliziert. Wenn Sie wollen, unterstützen einen alpha-Kanal, stellen Sie sicher, dass die EnableV5Header32bppBGRA Eigenschaft VARIANT_TRUE (siehe BMP-Format: Codierung).
    • Keine Unterstützung für die Paletten-bitmaps (bpp <= 8). Wenn Sie sind den Umgang mit Paletten-bitmaps, stellen Sie sicher, dass die Bereitstellung eines entsprechenden HPALETTE im Aufruf IWICImagingFactory::CreateBitmapFromHBITMAP.
    • Der encoder initialisiert wird mit der GUID_WICPixelFormat24bppBGR pixel-format Konstante. Ein vielseitiger Implementierung ableiten, kompatibel, pixel-format von der Quelle HBITMAP.

    InformationsquelleAutor IInspectable

Schreibe einen Kommentar