public static byte[] GetBytesForUint64(ulong value, Endianess endian)
{
byte[] bRet = new byte[8];
if (endian == Endianess.Big)
{
bRet[0] = (byte)((value & 0xFF00000000000000) >> 56);
bRet[1] = (byte)((value & 0x00FF000000000000) >> 48);
bRet[2] = (byte)((value & 0x0000FF0000000000) >> 40);
bRet[3] = (byte)((value & 0x000000FF00000000) >> 32);
bRet[4] = (byte)((value & 0x00000000FF000000) >> 24);
bRet[5] = (byte)((value & 0x0000000000FF0000) >> 16);
bRet[6] = (byte)((value & 0x000000000000FF00) >> 8);
bRet[7] = (byte)((value & 0x00000000000000FF));
}
else
{
bRet[7] = (byte)((value & 0xFF00000000000000) >> 56);
bRet[6] = (byte)((value & 0x00FF000000000000) >> 48);
bRet[5] = (byte)((value & 0x0000FF0000000000) >> 40);
bRet[4] = (byte)((value & 0x000000FF00000000) >> 32);
bRet[3] = (byte)((value & 0x00000000FF000000) >> 24);
bRet[2] = (byte)((value & 0x0000000000FF0000) >> 16);
bRet[1] = (byte)((value & 0x000000000000FF00) >> 8);
bRet[0] = (byte)((value & 0x00000000000000FF));
}
return bRet;
}
public static IPixelBlender GetBlender(PixelFormat backBuffer, Endianess backBufferEndianess, PixelFormat fronBuffer, Endianess frontBufferEndianes, PixelFormat output, Endianess outputEndianess, PixelFormat? clutForegroundFormat = null, PixelFormat? clutBackgroundFormat = null)
{
var blenderConfiguration = Tuple.Create(backBuffer, backBufferEndianess, fronBuffer, frontBufferEndianes, output, outputEndianess);
if(!blendersCache.ContainsKey(blenderConfiguration))
{
blendersCache[blenderConfiguration] = new PixelBlender(backBuffer, fronBuffer, output,
GenerateBlendMethod(
new BufferDescriptor
{
ColorFormat = backBuffer,
ClutColorFormat = clutBackgroundFormat,
DataEndianness = backBufferEndianess
},
new BufferDescriptor
{
ColorFormat = fronBuffer,
ClutColorFormat = clutForegroundFormat,
DataEndianness = frontBufferEndianes
},
new BufferDescriptor
{
ColorFormat = output,
DataEndianness = outputEndianess
}));
}
return blendersCache[blenderConfiguration];
}
public static IPixelBlender GetBlender(PixelFormat backBuffer, Endianess backBufferEndianess, PixelFormat fronBuffer, Endianess frontBufferEndianes, PixelFormat output, Endianess outputEndianess)
{
var tuple = Tuple.Create(backBuffer, backBufferEndianess, fronBuffer, frontBufferEndianes, output, outputEndianess);
if(!blendersCache.ContainsKey(tuple))
{
blendersCache[tuple] = new PixelBlender(backBuffer, fronBuffer, output, GenerateBlendMethod(backBuffer, backBufferEndianess, fronBuffer, frontBufferEndianes, output, outputEndianess));
}
return blendersCache[tuple];
}
public static IPixelConverter GetConverter(PixelFormat input, Endianess inputEndianess, PixelFormat output, Endianess outputEndianess)
{
var tuple = Tuple.Create(input, inputEndianess, output, outputEndianess);
if(!convertersCache.ContainsKey(tuple))
{
convertersCache[tuple] = ((input == output) && (inputEndianess == outputEndianess)) ?
(IPixelConverter) new IdentityPixelConverter(input) :
new PixelConverter(input, output, GenerateConvertMethod(input, inputEndianess, output, outputEndianess));
}
return convertersCache[tuple];
}
public static Int16 ToInt16(this Byte[] source, Endianess endianess, Int32 startIndex = 0)
{
var bytes = source.Copy(startIndex, NumberHelpers.Int16ByteCount);
if (NumberHelpers.Endianess != endianess)
{
bytes.Swap();
}
return bytes.ToInt16();
}
public CortexM(string cpuType, Machine machine, NVIC nvic, Endianess endianness = Endianess.LittleEndian) : base(cpuType, machine, endianness)
{
if(nvic == null)
{
throw new RecoverableException(new ArgumentNullException("nvic"));
}
this.nvic = nvic;
nvic.AttachCPU(this);
Init();
}
/// <summary>
/// Creates new QMessage object.
/// </summary>
/// <param name="data"> data payload</param>
/// <param name="messageType">type of the q message</param>
/// <param name="endianess">endianess of the data</param>
/// <param name="compressed">true if message was compressed, false otherwise</param>
/// <param name="raw">true if raw message was retrieved, false if message was parsed</param>
/// <param name="messageSize">size of the message</param>
/// <param name="dataSize">size of the data payload section</param>
public QMessage(object data, MessageType messageType, Endianess endianess, bool compressed, bool raw, int messageSize, int dataSize)
: this()
{
Data = data;
MessageType = messageType;
Endianess = endianess;
Compressed = compressed;
Raw = raw;
MessageSize = messageSize;
DataSize = dataSize;
}
public void Read(Stream inputStream)
{
BinaryReader headerReader = new BinaryReader(inputStream, Encoding.UTF8, true);
BinaryReader reader;
int magicNumber = headerReader.ReadInt32();
int version = headerReader.ReadInt32(); // GZ 2, TPP 3
int endianess = headerReader.ReadInt32(); // LE, BE
switch (endianess)
{
case LittleEndianConstant: // LE
Endianess = Endianess.LittleEndian;
reader = headerReader;
break;
case BigEndianConstant: // BE
Endianess = Endianess.BigEndian;
version = EndianessBitConverter.FlipEndianess(version);
reader = new BigEndianBinaryReader(inputStream, Encoding.UTF8, true);
break;
default:
throw new Exception(string.Format("Unknown endianess: {0:X}", endianess));
}
int entryCount = reader.ReadInt32();
int valuesOffset = reader.ReadInt32();
int keysOffset = reader.ReadInt32();
inputStream.Position = valuesOffset;
Dictionary<int, LangEntry> offsetEntryDictionary = new Dictionary<int, LangEntry>();
for (int i = 0; i < entryCount; i++)
{
int valuePosition = (int)inputStream.Position - valuesOffset;
short valueConstant = headerReader.ReadInt16();
Debug.Assert(valueConstant == 1);
string value = reader.ReadNullTerminatedString();
offsetEntryDictionary.Add(valuePosition, new LangEntry
{
Value = value
});
}
inputStream.Position = keysOffset;
for (int i = 0; i < entryCount; i++)
{
uint key = reader.ReadUInt32();
int offset = reader.ReadInt32();
offsetEntryDictionary[offset].Key = key;
}
Entries = offsetEntryDictionary.Values.ToList();
}
public static byte[] GetBytesForInt32(int value, Endianess endian)
{
byte[] bRet = new byte[4];
if (endian == Endianess.Big)
{
bRet[0] = (byte)((value & 0xFF000000) >> 24);
bRet[1] = (byte)((value & 0xFF0000) >> 16);
bRet[2] = (byte)((value & 0x00FF00) >> 8);
bRet[3] = (byte)((value & 0x0000FF));
}
else
{
bRet[3] = (byte)((value & 0xFF000000) >> 24);
bRet[2] = (byte)((value & 0xFF0000) >> 16);
bRet[1] = (byte)((value & 0x00FF00) >> 8);
bRet[0] = (byte)((value & 0x0000FF));
}
return bRet;
}
public static IPixelConverter GetConverter(PixelFormat inputFormat, Endianess inputEndianess, PixelFormat outputFormat, Endianess outputEndianess, PixelFormat? clutInputFormat = null)
{
var converterConfiguration = Tuple.Create(inputFormat, inputEndianess, outputFormat, outputEndianess);
if(!convertersCache.ContainsKey(converterConfiguration))
{
convertersCache[converterConfiguration] = ((inputFormat == outputFormat) && (inputEndianess == outputEndianess)) ?
(IPixelConverter)new IdentityPixelConverter(inputFormat) :
new PixelConverter(inputFormat, outputFormat, GenerateConvertMethod(
new BufferDescriptor
{
ColorFormat = inputFormat,
ClutColorFormat = clutInputFormat,
DataEndianness = inputEndianess
},
new BufferDescriptor
{
ColorFormat = outputFormat,
DataEndianness = outputEndianess
}));
}
return convertersCache[converterConfiguration];
}
protected TranslationCPU(string cpuType, Machine machine, Endianess endianness)
{
if(cpuType == null)
{
throw new RecoverableException(new ArgumentNullException("cpuType"));
}
oldMaximumBlockSize = -1;
Endianness = endianness;
PerformanceInMips = 100;
currentCountThreshold = 5000;
this.cpuType = cpuType;
DisableInterruptsWhileStepping = true;
ClockSource = new BaseClockSource();
ClockSource.NumberOfEntriesChanged += (oldValue, newValue) =>
{
if(oldValue > newValue)
{
Misc.Swap(ref oldValue, ref newValue);
}
if(oldValue == 0 && newValue != 0)
{
ClearTranslationCache();
}
};
this.translationCacheSize = DefaultTranslationCacheSize;
this.machine = machine;
started = false;
isHalted = false;
translationCacheSync = new object();
pagesAccessedByIo = new HashSet<long>();
pauseGuard = new CpuThreadPauseGuard(this);
InitializeRegisters();
InitInterruptEvents();
Init();
InitDisas();
}
/// <summary>
/// Запись 2-х байтового значения по указанному адресу
/// </summary>
public Boolean WriteByte32(UInt32 addr, UInt32 value, Endianess endian, out String error)
{
Byte[] buffer = value.ToBufferEx(endian);
WriteBuffer(addr, buffer);
error = "";
return true;
}
/// <summary>
/// Чтение 4-х байтного значения по указанному адресу
/// </summary>
public Boolean ReadByte32(UInt32 addr, out UInt32 value, Endianess endian, out String error)
{
value = 0;
Byte[] buffer = ReadBuffer(addr, 4, out error);
if (buffer == null)
return false;
value = buffer.GetByte32Ex(0, endian);
return true;
}
public EndianessBinaryReader(Stream input, Encoding encoding, Endianess endianess)
: base(input, encoding)
{
this.Endianess = endianess;
}
/// <summary>
/// Generates expression converting and storing one pixel in output format to output buffer (ordering bytes accordingly to endianess) at given position using channels values provided by red/green/blue/alpha variables.
/// </summary>
/// <returns>Generated expression.</returns>
/// <param name="outputFormat">Pixel color format of pixels stored in output buffer.</param>
/// <param name="endianess">Endianess of output buffer.</param>
/// <param name="outBuffer">Output buffer.</param>
/// <param name="outPosition">Position of pixel in output buffer.</param>
/// <param name="redByte">Variable from which value of red channel should be read.</param>
/// <param name="greenByte">Variable from which value of green channel should be read.</param>
/// <param name="blueByte">Variable from which value of blue channel should be read.</param>
/// <param name="alphaByte">Variable from which value of alpha channel should be read.</param>
private static Expression GenerateTo(PixelFormat outputFormat, Endianess endianess, Expression outBuffer, Expression outPosition, Expression redByte, Expression greenByte, Expression blueByte, Expression alphaByte)
{
byte currentBit = 0;
byte currentByte = 0;
var expressions = new List<Expression>();
Expression currentExpression = null;
foreach(var colorDescriptor in outputFormat.GetColorsLengths())
{
Expression colorExpression = null;
switch(colorDescriptor.Key)
{
case ColorType.A:
colorExpression = alphaByte;
break;
case ColorType.B:
colorExpression = blueByte;
break;
case ColorType.G:
colorExpression = greenByte;
break;
case ColorType.R:
colorExpression = redByte;
break;
case ColorType.X:
colorExpression = Expression.Constant((uint)0xFF);
break;
}
foreach(var transformation in ByteSqueezeAndMove(colorDescriptor.Value, currentBit))
{
Expression currentExpressionFragment = colorExpression;
if(transformation.MaskBits != 0xFF)
{
currentExpressionFragment = Expression.And(currentExpressionFragment, Expression.Constant((uint)transformation.MaskBits));
}
if(transformation.ShiftBits > 0)
{
currentExpressionFragment = Expression.RightShift(currentExpressionFragment, Expression.Constant((int)transformation.ShiftBits));
}
else if(transformation.ShiftBits < 0)
{
currentExpressionFragment = Expression.And(
Expression.LeftShift(currentExpressionFragment, Expression.Constant((int)(-transformation.ShiftBits))),
Expression.Constant((uint)0xFF));
}
currentExpression = (currentExpression == null) ? currentExpressionFragment : Expression.Or(currentExpression, currentExpressionFragment);
currentBit += transformation.UsedBits;
while(currentBit >= 8)
{
expressions.Add(
Expression.Assign(
Expression.ArrayAccess(outBuffer,
Expression.Add(
outPosition,
Expression.Constant((endianess == Endianess.BigEndian) ? (int) currentByte : (outputFormat.GetColorDepth() - currentByte - 1)))),
Expression.Convert(currentExpression, typeof(byte))));
currentExpression = null;
currentBit -= 8;
currentByte++;
}
}
}
return Expression.Block(expressions);
}
public static Byte[] ToBytes(this Double value, Endianess endianess)
{
var bytes = value.ToBytes();
if (NumberHelpers.Endianess != endianess)
{
bytes.Swap();
}
return bytes;
}
public EndianBinaryReader(byte[] rawData, Endianess endianess = Endianess.LittleEndian)
{
this.rawData = rawData;
Position = 0;
Endianess = endianess;
}
/// <summary>
/// Initializes a new resource data reader for the specified system- and graphics-stream.
/// </summary>
public ResourceDataWriter(Stream systemStream, Stream graphicsStream, Endianess endianess = Endianess.LittleEndian)
: base((Stream)null, endianess)
{
this.systemStream = systemStream;
this.graphicsStream = graphicsStream;
}
private static BlendDelegate GenerateBlendMethod(PixelFormat backBuffer, Endianess backBufferEndianess, PixelFormat frontBuffer, Endianess frontBufferEndianess, PixelFormat output, Endianess outputEndianess)
{
var vRed = Expression.Variable(typeof(uint), "red");
var vGreen = Expression.Variable(typeof(uint), "green");
var vBlue = Expression.Variable(typeof(uint), "blue");
var vAlpha = Expression.Variable(typeof(uint), "alpha");
var vBackRed = Expression.Variable(typeof(uint), "backRed");
var vBackGreen = Expression.Variable(typeof(uint), "backGreen");
var vBackBlue = Expression.Variable(typeof(uint), "backBlue");
var vBackAlpha = Expression.Variable(typeof(uint), "backAlpha");
var vFrontRed = Expression.Variable(typeof(uint), "frontRed");
var vFrontGreen = Expression.Variable(typeof(uint), "frontGreen");
var vFrontBlue = Expression.Variable(typeof(uint), "frontBlue");
var vFrontAlpha = Expression.Variable(typeof(uint), "frontAlpha");
var vBackgroundColorRed = Expression.Variable(typeof(uint), "backgroundColorRed");
var vBackgroundColorGreen = Expression.Variable(typeof(uint), "backgroundColorGreen");
var vBackgroundColorBlue = Expression.Variable(typeof(uint), "backgroundColorBlue");
var vBackgroundColorAlpha = Expression.Variable(typeof(uint), "backgroundColorAlpha");
var vBackPos = Expression.Variable(typeof(int), "backPos");
var vFrontPos = Expression.Variable(typeof(int), "frontPos");
var vOutPos = Expression.Variable(typeof(int), "outPos");
var vBackStep = Expression.Variable(typeof(int), "backStep");
var vFrontStep = Expression.Variable(typeof(int), "frontStep");
var vOutStep = Expression.Variable(typeof(int), "outStep");
var vLength = Expression.Variable(typeof(int), "length");
var vBackBuffer = Expression.Parameter(typeof(byte[]), "backBuffer");
var vFrontBuffer = Expression.Parameter(typeof(byte[]), "fronBuffer");
var vOutputBuffer = Expression.Parameter(typeof(byte[]).MakeByRefType(), "outputBuffer");
var vBackgroundColor = Expression.Parameter(typeof(Pixel), "backgroundColor");
var vBackBufferAlphaMultiplier = Expression.Parameter(typeof(byte), "backBufferAlphaMultiplier");
var vFrontBufferAlphaMultiplier = Expression.Parameter(typeof(byte), "frontBufferAlphaMultiplier");
var vBackAlphaBlended = Expression.Variable(typeof(uint), "backAlphaBlended");
var vBackgroundColorAlphaBlended = Expression.Variable(typeof(uint), "backgroundColorAlphaBlended");
var outOfLoop = Expression.Label();
var block = Expression.Block(
new [] { vRed, vGreen, vBlue, vAlpha,
vFrontRed, vFrontGreen, vFrontBlue, vFrontAlpha,
vBackRed, vBackGreen, vBackBlue, vBackAlpha,
vBackStep, vFrontStep, vOutStep, vLength, vBackPos, vFrontPos, vOutPos,
vBackgroundColorRed, vBackgroundColorGreen, vBackgroundColorBlue, vBackgroundColorAlpha,
vBackAlphaBlended, vBackgroundColorAlphaBlended
},
Expression.Assign(vBackStep, Expression.Constant(backBuffer.GetColorDepth())),
Expression.Assign(vFrontStep, Expression.Constant(frontBuffer.GetColorDepth())),
Expression.Assign(vOutStep, Expression.Constant(output.GetColorDepth())),
Expression.Assign(vLength, Expression.Property(vBackBuffer, "Length")),
Expression.Assign(vBackPos, Expression.Constant(0x00)),
Expression.Assign(vFrontPos, Expression.Constant(0x00)),
Expression.Assign(vOutPos, Expression.Constant(0x00)),
Expression.Assign(vBackgroundColorAlpha, Expression.Convert(Expression.Property(vBackgroundColor, "Alpha"), typeof(uint))),
Expression.Assign(vBackgroundColorRed, Expression.Convert(Expression.Property(vBackgroundColor, "Red"), typeof(uint))),
Expression.Assign(vBackgroundColorGreen, Expression.Convert(Expression.Property(vBackgroundColor, "Green"), typeof(uint))),
Expression.Assign(vBackgroundColorBlue, Expression.Convert(Expression.Property(vBackgroundColor, "Blue"), typeof(uint))),
Expression.Loop(
Expression.IfThenElse(Expression.LessThan(vBackPos, vLength),
Expression.Block(
GenerateFrom(backBuffer, backBufferEndianess, vBackBuffer, vBackPos, vBackRed, vBackGreen, vBackBlue, vBackAlpha),
GenerateFrom(frontBuffer, frontBufferEndianess, vFrontBuffer, vFrontPos, vFrontRed, vFrontGreen, vFrontBlue, vFrontAlpha),
Expression.Assign(vBackAlpha, Expression.Divide(Expression.Multiply(vBackAlpha, Expression.Convert(vBackBufferAlphaMultiplier, typeof(uint))), Expression.Constant((uint)0xFF))),
Expression.Assign(vFrontAlpha, Expression.Divide(Expression.Multiply(vFrontAlpha, Expression.Convert(vFrontBufferAlphaMultiplier, typeof(uint))), Expression.Constant((uint)0xFF))),
Expression.Block(
// (b_alpha * (0xFF - f_alpha)) / 0xFF
Expression.Assign(
vBackAlphaBlended,
Expression.Divide(
Expression.Multiply(
vBackAlpha,
Expression.Subtract(
Expression.Constant((uint)0xFF),
vFrontAlpha)),
Expression.Constant((uint)0xFF))),
// (c_alpha * (0xFF - (f_alpha + b_alpha * (0xFF - f_alpha)))) / 0xFF
Expression.Assign(
vBackgroundColorAlphaBlended,
Expression.Divide(
Expression.Multiply(
vBackgroundColorAlpha,
Expression.Subtract(
Expression.Constant((uint)0xFF),
Expression.Add(
vFrontAlpha,
vBackAlphaBlended))),
Expression.Constant((uint)0xFF))),
Expression.Assign(
vAlpha,
Expression.Add(
vFrontAlpha,
Expression.Add(
vBackAlphaBlended,
vBackgroundColorAlphaBlended))),
Expression.IfThenElse(
Expression.Equal(vAlpha, Expression.Constant((uint)0)),
Expression.Block(
Expression.Assign(vRed, vBackgroundColorRed),
Expression.Assign(vGreen, vBackgroundColorGreen),
Expression.Assign(vBlue, vBackgroundColorBlue),
Expression.Assign(vAlpha, vBackgroundColorAlpha)),
Expression.Block(
Expression.Assign(
vRed,
Expression.Divide(
Expression.Add(
Expression.Add(
Expression.Multiply(vBackgroundColorAlphaBlended, vBackgroundColorRed),
Expression.Multiply(vBackAlphaBlended, vBackRed)),
Expression.Multiply(vFrontAlpha, vFrontRed)),
vAlpha)),
Expression.Assign(
vGreen,
Expression.Divide(
Expression.Add(
Expression.Add(
Expression.Multiply(vBackgroundColorAlphaBlended, vBackgroundColorGreen),
Expression.Multiply(vBackAlphaBlended, vBackGreen)),
Expression.Multiply(vFrontAlpha, vFrontGreen)),
vAlpha)),
Expression.Assign(
vBlue,
Expression.Divide(
Expression.Add(
Expression.Add(
Expression.Multiply(vBackgroundColorAlphaBlended, vBackgroundColorBlue),
Expression.Multiply(vBackAlphaBlended, vBackBlue)),
Expression.Multiply(vFrontAlpha, vFrontBlue)),
vAlpha))))
),
GenerateTo(output, outputEndianess, vOutputBuffer, vOutPos, vRed, vGreen, vBlue, vAlpha),
Expression.AddAssign(vBackPos, vBackStep),
Expression.AddAssign(vFrontPos, vFrontStep),
Expression.AddAssign(vOutPos, vOutStep)
),
Expression.Break(outOfLoop)
),
outOfLoop
)
);
return Expression.Lambda<BlendDelegate>(block, vBackBuffer, vFrontBuffer, vOutputBuffer, vBackgroundColor, vBackBufferAlphaMultiplier, vFrontBufferAlphaMultiplier).Compile();
}
private static ConvertDelegate GenerateConvertMethod(PixelFormat input, Endianess inputEndianess, PixelFormat output, Endianess outputEndianess)
{
var vRed = Expression.Variable(typeof(uint), "red");
var vGreen = Expression.Variable(typeof(uint), "green");
var vBlue = Expression.Variable(typeof(uint), "blue");
var vAlpha = Expression.Variable(typeof(uint), "alpha");
var vInStep = Expression.Variable(typeof(int), "inStep");
var vOutStep = Expression.Variable(typeof(int), "outStep");
var vLength = Expression.Variable(typeof(int), "length");
var vInputBuffer = Expression.Parameter(typeof(byte[]), "inputBuffer");
var vOutputBuffer = Expression.Parameter(typeof(byte[]).MakeByRefType(), "outputBuffer");
var vInPos = Expression.Variable(typeof(int), "inPos");
var vOutPos = Expression.Variable(typeof(int), "outPos");
var outOfLoop = Expression.Label();
var block = Expression.Block(
new [] { vRed, vGreen, vBlue, vAlpha, vInStep, vOutStep, vLength, vInPos, vOutPos },
Expression.Assign(vInStep, Expression.Constant(input.GetColorDepth())),
Expression.Assign(vOutStep, Expression.Constant(output.GetColorDepth())),
Expression.Assign(vLength, Expression.Property(vInputBuffer, "Length")),
Expression.Assign(vInPos, Expression.Constant(0)),
Expression.Assign(vOutPos, Expression.Constant(0)),
Expression.Loop(
Expression.IfThenElse(Expression.LessThan(vInPos, vLength),
Expression.Block(
GenerateFrom(input, inputEndianess, vInputBuffer, vInPos, vRed, vGreen, vBlue, vAlpha),
GenerateTo(output, outputEndianess, vOutputBuffer, vOutPos, vRed, vGreen, vBlue, vAlpha),
Expression.AddAssign(vInPos, vInStep),
Expression.AddAssign(vOutPos, vOutStep)
),
Expression.Break(outOfLoop)
),
outOfLoop
)
);
return Expression.Lambda<ConvertDelegate>(block, vInputBuffer, vOutputBuffer).Compile();
}
public EndianessBinaryReader(Stream input, Endianess endianess)
: this(input, new UTF8Encoding(false, true), endianess)
{
}
/// <summary>
/// Initializes a new data reader for the specified stream.
/// </summary>
public DataReader(Stream stream, Endianess endianess = Endianess.LittleEndian)
{
this.baseStream = stream;
this.Endianess = endianess;
}
/// <summary>
/// Generates expression reading one pixel encoded in given format from input buffer (with bytes ordered accordingly to endianess) at given position
/// and storing each channel in separate variable expression.
/// </summary>
/// <returns>Generated expression.</returns>
/// <param name="inputFormat">Pixel color format of pixels in input buffer.</param>
/// <param name="endianess">Endianess of input buffer.</param>
/// <param name="inBuffer">Input buffer.</param>
/// <param name="inPosition">Position of pixel in buffer.</param>
/// <param name="redByte">Variable to which value of red channel should be stored.</param>
/// <param name="greenByte">Variable to which value of green channel should be stored.</param>
/// <param name="blueByte">Variable to which value of blue channel should be stored.</param>
/// <param name="alphaByte">Variable to which value of alpha channel should be stored.</param>
private static Expression GenerateFrom(PixelFormat inputFormat, Endianess endianess, Expression inBuffer, Expression inPosition, Expression redByte, Expression greenByte, Expression blueByte, Expression alphaByte)
{
byte currentBit = 0;
byte currentByte = 0;
bool isAlphaSet = false;
var expressions = new List<Expression>();
var inputBytes = new ParameterExpression[inputFormat.GetColorDepth()];
for(int i = 0; i < inputBytes.Length; i++)
{
inputBytes[i] = Expression.Variable(typeof(uint));
expressions.Add(
Expression.Assign(
inputBytes[i],
Expression.Convert(
Expression.ArrayIndex(
inBuffer,
Expression.Add(
inPosition,
Expression.Constant((endianess == Endianess.BigEndian) ? i : inputBytes.Length - i - 1))),
typeof(uint))));
}
foreach(var colorDescriptor in inputFormat.GetColorsLengths())
{
Expression colorExpression = null;
foreach(var transformation in ByteInflate(colorDescriptor.Value, currentBit))
{
Expression currentExpressionFragment = inputBytes[currentByte];
if(transformation.MaskBits != 0xFF)
{
currentExpressionFragment = Expression.And(currentExpressionFragment, Expression.Constant((uint)transformation.MaskBits));
}
if(transformation.ShiftBits > 0)
{
currentExpressionFragment = Expression.RightShift(currentExpressionFragment, Expression.Constant((int)transformation.ShiftBits));
}
else if(transformation.ShiftBits < 0)
{
currentExpressionFragment = Expression.And(
Expression.LeftShift(currentExpressionFragment, Expression.Constant((int)(-transformation.ShiftBits))),
Expression.Constant((uint)0xFF));
}
currentBit += transformation.UsedBits;
if(currentBit >= 8)
{
currentBit -= 8;
currentByte++;
}
colorExpression = (colorExpression == null) ? currentExpressionFragment : Expression.Or(colorExpression, currentExpressionFragment);
}
if(colorDescriptor.Key == ColorType.X)
{
continue;
}
Expression currentColor = null;
switch(colorDescriptor.Key)
{
case ColorType.A:
currentColor = alphaByte;
isAlphaSet = true;
break;
case ColorType.B:
currentColor = blueByte;
break;
case ColorType.G:
currentColor = greenByte;
break;
case ColorType.R:
currentColor = redByte;
break;
}
expressions.Add(Expression.Assign(currentColor, colorExpression));
// filling lsb '0'-bits with copy of msb pattern
var numberOfBits = colorDescriptor.Value;
var zeroBits = 8 - numberOfBits;
while(zeroBits > 0)
{
expressions.Add(Expression.OrAssign(
currentColor,
Expression.RightShift(
currentColor,
Expression.Constant((int)numberOfBits))));
zeroBits -= numberOfBits;
}
}
if(!isAlphaSet)
{
expressions.Add(Expression.Assign(alphaByte, Expression.Constant((uint)0xFF)));
}
return Expression.Block(inputBytes, expressions);
}
private byte[] Uncompress(byte[] compressed, Endianess endianess)
{
// size of the uncompressed message is encoded on first 4 bytes
// size has to be decreased by header length (8 bytes)
var uncompressedSize = -8 +
(int)
(endianess == Endianess.BigEndian
? EndianBinaryReader.FromBigEndian(compressed, 0, 4)
: EndianBinaryReader.FromLittleEndian(compressed, 0, 4));
if (uncompressedSize <= 0)
{
throw new QReaderException("Error while data uncompression.");
}
var uncompressed = new byte[uncompressedSize];
var buffer = new int[256];
short i = 0;
var n = 0;
int f = 0, s = 0, p = 0, d = 4;
while (s < uncompressedSize)
{
if (i == 0)
{
f = 0xff & compressed[d++];
i = 1;
}
if ((f & i) != 0)
{
var r = buffer[0xff & compressed[d++]];
uncompressed[s++] = uncompressed[r++];
uncompressed[s++] = uncompressed[r++];
n = 0xff & compressed[d++];
for (var m = 0; m < n; m++)
{
uncompressed[s + m] = uncompressed[r + m];
}
}
else
{
uncompressed[s++] = compressed[d++];
}
while (p < s - 1)
{
buffer[(0xff & uncompressed[p]) ^ (0xff & uncompressed[p + 1])] = p++;
}
if ((f & i) != 0)
{
p = s += n;
}
i *= 2;
if (i == 256)
{
i = 0;
}
}
return uncompressed;
}
public EndianessAttribute(Endianess endianess)
{
this.endianess = endianess;
}
public PowerPc(string cpuType, Machine machine, Endianess endianness = Endianess.BigEndian) : base(cpuType, machine, endianness)
{
irqSync = new object();
machine.ObtainClockSource().AddClockEntry(
new ClockEntry(long.MaxValue / 2, ClockEntry.FrequencyToRatio(this, 128000000), DecrementerHandler, false, Direction.Descending));
}
public static Decimal ToDecimal(this Byte[] source, Endianess endianess, Int32 startIndex = 0)
{
var bytes = source.Copy(startIndex, NumberHelpers.DecimalByteCount);
if (NumberHelpers.Endianess != endianess)
{
bytes.Swap();
}
return bytes.ToDecimal();
}
