/// <summary>

/// Reads and loads a Truevision TGA Format image file.

/// </summary>

internal class TargaImage : IDisposable

{

internal static class TargaConstants

{

// constant byte lengths for various fields in the Targa format

internal const int HeaderByteLength = 18;

internal const int FooterByteLength = 26;

internal const int FooterSignatureOffsetFromEnd = 18;

internal const int FooterSignatureByteLength = 16;

internal const int FooterReservedCharByteLength = 1;

internal const int ExtensionAreaAuthorNameByteLength = 41;

internal const int ExtensionAreaAuthorCommentsByteLength = 324;

internal const int ExtensionAreaJobNameByteLength = 41;

internal const int ExtensionAreaSoftwareIDByteLength = 41;

internal const int ExtensionAreaSoftwareVersionLetterByteLength = 1;

internal const int ExtensionAreaColorCorrectionTableValueLength = 256;

internal const string TargaFooterASCIISignature = "TRUEVISION-XFILE";

}

/// <summary>

/// The Targa format of the file.

/// </summary>

public enum TGAFormat

{

/// <summary>

/// Unknown Targa Image format.

/// </summary>

UNKNOWN = 0,

/// <summary>

/// Original Targa Image format.

/// </summary>

/// <remarks>Targa Image does not have a Signature of ""TRUEVISION-XFILE"".</remarks>

ORIGINAL_TGA = 100,

/// <summary>

/// New Targa Image format

/// </summary>

/// <remarks>Targa Image has a TargaFooter with a Signature of ""TRUEVISION-XFILE"".</remarks>

NEW_TGA = 200

}

/// <summary>

/// Indicates the type of color map, if any, included with the image file.

/// </summary>

public enum ColorMapTypes: byte

{

/// <summary>

/// No color map was included in the file.

/// </summary>

NO_COLOR_MAP = 0,

/// <summary>

/// Color map was included in the file.

/// </summary>

COLOR_MAP_INCLUDED = 1

}

/// <summary>

/// The type of image read from the file.

/// </summary>

public enum ImageType : byte

{

/// <summary>

/// No image data was found in file.

/// </summary>

NO_IMAGE_DATA = 0,

/// <summary>

/// Image is an uncompressed, indexed color-mapped image.

/// </summary>

UNCOMPRESSED_COLOR_MAPPED = 1,

/// <summary>

/// Image is an uncompressed, RGB image.

/// </summary>

UNCOMPRESSED_TRUE_COLOR = 2,

/// <summary>

/// Image is an uncompressed, Greyscale image.

/// </summary>

UNCOMPRESSED_BLACK_AND_WHITE = 3,

/// <summary>

/// Image is a compressed, indexed color-mapped image.

/// </summary>

RUN_LENGTH_ENCODED_COLOR_MAPPED = 9,

/// <summary>

/// Image is a compressed, RGB image.

/// </summary>

RUN_LENGTH_ENCODED_TRUE_COLOR = 10,

/// <summary>

/// Image is a compressed, Greyscale image.

/// </summary>

RUN_LENGTH_ENCODED_BLACK_AND_WHITE = 11

}

/// <summary>

/// The top-to-bottom ordering in which pixel data is transferred from the file to the screen.

/// </summary>

public enum VerticalTransferOrder

{

/// <summary>

/// Unknown transfer order.

/// </summary>

UNKNOWN = -1,

/// <summary>

/// Transfer order of pixels is from the bottom to top.

/// </summary>

BOTTOM = 0,

/// <summary>

/// Transfer order of pixels is from the top to bottom.

/// </summary>

TOP = 1

}

/// <summary>

/// The left-to-right ordering in which pixel data is transferred from the file to the screen.

/// </summary>

public enum HorizontalTransferOrder

{

/// <summary>

/// Unknown transfer order.

/// </summary>

UNKNOWN = -1,

/// <summary>

/// Transfer order of pixels is from the right to left.

/// </summary>

RIGHT = 0,

/// <summary>

/// Transfer order of pixels is from the left to right.

/// </summary>

LEFT = 1

}

/// <summary>

/// Screen destination of first pixel based on the VerticalTransferOrder and HorizontalTransferOrder.

/// </summary>

public enum FirstPixelDestination

{

/// <summary>

/// Unknown first pixel destination.

/// </summary>

UNKNOWN = 0,

/// <summary>

/// First pixel destination is the top-left corner of the image.

/// </summary>

TOP_LEFT = 1,

/// <summary>

/// First pixel destination is the top-right corner of the image.

/// </summary>

TOP_RIGHT = 2,

/// <summary>

/// First pixel destination is the bottom-left corner of the image.

/// </summary>

BOTTOM_LEFT = 3,

/// <summary>

/// First pixel destination is the bottom-right corner of the image.

/// </summary>

BOTTOM_RIGHT = 4

}

/// <summary>

/// The RLE packet type used in a RLE compressed image.

/// </summary>

public enum RLEPacketType

{

/// <summary>

/// A raw RLE packet type.

/// </summary>

RAW = 0,

/// <summary>

/// A run-length RLE packet type.

/// </summary>

RUN_LENGTH = 1

}

private TargaHeader objTargaHeader = null;

private TargaExtensionArea objTargaExtensionArea = null;

private TargaFooter objTargaFooter = null;

private Bitmap bmpTargaImage = null;

private Bitmap bmpImageThumbnail = null;

private TGAFormat eTGAFormat = TGAFormat.UNKNOWN;

private string strFileName = string.Empty;

private int intStride = 0;

private int intPadding = 0;

public byte[] ImageData = null;

public ColorPalette Palette = null;

private GCHandle ImageByteHandle;

private GCHandle ThumbnailByteHandle;

private System.Collections.Generic.List<System.Collections.Generic.List<byte>> rows = new System.Collections.Generic.List<System.Collections.Generic.List<byte>>();

private System.Collections.Generic.List<byte> row = new System.Collections.Generic.List<byte>();

// Track whether Dispose has been called.

private bool disposed = false;

/// <summary>

/// Creates a new instance of the TargaImage object.

/// </summary>

public TargaImage(TargaHeader prevHeader = null)

{

this.objTargaFooter = new TargaFooter();

this.objTargaHeader = prevHeader ?? new TargaHeader();

this.objTargaExtensionArea = new TargaExtensionArea();

this.bmpTargaImage = null;

this.bmpImageThumbnail = null;

}

/// <summary>

/// Gets a TargaHeader object that holds the Targa Header information of the loaded file.

/// </summary>

public TargaHeader Header

{

get { return this.objTargaHeader; }

}

/// <summary>

/// Gets a TargaExtensionArea object that holds the Targa Extension Area information of the loaded file.

/// </summary>

public TargaExtensionArea ExtensionArea

{

get { return this.objTargaExtensionArea; }

}

/// <summary>

/// Gets a TargaExtensionArea object that holds the Targa Footer information of the loaded file.

/// </summary>

public TargaFooter Footer

{

get { return this.objTargaFooter; }

}

/// <summary>

/// Gets the Targa format of the loaded file.

/// </summary>

public TGAFormat Format

{

get { return this.eTGAFormat; }

}

/// <summary>

/// Gets a Bitmap representation of the loaded file.

/// </summary>

/*public Bitmap Image

/// <summary>

/// Gets the thumbnail of the loaded file if there is one in the file.

/// </summary>

public Bitmap Thumbnail

{

get { return this.bmpImageThumbnail; }

}

/// <summary>

/// Gets the full path and filename of the loaded file.

/// </summary>

public string FileName

{

get { return this.strFileName; }

}

/// <summary>

/// Gets the byte offset between the beginning of one scan line and the next. Used when loading the image into the Image Bitmap.

/// </summary>

/// <remarks>

/// The memory allocated for Microsoft Bitmaps must be aligned on a 32bit boundary.

/// The stride refers to the number of bytes allocated for one scanline of the bitmap.

/// </remarks>

public int Stride

{

get { return this.intStride; }

}

/// <summary>

/// Gets the number of bytes used to pad each scan line to meet the Stride value. Used when loading the image into the Image Bitmap.

/// </summary>

/// <remarks>

/// The memory allocated for Microsoft Bitmaps must be aligned on a 32bit boundary.

/// The stride refers to the number of bytes allocated for one scanline of the bitmap.

/// In your loop, you copy the pixels one scanline at a time and take into

/// consideration the amount of padding that occurs due to memory alignment.

/// </remarks>

public int Padding

{

get { return this.intPadding; }

}

// Use C# destructor syntax for finalization code.

// This destructor will run only if the Dispose method

// does not get called.

// It gives your base class the opportunity to finalize.

// Do not provide destructors in types derived from this class.

/// <summary>

/// TargaImage deconstructor.

/// </summary>

~TargaImage()

{

// Do not re-create Dispose clean-up code here.

// Calling Dispose(false) is optimal in terms of

// readability and maintainability.

Dispose(false);

}

public void Save(MemoryStream ms, WriteableBitmap img)

{

TargaHeader header = new TargaHeader();

}

/// <summary>

/// Creates a new instance of the TargaImage object with strFileName as the image loaded.

/// </summary>

public TargaImage(string strFileName)

: this()

{

// make sure we have a .tga file

if (System.IO.Path.GetExtension(strFileName).ToLower() == ".tga")

{

// make sure the file exists

if (System.IO.File.Exists(strFileName) == true)

{

this.strFileName = strFileName;

MemoryStream filestream = null;

byte[] filebytes = null;

// load the file as an array of bytes

filebytes = System.IO.File.ReadAllBytes(this.strFileName);

if (filebytes != null && filebytes.Length > 0)

filestream = LoadFromStream(filebytes);

else

throw new Exception(@"Error loading file, could not read file from disk.");

}

else

throw new Exception(@"Error loading file, could not find file '" + strFileName + "' on disk.");

}

else

throw new Exception(@"Error loading file, file '" + strFileName + "' must have an extension of '.tga'.");

}

/// <summary>

/// Creates TGA image from stream.

/// </summary>

/// <param name="stream">Stream containing image.</param>

/// <param name="prevHeader">TargaHeader if previously loaded.</param>

public TargaImage(Stream stream, TargaHeader prevHeader = null) : this(prevHeader)

{

byte[] filebytes = stream.ReadBytes((int)stream.Length);

LoadFromStream(filebytes);

}

private MemoryStream LoadFromStream(byte[] filebytes)

{

MemoryStream filestream = null;

BinaryReader binReader = null;

// create a seekable memory stream of the file bytes

using (filestream = new MemoryStream(filebytes))

{

if (filestream != null && filestream.Length > 0 && filestream.CanSeek == true)

{

// create a BinaryReader used to read the Targa file

using (binReader = new BinaryReader(filestream))

{

this.LoadTGAFooterInfo(binReader);

if (Header.ImageType == ImageType.NO_IMAGE_DATA)

LoadTGAHeaderInfo(binReader, Header);

this.LoadTGAExtensionArea(binReader);

this.LoadTGAImage(binReader);

}

}

else

throw new Exception(@"Error loading file, could not read file from disk.");

}

return filestream;

}

/// <summary>

/// Loads the Targa Footer information from the file.

/// </summary>

/// <param name="binReader">A BinaryReader that points the loaded file byte stream.</param>

private void LoadTGAFooterInfo(BinaryReader binReader)

{

if (binReader != null && binReader.BaseStream != null && binReader.BaseStream.Length > 0 && binReader.BaseStream.CanSeek == true)

{

try

{

// set the cursor at the beginning of the signature string.

binReader.BaseStream.Seek((TargaConstants.FooterSignatureOffsetFromEnd * -1), SeekOrigin.End);

// read the signature bytes and convert to ascii string

string Signature = System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.FooterSignatureByteLength)).TrimEnd('\0');

// do we have a proper signature

if (string.Compare(Signature, TargaConstants.TargaFooterASCIISignature) == 0)

{

// this is a NEW targa file.

// create the footer

this.eTGAFormat = TGAFormat.NEW_TGA;

// set cursor to beginning of footer info

binReader.BaseStream.Seek((TargaConstants.FooterByteLength * -1), SeekOrigin.End);

// read the Extension Area Offset value

int ExtOffset = binReader.ReadInt32();

// read the Developer Directory Offset value

int DevDirOff = binReader.ReadInt32();

// skip the signature we have already read it.

binReader.ReadBytes(TargaConstants.FooterSignatureByteLength);

// read the reserved character

string ResChar = System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.FooterReservedCharByteLength)).TrimEnd('\0');

// set all values to our TargaFooter class

this.objTargaFooter.SetExtensionAreaOffset(ExtOffset);

this.objTargaFooter.SetDeveloperDirectoryOffset(DevDirOff);

this.objTargaFooter.SetSignature(Signature);

this.objTargaFooter.SetReservedCharacter(ResChar);

}

else

{

// this is not an ORIGINAL targa file.

this.eTGAFormat = TGAFormat.ORIGINAL_TGA;

}

}

catch (Exception ex)

{

// clear all

this.ClearAll();

throw ex;

}

}

else

{

this.ClearAll();

throw new Exception(@"Error loading file, could not read file from disk.");

}

}

/// <summary>

/// Loads the Targa Header information from the file.

/// </summary>

/// <param name="binReader">A BinaryReader that points the loaded file byte stream.</param>

public static void LoadTGAHeaderInfo(BinaryReader binReader, TargaHeader objTargaHeader)

{

if (binReader != null && binReader.BaseStream != null && binReader.BaseStream.Length > 0 && binReader.BaseStream.CanSeek == true)

{

try

{

// set the cursor at the beginning of the file.

binReader.BaseStream.Seek(0, SeekOrigin.Begin);

// read the header properties from the file

objTargaHeader.SetImageIDLength(binReader.ReadByte());

objTargaHeader.SetColorMapType((ColorMapTypes)binReader.ReadByte());

objTargaHeader.SetImageType((ImageType)binReader.ReadByte());

objTargaHeader.SetColorMapFirstEntryIndex(binReader.ReadInt16());

objTargaHeader.SetColorMapLength(binReader.ReadInt16());

objTargaHeader.SetColorMapEntrySize(binReader.ReadByte());

objTargaHeader.SetXOrigin(binReader.ReadInt16());

objTargaHeader.SetYOrigin(binReader.ReadInt16());

objTargaHeader.SetWidth(binReader.ReadInt16());

objTargaHeader.SetHeight(binReader.ReadInt16());

byte pixeldepth = binReader.ReadByte();

switch (pixeldepth)

{

case 8:

case 16:

case 24:

case 32:

objTargaHeader.SetPixelDepth(pixeldepth);

break;

default:

throw new Exception("Targa Image only supports 8, 16, 24, or 32 bit pixel depths.");

}

byte ImageDescriptor = binReader.ReadByte();

objTargaHeader.SetAttributeBits((byte)Utilities.GetBits(ImageDescriptor, 0, 4));

objTargaHeader.SetVerticalTransferOrder((VerticalTransferOrder)Utilities.GetBits(ImageDescriptor, 5, 1));

objTargaHeader.SetHorizontalTransferOrder((HorizontalTransferOrder)Utilities.GetBits(ImageDescriptor, 4, 1));

// load ImageID value if any

if (objTargaHeader.ImageIDLength > 0)

{

byte[] ImageIDValueBytes = binReader.ReadBytes(objTargaHeader.ImageIDLength);

objTargaHeader.SetImageIDValue(System.Text.Encoding.ASCII.GetString(ImageIDValueBytes).TrimEnd('\0'));

}

}

catch (Exception ex)

{

throw ex;

}

// load color map if it's included and/or needed

// Only needed for UNCOMPRESSED_COLOR_MAPPED and RUN_LENGTH_ENCODED_COLOR_MAPPED

// image types. If color map is included for other file types we can ignore it.

if (objTargaHeader.ColorMapType == ColorMapTypes.COLOR_MAP_INCLUDED)

{

if (objTargaHeader.ImageType == ImageType.UNCOMPRESSED_COLOR_MAPPED ||

objTargaHeader.ImageType == ImageType.RUN_LENGTH_ENCODED_COLOR_MAPPED)

{

if (objTargaHeader.ColorMapLength > 0)

{

try

{

for (int i = 0; i < objTargaHeader.ColorMapLength; i++)

{

int a = 0;

int r = 0;

int g = 0;

int b = 0;

// load each color map entry based on the ColorMapEntrySize value

switch (objTargaHeader.ColorMapEntrySize)

{

case 15:

byte[] color15 = binReader.ReadBytes(2);

// remember that the bytes are stored in reverse oreder

objTargaHeader.ColorMap.Add(Utilities.GetColorFrom2Bytes(color15[1], color15[0]));

break;

case 16:

byte[] color16 = binReader.ReadBytes(2);

// remember that the bytes are stored in reverse oreder

objTargaHeader.ColorMap.Add(Utilities.GetColorFrom2Bytes(color16[1], color16[0]));

break;

case 24:

b = Convert.ToInt32(binReader.ReadByte());

g = Convert.ToInt32(binReader.ReadByte());

r = Convert.ToInt32(binReader.ReadByte());

objTargaHeader.ColorMap.Add(System.Drawing.Color.FromArgb(r, g, b));

break;

case 32:

a = Convert.ToInt32(binReader.ReadByte());

b = Convert.ToInt32(binReader.ReadByte());

g = Convert.ToInt32(binReader.ReadByte());

r = Convert.ToInt32(binReader.ReadByte());

objTargaHeader.ColorMap.Add(System.Drawing.Color.FromArgb(a, r, g, b));

break;

default:

throw new Exception("TargaImage only supports ColorMap Entry Sizes of 15, 16, 24 or 32 bits.");

}

}

}

catch (Exception ex)

{

throw ex;

}

}

else

{

throw new Exception("Image Type requires a Color Map and Color Map Length is zero.");

}

}

}

else

{

if (objTargaHeader.ImageType == ImageType.UNCOMPRESSED_COLOR_MAPPED ||

objTargaHeader.ImageType == ImageType.RUN_LENGTH_ENCODED_COLOR_MAPPED)

{

throw new Exception("Image Type requires a Color Map and there was not a Color Map included in the file.");

}

}

}

else

{

throw new Exception(@"Error loading file, could not read file from disk.");

}

}

/// <summary>

/// Loads the Targa Extension Area from the file, if it exists.

/// </summary>

/// <param name="binReader">A BinaryReader that points the loaded file byte stream.</param>

private void LoadTGAExtensionArea(BinaryReader binReader)

{

if (binReader != null && binReader.BaseStream != null && binReader.BaseStream.Length > 0 && binReader.BaseStream.CanSeek == true)

{

// is there an Extension Area in file

if (this.objTargaFooter.ExtensionAreaOffset > 0)

{

try

{

// set the cursor at the beginning of the Extension Area using ExtensionAreaOffset.

binReader.BaseStream.Seek(this.objTargaFooter.ExtensionAreaOffset, SeekOrigin.Begin);

// load the extension area fields from the file

this.objTargaExtensionArea.SetExtensionSize((int)(binReader.ReadInt16()));

this.objTargaExtensionArea.SetAuthorName(System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.ExtensionAreaAuthorNameByteLength)).TrimEnd('\0'));

this.objTargaExtensionArea.SetAuthorComments(System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.ExtensionAreaAuthorCommentsByteLength)).TrimEnd('\0'));

// get the date/time stamp of the file

Int16 iMonth = binReader.ReadInt16();

Int16 iDay = binReader.ReadInt16();

Int16 iYear = binReader.ReadInt16();

Int16 iHour = binReader.ReadInt16();

Int16 iMinute = binReader.ReadInt16();

Int16 iSecond = binReader.ReadInt16();

DateTime dtstamp;

string strStamp = iMonth.ToString() + @"/" + iDay.ToString() + @"/" + iYear.ToString() + @" ";

strStamp += iHour.ToString() + @":" + iMinute.ToString() + @":" + iSecond.ToString();

if (DateTime.TryParse(strStamp, out dtstamp) == true)

this.objTargaExtensionArea.SetDateTimeStamp(dtstamp);

this.objTargaExtensionArea.SetJobName(System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.ExtensionAreaJobNameByteLength)).TrimEnd('\0'));

// get the job time of the file

iHour = binReader.ReadInt16();

iMinute = binReader.ReadInt16();

iSecond = binReader.ReadInt16();

TimeSpan ts = new TimeSpan((int)iHour, (int)iMinute, (int)iSecond);

this.objTargaExtensionArea.SetJobTime(ts);

this.objTargaExtensionArea.SetSoftwareID(System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.ExtensionAreaSoftwareIDByteLength)).TrimEnd('\0'));

// get the version number and letter from file

float iVersionNumber = (float)binReader.ReadInt16() / 100.0F;

string strVersionLetter = System.Text.Encoding.ASCII.GetString(binReader.ReadBytes(TargaConstants.ExtensionAreaSoftwareVersionLetterByteLength)).TrimEnd('\0');

this.objTargaExtensionArea.SetSoftwareID(iVersionNumber.ToString(@"F2") + strVersionLetter);

// get the color key of the file

int a = (int)binReader.ReadByte();

int r = (int)binReader.ReadByte();

int b = (int)binReader.ReadByte();

int g = (int)binReader.ReadByte();

this.objTargaExtensionArea.SetKeyColor(Color.FromArgb(a, r, g, b));

this.objTargaExtensionArea.SetPixelAspectRatioNumerator((int)binReader.ReadInt16());

this.objTargaExtensionArea.SetPixelAspectRatioDenominator((int)binReader.ReadInt16());

this.objTargaExtensionArea.SetGammaNumerator((int)binReader.ReadInt16());

this.objTargaExtensionArea.SetGammaDenominator((int)binReader.ReadInt16());

this.objTargaExtensionArea.SetColorCorrectionOffset(binReader.ReadInt32());

this.objTargaExtensionArea.SetPostageStampOffset(binReader.ReadInt32());

this.objTargaExtensionArea.SetScanLineOffset(binReader.ReadInt32());

this.objTargaExtensionArea.SetAttributesType((int)binReader.ReadByte());

// load Scan Line Table from file if any

if (this.objTargaExtensionArea.ScanLineOffset > 0)

{

binReader.BaseStream.Seek(this.objTargaExtensionArea.ScanLineOffset, SeekOrigin.Begin);

for (int i = 0; i < this.objTargaHeader.Height; i++)

{

this.objTargaExtensionArea.ScanLineTable.Add(binReader.ReadInt32());

}

}

// load Color Correction Table from file if any

if (this.objTargaExtensionArea.ColorCorrectionOffset > 0)

{

binReader.BaseStream.Seek(this.objTargaExtensionArea.ColorCorrectionOffset, SeekOrigin.Begin);

for (int i = 0; i < TargaConstants.ExtensionAreaColorCorrectionTableValueLength; i++)

{

a = (int)binReader.ReadInt16();

r = (int)binReader.ReadInt16();

b = (int)binReader.ReadInt16();

g = (int)binReader.ReadInt16();

this.objTargaExtensionArea.ColorCorrectionTable.Add(Color.FromArgb(a, r, g, b));

}

}

}

catch (Exception ex)

{

this.ClearAll();

throw ex;

}

}

}

else

{

this.ClearAll();

throw new Exception(@"Error loading file, could not read file from disk.");

}

}

/// <summary>

/// Reads the image data bytes from the file. Handles Uncompressed and RLE Compressed image data.

/// Uses FirstPixelDestination to properly align the image.

/// </summary>

/// <param name="binReader">A BinaryReader that points the loaded file byte stream.</param>

/// <returns>An array of bytes representing the image data in the proper alignment.</returns>

private byte[] LoadImageBytes(BinaryReader binReader)

{

// read the image data into a byte array

// take into account stride has to be a multiple of 4

// use padding to make sure multiple of 4

byte[] data = null;

if (binReader != null && binReader.BaseStream != null && binReader.BaseStream.Length > 0 && binReader.BaseStream.CanSeek == true)

{

if (this.objTargaHeader.ImageDataOffset > 0)

{

// padding bytes

byte[] padding = new byte[this.intPadding];

MemoryStream msData = null;

// seek to the beginning of the image data using the ImageDataOffset value

binReader.BaseStream.Seek(this.objTargaHeader.ImageDataOffset, SeekOrigin.Begin);

// get the size in bytes of each row in the image

int intImageRowByteSize = (int)this.objTargaHeader.Width * ((int)this.objTargaHeader.BytesPerPixel);

// get the size in bytes of the whole image

int intImageByteSize = intImageRowByteSize * (int)this.objTargaHeader.Height;

// is this a RLE compressed image type

if (this.objTargaHeader.ImageType == ImageType.RUN_LENGTH_ENCODED_BLACK_AND_WHITE ||

this.objTargaHeader.ImageType == ImageType.RUN_LENGTH_ENCODED_COLOR_MAPPED ||

this.objTargaHeader.ImageType == ImageType.RUN_LENGTH_ENCODED_TRUE_COLOR)

{

#region COMPRESSED

// RLE Packet info

byte bRLEPacket = 0;

int intRLEPacketType = -1;

int intRLEPixelCount = 0;

byte[] bRunLengthPixel = null;

// used to keep track of bytes read

int intImageBytesRead = 0;

int intImageRowBytesRead = 0;

// keep reading until we have the all image bytes

while (intImageBytesRead < intImageByteSize)

{

// get the RLE packet

bRLEPacket = binReader.ReadByte();

intRLEPacketType = Utilities.GetBits(bRLEPacket, 7, 1);

intRLEPixelCount = Utilities.GetBits(bRLEPacket, 0, 7) + 1;

// check the RLE packet type

if ((RLEPacketType)intRLEPacketType == RLEPacketType.RUN_LENGTH)

{

// get the pixel color data

bRunLengthPixel = binReader.ReadBytes((int)this.objTargaHeader.BytesPerPixel);

// add the number of pixels specified using the read pixel color

for (int i = 0; i < intRLEPixelCount; i++)

{

foreach (byte b in bRunLengthPixel)

row.Add(b);

// increment the byte counts

intImageRowBytesRead += bRunLengthPixel.Length;

intImageBytesRead += bRunLengthPixel.Length;

// if we have read a full image row

// add the row to the row list and clear it

// restart row byte count

if (intImageRowBytesRead == intImageRowByteSize)

{

rows.Add(row);

row = new System.Collections.Generic.List<byte>();

intImageRowBytesRead = 0;

}

}

}

else if ((RLEPacketType)intRLEPacketType == RLEPacketType.RAW)

{

// get the number of bytes to read based on the read pixel count

int intBytesToRead = intRLEPixelCount * (int)this.objTargaHeader.BytesPerPixel;

// read each byte

for (int i = 0; i < intBytesToRead; i++)

{

row.Add(binReader.ReadByte());

// increment the byte counts

intImageBytesRead++;

intImageRowBytesRead++;

// if we have read a full image row

// add the row to the row list and clear it

// restart row byte count

if (intImageRowBytesRead == intImageRowByteSize)

{

rows.Add(row);

row = new System.Collections.Generic.List<byte>();

intImageRowBytesRead = 0;

}

}

}

}

#endregion

}

else

{

#region NON-COMPRESSED

// loop through each row in the image

for (int i = 0; i < (int)this.objTargaHeader.Height; i++)

{

// loop through each byte in the row

for (int j = 0; j < intImageRowByteSize; j++)

{

// add the byte to the row

row.Add(binReader.ReadByte());

}

// add row to the list of rows

rows.Add(row);

// create a new row

row = new System.Collections.Generic.List<byte>();

}

#endregion

}

// flag that states whether or not to reverse the location of all rows.

bool blnRowsReverse = false;

// flag that states whether or not to reverse the bytes in each row.

bool blnEachRowReverse = false;

// use FirstPixelDestination to determine the alignment of the

// image data byte

switch (this.objTargaHeader.FirstPixelDestination)

{

case FirstPixelDestination.TOP_LEFT:

blnRowsReverse = false;

blnEachRowReverse = true;

break;

case FirstPixelDestination.TOP_RIGHT:

blnRowsReverse = false;

blnEachRowReverse = false;

break;

case FirstPixelDestination.BOTTOM_LEFT:

blnRowsReverse = true;

blnEachRowReverse = true;

break;

case FirstPixelDestination.BOTTOM_RIGHT:

case FirstPixelDestination.UNKNOWN:

blnRowsReverse = true;

blnEachRowReverse = false;

break;

}

// write the bytes from each row into a memory stream and get the

// resulting byte array

using (msData = new MemoryStream())

{

// do we reverse the rows in the row list.

if (blnRowsReverse == true)

rows.Reverse();

// go through each row

for (int i = 0; i < rows.Count; i++)