public static RemoveObjectTag Create(SwfStreamReader reader)
{
return(new RemoveObjectTag {
CharacterId = reader.ReadUInt16(),
Depth = reader.ReadUInt16()
});
}
public static DefineSceneAndFrameLabelDataTag Create(SwfStreamReader reader)
{
var scene_count = reader.ReadEncodedU32();
var scenes = new List <SceneOffsetData>((int)scene_count);
for (var i = 0; i < scene_count; ++i)
{
scenes.Add(new SceneOffsetData {
Offset = reader.ReadEncodedU32(),
Name = reader.ReadString()
});
}
var frame_count = reader.ReadEncodedU32();
var frames = new List <FrameLabelData>((int)frame_count);
for (var i = 0; i < frame_count; ++i)
{
frames.Add(new FrameLabelData {
Number = reader.ReadEncodedU32(),
Label = reader.ReadString()
});
}
return(new DefineSceneAndFrameLabelDataTag {
Scenes = scenes,
Frames = frames
});
}
protected IEnumerable <TagBinaryInfo> GetTagFullBinariesFromSwfResource(string resourceName)
{
var file = new SwfFile();
var stream = OpenEmbeddedResource(resourceName);
SwfStreamReader reader = new SwfStreamReader(stream);
file.FileInfo = reader.ReadSwfFileInfo();
stream = DecompressIfNeeded(file.FileInfo, stream);
stream.Seek(8, SeekOrigin.Begin);
reader = new SwfStreamReader(stream);
file.Header = reader.ReadSwfHeader();
while (stream.Position < stream.Length)
{
var position = stream.Position;
ushort typeAndSize = reader.ReadUInt16();
SwfTagType type = (SwfTagType)(typeAndSize >> 6);
int shortSize = typeAndSize & 0x3f;
int size = shortSize < 0x3f ? shortSize : reader.ReadInt32();
var length = stream.Position - position + size;
stream.Seek(position, SeekOrigin.Begin);
yield return(new TagBinaryInfo {
Type = type, Binary = reader.ReadBytes((int)length)
});
}
}
static void SkipLine2Style(SwfStreamReader reader)
{
reader.ReadUInt16(); // Width
reader.ReadUnsignedBits(2); // StartCapStyle
var join_style = reader.ReadUnsignedBits(2);
var has_fill_flag = reader.ReadBit();
reader.ReadBit(); // NoHScaleFlag
reader.ReadBit(); // NoVScaleFlag
reader.ReadBit(); // PixelHintingFlag
reader.ReadUnsignedBits(5); // Reserved
reader.ReadBit(); // NoClose
reader.ReadUnsignedBits(2); // EndCapStyle
if (join_style == 2)
{
reader.ReadFixedPoint_8_8(); // MiterLimitFactor
}
if (has_fill_flag)
{
ReadFillStyle(reader, true); // FillStyle
}
else
{
SwfColor.Read(reader, true);
}
}
static Filter CreateFilterFromTypeId(byte type_id, SwfStreamReader reader)
{
switch (type_id)
{
case 0: return(ReadConcreteFilter(new DropShadowFilter(), reader));
case 1: return(ReadConcreteFilter(new BlurFilter(), reader));
case 2: return(ReadConcreteFilter(new GlowFilter(), reader));
case 3: return(ReadConcreteFilter(new BevelFilter(), reader));
case 4: return(ReadConcreteFilter(new GradientGlowFilter(), reader));
case 5: return(ReadConcreteFilter(new ConvolutionFilter(), reader));
case 6: return(ReadConcreteFilter(new ColorMatrixFilter(), reader));
case 7: return(ReadConcreteFilter(new GradientBevelFilter(), reader));
default:
throw new System.Exception(string.Format(
"Incorrect surface filter type id: {0}", type_id));
}
}
public void ReadColorTransformRGBAFromBitsMultAddTest()
{
var mem = new MemoryStream();
WriteBits(mem,
"1", "1", "1001", "0.00001010", "1.11110110", "0.11100000", "0.10110000",
"1.11110111", "0.10000001", "0.00010000", "0.00001111");
var reader = new SwfStreamReader(mem);
ColorTransformRGBA color;
reader.ReadColorTransformRGBA(out color);
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
AssertData.AreEqual(new ColorTransformRGBA {
HasAddTerms = true,
HasMultTerms = true,
RedMultTerm = 10,
GreenMultTerm = -10,
BlueMultTerm = 224,
AlphaMultTerm = 176,
RedAddTerm = -9,
GreenAddTerm = 129,
BlueAddTerm = 16,
AlphaAddTerm = 15
}, color, "ColorTransform");
}
public void ReadBitTest()
{
var mem = new MemoryStream();
mem.WriteByte(0xaa);
mem.WriteByte(0x73);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(true, reader.ReadBit(), "Bit 0");
Assert.AreEqual(false, reader.ReadBit(), "Bit 1");
Assert.AreEqual(true, reader.ReadBit(), "Bit 2");
Assert.AreEqual(false, reader.ReadBit(), "Bit 3");
Assert.AreEqual(true, reader.ReadBit(), "Bit 4");
Assert.AreEqual(false, reader.ReadBit(), "Bit 5");
Assert.AreEqual(true, reader.ReadBit(), "Bit 6");
Assert.AreEqual(false, reader.ReadBit(), "Bit 7");
Assert.AreEqual(false, reader.ReadBit(), "Bit 8");
Assert.AreEqual(true, reader.ReadBit(), "Bit 9");
Assert.AreEqual(true, reader.ReadBit(), "Bit 10");
Assert.AreEqual(true, reader.ReadBit(), "Bit 11");
Assert.AreEqual(false, reader.ReadBit(), "Bit 12");
Assert.AreEqual(false, reader.ReadBit(), "Bit 13");
Assert.AreEqual(true, reader.ReadBit(), "Bit 14");
Assert.AreEqual(true, reader.ReadBit(), "Bit 15");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
protected void CheckBits(Stream stream, params string[] bits)
{
stream.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(stream);
uint bitIndex = 0;
foreach (var bitString in bits)
{
foreach (var ch in bitString)
{
switch (ch)
{
case '0':
Assert.AreEqual(false, reader.ReadBit(), "Checking bit " + bitIndex);
bitIndex++;
break;
case '1':
Assert.AreEqual(true, reader.ReadBit(), "Checking bit " + bitIndex);
bitIndex++;
break;
case '.':
break;
default:
throw new InvalidOperationException("Invalid character " + ch);
}
}
}
Assert.AreEqual(stream.Length, stream.Position, "Should reach end of the stream");
}
public static SwfColorTransform Read(SwfStreamReader reader, bool with_alpha)
{
var transform = SwfColorTransform.identity;
transform.HasAdd = reader.ReadBit();
transform.HasMul = reader.ReadBit();
var bits = reader.ReadUnsignedBits(4);
if (transform.HasMul)
{
transform.RMul = (short)reader.ReadSignedBits(bits);
transform.GMul = (short)reader.ReadSignedBits(bits);
transform.BMul = (short)reader.ReadSignedBits(bits);
transform.AMul = with_alpha ? (short)reader.ReadSignedBits(bits) : byte.MaxValue;
}
if (transform.HasAdd)
{
transform.RAdd = (short)reader.ReadSignedBits(bits);
transform.GAdd = (short)reader.ReadSignedBits(bits);
transform.BAdd = (short)reader.ReadSignedBits(bits);
transform.AAdd = with_alpha ? (short)reader.ReadSignedBits(bits) : (short)0;
}
reader.AlignToByte();
return(transform);
}
public void ReadUnsignedBits2Test()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(true);
writer.WriteBit(false);
writer.WriteBit(true);
writer.WriteBit(false);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(true, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(true, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
}
public static ScriptLimitsTag Create(SwfStreamReader reader)
{
return(new ScriptLimitsTag {
MaxRecursionDepth = reader.ReadUInt16(),
ScriptTimeoutSeconds = reader.ReadUInt16()
});
}
public void ReadBitTest()
{
var mem = new MemoryStream();
mem.WriteByte(0xaa);
mem.WriteByte(0x73);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(true, reader.ReadBit(), "Bit 0");
Assert.AreEqual(false, reader.ReadBit(), "Bit 1");
Assert.AreEqual(true, reader.ReadBit(), "Bit 2");
Assert.AreEqual(false, reader.ReadBit(), "Bit 3");
Assert.AreEqual(true, reader.ReadBit(), "Bit 4");
Assert.AreEqual(false, reader.ReadBit(), "Bit 5");
Assert.AreEqual(true, reader.ReadBit(), "Bit 6");
Assert.AreEqual(false, reader.ReadBit(), "Bit 7");
Assert.AreEqual(false, reader.ReadBit(), "Bit 8");
Assert.AreEqual(true, reader.ReadBit(), "Bit 9");
Assert.AreEqual(true, reader.ReadBit(), "Bit 10");
Assert.AreEqual(true, reader.ReadBit(), "Bit 11");
Assert.AreEqual(false, reader.ReadBit(), "Bit 12");
Assert.AreEqual(false, reader.ReadBit(), "Bit 13");
Assert.AreEqual(true, reader.ReadBit(), "Bit 14");
Assert.AreEqual(true, reader.ReadBit(), "Bit 15");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadSwfHeaderTest()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
var rect = new SwfRect {
XMin = 0x004,
XMax = 0x48f,
YMin = 0x008,
YMax = 0x0ee
};
writer.WriteRect(ref rect);
writer.WriteFixedPoint8(23.75);
writer.WriteUInt16(20);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var hdr = reader.ReadSwfHeader();
Assert.AreEqual(rect, hdr.FrameSize);
Assert.AreEqual(23.75, hdr.FrameRate);
Assert.AreEqual(20, hdr.FrameCount);
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
protected IEnumerable<TagBinaryInfo> GetTagFullBinariesFromSwfResource(string resourceName)
{
var file = new SwfFile();
var stream = OpenEmbeddedResource(resourceName);
SwfStreamReader reader = new SwfStreamReader(stream);
file.FileInfo = reader.ReadSwfFileInfo();
stream = DecompressIfNeeded(file.FileInfo, stream);
stream.Seek(8, SeekOrigin.Begin);
reader = new SwfStreamReader(stream);
file.Header = reader.ReadSwfHeader();
while (stream.Position < stream.Length) {
var position = stream.Position;
ushort typeAndSize = reader.ReadUInt16();
SwfTagType type = (SwfTagType)(typeAndSize >> 6);
int shortSize = typeAndSize & 0x3f;
int size = shortSize < 0x3f ? shortSize : reader.ReadInt32();
var length = stream.Position - position + size;
stream.Seek(position, SeekOrigin.Begin);
yield return new TagBinaryInfo { Type = type, Binary = reader.ReadBytes((int)length) };
}
}
protected void CheckBits(Stream stream, params string[] bits)
{
stream.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(stream);
uint bitIndex = 0;
foreach (var bitString in bits) {
foreach (var ch in bitString) {
switch (ch) {
case '0':
Assert.AreEqual(false, reader.ReadBit(), "Checking bit " + bitIndex);
bitIndex++;
break;
case '1':
Assert.AreEqual(true, reader.ReadBit(), "Checking bit " + bitIndex);
bitIndex++;
break;
case '.':
break;
default:
throw new InvalidOperationException("Invalid character " + ch);
}
}
}
Assert.AreEqual(stream.Length, stream.Position, "Should reach end of the stream");
}
protected T ReadTag <T>(string resourceName, string tagHash) where T : SwfTagBase
{
using (var stream = OpenEmbeddedResource(resourceName)) {
var file = new SwfFile();
var reader = new SwfStreamReader(stream);
file.FileInfo = reader.ReadSwfFileInfo();
reader = GetSwfStreamReader(file.FileInfo, stream);
file.Header = reader.ReadSwfHeader();
while (!reader.IsEOF)
{
var tagData = reader.ReadTagData();
var hash = GetTagHash(tagData);
if (tagHash == hash)
{
var tagReader = new SwfTagDeserializer(file);
//using (var dump = File.Open(@"D:\temp\1.bin", FileMode.Create)) {
// dump.Write(tagData.Data, 0, tagData.Data.Length);
// dump.Flush();
//}
return(tagReader.ReadTag <T>(tagData));
}
}
}
return(null);
}
static Filter ReadConcreteFilter(GradientBevelFilter filter, SwfStreamReader reader)
{
var num_colors = reader.ReadByte();
filter.GradientColors = new SwfColor[num_colors];
for (var i = 0; i < num_colors; ++i)
{
filter.GradientColors[i] = SwfColor.Read(reader, true);
}
filter.GradientRatio = new byte[num_colors];
for (var i = 0; i < num_colors; ++i)
{
filter.GradientRatio[i] = reader.ReadByte();
}
filter.BlurX = reader.ReadFixedPoint_16_16();
filter.BlurY = reader.ReadFixedPoint_16_16();
filter.Angle = reader.ReadFixedPoint_16_16();
filter.Distance = reader.ReadFixedPoint_16_16();
filter.Strength = reader.ReadFixedPoint_8_8();
filter.InnerShadow = reader.ReadBit();
filter.Knockout = reader.ReadBit();
filter.CompositeSource = reader.ReadBit();
filter.OnTop = reader.ReadBit();
filter.Passes = reader.ReadUnsignedBits(4);
return(filter);
}
public void ReadLongTagDataTest()
{
const SwfTagType tagType = SwfTagType.ExportAssets;
var data = new byte[4096];
for (var i = 0; i < data.Length; i++)
{
data[i] = (byte)(i & 0xff);
}
const int header = ((int)tagType << 6) | 0x3f;
var mem = new MemoryStream();
mem.WriteByte(header & 0xff);
mem.WriteByte(header >> 8);
var tagLength = data.Length;
mem.WriteByte((byte)((tagLength >> 0) & 0xff));
mem.WriteByte((byte)((tagLength >> 8) & 0xff));
mem.WriteByte((byte)((tagLength >> 16) & 0xff));
mem.WriteByte((byte)((tagLength >> 24) & 0xff));
mem.Write(data, 0, data.Length);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var tagData = reader.ReadTagData();
Assert.IsNotNull(tagData);
Assert.AreEqual(tagType, tagData.Type);
Assert.IsNotNull(tagData.Data);
AssertExt.AreEqual(data, tagData.Data, "Data should be equal");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadEmptyColorTransformTest()
{
var mem = new MemoryStream(new byte[] { 0 });
var reader = new SwfStreamReader(mem);
var transform = reader.ReadColorTransformRGBA();
Assert.IsFalse(transform.HasAddTerms);
Assert.IsFalse(transform.HasMultTerms);
}
public static SwfShortHeader Read(SwfStreamReader reader)
{
return(new SwfShortHeader {
Format = new string(reader.ReadChars(3)),
Version = reader.ReadByte(),
FileLength = reader.ReadUInt32()
});
}
static Filter ReadConcreteFilter(BlurFilter filter, SwfStreamReader reader)
{
filter.BlurX = reader.ReadFixedPoint_16_16();
filter.BlurY = reader.ReadFixedPoint_16_16();
filter.Passes = reader.ReadUnsignedBits(5);
reader.ReadUnsignedBits(3); // reserved
return(filter);
}
public static SwfBlendMode Read(SwfStreamReader reader)
{
var mode_id = reader.ReadByte();
return(new SwfBlendMode {
Value = ModeFromByte(mode_id)
});
}
public static FrameLabelTag Create(SwfStreamReader reader)
{
var tag = new FrameLabelTag();
tag.Name = reader.ReadString();
tag.AnchorFlag = reader.IsEOF ? (byte)0 : reader.ReadByte();
return(tag);
}
public static SwfFillStyleType Read(SwfStreamReader reader)
{
var type_id = reader.ReadByte();
return(new SwfFillStyleType {
Value = TypeFromByte(type_id)
});
}
public static DefineSpriteTag Create(SwfStreamReader reader)
{
var tag = new DefineSpriteTag();
tag.SpriteId = reader.ReadUInt16();
tag.FrameCount = reader.ReadUInt16();
tag.ControlTags = SwfControlTags.Read(reader);
return(tag);
}
public void ReadEncodedU32Bytes4Test()
{
var mem = new MemoryStream();
WriteBits(mem, "10101000", "11110101", "10000100", "01000000");
var reader = new SwfStreamReader(mem);
var actual = reader.ReadEncodedU32();
Assert.AreEqual(4, mem.Position);
Assert.AreEqual(0x08013aa8, actual);
}
public static SwfLongHeader Read(SwfStreamReader reader)
{
return(new SwfLongHeader {
ShortHeader = SwfShortHeader.Read(reader),
FrameSize = SwfRect.Read(reader),
FrameRate = reader.ReadFixedPoint_8_8(),
FrameCount = reader.ReadUInt16()
});
}
public static DefineShape2Tag Create(SwfStreamReader reader)
{
var tag = new DefineShape2Tag();
tag.ShapeId = reader.ReadUInt16();
tag.ShapeBounds = SwfRect.Read(reader);
tag.Shapes = SwfShapesWithStyle.Read(reader, SwfShapesWithStyle.ShapeStyleType.Shape2);
return(tag);
}
static void SkipCurvedEdgeShapeRecord(SwfStreamReader reader)
{
var num_bits = reader.ReadUnsignedBits(4) + 2;
reader.ReadSignedBits(num_bits); // control_delta_x
reader.ReadSignedBits(num_bits); // control_delta_y
reader.ReadSignedBits(num_bits); // anchor_delta_x
reader.ReadSignedBits(num_bits); // anchor_delta_y
}
static Filter ReadConcreteFilter(ColorMatrixFilter filter, SwfStreamReader reader)
{
filter.Matrix = new float[20];
for (var i = 0; i < filter.Matrix.Length; ++i)
{
filter.Matrix[i] = reader.ReadFloat32();
}
return(filter);
}
public void ReadEmptyColorTransformTest()
{
var mem = new MemoryStream(new byte[] { 0 });
var reader = new SwfStreamReader(mem);
var transform = reader.ReadColorTransformRGB();
Assert.IsFalse(transform.HasAddTerms);
Assert.IsFalse(transform.HasMultTerms);
}
public static ProtectTag Create(SwfStreamReader reader)
{
var md5_password = reader.IsEOF
? string.Empty
: reader.ReadString();
return(new ProtectTag {
MD5Password = md5_password
});
}
public void ReadEmptyMatrixTest()
{
var mem = new MemoryStream(new byte[] { 0 });
var reader = new SwfStreamReader(mem);
var matrix = reader.ReadMatrix();
Assert.IsFalse(matrix.HasScale);
Assert.IsFalse(matrix.HasRotate);
Assert.AreEqual(0, matrix.TranslateX);
Assert.AreEqual(0, matrix.TranslateY);
}
public static EnableDebuggerTag Create(SwfStreamReader reader)
{
var md5 = reader.IsEOF
? string.Empty
: reader.ReadString();
return(new EnableDebuggerTag {
MD5PasswordHash = md5
});
}
public void ReadEncodedU32Bytes5Test()
{
var mem = new MemoryStream();
WriteBits(mem, "10101000", "11110101", "10000100", "11000000", "00001010");
var reader = new SwfStreamReader(mem);
var actual = reader.ReadEncodedU32();
Assert.AreEqual(5, mem.Position);
Assert.AreEqual(0xa8013aa8, actual);
}
public void ReadEmptyMatrixTest()
{
var mem = new MemoryStream(new byte[] { 0 });
var reader = new SwfStreamReader(mem);
var matrix = reader.ReadMatrix();
Assert.IsFalse(matrix.HasScale);
Assert.IsFalse(matrix.HasRotate);
Assert.AreEqual(0, matrix.TranslateX);
Assert.AreEqual(0, matrix.TranslateY);
}
public void ReadRectTest()
{
var etalon = new SwfRect {
XMin = 0,
XMax = 11000,
YMin = 0,
YMax = 8000
};
var mem = new MemoryStream(new byte[] { 0x78, 0x00, 0x05, 0x5f, 0x00, 0x00, 0x0f, 0xa0, 0x00 });
var reader = new SwfStreamReader(mem);
SwfRect rect = reader.ReadRect();
Assert.IsTrue(AreEqual(etalon, rect));
Assert.AreEqual(mem.Length, mem.Position);
}
public void ReadRectTest2()
{
var etalon = new SwfRect {
XMin = 0x004,
XMax = 0x48f,
YMin = 0x008,
YMax = 0x0ee
};
var mem = new MemoryStream();
WriteBits(mem, "01100", "0000.00000100", "0100.10001111", "0000.00001000", "0000.11101110");
var reader = new SwfStreamReader(mem);
SwfRect rect = reader.ReadRect();
Assert.IsTrue(AreEqual(etalon, rect));
Assert.AreEqual(mem.Length, mem.Position);
}
public void ReadRectMustBeByteAlignedTest()
{
var etalon = new SwfRect {
XMin = 0,
XMax = 11000,
YMin = 0,
YMax = 8000
};
var mem = new MemoryStream(new byte[] { 0x78, 0x00, 0x05, 0x5f, 0x00, 0x00, 0x0f, 0xa0, 0x00, 0xb3 });
var reader = new SwfStreamReader(mem);
SwfRect rect = reader.ReadRect();
Assert.IsTrue(AreEqual(etalon, rect));
var tail = reader.ReadUnsignedBits(8);
Assert.AreEqual(0xb3, tail);
Assert.AreEqual(mem.Length, mem.Position);
}
public void ReadColorTransformRGBFromBitsAddTest()
{
var mem = new MemoryStream();
WriteBits(mem,
"1", "0", "1001", "0.00001010", "1.11110110", "0.11100000");
var reader = new SwfStreamReader(mem);
var color = reader.ReadColorTransformRGB();
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
AssertData.AreEqual(new ColorTransformRGB {
HasAddTerms = true,
HasMultTerms = false,
RedAddTerm = 10,
GreenAddTerm = -10,
BlueAddTerm = 224
}, color, "ColorTransform");
}
public void ReadRGBTest()
{
var mem = new MemoryStream();
mem.WriteByte(0x0a);
mem.WriteByte(0xff);
mem.WriteByte(0x83);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
SwfRGB val;
reader.ReadRGB(out val);
Assert.AreEqual(0x0a, val.Red, "Red");
Assert.AreEqual(0xff, val.Green, "Green");
Assert.AreEqual(0x83, val.Blue, "Blue");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadMatrixFromBitsTest()
{
var mem = new MemoryStream();
WriteBits(mem,
"1", "10011", "010.10000000.00000000", "001.11000000.00000000",
"1", "10011", "011.01000000.00000000", "000.10000000.00000000",
"00110", "010000", "011000");
var reader = new SwfStreamReader(mem);
SwfMatrix matrix = reader.ReadMatrix();
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
Assert.AreEqual(matrix.ScaleX, 2.5);
Assert.AreEqual(matrix.ScaleY, 1.75);
Assert.AreEqual(matrix.RotateSkew0, 3.25);
Assert.AreEqual(matrix.RotateSkew1, 0.5);
Assert.AreEqual(matrix.TranslateX, 16);
Assert.AreEqual(matrix.TranslateY, 24);
}
public void ReadOneByteActionsTest()
{
var vals = Enum.GetValues(typeof(ActionCode));
foreach (ActionCode type in vals) {
if ((byte)type < 0x80) {
var mem = new MemoryStream();
mem.WriteByte((byte)type);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var actionReader = new ActionReader(reader);
var action = actionReader.ReadAction();
Assert.IsNotNull(action);
var actualType = action.ActionCode;
Assert.AreEqual(type, actualType);
Assert.AreEqual(1, mem.Position);
}
}
}
public void ReadSignedBitsPositiveTest()
{
var mem = new MemoryStream();
mem.WriteByte(0x2a);
mem.WriteByte(0xc3);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(0x0ab, reader.ReadSignedBits(10), "Value");
Assert.AreEqual(false, reader.ReadBit(), "Bit 10");
Assert.AreEqual(false, reader.ReadBit(), "Bit 11");
Assert.AreEqual(false, reader.ReadBit(), "Bit 12");
Assert.AreEqual(false, reader.ReadBit(), "Bit 13");
Assert.AreEqual(true, reader.ReadBit(), "Bit 14");
Assert.AreEqual(true, reader.ReadBit(), "Bit 15");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadSwfFileInfoTest()
{
var mem = new MemoryStream();
mem.WriteByte((byte)'C');
mem.WriteByte((byte)'W');
mem.WriteByte((byte)'S');
mem.WriteByte(10);
mem.WriteByte(0x78);
mem.WriteByte(0x56);
mem.WriteByte(0x34);
mem.WriteByte(0x12);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var fileInfo = reader.ReadSwfFileInfo();
Assert.AreEqual("CWS", fileInfo.Format);
Assert.AreEqual(10, fileInfo.Version);
Assert.AreEqual(0x12345678, fileInfo.FileLength);
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadColorTransformRGBAFromBitsMultAddTest()
{
var mem = new MemoryStream();
WriteBits(mem,
"1", "1", "1001", "0.00001010", "1.11110110", "0.11100000", "0.10110000",
"1.11110111", "0.10000001", "0.00010000", "0.00001111");
var reader = new SwfStreamReader(mem);
ColorTransformRGBA color;
reader.ReadColorTransformRGBA(out color);
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
AssertData.AreEqual(new ColorTransformRGBA {
HasAddTerms = true,
HasMultTerms = true,
RedMultTerm = 10,
GreenMultTerm = -10,
BlueMultTerm = 224,
AlphaMultTerm = 176,
RedAddTerm = -9,
GreenAddTerm = 129,
BlueAddTerm = 16,
AlphaAddTerm = 15
}, color, "ColorTransform");
}
public void ReadSwfHeaderTest()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
var rect = new SwfRect {
XMin = 0x004,
XMax = 0x48f,
YMin = 0x008,
YMax = 0x0ee
};
writer.WriteRect(ref rect);
writer.WriteFixedPoint8(23.75);
writer.WriteUInt16(20);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var hdr = reader.ReadSwfHeader();
Assert.AreEqual(rect, hdr.FrameSize);
Assert.AreEqual(23.75, hdr.FrameRate);
Assert.AreEqual(20, hdr.FrameCount);
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadShortFloatTest()
{
var mem = new MemoryStream();
mem.WriteByte(0xde);
mem.WriteByte(0x42);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(3.43359375f, reader.ReadShortFloat(), "Value");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public DualSwfStreamReader(SwfStreamReader first, SwfStreamReader second)
: base(new MemoryStream())
{
_first = first;
_second = second;
}
public void ReadUInt32Test()
{
var mem = new MemoryStream();
mem.WriteByte(0x20);
mem.WriteByte(0x71);
mem.WriteByte(0x6e);
mem.WriteByte(0x45);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(0x456e7120, reader.ReadUInt32(), "Value");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void ReadUnsignedBits2Test()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(false);
writer.WriteBit(true);
writer.WriteBit(false);
writer.WriteBit(true);
writer.WriteBit(false);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(true, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
Assert.AreEqual(true, reader.ReadBit());
Assert.AreEqual(false, reader.ReadBit());
}
public void ReadShortTagDataTest()
{
const SwfTagType tagType = SwfTagType.ExportAssets;
var data = new byte[10];
for (var i = 0; i < data.Length; i++) {
data[i] = (byte)(i & 0xff);
}
var header = ((int)tagType << 6) | data.Length;
var mem = new MemoryStream();
mem.WriteByte((byte)(header & 0xff));
mem.WriteByte((byte)(header >> 8));
mem.Write(data, 0, data.Length);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
var tagData = reader.ReadTagData();
Assert.IsNotNull(tagData);
Assert.AreEqual(tagType, tagData.Type);
Assert.IsNotNull(tagData.Data);
AssertExt.AreEqual(data, tagData.Data, "Data should be equal");
Assert.AreEqual(mem.Length, mem.Position, "Should reach end of the stream");
}
public void WriteNegativeFixedPoint16FromBitsTest()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
var bits = new SignedBitsCount(-81920).GetBits();
writer.WriteFixedPoint16(-1.25, bits);
writer.FlushBits();
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
int actual = reader.ReadSignedBits(bits);
Assert.AreEqual(-81920, actual);
}
public void ReadNegativeFixedPoint16FromBitsTest()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
const int val = -81920;
var bits = new SignedBitsCount(val).GetBits();
writer.WriteSignedBits(val, bits);
writer.FlushBits();
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
double actual = reader.ReadFixedPoint16(bits);
Assert.AreEqual(-1.25, actual);
}
public void ReadFixedPoint8Test()
{
var mem = new MemoryStream();
const int val = 0xc3aa;
const byte hi = val >> 8;
const byte low = val & 0xff;
const double expected = hi + low / 256.0;
mem.WriteByte(low);
mem.WriteByte(hi);
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
double actual = reader.ReadFixedPoint8();
Assert.AreEqual(expected, actual);
}
protected IEnumerable<SwfTagData> IterateTags(Stream stream)
{
var file = new SwfFile();
var reader = new SwfStreamReader(stream);
file.FileInfo = reader.ReadSwfFileInfo();
reader = GetSwfStreamReader(file.FileInfo, stream);
file.Header = reader.ReadSwfHeader();
while (!reader.IsEOF) {
var tagData = reader.ReadTagData();
yield return tagData;
}
}
public void ReadFixedPoint16FromBitsTest()
{
var mem = new MemoryStream();
var writer = new SwfStreamWriter(mem);
const int val = 0x03aa4523;
const ushort hi = val >> 16;
const ushort low = val & 0xffff;
const double expected = hi + low / 65536.0;
var bits = new SignedBitsCount(hi).GetBits();
writer.WriteUnsignedBits(hi, bits);
writer.WriteUnsignedBits(low, 16);
writer.FlushBits();
mem.Seek(0, SeekOrigin.Begin);
var reader = new SwfStreamReader(mem);
double actual = reader.ReadFixedPoint16(bits + 16);
Assert.AreEqual(expected, actual);
}
