Question

I have a program which displays an image to the windows form, and places a message within the image as it paints it (this works fine) i then have a method which reads the message back. However, doing this causes the winforms screen to freeze! i must be getting stuck in an endless loop. The method does work as i do get the message back…. can anyone help un-freeze my program?

Code below:

    public partial class MyImages : Form
    {
        //I have variables related to encoding and decoding here(deleted)
        private const String MESSAGE = "2008-01-07";

        Bitmap firstLoaded;
        Bitmap theImage;
        Bitmap imageEmbedded; 
        Boolean isGetMessage = false; 
        Boolean isEmbedImage = false; 
        Boolean isLoaded = false;
        Graphics graphicsWindow;   // reference to the graphic surface of this window
        Graphics graphicsImage;     // reference to in-memory surface
        BitArray bitsOfMessage = new BitArray(8);
        String bytesOfTheMessage = null;

        public MyImages()
        {
            InitializeComponent();
            this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.UserPaint | ControlStyles.DoubleBuffer, true);
        }

        private void MyImages_Paint(object sender, PaintEventArgs e)
        {
            HandlePainting(); 
        }

        public void HandlePainting()
        {
            if (isLoaded == true)
            {
                theImage = new Bitmap(Width, Height);     // bitmap for window surface copy
                graphicsWindow = CreateGraphics();   // get our current window's surface
                graphicsImage = Graphics.FromImage(theImage);     // create surfaces from the bitmaps
                graphicsImage.DrawImage(firstLoaded, 0, 0, Width, Height);

                if (isEmbedImage == true)
                {
                    theImage = embedMessageInImage(theImage);
                }
                else if (isGetMessage == true)
                {
                    getEmbeddedMessage(imageEmbedded);
                }

                if (isGetMessage == false)
                {
                    graphicsWindow.DrawImage(theImage, 0, 0);
                }
                else if (isGetMessage == true)
                {
                    graphicsWindow.DrawImage(imageEmbedded, 0, 0);
                }
            }
        }

        private void toolStripMenuItemLoadImage_Click(object sender, EventArgs e)
        {
            using (OpenFileDialog ofd = new OpenFileDialog())
            {
                ofd.Title = "Load Image";

                if (ofd.ShowDialog() == DialogResult.OK)
                {
                    firstLoaded = new Bitmap(ofd.FileName);
                    this.Invalidate();
                }
            }
            isLoaded = true;
        }

        private void toolStripMenuEmbedMessage_Click(object sender, EventArgs e)
        {
            isEmbedImage = true;
            isGetMessage = false; 
            this.Invalidate(); 
        }

        private void toolStripMenuItemGetMessage_Click(object sender, EventArgs e)
        {
            isEmbedImage = false;
            isGetMessage = true;
            this.Invalidate(); 
        }

        public void convertToChar(int byteChar)
        {
            char val = Convert.ToChar(byteChar);
            String nextChar = val.ToString();
            bytesOfTheMessage += nextChar;

        }

        private Bitmap embedMessageInImage(Bitmap bmp)
        {
           //Embed message in this method (deleted)

                //unlock the bitmaps
                newBitmap.UnlockBits(newData);
                bmp.Save("tina.bmp"); 
                bmp.UnlockBits(originalData);
                newBitmap.Save("tina7.bmp");
                imageEmbedded = newBitmap; 
                return newBitmap;
            }
        }

        private void getEmbeddedMessage(Bitmap bmp)
        {
            unsafe
            {
                //create an empty bitmap the same size as original
                Bitmap newBitmap = new Bitmap(bmp.Width, bmp.Height);

                //lock the original bitmap in memory
                System.Drawing.Imaging.BitmapData originalData = bmp.LockBits(
                   new Rectangle(0, 0, bmp.Width, bmp.Height),
                   System.Drawing.Imaging.ImageLockMode.ReadOnly,
                   System.Drawing.Imaging.PixelFormat.Format24bppRgb);

                //lock the new bitmap in memory
                System.Drawing.Imaging.BitmapData newData = newBitmap.LockBits(
                   new Rectangle(0, 0, bmp.Width, bmp.Height),
                   System.Drawing.Imaging.ImageLockMode.WriteOnly,
                   System.Drawing.Imaging.PixelFormat.Format24bppRgb);

                //set the number of bytes per pixel
                int pixelSize = 3;

                for (int y = 0; y < bmp.Height; y++)
                {
                    //get the data from the original image
                    byte* originalImageRow = (byte*)originalData.Scan0 + (y * originalData.Stride);

                    //get the data from the new image
                    byte* newImageRow = (byte*)newData.Scan0 + (y * newData.Stride);

                    for (int x = 0; x < bmp.Width; x++)
                    {

                        byte b = (byte)(originalImageRow[x * pixelSize + 0]); // B
                        getEachBitOfMessage(b, BLUE);

                        byte g = (byte)(originalImageRow[x * pixelSize + 1]); // G
                        getEachBitOfMessage(g, GREEN);

                        byte r = ((byte)(originalImageRow[x * pixelSize + 2])); //R
                        getEachBitOfMessage(r, RED);

                    }
                }

                //unlock the bitmaps
                newBitmap.UnlockBits(newData);
                bmp.UnlockBits(originalData);
            }
        }

        public byte changeEachBit(byte byteToManipulate, int colour, byte theMessage)
        {
            byte value = 0;
            byte returnByte = 0; 

            if (colour == BLUE)
            {
               value= (byte)(theMessage & BValueMask);
               value = (byte)(value>>5); 
               returnByte = (byte)(byteToManipulate & BlueMask);
               returnByte = (byte)(returnByte | value); 

            }
            else if (colour == GREEN)
            {
                value = (byte)(theMessage & GValueMask);
                value = (byte)(value >> 3);
                returnByte = (byte)(byteToManipulate & GreenMask);
                returnByte = (byte)(returnByte | value);

            }
            else if (colour == RED)
            {
                value = (byte)(theMessage & RValueMask);
                returnByte = (byte)(byteToManipulate & RedMask);
                returnByte = (byte)(returnByte | value);
            }

            return returnByte;
        }

        public void getEachBitOfMessage(byte byteToManipulate, int colour)
        {
            //I Input bits into image here (deleted)

        }
    }
}

Answer 1

Let it freeze and click the Pause button on the top toolbar.
This will cause the debugger to break wherever execution may be, and you can then easily identify where it got stuck, and try and find out why as well (don’t forget to watch values using the watch window or hovering them).