Question

Goal

Pass images generated by one process efficiently and at very high speed to another process. The two processes run on the same machine and on the same desktop. The operating system may be WinXP, Vista and Win7.

Detailed description

The first process is solely for controlling the communication with a device which produces the images. These images are about 500x300px in size and may be updated up to several hundred times per second. The second process needs these images to process them. The first process uses a third party API to paint the images from the device to a HDC. This HDC has to be provided by me.

Note: There is already a connection open between the two processes. They are communicating via anonymous pipes and share memory mapped file views.

Thoughts

How would I achieve this goal with as little work as possible? And I mean both work for the computer and me (of course ;)). I am using Delphi, so maybe there is some component available for doing this? I think I could always paint to any image component’s HDC, save the content to memory stream, copy the contents via the memory mapped file, unpack it on the other side and paint it there to the destination HDC. I also read about a IPicture interface which can be used to marshal images. I need it as quick as possible, so the less overhead the better. I don’t want the machine to be stressed just by copying some images.

What are your ideas? I appreciate every thought on this!

Answer 1

Ok it seems as if memory mapped files and pipes are the right way to go. That is not too bad because the two processes already share a MMF and two pipes (for bidirectional communication). The only thing left to solve was how to pass the data with as little copy operations as possible.

The design which works quite well looks as follows (sequential flow):

Process 1 (wants image)

• give signal to process 2 (via pipe 1) to store image in shared memory
• go to sleep and wait for response (blocking read from pipe 2)

Process 2 (provides images)

• on signal (via pipe 1) wake up and tell hardware device to paint to HDC 1 (this is backed by shared memory, see below)
• give signal to process 1 (via pipe 2)
• go to sleep and wait for new job (via pipe 1)

Process 1 (wants image)

• on signal (via pipe 2) wake up and paint from shared memory to destination HDC 2

Now for the image transfer via shared memory (my goal was to use not more than one additional copy operation):

Process 2 creates a HBITMAP via CreateDIBSection and provides the handle of the file mapping and the offset of the mapped view. Thus the image data lives in the shared memory. This creates an HBITMAP which is selected into HDC 1 (which is also created by process 2) and which will be used from now on by process 2.

Process 1 uses StretchDIBits with a pointer to the mapped view’s memory (as described here). This seems to be the only function for getting bits from memory directly into another HDC (in this case HDC 2). Other functions would copy them first into some intermediary buffer before you could transfer them from there to the final HDC.

So in the end it seems the bits needed to be transferred are about twice as much as in the beginning. But I think this is as good as it gets unless sharing GDI handles between processes would be possible.

Note: I used pipes instead of signals because I need to transfer some additional data, too.