WPF环境下C#在JPG视频帧上绘制矩形的性能优化方案求助

你的核心问题在于GDI+与WPF图像格式转换的开销，加上低效的逐像素画框逻辑，导致单帧处理时间波动大，达不到25fps的要求。下面是针对性的优化建议，按见效优先级排序：

1. 立即替换低效的逐像素画框逻辑 #

你当前的DrawRectangleBorder用两层循环调用SetPixel画边框，这是GDI+里最慢的操作之一——每次SetPixel都要锁定/解锁位图内存，640×480的图上画一个框要循环上千次，完全没必要。

直接用GDI+的Graphics.DrawRectangle（硬件加速批量操作）替代，速度能提升几个数量级：

private static Bitmap DrawRectangleBorder(Bitmap image, Rectangle rectangle, Color colour)
{
    // 若允许修改原图像，直接在原图上绘制（省掉Bitmap克隆开销）
    using (var graphics = Graphics.FromImage(image))
    using (var pen = new Pen(colour, 1)) // 1像素宽绿色画笔
    {
        // 消除边框模糊问题
        graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
        graphics.DrawRectangle(pen, rectangle);
    }
    return image;

    // 若必须保留原图像，先克隆再绘制：
    // Bitmap newBitmap = (Bitmap)image.Clone();
    // using (var graphics = Graphics.FromImage(newBitmap))
    // using (var pen = new Pen(colour, 1))
    // {
    //     graphics.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.Half;
    //     graphics.DrawRectangle(pen, rectangle);
    // }
    // return newBitmap;
}

2. 优化Bitmap到BitmapImage的转换流程 #

你当前把Bitmap保存为PNG到MemoryStream，PNG压缩是额外的耗时操作。换成无压缩的BMP格式，或者直接从Bitmap的内存句柄创建BitmapImage，能大幅减少转换时间：

方案A：用BMP格式替代PNG #

using (MemoryStream memory = new MemoryStream())
{
    newImage.Save(memory, ImageFormat.Bmp); // 无压缩，写入速度快
    memory.Position = 0;
    BitmapImage bitmapImage = new BitmapImage();
    bitmapImage.BeginInit();
    bitmapImage.StreamSource = memory;
    bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
    // 固定解码尺寸，避免WPF自动缩放开销
    bitmapImage.DecodePixelWidth = newImage.Width;
    bitmapImage.DecodePixelHeight = newImage.Height;
    bitmapImage.EndInit();
    ImportImage.Source = bitmapImage;
}

方案B：直接从HBitmap创建BitmapImage（最快转换方式） #

跳过流保存步骤，直接用GDI句柄转换，避免内存拷贝：

private BitmapImage BitmapToBitmapImage(Bitmap bitmap)
{
    IntPtr hBitmap = bitmap.GetHbitmap();
    try
    {
        BitmapImage bitmapImage = new BitmapImage();
        bitmapImage.BeginInit();
        bitmapImage.Source = System.Windows.Interop.Imaging.CreateBitmapSourceFromHBitmap(
            hBitmap,
            IntPtr.Zero,
            Int32Rect.Empty,
            BitmapSizeOptions.FromEmptyOptions());
        bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
        bitmapImage.EndInit();
        return bitmapImage;
    }
    finally
    {
        // 必须释放GDI句柄，避免内存泄漏
        DeleteObject(hBitmap);
    }
}

// 导入GDI释放函数
[System.Runtime.InteropServices.DllImport("gdi32.dll")]
private static extern bool DeleteObject(IntPtr hObject);

3. 彻底切换到WPF原生的WriteableBitmap #

既然是WPF应用，直接用WriteableBitmap操作像素，完全避免GDI+与WPF的格式转换开销，这是最适合实时绘制的方案：

核心代码示例 #

// 提前加载图片到WriteableBitmap（建议缓存已加载的帧，避免重复磁盘IO）
private WriteableBitmap LoadImageToWriteableBitmap(string imagePath)
{
    BitmapImage bitmapImage = new BitmapImage(new Uri(imagePath));
    return new WriteableBitmap(bitmapImage);
}

// 在WriteableBitmap上绘制绿色边框
private void DrawRectangleOnWriteableBitmap(WriteableBitmap wb, int x, int y, int width, int height)
{
    int greenArgb = Colors.Green.A << 24 | Colors.Green.R << 16 | Colors.Green.G << 8 | Colors.Green.B;
    int stride = wb.PixelWidth * 4; // 每个像素4字节（BGRA格式）

    wb.Lock();
    unsafe
    {
        int* pBuffer = (int*)(void*)wb.BackBuffer;
        
        // 画顶部边框
        for (int i = x; i < x + width && i < wb.PixelWidth; i++)
            pBuffer[y * wb.PixelWidth + i] = greenArgb;
        
        // 画底部边框
        int bottomY = y + height - 1;
        if (bottomY < wb.PixelHeight)
            for (int i = x; i < x + width && i < wb.PixelWidth; i++)
                pBuffer[bottomY * wb.PixelWidth + i] = greenArgb;
        
        // 画左边边框
        for (int i = y; i < y + height && i < wb.PixelHeight; i++)
            pBuffer[i * wb.PixelWidth + x] = greenArgb;
        
        // 画右边边框
        int rightX = x + width - 1;
        if (rightX < wb.PixelWidth)
            for (int i = y; i < y + height && i < wb.PixelHeight; i++)
                pBuffer[i * wb.PixelWidth + rightX] = greenArgb;
    }

    // 只更新矩形区域，减少刷新开销
    wb.AddDirtyRect(new Int32Rect(x, y, width, height));
    wb.Unlock();
}

// 最终的更新方法
public async void UpdateImage(string imageName, int[] boxData)
{
    // 后台线程处理，避免阻塞UI
    WriteableBitmap wb = await Task.Run(() =>
    {
        WriteableBitmap writeableBitmap = LoadImageToWriteableBitmap(imageName);
        if (boxData.Length != 0)
        {
            int newXC = boxData[0] - (boxData[2] / 2);
            int newYC = boxData[1] - (boxData[3] / 2);
            newXC = Math.Max(newXC, 0);
            newYC = Math.Max(newYC, 0);
            DrawRectangleOnWriteableBitmap(writeableBitmap, newXC, newYC, boxData[2], boxData[3]);
        }
        return writeableBitmap;
    });

    // UI线程更新图像源
    Application.Current.Dispatcher.Invoke(() => ImportImage.Source = wb);
}

4. 额外优化：帧缓存与预加载 #

磁盘IO是另一个隐形瓶颈，你可以：

• 预加载后续5-10帧到内存（比如在播放当前帧时，后台加载下几帧）
• 缓存已处理过的帧（如果有重复播放需求）

这些策略能把磁盘读取时间分摊到空闲时段，进一步稳定帧率。

内容的提问来源于stack exchange，提问作者ChaseRatliff