Beispiel #1
0
        CPPFrameBufferData GetFrame()
        {
            CPPFrameBufferData frame = new CPPFrameBufferData();

            using (Bitmap bmp = new Bitmap(FileList[FileCount]))
            {
                using (Bitmap fb = new Bitmap(bmp.Width, bmp.Height, PixelFormat.Format32bppRgb))
                {
                    using (Graphics gra = Graphics.FromImage(fb))
                    {
                        gra.DrawImageUnscaled(bmp, 0, 0);
                    }

                    BitmapData bmpd  = fb.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppRgb);
                    byte[]     bytes = new byte[bmpd.Stride * bmpd.Height];
                    Marshal.Copy(bmpd.Scan0, bytes, 0, bmpd.Stride * bmpd.Height);
                    fb.UnlockBits(bmpd);
                    frame.CursorX = 5;
                    frame.CursorY = 5;
                    frame.Data    = bytes;
                    frame.X       = fb.Width;
                    frame.Y       = fb.Height;
                }
            }
            FileCount++;
            return(frame);
        }
Beispiel #2
0
        public PushScreenData GetFullscreen()
        {
            MainScreenSystemClient.LastCalled = DateTime.Now;
            PushScreenData     data   = new PushScreenData();
            CPPFrameBufferData screen = ProgramAgent.CPP.GetFrameBufferData();

            if (screen == null)
            {
                data.X          = data.Y = 0;
                data.FailedCode = -1;
                return(data);
            }

            if (screen.Failed == true)
            {
                Debug.WriteLine("Screendata failed @ " + screen.FailedAt.ToString() + " 0x" + screen.Win32Error.ToString("X"));

                data.X          = data.Y = 0;
                data.FailedCode = screen.FailedAt;
                return(data);
            }

            data.X        = screen.X;
            data.Y        = screen.Y;
            data.CursorX  = screen.CursorX;
            data.CursorY  = screen.CursorY;
            data.DataType = 0;

            lock (ScreenLock)
            {
                ScreenX        = screen.X;
                ScreenY        = screen.Y;
                ScreenRawBytes = screen.Data;
            }

            try
            {
                Bitmap bmp = new Bitmap(screen.X, screen.Y, 4 * screen.X, PixelFormat.Format32bppArgb, Marshal.UnsafeAddrOfPinnedArrayElement(screen.Data, 0));

                MemoryStream      mem   = new MemoryStream();
                ImageCodecInfo    codec = GetEncoder(ImageFormat.Jpeg);
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                myEncoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 50L);

                bmp.Save(mem, codec, myEncoderParameters);
                mem.Seek(0, SeekOrigin.Begin);
                data.Data = new byte[mem.Length];
                mem.Read(data.Data, 0, (int)mem.Length);
            }
            catch (Exception ee)
            {
                Debug.WriteLine(ee.ToString());
                data.X          = data.Y = 0;
                data.FailedCode = -2;
                return(data);
            }

            return(data);
        }
Beispiel #3
0
        PushScreenData GetDeltaScreen(GetFrameBufferDataDG GetFBData)
        {
            MainScreenSystemClient.LastCalled = DateTime.Now;
            PushScreenData     data   = new PushScreenData();
            CPPFrameBufferData screen = GetFBData();

            if (screen == null)
            {
                data.X          = data.Y = 0;
                data.FailedCode = -1;
                return(data);
            }

            if (screen.Failed == true)
            {
                Debug.WriteLine("Screendata failed @ " + screen.FailedAt.ToString() + " 0x" + screen.Win32Error.ToString("X"));

                data.X          = data.Y = 0;
                data.FailedCode = screen.FailedAt;
                return(data);
            }

            lock (ScreenLock)
            {
                if (screen.X != ScreenX || screen.Y != ScreenY)
                {
                    ScreenX        = screen.X;
                    ScreenY        = screen.Y;
                    ScreenRawBytes = screen.Data;

                    try
                    {
                        Bitmap bmp = new Bitmap(screen.X, screen.Y, 4 * screen.X, PixelFormat.Format32bppArgb, Marshal.UnsafeAddrOfPinnedArrayElement(screen.Data, 0));

                        MemoryStream      mem   = new MemoryStream();
                        ImageCodecInfo    codec = GetEncoder(ImageFormat.Jpeg);
                        EncoderParameters myEncoderParameters = new EncoderParameters(1);
                        myEncoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 50L);

                        bmp.Save(mem, codec, myEncoderParameters);
                        mem.Seek(0, SeekOrigin.Begin);
                        data.Data = new byte[mem.Length];
                        mem.Read(data.Data, 0, (int)mem.Length);
                        data.CursorX = screen.CursorX;
                        data.CursorY = screen.CursorY;
                        return(data);
                    }
                    catch (Exception ee)
                    {
                        Debug.WriteLine(ee.ToString());
                        data.X          = data.Y = 0;
                        data.FailedCode = -2;
                        return(data);
                    }
                }
            }

            int BlockX   = 64;
            int BlockY   = 64;
            int VScreenX = screen.X + (BlockX - (screen.X % BlockX));
            int VScreenY = screen.Y + (BlockY - (screen.Y % BlockY));

            byte[] deltadata = new byte[screen.Data.Length];
            int    XSZ       = screen.X * 4;

            data.ChangedBlocks = new List <long>();
            data.DataType      = 1;
            data.BlockX        = BlockX;
            data.BlockY        = BlockY;
            data.X             = screen.X;
            data.Y             = screen.Y;

            lock (ScreenLock)
            {
                for (int y = 0; y < VScreenY; y += BlockY)
                {
                    for (int x = 0; x < VScreenX; x += BlockX)
                    {
                        bool Changed = false;

                        for (int by = 0; by < BlockY; by++)
                        {
                            for (int bx = 0; bx < BlockX; bx++)
                            {
                                int pos = ((by + y) * XSZ) + ((bx + x) * 4);
                                if (pos >= screen.Data.Length)
                                {
                                    continue;
                                }
                                if (BitConverter.ToInt32(screen.Data, pos) != BitConverter.ToInt32(ScreenRawBytes, pos))
                                {
                                    Changed = true;
                                    break;
                                }
                            }
                            if (Changed == true)
                            {
                                break;
                            }
                        }

                        if (Changed == true)
                        {
                            for (int by = 0; by < BlockY; by++)
                            {
                                for (int bx = 0; bx < BlockX; bx++)
                                {
                                    int pos = ((by + y) * XSZ) + ((bx + x) * 4);
                                    if (pos >= screen.Data.Length)
                                    {
                                        continue;
                                    }
                                    deltadata[pos + 0] = screen.Data[pos + 0];
                                    deltadata[pos + 1] = screen.Data[pos + 1];
                                    deltadata[pos + 2] = screen.Data[pos + 2];
                                    deltadata[pos + 3] = screen.Data[pos + 3];
                                }
                            }
                            data.ChangedBlocks.Add(((Int64)x << 32) | (Int64)y);
                        }
                    }
                }
            }

            try
            {
                Bitmap bmp = new Bitmap(screen.X, screen.Y, 4 * screen.X, PixelFormat.Format32bppArgb, Marshal.UnsafeAddrOfPinnedArrayElement(deltadata, 0));

                MemoryStream      mem   = new MemoryStream();
                ImageCodecInfo    codec = GetEncoder(ImageFormat.Jpeg);
                EncoderParameters myEncoderParameters = new EncoderParameters(1);
                myEncoderParameters.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, 50L);

                bmp.Save(mem, codec, myEncoderParameters);
                mem.Seek(0, SeekOrigin.Begin);
                data.Data = new byte[mem.Length];
                mem.Read(data.Data, 0, (int)mem.Length);

                //string Filename = "C:\\Temp\\SSDCSC-" + DateTime.Now.ToString("yyyyddMMHHmmss") + ".jpg";
                //File.WriteAllBytes(Filename, data.Data);
            }
            catch (Exception ee)
            {
                Debug.WriteLine(ee.ToString());
                data.X          = data.Y = 0;
                data.FailedCode = -2;
                return(data);
            }

            lock (ScreenLock)
            {
                ScreenX        = screen.X;
                ScreenY        = screen.Y;
                ScreenRawBytes = screen.Data;
            }

            data.CursorX = screen.CursorX;
            data.CursorY = screen.CursorY;

            return(data);
        }