【问题标题】:Unsafe Per Pixel access, 30ms access for 1756000 pixels不安全的每像素访问,30ms 访问 1756000 像素
【发布时间】:2009-05-21 14:42:39
【问题描述】:

因此,我一直在我的网站上就上述主题标题分享一些关于快速、不安全的像素访问的想法。一位先生给了我一个粗略的例子,说明他如何在 C++ 中做到这一点,但这对我在 C# 中没有帮助,除非我可以互操作,而且互操作也很快。我在互联网上找到了一个使用 MSDN 帮助编写的类,用于不安全地访问像素。上课速度特别快,但还不够快。这是课程:

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;

namespace DCOMProductions.Desktop.ScreenViewer {
public unsafe class UnsafeBitmap {
    Bitmap bitmap;

    // three elements used for MakeGreyUnsafe
    int width;
    BitmapData bitmapData = null;
    Byte* pBase = null;

    public UnsafeBitmap(Bitmap bitmap) {
        this.bitmap = new Bitmap(bitmap);
    }

    public UnsafeBitmap(int width, int height) {
        this.bitmap = new Bitmap(width, height, PixelFormat.Format32bppArgb);
    }

    public void Dispose() {
        bitmap.Dispose();
    }

    public Bitmap Bitmap {
        get {
            return (bitmap);
        }
    }

    private Point PixelSize {
        get {
            GraphicsUnit unit = GraphicsUnit.Pixel;
            RectangleF bounds = bitmap.GetBounds(ref unit);

            return new Point((int)bounds.Width, (int)bounds.Height);
        }
    }

    public void LockBitmap() {
        GraphicsUnit unit = GraphicsUnit.Pixel;
        RectangleF boundsF = bitmap.GetBounds(ref unit);
        Rectangle bounds = new Rectangle((int)boundsF.X,
      (int)boundsF.Y,
      (int)boundsF.Width,
      (int)boundsF.Height);

        // Figure out the number of bytes in a row
        // This is rounded up to be a multiple of 4
        // bytes, since a scan line in an image must always be a multiple of 4 bytes
        // in length. 
        width = (int)boundsF.Width * sizeof(Pixel);
        if (width % 4 != 0) {
            width = 4 * (width / 4 + 1);
        }
        bitmapData =
      bitmap.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);

        pBase = (Byte*)bitmapData.Scan0.ToPointer();
    }

    public Pixel GetPixel(int x, int y) {
        Pixel returnValue = *PixelAt(x, y);
        return returnValue;
    }

    public void SetPixel(int x, int y, Pixel colour) {
        Pixel* pixel = PixelAt(x, y);
        *pixel = colour;
    }

    public void UnlockBitmap() {
        bitmap.UnlockBits(bitmapData);
        bitmapData = null;
        pBase = null;
    }
    public Pixel* PixelAt(int x, int y) {
        return (Pixel*)(pBase + y * width + x * sizeof(Pixel));
    }
}

}

基本上我正在做的是复制整个屏幕并将每个像素与旧副本进行比较。在 1680x1050 位图上,使用以下代码大约需要 300 毫秒。

private Bitmap GetInvalidFrame(Bitmap frame) {
        Stopwatch sp = new Stopwatch();
        sp.Start();

        if (m_FrameBackBuffer == null) {
            return frame;
        }

        Int32 pixelsToRead = frame.Width * frame.Height;
        Int32 x = 0, y = 0;

        UnsafeBitmap unsafeBitmap = new UnsafeBitmap(frame);
        UnsafeBitmap unsafeBuffBitmap = new UnsafeBitmap(m_FrameBackBuffer);
        UnsafeBitmap retVal = new UnsafeBitmap(frame.Width, frame.Height);

        unsafeBitmap.LockBitmap();
        unsafeBuffBitmap.LockBitmap();
        retVal.LockBitmap();

        do {
            for (x = 0; x < frame.Width; x++) {
                Pixel newPixel = unsafeBitmap.GetPixel(x, y);
                Pixel oldPixel = unsafeBuffBitmap.GetPixel(x, y);

                if (newPixel.Alpha != oldPixel.Alpha || newPixel.Red != oldPixel.Red || newPixel.Green != oldPixel.Green || newPixel.Blue != oldPixel.Blue) {
                   retVal.SetPixel(x, y, newPixel);
                }
                else {
                    // Skip pixel
                }
            }

            y++;
        } while (y != frame.Height);

        unsafeBitmap.UnlockBitmap();
        unsafeBuffBitmap.UnlockBitmap();
        retVal.UnlockBitmap();

        sp.Stop();

        System.Diagnostics.Debug.WriteLine(sp.Elapsed.Milliseconds.ToString());

        sp.Reset();

        return retVal.Bitmap;
    }

是否有任何可能的方法/手段/方法可以将其加速到大约 30 毫秒?我可以使用 Graphics.CopyFromScreen() 在大约 30 毫秒内复制屏幕,从而每秒产生大约 30 帧。但是,一个程序的运行速度与其较慢的对应程序一样快,因此 GetInvalidFrame 中的 300 毫秒延迟将其减慢到每秒大约 1 - 3 帧。这不适合会议软件。

任何朝着正确方向的建议、方法和指示都将非常棒!此外,用于在客户端绘制位图的代码也在下面。

评论 Dmitriy 的回答/评论:

#region RootWorkItem

    private ScreenClient m_RootWorkItem;
    /// <summary>
    /// Gets the RootWorkItem
    /// </summary>
    public ScreenClient RootWorkItem {
        get {
            if (m_RootWorkItem == null) {
                m_RootWorkItem = new ScreenClient();
                m_RootWorkItem.FrameRead += new EventHandler<FrameEventArgs>(RootWorkItem_FrameRead);
            }
            return m_RootWorkItem;
        }
    }

    #endregion

    private void RootWorkItem_FrameRead(Object sender, FrameEventArgs e) {
        if (e.Frame != null) {
            if (uxSurface.Image != null) {
                Bitmap frame = (Bitmap)uxSurface.Image;

                Graphics g = Graphics.FromImage(frame);
                g.DrawImage(e.Frame, 0, 0); // Draw only updated pixels

                uxSurface.Image = frame;
            }
            else {
                uxSurface.Image = e.Frame; // Draw initial, full image
            }
        }
        else {
            uxSurface.Image = null;
        }
    }

【问题讨论】:

  • 请注意,如果您尝试执行远程桌面之类的操作,则不是通过比较位图来确定要发送给客户端的内容。它在将绘图命令写入屏幕之前拦截它们。
  • 看看你是否在opensubscriber.com/message/dotnet-cx@discuss.develop.com/…的线程中找到任何有用的提示。
  • @David:我想起了一些远程桌面软件用来处理与您描述的问题类似的计算机的策略:以较低的像素深度发送显示信息。如果您使用 8 位图形(至少对于比较部分),您的比较运行速度会快 4 倍。
  • @David Anderson:dreamincode.net/code/snippet2859.htm 非常快,但它确实使用了哈希。它还允许您在不编写自己的不安全代码的情况下获取字节数组(耶)。
  • 教程解释了在 GDI+ 中使用 unsafe:codeproject.com/KB/GDI-plus/csharpgraphicfilters11.aspx

标签: c# performance gdi+


【解决方案1】:

使用整数而不是像素和单循环的不安全方法:

private static Bitmap GetInvalidFrame(Bitmap oldFrame, Bitmap newFrame)
{
    if (oldFrame.Size != newFrame.Size)
    {
        throw new ArgumentException();
    }
    Bitmap result = new Bitmap(oldFrame.Width, oldFrame.Height, oldFrame.PixelFormat);

    Rectangle lockArea = new Rectangle(Point.Empty, oldFrame.Size);
    PixelFormat format = PixelFormat.Format32bppArgb;
    BitmapData oldData = oldFrame.LockBits(lockArea, ImageLockMode.ReadOnly, format);
    BitmapData newData = newFrame.LockBits(lockArea, ImageLockMode.ReadOnly, format);
    BitmapData resultData = result.LockBits(lockArea, ImageLockMode.WriteOnly, format);

    int len = resultData.Height * Math.Abs(resultData.Stride) / 4;

    unsafe
    {
        int* pOld = (int*)oldData.Scan0;
        int* pNew = (int*)newData.Scan0;
        int* pResult = (int*)resultData.Scan0;

        for (int i = 0; i < len; i++)
        {
            int oldValue = *pOld++;
            int newValue = *pNew++;
            *pResult++ = oldValue != newValue ? newValue : 0 /* replace with 0xff << 24 if you need non-transparent black pixel */;
            // *pResult++ = *pOld++ ^ *pNew++; // if you can use XORs.
        }
    }

    oldFrame.UnlockBits(oldData);
    newFrame.UnlockBits(newData);
    result.UnlockBits(resultData);

    return result;
}

我认为你真的可以在这里使用 XORed 帧,我希望这可以在双方都有更好的性能。

    private static void XorFrames(Bitmap leftFrame, Bitmap rightFrame)
    {
        if (leftFrame.Size != rightFrame.Size)
        {
            throw new ArgumentException();
        }

        Rectangle lockArea = new Rectangle(Point.Empty, leftFrame.Size);
        PixelFormat format = PixelFormat.Format32bppArgb;
        BitmapData leftData = leftFrame.LockBits(lockArea, ImageLockMode.ReadWrite, format);
        BitmapData rightData = rightFrame.LockBits(lockArea, ImageLockMode.ReadOnly, format);

        int len = leftData.Height * Math.Abs(rightData.Stride) / 4;

        unsafe
        {
            int* pLeft = (int*)leftData.Scan0;
            int* pRight = (int*)rightData.Scan0;

            for (int i = 0; i < len; i++)
            {
                *pLeft++ ^= *pRight++;
            }
        }

        leftFrame.UnlockBits(leftData);
        rightFrame.UnlockBits(rightData);
    }

您可以通过以下方式在两侧使用此过程:
在服务器端,您需要评估新旧框架之间的差异,将其发送给客户端并用新框架替换旧框架。服务器代码应如下所示:

  XorFrames(oldFrame, newFrame); // oldFrame ^= newFrame
  Send(oldFrame); // send XOR of two frames
  oldFrame = newFrame;

在客户端,您需要使用从服务器接收到的异或帧更新当前帧:

  XorFrames((Bitmap)uxSurface.Image, e.Frame);

【讨论】:

  • 调用 Graphics.CopyFromScreen 后,我在位图上调用 GetInvalidFrame 以将像素与屏幕的旧副本进行比较。对于每个“未”更改的像素,我删除该像素。最终结果是一个仅包含更改像素的透明位图,以及大约 4000 字节的图像。所以这是轻量级的,可以跨网络使用。最大的问题是我需要在大约 30 毫秒内比较所有 17~00 万像素,这样我才能产生 30 fps 的速度发送给客户端。如果 1 帧 = 4kb,4*30 = 120kb,则 1.5mbit 连接足以使用 1680x1050 发送 30fps。在局域网上,这会更好
  • 好吧,我会被诅咒的。这给了我 10 - 30 毫秒。你不知道我多么感激你为我所做的一切。太棒了!
  • 如何在客户端绘制这些位图?
  • 基本上我有一个当然可以接收所有字节的套接字。解压缩 GZipped 位图,然后将其发送到名为 FrameRead 的事件。评论不能包含代码,所以我会在这个上面贴一个答案
  • 我尝试实现 Xor 客户端,但它似乎没有更新图像。在调用 xor 之前,我还在客户端上制作了旧位图的副本,然后将副本绘制回来,但它会严重闪烁并留下无效像素。可能我没有在客户端正确实现它,使用 xor 服务器端并绘制它我以前的样子也很好。
【解决方案2】:

这里:Utilizing the GPU with c# 提到了一些从 C# 使用 GPU 的库。

【讨论】:

  • 现在我正试图避免使用 GPU,因为我在该领域没有太多知识。我在找到有关如何使用 MManaged DirectX 使用 GPU 比较像素的任何资源方面并没有太成功。我避免这样做的另一个原因是因为我不打算在我的应用程序中包含任何第三方库。不过,我非常重视该链接,我将研究 Microsoft Accelerator。很好的资源,感谢您指出我的方向
【解决方案3】:

是的,您可以使用unsafe 代码来实现。

BitmapData d = l.LockBits(new Rectangle(0, 0, l.Width, l.Height), ImageLockMode.ReadOnly,l.PixelFormat);
IntPtr scan = d.Scan0;
unsafe
{
    byte* p = (byte*)(void*)scan;
    //dostuff               
}

查看http://www.codeproject.com/KB/GDI-plus/csharpgraphicfilters11.aspx 了解此类内容的一些基本示例。我的代码就是以此为基础的。

注意: 这比您的要快得多的原因之一是您分别比较每个通道,而不是仅使用一个操作比较整个字节。同样,将 PixelAt 更改为给您一个字节以促进这一点可能会给您带来改进。

【讨论】:

  • 是的,这与 unsafebitmap 的工作方式相同。但是直接使用这个东西会更快。如果您利用现在直接使用内存并使用一次比较多个字节的操作这一事实,您可能会获得更快的结果。
  • 一个像素由四个字节组成(四个通道 = 红色、绿色、蓝色、alpha),要获得准确的比较,您必须比较所有四个字节。我不知道有什么方法可以同时比较所有四个,即使底层代码与我已经拥有的代码相同。除非我错过了你的意思 ARGB 蓝色 = 第一个字节绿色 = 第二个字节红色 = 第三个字节 Alpha = 第四个字节 但是我确实尝试比较每个循环最多 30 个像素,但性能只增加了大约 60 毫秒,并且仍然坐在附近240ms,还是很慢
  • @David:您使用长指针同时比较所有 4 个,并在每一步递增 4。
  • 哦,酷。可以(请,呵呵)你给我看一个关于如何做到这一点的简短例子吗?到目前为止,还没有在 C# 中深入使用过指针。
  • 我也没有,但你应该可以只替换 byte* p = (byte*)(void*)scan;用 long* p = (long*)(void*)scan; .您将使用 p[0] 来引用 th elong 并将 p 设置为 p + 4 以处理下一个像素。也就是说,通过转换为 long 而不是 Pixel 来更改 unsafebitmap 以返回 long 会更简单(这不太通用;如果您的像素不完全是 32 位,它将中断)。
【解决方案4】:

您可以只对 2 个位图进行基本的内存比较,而不是检查每个像素。在 C 中,类似于 memcmp()。

这会给您一个更快的测试,让您知道图像是否相同。只有当您知道它们不同时,您才需要使用更昂贵的代码来帮助您确定它们的不同之处(如果您甚至需要知道的话)。

虽然我不是 C# 人,所以我不知道访问原始内存有多容易。

【讨论】:

  • 由于这是会议软件,屏幕会发生很大变化,所以我必须比较像素,只将变化的像素写入输出帧发送给客户端。这并不是真正可以避免的,因为进行每像素比较是为网络旅行获得最佳位图大小的唯一方法
【解决方案5】:

能够减少大约 60 毫秒。我认为这将需要 GPU。我没有看到任何使用 CPU 的解决方案,即使一次比较多个字节/像素,除非有人可以编写代码示例来向我展示。仍然停留在大约 200-260 毫秒,对于 30 fps 来说太慢了。

private static BitmapData m_OldData;
private static BitmapData m_NewData;
private static unsafe Byte* m_OldPBase;
private static unsafe Byte* m_NewPBase;
private static unsafe Pixel* m_OldPixel;
private static unsafe Pixel* m_NewPixel;
private static Int32 m_X;
private static Int32 m_Y;
private static Stopwatch m_Watch = new Stopwatch();
private static GraphicsUnit m_GraphicsUnit = GraphicsUnit.Pixel;
private static RectangleF m_OldBoundsF;
private static RectangleF m_NewBoundsF;
private static Rectangle m_OldBounds;
private static Rectangle m_NewBounds;
private static Pixel m_TransparentPixel = new Pixel() { Alpha = 0x00, Red = 0, Green = 0, Blue = 0 };

private Bitmap GetInvalidFrame(Bitmap frame) {
    if (m_FrameBackBuffer == null) {
        return frame;
    }

    m_Watch.Start();

    unsafe {
        m_OldBoundsF = m_FrameBackBuffer.GetBounds(ref m_GraphicsUnit);
        m_OldBounds = new Rectangle((Int32)m_OldBoundsF.X, (Int32)m_OldBoundsF.Y, (Int32)m_OldBoundsF.Width, (Int32)m_OldBoundsF.Height);
        m_OldData = m_FrameBackBuffer.LockBits(m_OldBounds, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);

        m_NewBoundsF = m_FrameBackBuffer.GetBounds(ref m_GraphicsUnit);
        m_NewBounds = new Rectangle((Int32)m_NewBoundsF.X, (Int32)m_NewBoundsF.Y, (Int32)m_NewBoundsF.Width, (Int32)m_NewBoundsF.Height);
        m_NewData = frame.LockBits(m_NewBounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);

        m_OldPBase = (Byte*)m_OldData.Scan0.ToPointer();
        m_NewPBase = (Byte*)m_NewData.Scan0.ToPointer();

        do {
            for (m_X = 0; m_X < frame.Width; m_X++) {

                m_OldPixel = (Pixel*)(m_OldPBase + m_Y * m_OldData.Stride + 1 + m_X * sizeof(Pixel));
                m_NewPixel = (Pixel*)(m_NewPBase + m_Y * m_NewData.Stride + 1 + m_X * sizeof(Pixel));

                if (m_OldPixel->Alpha == m_NewPixel->Alpha // AccessViolationException accessing Property in get {}
                    || m_OldPixel->Red == m_NewPixel->Red
                    || m_OldPixel->Green == m_NewPixel->Green
                    || m_OldPixel->Blue == m_NewPixel->Blue) {

                    // Set the transparent pixel
                    *m_NewPixel = m_TransparentPixel;
                }
            }

            m_Y++; //Debug.WriteLine(String.Format("X: {0}, Y: {1}", m_X, m_Y));
        } while (m_Y < frame.Height);
    }

    m_Y = 0;

    m_Watch.Stop();
    Debug.WriteLine("Time elapsed: " + m_Watch.ElapsedMilliseconds.ToString());
    m_Watch.Reset();

    return frame;
}

【讨论】:

  • 这个“像素”结构从何而来?
猜你喜欢
  • 1970-01-01
  • 1970-01-01
  • 2013-05-21
  • 2015-11-12
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
相关资源
最近更新 更多