如何让我的屏幕录像程序识别屏幕截图之间的差异并仅保留不一样的屏幕截图？

Question

我正在制作一台录像机，该应用程序通过截取大量屏幕截图并将它们放在一个视频中来工作。 另外，我正在尝试制作屏幕运动检测之类的东西。 仅当检测到屏幕差异时，我才需要该应用程序截取屏幕截图。 我正在考虑如何做到这一点，我相信我需要让它仍然截屏，但同时将它们与上一个进行比较。 我真的需要关于如何编写这样的代码的帮助，因为我无法理解它。

下面是我的代码。

using System.IO;
using System.Drawing;
using System.Diagnostics;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Runtime.InteropServices;

using Accord.Video.FFMPEG;

namespace BenScreenRecorder
{
    class ScreenRecorder
    {
        //Video variables:
        private Rectangle bounds;
        private string outputPath = "";
        private string tempPath = "";
        private int fileCount = 1;
        private List<string> inputImageSequence = new List<string>();

        //File variables:
        private string audioName = "mic.wav";
        private string videoName = "video.mp4";
        private string finalName = "FinalVideo.mp4";

        //Time variable:
        Stopwatch watch = new Stopwatch();

        //Audio variables:
        public static class NativeMethods
        {
            [DllImport("winmm.dll", EntryPoint = "mciSendStringA", ExactSpelling = true, CharSet = CharSet.Ansi, SetLastError = true)]
            public static extern int record(string lpstrCommand, string lpstrReturnString, int uReturnLength, int hwndCallback);
        }

        //ScreenRecorder Object:
        public ScreenRecorder(Rectangle b, string outPath)
        {
            //Create temporary folder for screenshots:
            CreateTempFolder("tempScreenCaps");

            //Set variables:
            bounds = b;
            outputPath = outPath;
        }

        //Create temporary folder:
        private void CreateTempFolder(string name)
        {
            //Check if a C or D drive exists:
            if (Directory.Exists("D://"))
            {
                string pathName = $"D://{name}";
                Directory.CreateDirectory(pathName);
                tempPath = pathName;
            }
            else
            {
                string pathName = $"C://Documents//{name}";
                Directory.CreateDirectory(pathName);
                tempPath = pathName;
            }
        }

        //Change final video name:
        public void setVideoName(string name)
        {
            finalName = name;
        }

        //Delete all files and directory:
        private void DeletePath(string targetDir)
        {
            string[] files = Directory.GetFiles(targetDir);
            string[] dirs = Directory.GetDirectories(targetDir);

            //Delete each file:
            foreach (string file in files)
            {
                File.SetAttributes(file, FileAttributes.Normal);
                File.Delete(file);
            }

            //Delete the path:
            foreach (string dir in dirs)
            {
                DeletePath(dir);
            }

            Directory.Delete(targetDir, false);
        }

        //Delete all files except the one specified:
        private void DeleteFilesExcept(string targetDir, string excDir)
        {
            string[] files = Directory.GetFiles(targetDir);

            //Delete each file except specified:
            foreach (string file in files)
            {
                if (file != excDir)
                {
                    File.SetAttributes(file, FileAttributes.Normal);
                    File.Delete(file);
                }
            }
        }

        //Clean up program on crash:
        public void cleanUp()
        {
            if (Directory.Exists(tempPath))
            {
                DeletePath(tempPath);
            }
        }

        //Return elapsed time:
        public string getElapsed()
        {
            return string.Format("{0:D2}:{1:D2}:{2:D2}", watch.Elapsed.Hours, watch.Elapsed.Minutes, watch.Elapsed.Seconds);
        }

        //Record video:
        public void RecordVideo()
        {
            //Keep track of time:
            watch.Start();

            using (Bitmap bitmap = new Bitmap(bounds.Width, bounds.Height))
            {
                using (Graphics g = Graphics.FromImage(bitmap))
                {
                    //Add screen to bitmap:
                    g.CopyFromScreen(new Point(bounds.Left, bounds.Top), Point.Empty, bounds.Size);
                }
                //Save screenshot:

                string name = tempPath + "//screenshot-" + fileCount + ".png";
                bitmap.Save(name, ImageFormat.Png);
                inputImageSequence.Add(name);
                fileCount++;

                //Dispose of bitmap:
                bitmap.Dispose();
            }
        }


        //Record audio:
        public void RecordAudio()
        {
            NativeMethods.record("open new Type waveaudio Alias recsound", "", 0, 0);
            NativeMethods.record("record recsound", "", 0, 0);
        }

        //Save audio file:
        private void SaveAudio()
        {
            string audioPath = "save recsound " + outputPath + "//" + audioName;
            NativeMethods.record(audioPath, "", 0, 0);
            NativeMethods.record("close recsound", "", 0, 0);
        }

        //Save video file:
        private void SaveVideo(int width, int height, int frameRate)
        {
            using (VideoFileWriter vFWriter = new VideoFileWriter())
            {
                //Create new video file:
                vFWriter.Open(outputPath + "//" + videoName, width, height, frameRate, VideoCodec.MPEG4);

                //Make each screenshot into a video frame:
                foreach (string imageLocation in inputImageSequence)
                {
                    Bitmap imageFrame = System.Drawing.Image.FromFile(imageLocation) as Bitmap;
                    vFWriter.WriteVideoFrame(imageFrame);
                    imageFrame.Dispose();
                }

                //Close:
                vFWriter.Close();
            }
        }

        //Combine video and audio files:
        private void CombineVideoAndAudio(string video, string audio)
        {
            //FFMPEG command to combine video and audio:
            string args = $"/c ffmpeg -i \"{video}\" -i \"{audio}\" -shortest {finalName}";
            ProcessStartInfo startInfo = new ProcessStartInfo
            {
                CreateNoWindow = false,
                FileName = "cmd.exe",
                WorkingDirectory = outputPath,
                Arguments = args
            };

            //Execute command:
            using (Process exeProcess = Process.Start(startInfo))
            {
                exeProcess.WaitForExit();
            }
        }

        public void Stop()
        {
            //Stop watch:
            watch.Stop();

            //Video variables:
            int width = bounds.Width;
            int height = bounds.Height;
            int frameRate = 10;

            //Save audio:
            SaveAudio();

            //Save video:
            SaveVideo(width, height, frameRate);

            //Combine audio and video files:
            CombineVideoAndAudio(videoName, audioName);

            //Delete the screenshots and temporary folder:
            DeletePath(tempPath);

            //Delete separated video and audio files:
            DeleteFilesExcept(outputPath, outputPath + "\\" + finalName);
        }
    }
}

Answer 1

我有一些东西可能对你有用。 这个想法是只保存图像之间的差异，然后从起始图像和保存的更改中重新创建所有图像。

为此，您只需对图像字节进行 XOR 操作。 此方法允许您获取两个图像之间的差异（ array参数）：

protected void ApplyXor(Bitmap img1, Bitmap img2, byte[] array)
{
    const ImageLockMode rw = ImageLockMode.ReadWrite;
    const PixelFormat argb = PixelFormat.Format32bppArgb;

    var locked1 = img1.LockBits(new Rectangle(0, 0, img1.Width, img1.Height), rw, argb);
    var locked2 = img2.LockBits(new Rectangle(0, 0, img2.Width, img2.Height), rw, argb);

    try
    {
        ApplyXor(locked2, locked1, array);
    }
    finally
    {
        img1.UnlockBits(locked1);
        img2.UnlockBits(locked2);
    }
}

使用之前的img1位图和返回的array ，您可以使用以下方法获取img2 ：

protected void ApplyXor(Bitmap img1, byte[] array, Bitmap img2)
{
    const ImageLockMode rw = ImageLockMode.ReadWrite;
    const PixelFormat argb = PixelFormat.Format32bppArgb;

    var locked1 = img1.LockBits(new Rectangle(0, 0, img1.Width, img1.Height), rw, argb);
    var locked2 = img2.LockBits(new Rectangle(0, 0, img2.Width, img2.Height), rw, argb);

    try
    {
        ApplyXor(locked1, array, locked2);
    }
    finally
    {
        img1.UnlockBits(locked1);
        img2.UnlockBits(locked2);
    }
}

这里还有其他必需的方法：

private unsafe void ApplyXor(BitmapData img1, BitmapData img2, byte[] array)
{
    byte* prev0 = (byte*)img1.Scan0.ToPointer();
    byte* cur0 = (byte*)img2.Scan0.ToPointer();

    int height = img1.Height;
    int width = img1.Width;
    int halfwidth = width / 2;

    fixed (byte* target = array)
    {
        ulong* dst = (ulong*)target;

        for (int y = 0; y < height; ++y)
        {
            ulong* prevRow = (ulong*)(prev0 + img1.Stride * y);
            ulong* curRow = (ulong*)(cur0 + img2.Stride * y);

            for (int x = 0; x < halfwidth; ++x)
            {
                if (curRow[x] != prevRow[x])
                {
                    int a = 0;
                }

                *(dst++) = curRow[x] ^ prevRow[x];
            }
        }
    }
}

private unsafe void ApplyXor(BitmapData img1, byte[] array, BitmapData img2)
{
    byte* prev0 = (byte*)img1.Scan0.ToPointer();
    byte* cur0 = (byte*)img2.Scan0.ToPointer();

    int height = img1.Height;
    int width = img1.Width;
    int halfwidth = width / 2;

    fixed (byte* target = array)
    {
        ulong* dst = (ulong*)target;

        for (int y = 0; y < height; ++y)
        {
            ulong* prevRow = (ulong*)(prev0 + img1.Stride * y);
            ulong* curRow = (ulong*)(cur0 + img2.Stride * y);

            for (int x = 0; x < halfwidth; ++x)
            {
                curRow[x] = *(dst++) ^ prevRow[x];
            }
        }
    }
}

注意：您必须将项目配置为允许不安全。

使用以前的方法，您可以执行以下操作：

• 保存 img1 位图
• 获取img2位图，异或得到数组（例如array2）
• 使用 img3，获取与 img2 的 XOR（例如，array3）。 现在，不需要 img2
• 使用 img4，获得与 img3 (array4) 的 XOR。 现在，不需要 img3
• ...

您有 img1 和 array2、array3、array4...，您可以重新创建所有图像：

• 在 img1 和 array2 之间进行异或得到 img2
• 在img2和array3之间进行异或得到img3
• ...

如果您需要通过 TCP 发送视频，您可以发送图像发送一个图像和 XOR 数组（差异）。 或者更好的是，使用 K4os.Compression.LZ4 压缩 XOR 数组。