Exemplo n.º 1
0
        /*run in the case of the App sharing*/
        public void captureThreadFuncEx()
        {
            try
            {
                int nBlocks=nHeightBlocks *nWidthBlocks;
                /*
                 * Intialize Mouse Relevant Stuff
                 */
                IntializeMouseCoordinates();
                /*s
                 * set windows relevant stuff,like get its rectangle,its title,activate it etc..
                 * for more detail go to method header
                 */
                SetWindowStuff();
                /*
                 * initialize imageconverter object
                 * this will be used to convert image into byte array
                 */
                conv=new ImageConverter();
                /*
                 * create window bitmap sturcture on the shared window architecture
                 */
                CreateBitmapStructureForSharedWindow();
                /*
                 * initialize the buffer
                 */
                Initialize_buffer();
                /*
                 * send picture size
                 */
                SendSizeInformation(blockWidth,blockHeight);

                // variables to contain cursor position
                Win32.USER32.POINT cursorPosition = new Win32.USER32.POINT();

                Win32.USER32.RECT temprect = new Win32.USER32.RECT();

                // screen width and height,
                // these are used later to track whether the window has gone out of the screen or not
                // blocks that are out of screen are not painted or sent
                int _nScreenWidth = Screen.PrimaryScreen.Bounds.Width;
                int _nScreenHeight = Screen.PrimaryScreen.Bounds.Height;

                //int nTemp =0;

                // start coods
                int nStartX = 0,nStartY = 0;

                // current block width and height
                //int nCurrentBlockWidth = 0,nCurrentBlockHeight=0;

                // hash of the current block
                //byte[] hash = null;

                //int nQuantizeCount=10; // set the quanization count as 10 initially

                bt = new StringBuilder(1024);

                byte[] b;

                //PitchBlack = 0xffffff

                // create brush
                int _hBrush = Win32.USER32.CreateSolidBrush(0xffffff);

                Win32.USER32.RECT _tempRect = new Win32.USER32.RECT();

                //				int nCopyX,  nCopyY;

                // this is not used anywhere so we will comment this coz this isnt used anywhere
                //int hBitmap_dummy = CreateCompatibleBitmap(hdcSrc,blockWidth,blockHeight);

                //			int nBlockNo = 0;

                OctreeQuantizer quantizer = new OctreeQuantizer(255,8);

                // When u close App share it becomes  false
                // else it remain true uptill the App share is true

                while(m_bActive) // send data only if the window is active
                {
                    try
                    {
                        /*
                         * check window exist if not found then close app share process
                         */
                        if(!bCloseAppshare())
                        {
                            break;
                        }

                        /*
                         * check working window is not shared  then flush and continue
                         */

                        //Zaeem Addition

                        // In previous case thte Sleep was not added here , so that
                        //when it reaches the continue statement, it will skip all the next statement including the
                        // for loop , so that no Sleep in the way , which makes the processing very high
                        // Yet an other Stupid piece of code
                        // Another Check which zaeem is Adding is if the current tab is Appsharing then the image shd be send and same for receiving

                        Thread.Sleep(2000);
                        if(bFlashWindow())
                        {
                            continue;
                        }

                        quantizer =new OctreeQuantizer (255,8);

                        // get server full bitmap
                        if(staticImage!=null)
                        {
                            staticImage.Dispose();
                            staticImage=null;
                        }
                        staticImage= GetServerFullBitmap();
                        /*
                         * this function check last and current coordinate then check
                         * the window coordinate
                         */

                        SendMouseMovements();

                        // If window is inactive then we flush it
                        //
                        //						if(bFlashWindow())
                        //						{
                        //							continue;
                        //							/*
                        //									again return to while loop skip all next instruction in a while
                        //									block.
                        //								*/
                        //						}

                        int length2;//=buffer_CaptureThread.Length;
                        Image _quantized;
                        if(this.staticImage!=null)
                        {
                            _quantized = quantizer.Quantize(staticImage);
                        }
                        else
                            continue;

                        // convert quantized array to byte array
                        b=null;
                        b=(byte[]) conv.ConvertTo(_quantized, typeof(byte[]));

                        length2 = b.Length;

                        // send image
                        // note that image was added in the hash array list and
                        // this data is sent,
                        CompressAndSendBuffer(ref b,DataType.PictureBlock,
                            ref nStartX,ref nStartY,ref this.width_Bitmap,
                            ref this.height_Bitmap,ref length2);
                        SendDummyMouseMovements();
                        _quantized.Dispose();

                        Thread.Sleep(2000);
                    }
                    catch(Exception ex)
                    {
                        WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare public void captureThreadFuncEx()",ex,"",false);
                    }
                }

            }
            catch(Exception ex)
            {
                WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare public void captureThreadFuncEx()",ex,"",false);
            }
        }
Exemplo n.º 2
0
        // it is used only in desktop sharing (remote control)
        public void captureThreadFuncEx2()
        {
            try
            {
                //int nWidthBlocks=1;
                //int nHeightBlocks = 1;
                //int nBlocks=nHeightBlocks *nWidthBlocks;

                #region  Set window stuff
                // set window stuff
                Win32.USER32.GetWindowRect(sharedWnd, ref rect);

                //SetWindowPos((int)sharedWnd, (int)WindowPlacement.HWD_TOPMOST,rect.Left,rect.Top,
                //					rect.Right-rect.Left, rect.Bottom-rect.Top,0);

                //ShowWindow((IntPtr)sharedWnd, SW_SHOWMAXIMIZED);// new 5 dec

                //SetActiveWindow(sharedWnd);

                //SetForegroundWindow(sharedWnd);
                #endregion

                ImageConverter conv = new ImageConverter();

                #region Create screen bitmap

                // get window dimensions
                blockWidth = (rect.right - rect.left);//nWidthBlocks;
                blockHeight = (rect.bottom - rect.top);//nHeightBlocks;

                hdcSrc = (int)Win32.USER32.GetWindowDC((int)sharedWnd);
                int hdcDest =Win32.USER32.CreateCompatibleDC(hdcSrc);

                // create window bitmap
                int hBitmap = Win32.USER32.CreateCompatibleBitmap(hdcSrc,
                    blockWidth,blockHeight);
                Win32.USER32.SelectObject(hdcDest,hBitmap);

                #endregion

                #region Different initializations
                // get number of adjacent color bits for each pixel
                // in this we will get 4
                int nNumber = Win32.USER32.GetDeviceCaps(hdcSrc,Win32.USER32.BITSPIXEL);

                // calculate buffer size
                int bufferSize= blockWidth*blockHeight*nNumber / 8;

                // initialize buffer
                byte[] buffer = new byte[bufferSize];

                // initialiaze current block number
                //int nBlockNo = 0;

                // clear the hash array.
                //hashArray.Clear();

                // previous hash: this will contain, hash of previously captured blocks
                byte[] prevHash = new byte[blockWidth*blockHeight];

                // b containts a block data
                byte[] blockData=new byte[blockWidth*blockHeight];
                #endregion

                #region STEP1 Send Screen SIZE
                // send window size information
                SendSizeInformation((rect.right - rect.left),
                    (rect.bottom - rect.top));
                #endregion

                // variables to contain cursor position
                Win32.USER32.POINT cursorPosition = new Win32.USER32.POINT();

                Win32.USER32.POINT tempPosition = new Win32.USER32.POINT();
                Win32.USER32.RECT temprect = new Win32.USER32.RECT();

                // screen width and height,
                // these are used later to track whether the window has gone out of the screen or not
                // blocks that are out of screen are not painted or sent
                int _nScreenWidth = Screen.PrimaryScreen.Bounds.Width;
                int _nScreenHeight = Screen.PrimaryScreen.Bounds.Height;

                //int nTemp =0;

                // start coods
                int nStartX = 0,nStartY = 0;

                // current block width and height
                int nCurrentBlockWidth = blockWidth ,nCurrentBlockHeight=blockHeight;

                // hash of the current block
                //	byte[] hash = null;

                int nQuantizeCount=10; // set the quanization count as 10 initially

                //				bt = new StringBuilder(1024);

                //byte[] b;

                // get mouse coordinates
                Point lastMousePoint=new System.Drawing.Point(0,0);

                // create brush
                int _hBrush = Win32.USER32.CreateSolidBrush(0xffffff);

                Win32.USER32.RECT _tempRect = new Win32.USER32.RECT();

                //int nCopyX,  nCopyY;

                // this is not used anywhere so we will comment this coz this isnt used anywhere
                //int hBitmap_dummy = CreateCompatibleBitmap(hdcSrc,blockWidth,blockHeight);

                //bool bDifferenceFound = false;

                OctreeQuantizer quantizer = new OctreeQuantizer(255,8);

                while(m_bActive) // send data only if the window is active
                {
                    try
                    {
                        // whats quantizer count
                        if(nQuantizeCount > 5) // this will be true initially as the quantization count's been set to 10
                        {
                            nQuantizeCount=0; // reinitialize quantizer count
                            quantizer = null;
                            quantizer =new OctreeQuantizer (255,8);
                        }

                        nQuantizeCount++; // increment quantize count

                        /*
                        // get window rect again
                        GetWindowRect(sharedWnd, ref temprect);
                        int tempX= GetScrollPos(sharedWnd, SB_HORZ);
                        int tempY= GetScrollPos(sharedWnd, SB_VERT);
                    */
                        #region check if the window has been resized.
                        /*if(((temprect.Right - temprect.Left) != (rect.Right -rect.Left)) ||
                            ((temprect.Bottom - temprect.Top) != (rect.Bottom - rect.Top)) ||
                            (sPrevWindowText != oldString ) || (iPrev_HorXScroll != tempX) ||
                            (iPrev_VerXScroll != tempY))
                        {
                        #region WINDOW_RESIZED
                            //If the window has been resized
                            bool bRepeatIT = true;

                            while((bRepeatIT) && (m_bActive))
                            {
                                Trace.WriteLine("catptureThread: quantizer while((bRepeatIT) && (m_bActive)) ");
                                try
                                {
                                    rect = temprect;
                                    sPrevWindowText = oldString;
                                    iPrev_HorXScroll = tempX;
                                    iPrev_VerXScroll = tempY;

                                    blockWidth = (rect.Right - rect.Left)/nWidthBlocks;
                                    blockHeight = (rect.Bottom - rect.Top)/nHeightBlocks;

                                    hBitmap = CreateCompatibleBitmap(hdcSrc,blockWidth,blockHeight);
                                    SelectObject(hdcDest,hBitmap);

                                    // not used, not required
                                    //hBitmap_dummy = CreateCompatibleBitmap(hdcSrc,blockWidth,blockHeight);

                                    bufferSize=blockWidth*blockHeight*nNumber/8;//4;
                                    buffer = new byte[bufferSize];

                                    nBlockNo = 0;
                                    hashArray.Clear();
                                    b = null;

                                    b=new byte[blockWidth*blockHeight]; // reinitialize block data

                                    // send size information
                                    SendSizeInformation((rect.Right - rect.Left),
                                        (rect.Bottom - rect.Top));
                                    bRepeatIT = false;

                                }
                                catch(Exception )
                                {

                                    bRepeatIT = true;

                                }
                            }
                        #endregion
                        }
                        else if((temprect.Left != rect.Left) || (temprect.Top != rect.Top)  )
                        {
                        #region Window_Moved
                            //if the window has been moved
                            rect = temprect;

                        #endregion

                        }*/
                        #endregion

                        //nBlockNo = 0;

                        //for(int nRow = 0 ; nRow < nHeightBlocks ; nRow++)
                    {
                        // for each block
                        //for(int nColumn=0; nColumn< nWidthBlocks; nColumn++,nBlockNo++)
                    {
                        try
                        {
                            #region divided into blocks
                            /*
                                    // get start coods
                                    nStartX = nColumn * blockWidth;
                                    nStartY = nRow * blockHeight;

                                    // get block width
                                    nCurrentBlockWidth = blockWidth;
                                    nCurrentBlockHeight = blockHeight;

                                    //Tricking missing pisxels.
                                    // check if its the last column
                                    if(nColumn == (nWidthBlocks -1))
                                    {
                                        // if its the last column, append the remaining
                                        // bits with the rest of the stuff
                                        nTemp = nStartX + blockWidth;
                                        if(nTemp < (rect.Right - rect.Left))
                                            nCurrentBlockWidth += (rect.Right - rect.Left) - nTemp;

                                    }

                                    // if it's the last row
                                    if(nRow == (nHeightBlocks-1))
                                    {
                                        // increate the height
                                        nTemp = nStartY + blockHeight;

                                    }
                                    */
                            #endregion
                            #region BUILD_BITMAP
                            // build the bitmap

                            Win32.USER32.SelectObject(hdcDest,hBitmap);
                            /*
                                     * nCopyX = nCurrentBlockWidth;
                                    nCopyY = nCurrentBlockHeight;

                                    _tempRect.Left = 0;
                                    _tempRect.Top = 0;
                                    _tempRect.Right = nCurrentBlockWidth;
                                    _tempRect.Bottom = nCurrentBlockHeight;
                                    //								int startX=0;
                                    //								int startY=0;
                                    int endX=nCurrentBlockWidth;
                                    int endY=nCurrentBlockHeight;

                                    if(nCurrentBlockWidth + nStartX + temprect.Left > _nScreenWidth)
                                    {
                                        FillRect((IntPtr)hdcDest,ref _tempRect,(IntPtr)_hBrush);
                                        endX=(_nScreenWidth - nStartX- temprect.Left) % nCurrentBlockWidth;
                                        if(endX==0)
                                            endX=nCurrentBlockWidth;
                                    }
                                    else if(nStartX + temprect.Left < 0)
                                    {
                                        FillRect((IntPtr)hdcDest,ref _tempRect,(IntPtr)_hBrush);
                                        //startX=tempRect.Left;
                                    }
                                    else if(nCurrentBlockHeight + nStartY + temprect.Top > _nScreenHeight)
                                    {
                                        FillRect((IntPtr)hdcDest,ref _tempRect,(IntPtr)_hBrush);
                                        endY=(_nScreenHeight - nStartY- temprect.Top) % nCurrentBlockHeight;
                                        if(endY==0)
                                            endY=nCurrentBlockWidth;
                                    }
                                    else if(nStartY + temprect.Top < 0)
                                    {
                                        FillRect((IntPtr)hdcDest,ref _tempRect,(IntPtr)_hBrush);
                                    }
                                    */
                            /*BitBlt(hdcDest,0,0,endX,endY,
                                        hdcSrc,	nStartX,nStartY,
                                        0x00CC0020);
                                        */
                            Win32.USER32.BitBlt(hdcDest,0,0,blockWidth,blockHeight,
                                hdcSrc,	0,0,
                                0x00CC0020);

                            //GetBitmapBits((IntPtr)hBitmap,buffer.Length,buffer);

                            Image _image = Image.FromHbitmap((IntPtr)hBitmap);
                            using( Image _quantized = quantizer.Quantize(_image))
                            {
                                buffer =(byte[]) conv.ConvertTo(_quantized, typeof(byte[]));
                                //buffer = (byte[]) conv.ConvertTo(_image , typeof(byte[]));
                            }

                            _image.Dispose();

                            #endregion
                            #region hashing method
                            //Compute a hash for each image
                            SHA256Managed shaM = new SHA256Managed();
                            byte[] hash1 = shaM.ComputeHash(buffer);
                            byte[] hash2 = shaM.ComputeHash(prevHash );

                            //Compare the hash values
                            for (int i = 0; i < hash1.Length && i < hash2.Length  ; i++)
                            {
                                if (hash1[i] != hash2[i])
                                {								// image has changed
                                    Console.WriteLine(" new image has sent using hash  :  " + DateTime.Now.ToString()+ " " +DateTime.Now.Millisecond.ToString());
                                    int length2=buffer.Length;

                                    /*Image _image = Image.FromHbitmap((IntPtr)hBitmap);
                                            Image _quantized = quantizer.Quantize(_image);
                                            _image.Dispose();

                                            // convert quantized array to byte array
                                            b=(byte[]) conv.ConvertTo(_quantized, typeof(byte[]));
                                            length2 = b.Length;
                                            */
                                    // send image
                                    // note that image was added in the hash array list and
                                    // this data is sent,
                                    CompressAndSendBuffer(ref buffer,DataType.PictureBlock,
                                        ref nStartX,ref nStartY,ref nCurrentBlockWidth,
                                        ref nCurrentBlockHeight, ref length2);
                                    //_quantized.Dispose();
                                    prevHash = (byte[])buffer.Clone();
                                    break;
                                }
                            }

                            #endregion

                            /*int length2=buffer.Length;
                                    Image _image = Image.FromHbitmap((IntPtr)hBitmap);
                                    Image _quantized = quantizer.Quantize(_image);
                                    _image.Dispose();

                                    // convert quantized array to byte array
                                    b=(byte[]) conv.ConvertTo(_quantized, typeof(byte[]));
                                    length2 = b.Length;

                                    // send image
                                    // note that image was added in the hash array list and
                                    // this data is sent,
                                    CompressAndSendBuffer(ref b,DataType.PictureBlock,
                                        ref nStartX,ref nStartY,ref nCurrentBlockWidth,
                                        ref nCurrentBlockHeight,ref length2);

                                    _quantized.Dispose();*/

                        }
                        catch(Exception ex)
                        {
                            WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare public void captureThreadFuncEx2()",ex,"",false);
                        }
                    }
                        Thread.Sleep(500);
                    }

                    }
                    catch(Exception ex)
                    {
                        WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare public void captureThreadFuncEx2()",ex,"",false);
                    }
                }
            }
            catch(Exception ex)
            {
                WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare public void captureThreadFuncEx2()",ex,"",false);
            }
        }
Exemplo n.º 3
0
        /* Modularize code of Capture Thread*/
        private void IntializeMouseCoordinates()
        {
            try
            {

                // get mouse coordinates
                lastMousePoint=new System.Drawing.Point(0,0);
                tempPosition = new Win32.USER32.POINT();
                wp = new Win32.USER32.WINDOWPLACEMENT();
            }
            catch(Exception ex)
            {
                WebMeeting.Client.ClientUI.getInstance().ShowExceptionMessage("Module ::: AppShare private void IntializeMouseCoordinates()",ex,"",false);
            }
        }