title: How to create a new HBITMAP(DIB) from an existing HBITMAP(CreateCompatibleBitmap)?
body: <p>I created a bitmap by CreateCompatibleBitmap() for capturing the screen.
  Then I want to create a new DIB (in memory) from this bitmap. </p>
  
  <p>The code should look be:</p>
  
  <pre><code>HBITMAP ConvertToDIB(HBITMAP ddb)
  { ... }
  </code></pre>
  
  <p>I already have some code to write a bitmap into a file. However, I want a HBITMAP in memory.</p>
  
  <pre><code>//---------------------------------------------------------------------------
  void WriteBitmapToFile(HBITMAP bitmap, wchar_t* filename, HDC hDC)
  {
      BITMAP bmp;
      PBITMAPINFO pbmi;
      WORD cClrBits;
      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;
  
      // create the bitmapinfo header information
      if (!::GetObjectW(bitmap, sizeof(BITMAP), &amp;bmp))
      {
          return;
      }
  
      // Convert the color format to a count of bits.
      cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
      if (cClrBits == 1)
      cClrBits = 1;
      else if (cClrBits &lt;= 4)
      cClrBits = 4;
      else if (cClrBits &lt;= 8)
      cClrBits = 8;
      else if (cClrBits &lt;= 16)
      cClrBits = 16;
      else if (cClrBits &lt;= 24)
      cClrBits = 24;
      else cClrBits = 32;
  
  
  
      // Allocate memory for the BITMAPINFO structure.
      if (cClrBits != 24)
      pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
      sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1&lt;&lt; cClrBits));
      else
      pbmi = (PBITMAPINFO) LocalAlloc(LPTR, sizeof(BITMAPINFOHEADER));
  
      // Initialize the fields in the BITMAPINFO structure.
  
      pbmi-&gt;bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
      pbmi-&gt;bmiHeader.biWidth = bmp.bmWidth;
      pbmi-&gt;bmiHeader.biHeight = bmp.bmHeight;
      pbmi-&gt;bmiHeader.biPlanes = bmp.bmPlanes;
      pbmi-&gt;bmiHeader.biBitCount = bmp.bmBitsPixel;
      if (cClrBits &lt; 24)
      pbmi-&gt;bmiHeader.biClrUsed = (1&lt;&lt;cClrBits);
  
      // If the bitmap is not compressed, set the BI_RGB flag.
      pbmi-&gt;bmiHeader.biCompression = BI_RGB;
  
      // Compute the number of bytes in the array of color
      // indices and store the result in biSizeImage.
      pbmi-&gt;bmiHeader.biSizeImage = (pbmi-&gt;bmiHeader.biWidth + 7) /8 * pbmi-&gt;bmiHeader.biHeight * cClrBits;
      // Set biClrImportant to 0, indicating that all of the
      // device colors are important.
      pbmi-&gt;bmiHeader.biClrImportant = 0;
  
      // now open file and save the data
      pbih = (PBITMAPINFOHEADER) pbmi;
      lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih-&gt;biSizeImage);
  
      if (!lpBits)
      {
          return;
      }
  
      // Retrieve the color table (RGBQUAD array) and the bits
      if (!GetDIBits(hDC, HBITMAP(bitmap), 0, (WORD) pbih-&gt;biHeight, lpBits, pbmi,
      DIB_RGB_COLORS))
      {
          return;
      }
  
      // Create the .BMP file.
      hf = CreateFileW(filename, GENERIC_READ | GENERIC_WRITE, (DWORD) 0,
      NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,
      (HANDLE) NULL);
      if (hf == INVALID_HANDLE_VALUE){
      return;
      }
      hdr.bfType = 0x4d42; // 0x42 = "B" 0x4d = "M"
      // Compute the size of the entire file.
      hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) +
      pbih-&gt;biSize + pbih-&gt;biClrUsed
      * sizeof(RGBQUAD) + pbih-&gt;biSizeImage);
      hdr.bfReserved1 = 0;
      hdr.bfReserved2 = 0;
  
      // Compute the offset to the array of color indices.
      hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) +
      pbih-&gt;biSize + pbih-&gt;biClrUsed
      * sizeof (RGBQUAD);
  
      // Copy the BITMAPFILEHEADER into the .BMP file.
      if (!WriteFile(hf, (LPVOID) &amp;hdr, sizeof(BITMAPFILEHEADER),
      (LPDWORD) &amp;dwTmp, NULL)) {
      return;
      }
  
      // Copy the BITMAPINFOHEADER and RGBQUAD array into the file.
      if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER)
      + pbih-&gt;biClrUsed * sizeof (RGBQUAD),
      (LPDWORD) &amp;dwTmp, ( NULL))){
      return;
      }
  
  
      // Copy the array of color indices into the .BMP file.
      dwTotal = cb = pbih-&gt;biSizeImage;
      hp = lpBits;
      if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &amp;dwTmp,NULL)){
      return;
      }
  
      // Close the .BMP file.
      if (!CloseHandle(hf)){
      return;
      }
  
      // Free memory.
      GlobalFree((HGLOBAL)lpBits);
  }
  </code></pre>
  
  <p>Best regards,
  Zach</p>