Example #1
0
        public void HandleBlock(string type, MLVTypes.mlv_vidf_hdr_t header, byte[] rawData, int rawPos, int rawLength)
        {
            VidfHeader = header;

            if (FileHeader.videoClass != 0x01 || LockBitmap == null)
            {
                return;
            }

            if (!VideoEnabled)
            {
                return;
            }

            lock (this)
            {
                int frameSpace = (int)Math.Max(header.frameSpace - RawFixOffset, 0);
                int startPos   = rawPos + frameSpace;
                int length     = rawLength - frameSpace;

                if (!DebayeringEnabled)
                {
                    RawPixelData = new byte[length];
                    Array.Copy(rawData, startPos, RawPixelData, 0, length);
                    return;
                }

                /* first extract the raw channel values */
                Bitunpack.Process(rawData, startPos, rawLength, PixelData);

                /* then debayer the pixel data */
                Debayer.Process(PixelData, RGBData);

                /* and transform into a bitmap for displaying */
                LockBitmap.LockBits();

                int    pos     = 0;
                uint[] average = new uint[] { 0, 0, 0 };

                for (int y = 0; y < RawiHeader.yRes; y++)
                {
                    for (int x = 0; x < RawiHeader.xRes; x++)
                    {
                        float r = RGBData[y, x, 0];
                        float g = RGBData[y, x, 1];
                        float b = RGBData[y, x, 2];

                        if (ColorLut != null)
                        {
                            ColorLut.Lookup(r, g, b, out r, out g, out b);
                        }

                        /* now scale to TV black/white levels */
                        ScaleLevels(ref r);
                        ScaleLevels(ref g);
                        ScaleLevels(ref b);

                        average[0] += (uint)g;
                        average[1] += (uint)b;
                        average[2] += (uint)r;

                        /* limit RGB values */
                        LockBitmap.Pixels[pos++] = (byte)b;
                        LockBitmap.Pixels[pos++] = (byte)g;
                        LockBitmap.Pixels[pos++] = (byte)r;
                    }
                }
                LockBitmap.UnlockBits();

                int pixels = RawiHeader.yRes * RawiHeader.xRes;

                /* make sure the average brightness is somewhere in the mid range */
                if (Math.Abs(_ExposureCorrection) == 0.0f)
                {
                    double averageBrightness = (average[0] + average[1] + average[2]) / (3 * pixels);
                    if (averageBrightness < 100)
                    {
                        Debayer.Brightness *= 1.0f + (float)(100.0f - averageBrightness) / 100.0f;
                    }
                    if (averageBrightness > 200)
                    {
                        Debayer.Brightness /= 1.0f + (float)(averageBrightness - 200.0f) / 55.0f;
                    }
                }
                else
                {
                    Debayer.Brightness = (float)Math.Pow(2, _ExposureCorrection);
                }

                FrameUpdated = true;
            }
        }