public override void PixBltPixelBuffer24(GDIDIBSection fPixMap, int x, int y)
{
MemoryStream ms = new MemoryStream();
PixelAccessorBGRb accessor = new PixelAccessorBGRb(fPixMap.Width, fPixMap.Height, fPixMap.Orientation, fPixMap.Pixels);
// 2. Run length encode the image to a memory stream
NewTOAPIA.Imaging.TargaRunLengthCodec rlc = new NewTOAPIA.Imaging.TargaRunLengthCodec();
rlc.Encode(accessor, ms);
// 3. Get the bytes from the stream
byte[] imageBytes = ms.GetBuffer();
int dataLength = (int)imageBytes.Length;
// 4. Allocate a buffer chunk to accomodate the bytes, plus some more
BufferChunk chunk = new BufferChunk(dataLength + 128);
// 5. Put the command, destination, and data size into the buffer first
chunk += (int)UICommands.PixBltRLE;
ChunkUtils.Pack(chunk, x, y);
ChunkUtils.Pack(chunk, accessor.Width, accessor.Height);
chunk += dataLength;
// 6. Put the image bytes into the chunk
chunk += imageBytes;
// 6. Finally, send the packet
SendCommand(chunk);
}
void fCamera_NewFrame(object sender, CameraEventArgs e)
{
// Wrap the frame up in a PixelAccessor
PixelAccessorBGRb accessor = new PixelAccessorBGRb(e.Width, e.Height, PixmapOrientation.BottomToTop, e.fData, e.Width*3);
fAttendee.SendVideoFrame(accessor);
}
void ReceiveFrameFromCamera(object sender, CameraEventArgs camEvent)
{
// Wrap the frame up in a PixelAccessor
PixelAccessorBGRb accessor = new PixelAccessorBGRb(camEvent.Width, camEvent.Height, PixmapOrientation.BottomToTop, camEvent.fData, camEvent.Width * 3);
// Tell whomever is listening that we've received a video event
if (null != ReceivedVideoFrameEvent)
ReceivedVideoFrameEvent(accessor);
SendVideoFrame(accessor);
}
public PictureWindow(int locx, int locy)
: base("Run Length Encoding Viewer", locx, locy, 640, 480)
{
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("marbles.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("xing_b24.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("xing_b32.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("xing_t24.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("xing_t32.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("ctc24.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("flag_t32.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("flag_b32.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("utc32.tga");
//picture = NewTOAPIA.Drawing.TargaLoader.CreatePixelDataFromFile("utc24.tga");
//picture = CreateColorTestImage(40,40);
//picture = CreateSteppedTestImage(128, 32);
picture = CreateBarsTestImage(10);
// Perform the runlength encoding on the image
pixMap = new PixelArray<BGRb>(picture);
RLC rlc = new RLC();
//NewTOAPIA.Imaging.RunLengthCodec rlc = new RunLengthCodec();
MemoryStream ms = new MemoryStream();
rlc.Encode(new PixelAccessorBGRb(pixMap), ms);
byte[] imageBytes = ms.GetBuffer();
//Console.WriteLine("Image Bytes: {0}", imageBytes.Length);
// Now decode the bytes back into a new image
ms.Seek(0, SeekOrigin.Begin);
tPic = new PixelArray<BGRb>(pixMap.Width, pixMap.Height, pixMap.Orientation, new PixelInformation(PixelLayout.Bgr, PixelComponentType.Byte));
PixelAccessorBGRb accessor = new PixelAccessorBGRb(tPic);
rlc.Decode(ms, accessor);
}
public static IPixelArray CreatePixelDataFromFile(string filename)
{
int tgaSize;
bool isExtendedFile;
// Open the file.
if ((null == filename) || (string.Empty == filename))
return null;
FileStream filestream = new FileStream(filename, FileMode.Open, FileAccess.Read);
BinaryReader reader = new BinaryReader(filestream);
// Targa images come in many different formats, and there are a couple of different versions
// of the specification.
// First thing to do is determine if the file is adhereing to version 2.0 of the spcification.
// We do that by reading a 'footer', which is the last 26 bytes of the file.
long fileLength = filestream.Length;
long seekPosition = filestream.Seek(fileLength - 26, SeekOrigin.Begin);
byte[] targaFooterBytes = reader.ReadBytes(26);
string targaXFileID = "TRUEVISION-XFILE";
string targaFooterSignature = System.Text.ASCIIEncoding.ASCII.GetString(targaFooterBytes, 8, 16);
TargaFooter footer = null;
isExtendedFile = (0 == string.Compare(targaFooterSignature, targaXFileID));
if (isExtendedFile)
{
// Since we now know it's an extended file,
// we'll create the footer object and fill
// in the details.
footer = new TargaFooter();
// Of the 26 bytes we read from the end of the file
// the bytes are layed out as follows.
//Bytes 0-3: The Extension Area Offset
//Bytes 4-7: The Developer Directory Offset
//Bytes 8-23: The Signature
//Byte 24: ASCII Character “.”
//Byte 25: Binary zero string terminator (0x00)
// We take those raw bytes, and turn them into meaningful fields
// in the footer object.
footer.ExtensionAreaOffset = BitConverter.ToInt32(targaFooterBytes, 0);
footer.DeveloperDirectoryOffset = BitConverter.ToInt32(targaFooterBytes, 4);
footer.Signature = targaFooterSignature;
footer.Period = (byte)'.';
footer.BinaryZero = 0;
}
TargaHeader fHeader = new TargaHeader();
// If you want to use unsafe code, you could do the following
// there are two primary drawbacks.
// 1. The targa image data is in Little-Endian format. On platforms
// that are big-endian, the data will not necessarily show up correctly in the header.
// 2. You must compile with unsafe code. That may or may not be a problem depending
// on the application, but it really isn't a necessity.
//
// The speed gain may not be realized, so there's really no reason for the added complexity.
// First, just reader enough of bytes from the file to capture the
// header into a chunk of memory.
//byte[] headerBytes = reader.ReadBytes(Marshal.SizeOf(fHeader));
//IntPtr headerPtr;
//unsafe
//{
// GCHandle dataHandle = GCHandle.Alloc(headerBytes, GCHandleType.Pinned);
// try
// {
// headerPtr = (IntPtr)dataHandle.AddrOfPinnedObject();
// // Now use the marshaller to copy the header bytes into a structure
// fHeader = (TargaHeader)Marshal.PtrToStructure(headerPtr, typeof(TargaHeader));
// }
// finally
// {
// dataHandle.Free();
// }
//}
filestream.Seek(0, SeekOrigin.Begin);
fHeader.IDLength = reader.ReadByte();
fHeader.ColorMapType = (TargaColorMapType)reader.ReadByte();
fHeader.ImageType = (TargaImageType)reader.ReadByte();
fHeader.CMapStart = reader.ReadInt16();
fHeader.CMapLength = reader.ReadInt16();
fHeader.CMapDepth = reader.ReadByte();
// Image description
fHeader.XOffset = reader.ReadInt16();
fHeader.YOffset = reader.ReadInt16();
fHeader.Width = reader.ReadInt16(); // Width of image in pixels
fHeader.Height = reader.ReadInt16(); // Height of image in pixels
fHeader.PixelDepth = reader.ReadByte(); // How many bits per pixel
fHeader.ImageDescriptor = reader.ReadByte();
// Image Descriptor Byte. |
// Bits 3-0 - number of attribute bits associated with each |
// pixel. For the Targa 16, this would be 0 or |
// 1. For the Targa 24, it should be 0. For |
// Targa 32, it should be 8. |
// Bit 4 - controls left/right transfer of pixels to
/// the screen.
/// 0 = left to right
/// 1 = right to left
// Bit 5 - controls top/bottom transfer of pixels to
/// the screen.
/// 0 = bottom to top
/// 1 = top to bottom
///
/// In Combination bits 5/4, they would have these values
/// 00 = bottom left
/// 01 = bottom right
/// 10 = top left
/// 11 = top right
///
// Bits 7-6 - Data storage interleaving flag. |
// 00 = non-interleaved. |
// 01 = two-way (even/odd) interleaving. |
// 10 = four way interleaving. |
// 11 = reserved.
byte desc = fHeader.ImageDescriptor;
byte attrBits = (byte)(desc & 0x0F);
ImageOrigin origin = (ImageOrigin)(desc & (byte)ImageOrigin.OriginMask);
byte interleave = (byte)((desc & 0xC0) >> 6);
// This routine can only deal with the uncompressed image types.
// So, fail if this is not the case.
if ((TargaImageType.TrueColor != fHeader.ImageType) && (TargaImageType.Monochrome != fHeader.ImageType))
{
filestream.Close();
return null;
}
PixmapOrientation pixmapOrientation = PixmapOrientation.BottomToTop;
if ((ImageOrigin.BottomLeft == origin) || (ImageOrigin.BottomRight == origin))
pixmapOrientation = PixmapOrientation.BottomToTop;
else
pixmapOrientation = PixmapOrientation.TopToBottom;
int bytesPerPixel = fHeader.PixelDepth / 8;
// Skip past the Image Identification field
byte[] ImageIdentification;
if (fHeader.IDLength > 0)
ImageIdentification = reader.ReadBytes(fHeader.IDLength);
// calculate image size based on bytes per pixel, width and height.
tgaSize = fHeader.Width * fHeader.Height * bytesPerPixel;
byte[] imageData = reader.ReadBytes((int)tgaSize);
filestream.Close();
// Pin the array in mememory, and get a data pointer to it
IntPtr dataPtr;
unsafe
{
GCHandle dataHandle = GCHandle.Alloc(imageData, GCHandleType.Pinned);
dataPtr = (IntPtr)dataHandle.AddrOfPinnedObject();
// Create the appropriate PixelArray
// then create an accessor to match
// Copy the data from the buffer pointer to the new array
switch (bytesPerPixel)
{
case 3:
{
PixelAccessorBGRb srcAccess = new PixelAccessorBGRb(fHeader.Width, fHeader.Height, pixmapOrientation, dataPtr);
PixelArray<BGRb> pixmap = new PixelArray<BGRb>(srcAccess);
return pixmap;
}
break;
case 4:
{
PixelAccessorBGRAb srcAccess = new PixelAccessorBGRAb(fHeader.Width, fHeader.Height, pixmapOrientation, dataPtr);
PixelArray<BGRAb> pixmap = new PixelArray<BGRAb>(srcAccess);
return pixmap;
}
break;
case 1:
{
PixelAccessorLumb srcAccess = new PixelAccessorLumb(fHeader.Width, fHeader.Height, pixmapOrientation, dataPtr);
PixelArray<Lumb> pixmap = new PixelArray<Lumb>(srcAccess);
return pixmap;
}
break;
}
}
return null;
}
public virtual void ReceiveChunk(BufferChunk aRecord)
{
// First read out the record type
int recordType = aRecord.NextInt32();
// Then deserialize the rest from there
switch (recordType)
{
//case (int)UICommands.PixBlt:
// {
// // Get the X, Y
// int x = aRecord.NextInt32();
// int y = aRecord.NextInt32();
// // get the length of the image bytes buffer
// int dataSize = aRecord.NextInt32();
// byte[] imageBytes = (byte[])aRecord;
// // Create a memory stream from the imageBytes
// MemoryStream ms = new MemoryStream(imageBytes, false);
// // Create a pixelArray from the stream
// Bitmap bm = (Bitmap)Bitmap.FromStream(ms);
// PixelArray<BGRAb> pixMap = PixelBufferHelper.CreatePixelArrayFromBitmap(bm);
// // And finally, call the PixBlt function
// PixBltBGRAb(pixMap, x, y);
// }
// break;
case (int)UICommands.PixBltRLE:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
// get the length of the image bytes buffer
int dataSize = aRecord.NextInt32();
byte[] imageBytes = (byte[])aRecord;
// Create a memory stream from the imageBytes
MemoryStream ms = new MemoryStream(imageBytes, false);
// Create a pixelArray from the stream
if ((width != fPixMap.Width) || (height != fPixMap.Height))
fPixMap = new GDIDIBSection(width, height);
TargaRunLengthCodec rlc = new TargaRunLengthCodec();
PixelAccessorBGRb accessor = new PixelAccessorBGRb(fPixMap.Width, fPixMap.Height, fPixMap.Orientation, fPixMap.Pixels, fPixMap.BytesPerRow);
rlc.Decode(ms, accessor);
// And finally, call the local PixBlt function
PixBltPixelBuffer24(fPixMap, x, y);
}
break;
case (int)UICommands.PixBltLuminance:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
// get the length of the image bytes buffer
int dataSize = aRecord.NextInt32();
byte[] imageBytes = (byte[])aRecord;
// Create a memory stream from the imageBytes
MemoryStream ms = new MemoryStream(imageBytes, false);
// Create a pixelArray from the stream
if ((width != fGrayImage.Width) || (height != fGrayImage.Height))
fGrayImage = new PixelArray<Lumb>(width, height);
TargaLuminanceRLE rlc = new TargaLuminanceRLE();
rlc.Decode(ms, fGrayImage);
// And finally, call the local PixBlt function
PixBltLumb(fGrayImage, x, y);
}
break;
case (int)UICommands.Showcursor:
{
ShowCursor();
}
break;
case (int)UICommands.HideCursor:
{
HideCursor();
}
break;
case (int)UICommands.MoveCursor:
{
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
MoveCursor(x, y);
}
break;
default:
//if (CommandReceived != null)
// CommandReceived(aRecord);
break;
}
}
public virtual void PixBltPixelBuffer24(GDIDIBSection pixMap, int x, int y)
{
PixelAccessorBGRb accessor = new PixelAccessorBGRb(pixMap.Width, pixMap.Height, pixMap.Orientation, pixMap.Pixels, pixMap.Width * 3);
fDynamicTexture.UpdateImage(accessor);
}
public void UpdateImage(PixelAccessorBGRb accessor)
{
latestFrame++;
if (accessor.Width != Width || accessor.Height != Height)
{
newWidth = accessor.Width;
newHeight = accessor.Height;
newPixels = accessor.Pixels;
fNeedsResize = true;
return;
}
fPixelPtr = accessor.Pixels;
}
void fCameraSender_ReceivedVideoFrameEvent(PixelAccessorBGRb accessor)
{
//ClientAreaGraphPort.PixBlt(accessor, 10, 10);
}
