290 lines
8.6 KiB
C#
290 lines
8.6 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using StreamLibrary.src;
|
|
|
|
namespace StreamLibrary.UnsafeCodecs;
|
|
|
|
public class UnsafeStreamCodec : IUnsafeCodec
|
|
{
|
|
private byte[] EncodeBuffer;
|
|
|
|
private Bitmap decodedBitmap;
|
|
|
|
private PixelFormat EncodedFormat;
|
|
|
|
private int EncodedWidth;
|
|
|
|
private int EncodedHeight;
|
|
|
|
private bool UseJPEG;
|
|
|
|
public override ulong CachedSize { get; internal set; }
|
|
|
|
public override int BufferCount => 1;
|
|
|
|
public override CodecOption CodecOptions => CodecOption.RequireSameSize;
|
|
|
|
public Size CheckBlock { get; private set; }
|
|
|
|
public override event IVideoCodec.VideoDebugScanningDelegate onCodeDebugScan;
|
|
|
|
public override event IVideoCodec.VideoDebugScanningDelegate onDecodeDebugScan;
|
|
|
|
public UnsafeStreamCodec(int ImageQuality = 100, bool UseJPEG = true)
|
|
: base(ImageQuality)
|
|
{
|
|
CheckBlock = new Size(50, 1);
|
|
this.UseJPEG = UseJPEG;
|
|
}
|
|
|
|
public unsafe override void CodeImage(IntPtr Scan0, Rectangle ScanArea, Size ImageSize, PixelFormat Format, Stream outStream)
|
|
{
|
|
lock (base.ImageProcessLock)
|
|
{
|
|
byte* ptr = (byte*)Scan0.ToInt32();
|
|
if (!outStream.CanWrite)
|
|
{
|
|
throw new Exception("Must have access to Write in the Stream");
|
|
}
|
|
int num = 0;
|
|
int num2 = 0;
|
|
int num3 = 0;
|
|
switch (Format)
|
|
{
|
|
case PixelFormat.Format24bppRgb:
|
|
case PixelFormat.Format32bppRgb:
|
|
num3 = 3;
|
|
break;
|
|
case PixelFormat.Format32bppPArgb:
|
|
case PixelFormat.Format32bppArgb:
|
|
num3 = 4;
|
|
break;
|
|
default:
|
|
throw new NotSupportedException(Format.ToString());
|
|
}
|
|
num = ImageSize.Width * num3;
|
|
num2 = num * ImageSize.Height;
|
|
if (EncodeBuffer == null)
|
|
{
|
|
EncodedFormat = Format;
|
|
EncodedWidth = ImageSize.Width;
|
|
EncodedHeight = ImageSize.Height;
|
|
EncodeBuffer = new byte[num2];
|
|
fixed (byte* value = EncodeBuffer)
|
|
{
|
|
byte[] array = null;
|
|
using (Bitmap bmp = new Bitmap(ImageSize.Width, ImageSize.Height, num, Format, Scan0))
|
|
{
|
|
array = jpgCompression.Compress(bmp);
|
|
}
|
|
outStream.Write(BitConverter.GetBytes(array.Length), 0, 4);
|
|
outStream.Write(array, 0, array.Length);
|
|
NativeMethods.memcpy(new IntPtr(value), Scan0, (uint)num2);
|
|
}
|
|
return;
|
|
}
|
|
long position = outStream.Position;
|
|
outStream.Write(new byte[4], 0, 4);
|
|
int num4 = 0;
|
|
if (EncodedFormat != Format)
|
|
{
|
|
throw new Exception("PixelFormat is not equal to previous Bitmap");
|
|
}
|
|
if (EncodedWidth != ImageSize.Width || EncodedHeight != ImageSize.Height)
|
|
{
|
|
throw new Exception("Bitmap width/height are not equal to previous bitmap");
|
|
}
|
|
List<Rectangle> list = new List<Rectangle>();
|
|
int num5 = 0;
|
|
Size size = new Size(ScanArea.Width, CheckBlock.Height);
|
|
Size size2 = new Size(ScanArea.Width % CheckBlock.Width, ScanArea.Height % CheckBlock.Height);
|
|
int num6 = ScanArea.Height - size2.Height;
|
|
int num7 = ScanArea.Width - size2.Width;
|
|
Rectangle rectangle = default(Rectangle);
|
|
List<Rectangle> list2 = new List<Rectangle>();
|
|
size = new Size(ScanArea.Width, size.Height);
|
|
fixed (byte* ptr2 = EncodeBuffer)
|
|
{
|
|
for (int i = ScanArea.Y; i != ScanArea.Height; i += size.Height)
|
|
{
|
|
if (i == num6)
|
|
{
|
|
size = new Size(ScanArea.Width, size2.Height);
|
|
}
|
|
rectangle = new Rectangle(ScanArea.X, i, ScanArea.Width, size.Height);
|
|
if (onCodeDebugScan != null)
|
|
{
|
|
onCodeDebugScan(rectangle);
|
|
}
|
|
int num8 = i * num + ScanArea.X * num3;
|
|
if (NativeMethods.memcmp(ptr2 + num8, ptr + num8, (uint)num) != 0)
|
|
{
|
|
num5 = list.Count - 1;
|
|
if (list.Count != 0 && list[num5].Y + list[num5].Height == rectangle.Y)
|
|
{
|
|
rectangle = (list[num5] = new Rectangle(list[num5].X, list[num5].Y, list[num5].Width, list[num5].Height + rectangle.Height));
|
|
}
|
|
else
|
|
{
|
|
list.Add(rectangle);
|
|
}
|
|
}
|
|
}
|
|
int j = 0;
|
|
int x = ScanArea.X;
|
|
for (; j < list.Count; j++)
|
|
{
|
|
size = new Size(CheckBlock.Width, list[j].Height);
|
|
for (x = ScanArea.X; x != ScanArea.Width; x += size.Width)
|
|
{
|
|
if (x == num7)
|
|
{
|
|
size = new Size(size2.Width, list[j].Height);
|
|
}
|
|
rectangle = new Rectangle(x, list[j].Y, size.Width, list[j].Height);
|
|
bool flag = false;
|
|
int count = num3 * rectangle.Width;
|
|
for (int k = 0; k < rectangle.Height; k++)
|
|
{
|
|
int num9 = num * (rectangle.Y + k) + num3 * rectangle.X;
|
|
if (NativeMethods.memcmp(ptr2 + num9, ptr + num9, (uint)count) != 0)
|
|
{
|
|
flag = true;
|
|
}
|
|
NativeMethods.memcpy(ptr2 + num9, ptr + num9, (uint)count);
|
|
}
|
|
if (onCodeDebugScan != null)
|
|
{
|
|
onCodeDebugScan(rectangle);
|
|
}
|
|
if (flag)
|
|
{
|
|
num5 = list2.Count - 1;
|
|
if (list2.Count > 0 && list2[num5].X + list2[num5].Width == rectangle.X)
|
|
{
|
|
Rectangle rectangle3 = list2[num5];
|
|
int width = rectangle.Width + rectangle3.Width;
|
|
rectangle = (list2[num5] = new Rectangle(rectangle3.X, rectangle3.Y, width, rectangle3.Height));
|
|
}
|
|
else
|
|
{
|
|
list2.Add(rectangle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
for (int l = 0; l < list2.Count; l++)
|
|
{
|
|
Rectangle rectangle5 = list2[l];
|
|
int num10 = num3 * rectangle5.Width;
|
|
Bitmap bitmap = new Bitmap(rectangle5.Width, rectangle5.Height, Format);
|
|
BitmapData bitmapData = bitmap.LockBits(new Rectangle(0, 0, bitmap.Width, bitmap.Height), ImageLockMode.ReadWrite, bitmap.PixelFormat);
|
|
int m = 0;
|
|
int num11 = 0;
|
|
for (; m < rectangle5.Height; m++)
|
|
{
|
|
int num12 = num * (rectangle5.Y + m) + num3 * rectangle5.X;
|
|
NativeMethods.memcpy((byte*)bitmapData.Scan0.ToPointer() + num11, ptr + num12, (uint)num10);
|
|
num11 += num10;
|
|
}
|
|
bitmap.UnlockBits(bitmapData);
|
|
outStream.Write(BitConverter.GetBytes(rectangle5.X), 0, 4);
|
|
outStream.Write(BitConverter.GetBytes(rectangle5.Y), 0, 4);
|
|
outStream.Write(BitConverter.GetBytes(rectangle5.Width), 0, 4);
|
|
outStream.Write(BitConverter.GetBytes(rectangle5.Height), 0, 4);
|
|
outStream.Write(new byte[4], 0, 4);
|
|
long length = outStream.Length;
|
|
long position2 = outStream.Position;
|
|
if (UseJPEG)
|
|
{
|
|
jpgCompression.Compress(bitmap, ref outStream);
|
|
}
|
|
else
|
|
{
|
|
lzwCompression.Compress(bitmap, outStream);
|
|
}
|
|
length = outStream.Position - length;
|
|
outStream.Position = position2 - 4;
|
|
outStream.Write(BitConverter.GetBytes((int)length), 0, 4);
|
|
outStream.Position += length;
|
|
bitmap.Dispose();
|
|
num4 += (int)length + 20;
|
|
}
|
|
outStream.Position = position;
|
|
outStream.Write(BitConverter.GetBytes(num4), 0, 4);
|
|
list.Clear();
|
|
list2.Clear();
|
|
}
|
|
}
|
|
|
|
public unsafe override Bitmap DecodeData(IntPtr CodecBuffer, uint Length)
|
|
{
|
|
if (Length < 4)
|
|
{
|
|
return decodedBitmap;
|
|
}
|
|
int num = *(int*)(void*)CodecBuffer;
|
|
if (decodedBitmap == null)
|
|
{
|
|
byte[] array = new byte[num];
|
|
fixed (byte* value = array)
|
|
{
|
|
NativeMethods.memcpy(new IntPtr(value), new IntPtr(CodecBuffer.ToInt32() + 4), (uint)num);
|
|
}
|
|
decodedBitmap = (Bitmap)Image.FromStream(new MemoryStream(array));
|
|
return decodedBitmap;
|
|
}
|
|
return decodedBitmap;
|
|
}
|
|
|
|
public override Bitmap DecodeData(Stream inStream)
|
|
{
|
|
try
|
|
{
|
|
byte[] array = new byte[4];
|
|
inStream.Read(array, 0, 4);
|
|
int num = BitConverter.ToInt32(array, 0);
|
|
if (decodedBitmap == null)
|
|
{
|
|
array = new byte[num];
|
|
inStream.Read(array, 0, array.Length);
|
|
decodedBitmap = (Bitmap)Image.FromStream(new MemoryStream(array));
|
|
return decodedBitmap;
|
|
}
|
|
using (Graphics graphics = Graphics.FromImage(decodedBitmap))
|
|
{
|
|
while (num > 0)
|
|
{
|
|
byte[] array2 = new byte[20];
|
|
inStream.Read(array2, 0, array2.Length);
|
|
Rectangle scanArea = new Rectangle(BitConverter.ToInt32(array2, 0), BitConverter.ToInt32(array2, 4), BitConverter.ToInt32(array2, 8), BitConverter.ToInt32(array2, 12));
|
|
int num2 = BitConverter.ToInt32(array2, 16);
|
|
array2 = null;
|
|
byte[] array3 = new byte[num2];
|
|
inStream.Read(array3, 0, array3.Length);
|
|
if (onDecodeDebugScan != null)
|
|
{
|
|
onDecodeDebugScan(scanArea);
|
|
}
|
|
using (MemoryStream stream = new MemoryStream(array3))
|
|
{
|
|
using Bitmap image = (Bitmap)Image.FromStream(stream);
|
|
graphics.DrawImage(image, scanArea.Location);
|
|
}
|
|
array3 = null;
|
|
num -= num2 + 20;
|
|
}
|
|
}
|
|
return decodedBitmap;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
}
|