Constant garbage collection from converting Bitmap to BitmapImage

Question

My code is essentially attempting to create a video feed by constantly updating a BitmapImage that is binded to the UI (WPF). This means a bitmap is being converted to BitmapImage multiple times per second. However this is causing constant garbage collection (multiple times per second) which seems like a bad sign?

The bitmaps are being disposed of correctly its just the BitmapImage part which is causing the problem. I've tried writing to the BitmapImage instead of creating a new one, But once frozen it becomes Readonly. And if I unfreeze it I get Error: "Must create DependencySource on same Thread as the DependencyObject".

Below is the method I'm using to create a bitmap Image

        //CapturedBitmapmapImage bound to the UI
        CapturedBitmapImage = BitMap2BitMapImage(bitmap);

        //Method for converting Bitmap to BitmapImage
        public static BitmapImage BitMap2BitMapImage(Bitmap bitmap)
        {
            MemoryStream ms = new MemoryStream();           
            bitmap.Save(ms, System.Drawing.Imaging.ImageFormat.Bmp);
            BitmapImage image = new BitmapImage();
            image.BeginInit();
            ms.Seek(0, SeekOrigin.Begin);
            image.StreamSource = ms;
            image.EndInit();
            image.Freeze();
            return image;
        }

You may try a method like [this](https://stackoverflow.com/a/30729291/1136211), and possibly improve it by writing into a WriteableBitmap instead of creating a BitmapSource. — Clemens, Jun 28 '22 at 09:38

score 0 · Answer 1 · answered Jun 28 '22 at 09:43

This method will save the image and decode it for each frame, probably allocating the entire image buffer multiple times. So it should be no surprise that it will cause a lot of memory allocation, and probably on the Large object heap to make things even worse.

To fix this I would recommend using a WritableBitmap instead. Assuming you have the same size/color space of both bitmaps and are running unsafe code:

var bitmapData = sourceBitmap.LockBits(
    new Rectangle(0, 0, sourceBitmap.Width, sourceBitmap.Height),
    System.Drawing.Imaging.ImageLockMode.ReadOnly,
    sourceBitmap.PixelFormat);
var sourcePtr = bitmapData.Scan0;
myWriteableBitmap.Lock();
var destPtr = bitmap.BackBuffer;
 var totalBytes = bitmapData.Stride * bitmapData.Height * myWriteableBitmap.Format.BitsPerPixel / 8;
Buffer.MemoryCopy((byte*)sourcePtr, (byte*)destPtr, totalBytes, totalBytes);
myWriteableBitmap.Unlock();
sourceBitmap.UnlockBits(bitmapData);

But you might be able to call the C memcopy function to avoid any actual pointers. Also note that you should add error handling whenever locking/unlocking data.

This should allow you to avoid allocations, except for creating the bitmap in the first place. Ideally you would want to avoid creating any new bitmaps at all, and reuse any buffers for image data. But it is difficult to tell how to do this since you do not show how the bitmap is created.

Clemens · Accepted Answer · 2022-06-28T16:10:11.627

0

Instead of creating a new BitmapImage for each frame, you should use a WriteableBitmap that is once assigned to the Source property of an Image element.

int frameWidth = ...
int frameHeight = ...
var pixelFormat = PixelFormats.Bgr24; // must match Bitmap.PixelFormat

var writeableBitmap = new WriteableBitmap(
    frameWidth, frameHeight, 96, 96, pixelFormat, null);

image.Source = writeableBitmap;

You would then cyclically update the WriteableBitmap (and hence also the Image element) from a Bitmap like this:

Bitmap bitmap = ... // a frame

var bitmapData = bitmap.LockBits(
    new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height),
    System.Drawing.Imaging.ImageLockMode.ReadOnly, bitmap.PixelFormat);

image.Dispatcher.Invoke(() => writeableBitmap.WritePixels(
    new Int32Rect(0, 0, bitmap.Width, bitmap.Height),
    bitmapData.Scan0, bitmapData.Stride * bitmapData.Height, bitmapData.Stride));

bitmap.UnlockBits(bitmapData);

edited Jun 28 '22 at 16:10

answered Jun 28 '22 at 09:58

Clemens

123,504
12
155
268

Thanks for replying, The problem is my Image element is created in a seperate thread wheres its binded to the UI. This means any changed attempted result in Error:"Must create DependencySource on same Thread as the DependencyObject". – Ben Jun 28 '22 at 15:41
You may wrap the WritePixels call in a Dispatcher.Invoke call - see the edited answer. Or refer to the WriteableBitmap documentation for how to write to its BackBuffer from a thread other than the UI thread. Or go with the solution linked in my comment to your question. Freeze the resulting BitmapSource as you already do with the BitmapImage. – Clemens Jun 28 '22 at 16:12
Dispatcher worked, thanks a lot! – Ben Jun 28 '22 at 16:39

Constant garbage collection from converting Bitmap to BitmapImage

2 Answers2