internal static byte[] GetIndexedSMask(byte[] Img, int w, int h, byte[] tRNS, int BitsPerPixel)
{
int ScanLine = 1 + (w - 1) * BitsPerPixel / 8 + 1; //RowFilter+Bytes needed for a row.
byte[] RawImage = DecodeImage(Img, w, h, ScanLine);
byte[] SMask = BitsPerPixel == 8? RawImage: new byte[h * (w + 1)]; //no need for a new array if the image depth is 8.
int ScanPos = 0;
int SMaskPos = 1; //first byte is the row filter, already in 0.
byte MaxBit = (byte)(8 / BitsPerPixel);
byte[] Sh = new byte[8]; //Cached for speed.
byte[] Sr = new byte[8]; //Cached for speed.
for (int i = 0; i < BitsPerPixel; i++)
{
Sh[0] |= (byte)(1 << i);
}
for (int bit = 1; bit < MaxBit; bit++)
{
Sh[bit] = (byte)(Sh[bit - 1] << BitsPerPixel);
Sr[bit] = (byte)(Sr[bit - 1] + BitsPerPixel); //Sr[0]=0
}
for (int r = 0; r < h; r++)
{
int MaxSMaskPos = SMaskPos + w; //Some images might use only a part of the last byte.
for (int c = 1; c < ScanLine; c++)
{
byte b = RawImage[ScanPos + c];
for (int bit = MaxBit - 1; bit >= 0; bit--)
{
if (SMaskPos >= MaxSMaskPos)
{
break;
}
byte b0 = (byte)((b & Sh[bit]) >> Sr[bit]); byte x = b0 < tRNS.Length? (byte)tRNS[b0] : (byte)255;
SMask[SMaskPos] = x;
SMaskPos++;
}
}
ScanPos += ScanLine;
SMaskPos++; //Rowfilter
}
using (TCompressor Cmp = new TCompressor())
{
using (MemoryStream ms = new MemoryStream())
{
Cmp.Deflate(SMask, 0, ms);
return(ms.ToArray());
}
}
}
public static byte[] CompressData(byte[] Data)
{
using (TCompressor Cmp = new TCompressor())
{
using (MemoryStream ms = new MemoryStream())
{
Cmp.Deflate(Data, 0, ms);
return(ms.ToArray());
}
}
}
//Current implementation of TCompressor is not thread safe.
//private static TCompressor Cmp=null; //Wont be created until needed. //STATIC*
//[MethodImpl(MethodImplOptions.NoInlining)] //We don't want to check for ZLib until we are here.
internal static void ToXls(Byte[] ImgData, Stream OutStream, bool IsEMF)
{
#if (FRAMEWORK30 || !COMPACTFRAMEWORK)
int HeadOfs = 0;
if (!IsEMF && ImgData.Length > 4 && BitConverter.ToUInt32(ImgData, 0) == 0x9AC6CDD7)
{
HeadOfs += 22; //A wmf file might have a placeable header or not. If it does, it begins with the magic number 9AC6CDD7 and it must be stripped.
}
using (TCompressor Cmp = new TCompressor())
{
Cmp.Deflate(ImgData, HeadOfs, OutStream);
}
#else
throw new FlexCelException("Operation not supported in CF 2.0");
#endif
}
private static byte[] DecodeImage(byte[] Img, int w, int h, int ScanLine)
{
using (TCompressor Cmp = new TCompressor())
{
if (w <= 0)
{
return(new byte[2]);
}
byte[] Result = new byte[h * ScanLine];
using (MemoryStream InflatedStream = new MemoryStream())
{
unchecked
{
Cmp.Inflate(Img, 0, InflatedStream);
InflatedStream.Position = 0;
Sh.Read(InflatedStream, Result, 0, h * ScanLine);
return(UnFilter(Result, ScanLine, h));
}
}
}
}
//[MethodImpl(MethodImplOptions.NoInlining)] //We don't want to check for ZLib until we are here.
internal static void ToWMF(byte[] XlsData, int Offset, Stream OutStream, bool IsEMF)
{
if (!IsEMF)
{
WmfHeader WmfHead = new WmfHeader();
WmfHead.Key = 0x9AC6CDD7;
//On Xls format coords are 32 bits, on wmf file format they are 16. That's why we have to convert.
//catch overflows. We could use unchecked here, but this way we setup the final result.
try{ WmfHead.Left = (Int16)BitConverter.ToInt32(XlsData, Offset + 4 + 0); }
catch (OverflowException) { WmfHead.Left = 0; }
try{ WmfHead.Top = (Int16)BitConverter.ToInt32(XlsData, Offset + 4 + 4); }
catch (OverflowException) { WmfHead.Top = 0; }
try{ WmfHead.Right = (Int16)BitConverter.ToInt32(XlsData, Offset + 4 + 8); }
catch (OverflowException) { WmfHead.Right = 0xFFF; }
try{ WmfHead.Bottom = (Int16)BitConverter.ToInt32(XlsData, Offset + 4 + 12); }
catch (OverflowException) { WmfHead.Bottom = 0xFFF; }
WmfHead.Inch = 96;
WmfHead.CheckSum = ComputeAldusCheckSum(WmfHead.Data);
OutStream.Write(WmfHead.Data, 0, WmfHead.Data.Length);
}
//Common part on EMF and WMF
int IsCompressed = XlsData[Offset + 32];
#if (FRAMEWORK30 || !COMPACTFRAMEWORK)
if (IsCompressed == 0) //Data is compressed.
{
using (TCompressor Cmp = new TCompressor())
{
Cmp.Inflate(XlsData, Offset + 34, OutStream);
}
}
#else
throw new FlexCelException("Operation not supported in CF 2.0");
#endif
}
//We can't crop the image here, without changing the filters.
private static void SuppressAlpha(TPdfPngData OutData, byte IntBytes)
{
using (TCompressor Cmp = new TCompressor())
{
using (TCompressor Cmp2 = new TCompressor())
{
using (TCompressor Cmp3 = new TCompressor())
{
const int BuffLen = 4096;
bool MaskEmpty = true;
bool IsOneBitMask = true;
int h = (int)OutData.Height;
int w = (int)OutData.Width;
#if (FRAMEWORK20 || ICSHARP) && !COMPACTFRAMEWORK
byte[] NewData = new byte[BuffLen + IntBytes];
byte[] SMask = new byte[BuffLen + 1];
byte[] OneBitMask = new byte[BuffLen + 1];
#else
sbyte[] NewData = new sbyte[BuffLen + IntBytes];
sbyte[] SMask = new sbyte[BuffLen + 1];
sbyte[] OneBitMask = new sbyte[BuffLen + 1];
#endif
using (MemoryStream InflatedStream = new MemoryStream())
{
unchecked
{
int NewDataPos = 0;
int SMaskPos = 0;
int OneBitMaskPos = 0;
Cmp.Inflate(OutData.Data.ToArray(), 0, InflatedStream);
InflatedStream.Position = 0;
Cmp.BeginDeflate();
Cmp2.BeginDeflate();
Cmp3.BeginDeflate();
OutData.Data.SetLength(0); Stream OutStream = OutData.Data;
using (MemoryStream SMaskStream = new MemoryStream())
{
using (MemoryStream OneBitMaskStream = new MemoryStream())
{
int OneBitMaskInnerPos = 128;
for (int r = 0; r < h; r++)
{
byte LastSMask = 0;
#if (FRAMEWORK20 || ICSHARP) && !COMPACTFRAMEWORK
byte RowFilter = (byte)InflatedStream.ReadByte();
#else
sbyte RowFilter = (sbyte)InflatedStream.ReadByte();
#endif
#region inlined //for speed on debug mode
if (NewDataPos >= BuffLen)
{
Cmp.IncDeflate(NewData, 0, NewDataPos, OutStream);
NewDataPos = 0;
}
if (SMaskPos >= BuffLen)
{
Cmp2.IncDeflate(SMask, 0, SMaskPos, SMaskStream);
SMaskPos = 0;
}
if (OneBitMaskPos >= BuffLen)
{
Cmp3.IncDeflate(OneBitMask, 0, OneBitMaskPos, OneBitMaskStream);
OneBitMaskPos = 0;
OneBitMask[OneBitMaskPos] = 0;
OneBitMaskInnerPos = 128;
}
#endregion
NewData[NewDataPos++] = RowFilter;
SMask[SMaskPos++] = RowFilter;
if (IsOneBitMask)
{
if (OneBitMaskInnerPos < 128)
{
OneBitMaskPos++; //finish row.
OneBitMask[OneBitMaskPos] = 0;
OneBitMaskInnerPos = 128;
}
}
for (int c = 0; c < w; c++)
{
#region inlined //for speed on debug mode
if (NewDataPos >= BuffLen)
{
Cmp.IncDeflate(NewData, 0, NewDataPos, OutStream);
NewDataPos = 0;
}
if (SMaskPos >= BuffLen)
{
Cmp2.IncDeflate(SMask, 0, SMaskPos, SMaskStream);
SMaskPos = 0;
}
if (OneBitMaskPos >= BuffLen)
{
Cmp3.IncDeflate(OneBitMask, 0, OneBitMaskPos, OneBitMaskStream);
OneBitMaskPos = 0;
OneBitMask[OneBitMaskPos] = 0;
OneBitMaskInnerPos = 128;
}
#endregion
for (int b = 0; b < IntBytes; b++)
#if (FRAMEWORK20 || ICSHARP) && !COMPACTFRAMEWORK
{
NewData[NewDataPos++] = (byte)InflatedStream.ReadByte();
}
byte SMaskData = (byte)InflatedStream.ReadByte();
SMask[SMaskPos++] = SMaskData;
#else
{
NewData[NewDataPos++] = (sbyte)InflatedStream.ReadByte();
}
byte SMaskData = (byte)InflatedStream.ReadByte();
SMask[SMaskPos++] = (sbyte)SMaskData;
#endif
if (MaskEmpty && SMaskData != 0xFF)
{
MaskEmpty = false;
}
if (IsOneBitMask)
{
//SMaskData might have been flushed, and so contain invalid data.
//So we need a separate LastSMask for sub filter, and the whole last scanline for the others.
//As this is only an optimization (it will work the same with an SMask), we will only contemplate filters 0 and 1.
if (RowFilter == 1) //sub
{
unchecked { SMaskData += LastSMask; }
LastSMask = SMaskData;
}
if (RowFilter > 1 || (SMaskData != 0xFF && SMaskData != 0))
{
IsOneBitMask = false;
}
else
{
#if (FRAMEWORK20 || ICSHARP) && !COMPACTFRAMEWORK
OneBitMask[OneBitMaskPos] |= (byte)(~SMaskData & OneBitMaskInnerPos);
#else
OneBitMask[OneBitMaskPos] = (sbyte)((byte)OneBitMask[OneBitMaskPos] | (~(byte)SMaskData & OneBitMaskInnerPos));
#endif
if (OneBitMaskInnerPos > 1)
{
OneBitMaskInnerPos >>= 1;
}
else
{
OneBitMaskPos++;
OneBitMask[OneBitMaskPos] = 0;
OneBitMaskInnerPos = 128;
}
}
}
}
}
#region inlined //for speed on debug mode
if (NewDataPos > 0)
{
Cmp.IncDeflate(NewData, 0, NewDataPos, OutStream);
NewDataPos = 0;
}
if (SMaskPos > 0)
{
Cmp2.IncDeflate(SMask, 0, SMaskPos, SMaskStream);
SMaskPos = 0;
}
if (OneBitMaskPos > 0)
{
if (OneBitMaskInnerPos < 128)
{
OneBitMaskPos++; //finish row.
}
Cmp3.IncDeflate(OneBitMask, 0, OneBitMaskPos, OneBitMaskStream);
OneBitMaskPos = 0;
OneBitMask[OneBitMaskPos] = 0;
}
#endregion
Cmp.EndDeflate(OutStream);
Cmp2.EndDeflate(SMaskStream);
Cmp3.EndDeflate(OneBitMaskStream);
if (!MaskEmpty)
{
if (IsOneBitMask)
{
OutData.OneBitMask = OneBitMaskStream.ToArray();
}
OutData.SMask = SMaskStream.ToArray();
}
}
}
}
}
}
}
}
}
