private void Check_RGB_values_Click(object sender, EventArgs e)
        {
            int countPixel = 0;
            Bitmap myBitmap = new Bitmap("C:\\blackscreen.bmp");

            for (int x = 0; x < myBitmap.Width; x++) //1280
            {
                for (int y = 0; y < myBitmap.Height; y++) //720
                {
                    countPixel++;
                    Color pixelColor = myBitmap.GetPixel(x, y);

                    string rotAnteil = pixelColor.R.ToString();
                    string gelbAnteil = pixelColor.G.ToString();
                    string blauAnteil = pixelColor.B.ToString();

                    if (pixelColor.R > 22)
                    {
                        MessageBox.Show("Red from pixel No." + countPixel + " is out of range. " + rotAnteil + "> 22");
                        return;
                    }

                    if (pixelColor.G > 22)
                    {
                        MessageBox.Show("Yellow from pixel No." + countPixel + " is out of range. " + gelbAnteil + "> 22");
                        return;
                    }

                    if (pixelColor.B > 22)
                    {
                        MessageBox.Show("Blue from pixel No." + countPixel + " is out of range. " + blauAnteil + "> 22");
                        return;
                    }
                }
            }
        }

bool isAlphaBitmap = bitmap.PixelFormat == (bitmap.PixelFormat | PixelFormat.Alpha);

public byte[] CreateBitmapArray(Bitmap blackBitmap)
        {

               BitmapData bmpdata = blackBitmap.LockBits(new Rectangle(0, 0, blackBitmap.Width, blackBitmap.Height), ImageLockMode.ReadOnly, blackBitmap.PixelFormat);
                anzahlPixel = bmpdata.Stride * blackBitmap.Height;
                dataByte = new byte[anzahlPixel];
                IntPtr intPtr = bmpdata.Scan0;

                Marshal.Copy(intPtr, dataByte, 0, anzahlPixel);

                return dataByte;

                if (bmpdata != null)
                blackBitmap.UnlockBits(bmpdata);
        }

        private void button1_Click(object sender, EventArgs e)
        {
            Bitmap blackscreen = new Bitmap("c:\\blackscreen.bmp");

            BitmapToByteArray(blackscreen);

            for (int x = 0; x < anzahlPixel; x++)
            {
                if (dataByte[x] > 22)
                {
                    MessageBox.Show("Pixel "+x+" is not black");
                    return; // beende die Methode sobald der erste Pixel außerhalb der Toleranz liegt
                }
            }
        }

        public byte[] BitmapToByteArray(Bitmap bitmap)
        {

            BitmapData bmpdata = null;
            try
            {
                bmpdata = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly, bitmap.PixelFormat);
                numbytes = bmpdata.Stride * bitmap.Height;
                bytedata = new byte[numbytes];
                IntPtr ptr = bmpdata.Scan0;

                Marshal.Copy(ptr, bytedata, 0, numbytes);

                return bytedata;
            }
            finally
            {
                if (bmpdata != null)
                    bitmap.UnlockBits(bmpdata);
            }

        }

 public void CheckScreenColor()
        {
            for (int counter = 0; counter < numbytes; counter++)
            {
                byte a = bytedata[counter];
                if (bytedata[counter] < farbgrenze)
                {
                    if (counter == 0 || (counter % 3) == 0)
                    {
                        MessageBox.Show("Pixel " + (counter + 1) + " (Value red) is not black.");
                        return;
                    }

                    else if ((counter == 1) || ((counter - 1) % 3) == 0)
                    {
                        MessageBox.Show("Pixel " + (counter + 1) + "(Value yellow) is not black.");
                        return;
                    }

                    else if ((counter == 2) || ((counter - 2) % 3) == 0)
                    {
                        MessageBox.Show("Pixel " + (counter + 1) + " (Value blue) is not black.");
                        return;
                    }

                }
            }

        

string path = "U:\\a.avi";

public byte[] GetBytesFromFile(string path)
{
            FileStream filestream = File.OpenRead(path);

                byte[] bytes = File.ReadAllBytes(path);
                filestream.Read(bytes, 0, Convert.ToInt32(filestream.Length));
                filestream.Close();

                return bytes;
}

void _NewFrame_Video(object sender, NewFrameEventArgs eventArgs)
        {
            video = (Bitmap)eventArgs.Frame.Clone();
            FileWriter.WriteVideoFrame(video);
            VideoToByteArray(video);
        }

        void FinalVideo_NewFrame(object sender, NewFrameEventArgs eventArgs)
        {
            if (stopVideo==false)
            {
                video = (Bitmap)eventArgs.Frame.Clone();
                VideoToByteArray(video);
                video.Save(pathXY);
                FileWriter.WriteVideoFrame(video);
            }
//....
}

struct BGR
{
    public byte B;
    public byte G;
    public byte R;
}

static BGR[,] GetPixels(Bitmap bitmap)
{
    Contract.Requires(bitmap != null);

    BGR[,] pixels = new BGR[bitmap.Height, bitmap.Width];
    GCHandle handle = GCHandle.Alloc(pixels, GCHandleType.Pinned);
    try
    {
        BitmapData data = new BitmapData();
        data.PixelFormat = PixelFormat.Format24bppRgb;
        data.Width = bitmap.Width;
        data.Height = bitmap.Height;
        data.Stride = bitmap.Width * 3;
        data.Scan0 = handle.AddrOfPinnedObject();
        data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly | ImageLockMode.UserInputBuffer, bitmap.PixelFormat, data);
        bitmap.UnlockBits(data);
    }
    finally
    {
        handle.Free();
    }
    return pixels;
}

data = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadOnly | ImageLockMode.UserInputBuffer, PixelFormat.Format48bppRgb);

data.PixelFormat = PixelFormat.Format24bppRgb; // <--