dibs | Debian Image Build System

In a camera application bitmap pixel arrays are retrieved from a streaming camera. The pixel arrays are captured by writing them to a named pipe, where on the other end of the pipe, ffmpeg retrieves them and creates an AVI file.

I will need to create one custom frame (with custom text on), and pipe its pixels as the first frame in the resulting movie.

The question is how can I use a TBitmap (for convenience) to

1. Create a X by Y monochrome (8 bit) bitmap from scratch, with custom text on. I want the background to be white, and the text to be black. (Mostly figured this step out, see below.)

2. Retrieve the pixel array that I can send/write to the pipe

Step 1: The following code creates a TBitmap and writes text on it:

So I have a working HBITMAP which can be set to the clipboard using SetClipboardData. What I'm trying to do is send the HBITMAP to another application (without writing anything to disk) which will receive it and be able set it to the clipboard just as the original application could do. I know that you can't just send the handle so I used GetObject and GetDIBits and sent the collected data across. I've looked at all the other people's stackoverflow questions about sending hbitmaps over a network but none of the answers given have worked for me.

UPDATE: Code still not working after updated.

This is now what it shows as when I paste the clipboard into mspaint

Here's what my code looks like now:

Client:

I have a dataframe like below

I am trying to generate bmp images (graphs) in nodeJS for use in C to display on a low-res display.

Creating the graphs (with d3.js) and converting the svg-code to a bmp works fine (via svg2img and Jimp) and everything appears correctly in the bmp-file.

When I try to display it on the low-res screen, the C code reports that the image height is negative and fails. Now I read that bmp's can be stored top-to-bottom or bottom-to-top (here for example).

In which direction does Jimp work and how could it be reversed?

I have converted the bmp that I generated with Jimp again (using XnConvert) and tried the resulting bmp, which did successfully display on the low-res screen.

In node:

When creating a bitmap you have three four choices:

• CreateBitmap: creates a device-dependent bitmap (and it better be compatible with the device you eventually intend to use it on)
• CreateCompatibleBitmap: creates a device-dependent bitmap (compatible with the DC you supply)
• CreateDIBitmap: creates a device-dependent bitmap, but lets you specify the device-independent bits to initialize the bitmap with¹ (functionally equivalent to calling CreateCompatibleBitmap + SetDIBits)
• CreateDIBSection: creates a device-independant bitmap (but i have to supply a DC?)

It makes sense why CreateCompatibleBitmap would need an hdc parameter: it has to know which DC to be compatible with.

Note: It doesn't make sense why CreateBitmap doesn't take an hdc. How does it know what DC to be compatible with?

CreateBitmap doesn't take a DC, and it doesn't know what DC to be compatible with. That's your job. And you better make sure it's compatible with the DC you eventually intended to use it with.

Why does CreateDIBSection take a handle to a device context?

CreateDIBSection function

The CreateDIBSection function creates a DIB that applications can write to directly. The function gives you a pointer to the location of the bitmap bit values. You can supply a handle to a file-mapping object that the function will use to create the bitmap, or you can let the system allocate the memory for the bitmap.

This code gets different scaling depending on which computer I run it on.

I have a MFC application with toolbars (using CMFCToolbar). I create the toolbar bitmap on the fly using bitmaps from files and resources. The DIBs have different color formats.

• So I create an empty bitmap toolbar image compatible to screen DC.
• Then I open all the bitmaps and blit the content to the toolbar bitmap (GDI does colorspace conversion and stretching for me).
• Then I save the bitmap to a 24-bit DIB file.
• Then I create the toolbar object and load the image.

That has worked for ages and is working now except for one case:

Recently we had to enable GDI scaling for Windows 10 1703 and later. On a system with high resolution display and 200% scaling (like Surface) the following effect occurs:

All toolbar icons are distorted.

I also found the reason:

When saving the composed image I only get the top-left quarter of the image. Width and height of the bitmap did not change (say 1024x15) compared to normal resolution display without GDI scaling. But that bitmap only contains the pixels of the top-left quarter (see example below).

So I assume the device context tells Windows about 200% scaling. When blitting from source to target the image gets scaled up automatically but the dimension of the bitmap does not change.

How can I save the unscaled bitmap?

-or-

How can I correctly save the scaled bitmap? Where to get the missing pixels? Where to get proper dimensions? (HBITMAP refers only to unscaled dimensions).

Example:

no GDI scaling, correct:

200% scaling, same dimensions, but only top-left quarter of the correct image:

I am trying to capture the screen contents, modify the bits of the grabbed image directly, and then put the result on the clipboard. (Actually, I'm not ultimately interested in the clipboard, but am using it as a testing step.)

I started with the example from one of the answers to this question. However, it uses CreateCompatibleBitmap, and from what I understand, there is no way to directly access the bits of bitmaps created with that function, so I am trying to use CreateDIBSection instead. Here is what I have so far: