Захват рабочего стола, сделать его 256 цветов и отправить его через Интернет

Question

Я работаю над проектом, и в этом проекте мне нужно сделать снимок экрана рабочего стола и отправить его через Интернет другому клиенту. Чтобы сжать изображение, я хочу преобразовать его в 256-цветное изображение. У меня есть общая 256 цветовая палитра, и я использую евклидово расстояние, чтобы найти ближайший цвет. Проблема в том, что мне нужно отправлять эти изображения со скоростью 10-15 кадров в секунду, а создание 256-цветного изображения занимает 7 секунд. Мне интересно, как другие программы (например, teamviewer или настоящий VNC) делают это.

for (int y=0;y<900;y++) //loop through the height
     for (int x=0;x<1600;x++) //loop through the width
         for (int p=0;p<256;p++) //loop through palette colors
             {
                calculate Euclidean distance of each pixel for each color in pallette and 
                 find the nearest color
                 ** these nested loops take 7 seconds to complete
             }

Спасибо

Answer 1

ХОРОШО. После нескольких дней борьбы со многими методами съемки и цветовыми квантизаторами я наконец нашел решение. Теперь я могу отправить все изображение рабочего стола со скоростью 10~14 FPS и изменить области рабочего стола со скоростью 20~30 FPS.

В коде я использовал классы rcravens для захвата экрана и изменений экрана. Затем я обрезал изображение до 10 кусочков. После этого я взял маленькие кусочки и сделал их 256-цветными, используя объясненный здесь Octree Color Quantizier, благодаря @Dai, который указал мне на это направление. После уменьшения цвета я преобразовал каждый кусок в байтовый массив и сжал их, используя библиотеку LZ4.Net.

Вот код:

    int all_count = 0;
    Bitmap _desktop = null;

    Bitmap _merged_bitmap = new Bitmap(1600, 900);

    int _height_part_ = 0;
    int _total_rows = 10;
    Bitmap[] crops = null;
    Bitmap[] _new_crops = null;
    Stopwatch sw = new Stopwatch();

    int _desktop_height = 0;
    int _desktop_width = 0;

    ImageManipulation.OctreeQuantizer _q ;
    RLC.RemoteDesktop.ScreenCapture cap = new RLC.RemoteDesktop.ScreenCapture();



   private void CaptureAndSend()
    {
        sw.Restart();

        //cap = new RLC.RemoteDesktop.ScreenCapture();

        int _left = -1, _top = -1; //Changed regions
        _desktop = cap.Screen(out _left, out _top); //Capture desktop or changed region of it

        if (_desktop == null) return; //if nothing has changed since last capture skip everything

        _desktop_height = _desktop.Height;
        _desktop_width = _desktop.Width;

        // If very small part has changed since last capture skip everything
        if (_desktop_height < 10 || _desktop_width < 10) return; 

        TotalRows(_total_rows); // Calculate the total number of rows 

        crops = new Bitmap[_total_rows]; // Cropped pieces of image
        _new_crops = new Bitmap[_total_rows];

        for (int i = 0; i < _total_rows - 1; i++) //Take whole image and split it into smaller images
            crops[i] = CropRow(i);
        crops[_total_rows - 1] = CropLastRow(_total_rows - 1);


        Parallel.For(0, _total_rows, i =>
        {
            ImageManipulation.OctreeQuantizer _q = new ImageManipulation.OctreeQuantizer(255, 4); // Initialize Octree
            _new_crops[i] = _q.Quantize(crops[i]);

            using (MemoryStream ms=new MemoryStream())
            { 
                _new_crops[i].Save(ms, ImageFormat.Png);
                //Install-Package LZ4.net
                //Compress each part and send them over network
                byte[] data = Lz4Net.Lz4.CompressBytes(ms.ToArray(), Lz4Net.Lz4Mode.HighCompression);

                all_count += data.Length; //Just to check the final size of image
            }                  
        });



        Console.WriteLine(String.Format("{0:0.0} FPS , {1} seconds , size {2} kb", 1.0 / sw.Elapsed.TotalSeconds, sw.Elapsed.TotalSeconds.ToString(), all_count / 1024));
        all_count = 0;

    }
    private void TotalRows(int parts)
    {
        _height_part_ = _desktop_height / parts;
    }
    private Bitmap CropRow(int row)
    {
        return Crop(_desktop, new Rectangle(0, row * _height_part_, _desktop_width, _height_part_));
    }
    private Bitmap CropLastRow(int row)
    {
        return Crop(_desktop, new Rectangle(0, row * _height_part_, _desktop_width, _desktop_height - (row * _height_part_)));
    }
 [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
    private unsafe static extern int memcpy(byte* dest, byte* src, long count);

    private unsafe Bitmap Crop(Bitmap srcImg, Rectangle rectangle)
    {
        if ((srcImg.Width == rectangle.Width) && (srcImg.Height == rectangle.Height))
            return srcImg;

        var srcImgBitmapData = srcImg.LockBits(new Rectangle(0, 0, srcImg.Width, srcImg.Height), ImageLockMode.ReadOnly, srcImg.PixelFormat);
        var bpp = srcImgBitmapData.Stride / srcImgBitmapData.Width; // 3 or 4
        var srcPtr = (byte*)srcImgBitmapData.Scan0.ToPointer() + rectangle.Y * srcImgBitmapData.Stride + rectangle.X * bpp;
        var srcStride = srcImgBitmapData.Stride;

        var dstImg = new Bitmap(rectangle.Width, rectangle.Height, srcImg.PixelFormat);
        var dstImgBitmapData = dstImg.LockBits(new Rectangle(0, 0, dstImg.Width, dstImg.Height), ImageLockMode.WriteOnly, dstImg.PixelFormat);
        var dstPtr = (byte*)dstImgBitmapData.Scan0.ToPointer();
        var dstStride = dstImgBitmapData.Stride;

        for (int y = 0; y < rectangle.Height; y++)
        {
            memcpy(dstPtr, srcPtr, dstStride);
            srcPtr += srcStride;
            dstPtr += dstStride;
        }

        srcImg.UnlockBits(srcImgBitmapData);
        dstImg.UnlockBits(dstImgBitmapData);
        return dstImg;
    }

Я знаю, что мой код не эффективен для памяти. Буду признателен, если кто-нибудь поможет мне оптимизировать этот код. Еще раз спасибо моим друзьям А. Абрамову, Даю, ХансПассанту, Тау и другим.

Answer 2

РЕДАКТИРОВАТЬ 2: я полностью удалил свой старый пост, потому что он не был актуален! 256, я думал, вы имели в виду 256 бит - а вы говорите о 256 байтах! Я понял, что, вставив в свой калькулятор ваши оригинальные900 x 900) и умножение на 256 для цвета. Результат был 20,7360,000 биты, что примерно 2.5 MB, Сжатый, это может достигать около 1 MB - в то время как битовый цвет эквивалентен (делится на 8) будет 300 KB база и сжатый будет намного меньше. Решение простое - это действительно занимает много времени, чтобы получить такое изображение. Большинство приложений, о которых вы говорите, таких как teamviewer, имеют более низкое FPS и намного более низкое качество изображения, в зависимости от производительности компьютера. Таким образом, я извиняюсь - но решение состоит в том, что, вероятно, невозможно сделать это в то время, когда вы запросили компьютер, подобный вашему.

РЕДАКТИРОВАТЬ 3: Ганс сделал математику в комментариях под вашим вопросом - мы говорим о 22 GB, Это не нормальная работа для среднего компьютера. Это не невозможно, но, начиная с 2015 года, домашний компьютер часто не обрабатывает столько данных за секунду.