protected override void WriteBodyTo(FlashWriter output)
{
output.Write(Id);
output.Write((uint)Data.Length);
output.Write(Data);
output.Write(AlphaData);
}
protected override void WriteValuesTo(FlashWriter output)
{
output.Write(DebugType);
output.WriteInt30(NameIndex);
output.Write(RegisterIndex);
output.WriteInt30(Extra);
}
public byte[] ToByteArray()
{
using (var asMethodBody = new FlashWriter())
{
asMethodBody.Write7BitEncodedInt(MethodIndex);
asMethodBody.Write7BitEncodedInt(MaxStack);
asMethodBody.Write7BitEncodedInt(LocalCount);
asMethodBody.Write7BitEncodedInt(InitialScopeDepth);
asMethodBody.Write7BitEncodedInt(MaxScopeDepth);
asMethodBody.Write7BitEncodedInt(Bytecode.Length);
asMethodBody.Write(Bytecode);
asMethodBody.Write7BitEncodedInt(Exceptions.Count);
foreach (ASException exception in Exceptions)
{
asMethodBody.Write(exception.ToByteArray());
}
asMethodBody.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asMethodBody.Write(trait.ToByteArray());
}
return(asMethodBody.ToArray());
}
}
public override void WriteTo(FlashWriter output)
{
output.WriteInt30(Parameters.Count);
output.WriteInt30(ReturnTypeIndex);
int optionalParamCount = 0;
int optionalParamStartIndex = (Parameters.Count - 1);
if (Parameters.Count > 0)
{
// This flag will be removed if at least a single parameter has no name assigned.
Flags |= MethodFlags.HasParamNames;
for (int i = 0; i < Parameters.Count; i++)
{
ASParameter parameter = Parameters[i];
output.WriteInt30(parameter.TypeIndex);
// This flag should only be present when all parameters are assigned a Name.
if (string.IsNullOrWhiteSpace(parameter.Name))
{
Flags &= ~MethodFlags.HasParamNames;
}
// Just one optional parameter is enough to attain this flag.
if (parameter.IsOptional)
{
if (i < optionalParamStartIndex)
{
optionalParamStartIndex = i;
}
optionalParamCount++;
Flags |= MethodFlags.HasOptional;
}
}
}
output.WriteInt30(NameIndex);
output.Write((byte)Flags);
if (Flags.HasFlag(MethodFlags.HasOptional))
{
output.WriteInt30(optionalParamCount);
for (int i = optionalParamStartIndex; i < Parameters.Count; i++)
{
ASParameter parameter = Parameters[i];
output.WriteInt30(parameter.ValueIndex);
output.Write((byte)parameter.ValueKind);
}
}
if (Flags.HasFlag(MethodFlags.HasParamNames))
{
for (int i = 0; i < Parameters.Count; i++)
{
ASParameter parameter = Parameters[i];
output.WriteInt30(parameter.NameIndex);
}
}
}
public byte[] ToByteArray()
{
using (var asMultiname = new FlashWriter())
{
asMultiname.Write((byte)MultinameType);
asMultiname.Write(Data.ToByteArray());
return(asMultiname.ToArray());
}
}
protected override void WriteBodyTo(FlashWriter output)
{
output.Write(Id);
output.WriteBits(4, Format);
output.WriteBits(2, Rate);
output.WriteBits(1, Size);
output.WriteBits(1, SoundType);
output.Write(SoundSampleCount);
output.Write(SoundData);
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter(4))
{
tag.Write(MaxRecursionDepth);
tag.Write(ScriptTimeoutSeconds);
return(tag.ToArray());
}
}
protected override void WriteBodyTo(FlashWriter output)
{
output.Write((ushort)Entries.Count);
foreach (var pair in Entries)
{
output.Write(pair.Item1);
output.WriteNullString(pair.Item2);
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write(Flags);
tag.WriteNullTerminatedString(Name);
tag.Write(ABC.ToByteArray());
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag =
new FlashWriter(6 + BinaryData.Length))
{
tag.Write(CharacterId);
tag.Position += 4;
tag.Write(BinaryData);
return(tag.ToArray());
}
}
public override void WriteTo(FlashWriter output)
{
var bitContainer = (byte)(
((byte)Attributes << 4) + (byte)Kind);
output.WriteInt30(QNameIndex);
output.Write(bitContainer);
output.WriteInt30(Id);
switch (Kind)
{
case TraitKind.Slot:
case TraitKind.Constant:
{
output.WriteInt30(TypeIndex);
output.WriteInt30(ValueIndex);
if (ValueIndex != 0)
{
output.Write((byte)ValueKind);
}
break;
}
case TraitKind.Method:
case TraitKind.Getter:
case TraitKind.Setter:
{
output.WriteInt30(MethodIndex);
break;
}
case TraitKind.Class:
{
output.WriteInt30(ClassIndex);
break;
}
case TraitKind.Function:
{
output.WriteInt30(FunctionIndex);
break;
}
}
if (Attributes.HasFlag(TraitAttributes.Metadata))
{
output.WriteInt30(MetadataIndices.Count);
for (int i = 0; i < MetadataIndices.Count; i++)
{
int metadatumIndex = MetadataIndices[i];
output.WriteInt30(metadatumIndex);
}
}
}
protected override void WriteBodyTo(FlashWriter output)
{
int symbolCount = Math.Min(Ids.Count, Names.Count);
output.Write((ushort)symbolCount);
for (int i = 0; i < symbolCount; i++)
{
output.Write(Ids[i]);
output.WriteNullString(Names[i]);
}
}
public override void WriteTo(FlashWriter output)
{
var header = ((uint)Kind << 6);
header |= (IsLongTag ? 63 : (uint)Length);
output.Write((ushort)header);
if (IsLongTag)
{
output.Write(Length);
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write((ushort)Assets.Count);
foreach (KeyValuePair <ushort, string> pair in Assets)
{
tag.Write(pair.Key);
tag.WriteNullTerminatedString(pair.Value);
}
return(tag.ToArray());
}
}
public override void WriteTo(FlashWriter output)
{
output.Write((ushort)Version.Minor);
output.Write((ushort)Version.Major);
Pool.WriteTo(output);
WriteTo(output, Methods);
WriteTo(output, Metadata);
WriteTo(output, Instances);
WriteTo(output, Classes, false);
WriteTo(output, Scripts);
WriteTo(output, MethodBodies);
}
public virtual void Assemble(FlashWriter output, CompressionKind compression, Action <TagItem> callback)
{
output.Write(((char)compression) + "WS", true);
output.Write(Version);
output.Write(uint.MinValue);
int fileLength = 8;
FlashWriter compressor = null;
switch (compression)
{
case CompressionKind.LZMA:
{
compressor = new FlashWriter((int)FileLength);
break;
}
case CompressionKind.ZLIB:
{
compressor = ZLIB.WrapCompressor(output.BaseStream, true);
break;
}
}
/* Body Start */
Frame.WriteTo(compressor ?? output);
fileLength += (Frame.Area.GetByteSize() + 4);
for (int i = 0; i < Tags.Count; i++)
{
TagItem tag = Tags[i];
callback?.Invoke(tag);
WriteTag(tag, compressor ?? output);
fileLength += tag.Header.Length;
fileLength += (tag.Header.IsLongTag ? 6 : 2);
}
if (compression == CompressionKind.LZMA)
{
byte[] uncompressedBody = ((MemoryStream)compressor.BaseStream).ToArray();
byte[] compressedBody = LZMA.Compress(uncompressedBody);
output.Write(compressedBody);
}
compressor?.Dispose();
/* Body End */
output.Position = 4;
output.Write((uint)fileLength);
output.Position = output.Length;
}
public byte[] ToByteArray()
{
using (var asConstants = new FlashWriter())
{
asConstants.Write7BitEncodedInt(_integers.Count);
for (int i = 1; i < _integers.Count; i++)
{
asConstants.Write7BitEncodedInt(_integers[i]);
}
asConstants.Write7BitEncodedInt(_uintegers.Count);
for (int i = 1; i < _uintegers.Count; i++)
{
asConstants.Write7BitEncodedInt((int)_uintegers[i]);
}
asConstants.Write7BitEncodedInt(_doubles.Count);
for (int i = 1; i < _doubles.Count; i++)
{
asConstants.Write(_doubles[i]);
}
asConstants.Write7BitEncodedInt(_strings.Count);
for (int i = 1; i < _strings.Count; i++)
{
asConstants.Write(_strings[i]);
}
asConstants.Write7BitEncodedInt(_namespaces.Count);
for (int i = 1; i < _namespaces.Count; i++)
{
asConstants.Write(_namespaces[i].ToByteArray());
}
asConstants.Write7BitEncodedInt(_namespaceSets.Count);
for (int i = 1; i < _namespaceSets.Count; i++)
{
asConstants.Write(_namespaceSets[i].ToByteArray());
}
asConstants.Write7BitEncodedInt(_multinames.Count);
for (int i = 1; i < _multinames.Count; i++)
{
asConstants.Write(_multinames[i].ToByteArray());
}
return(asConstants.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asInstance = new FlashWriter())
{
asInstance.Write7BitEncodedInt(TypeIndex);
asInstance.Write7BitEncodedInt(SuperTypeIndex);
asInstance.Write7BitEncodedInt((byte)ClassInfo);
if ((ClassInfo & ClassFlags.ProtectedNamespace) != 0)
{
asInstance.Write7BitEncodedInt(ProtectedNamespaceIndex);
}
asInstance.Write7BitEncodedInt(InterfaceIndices.Count);
foreach (int index in InterfaceIndices)
{
asInstance.Write7BitEncodedInt(index);
}
asInstance.Write7BitEncodedInt(ConstructorIndex);
asInstance.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asInstance.Write(trait.ToByteArray());
}
return(asInstance.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asNamespace = new FlashWriter())
{
asNamespace.Write((byte)NamespaceType);
asNamespace.Write7BitEncodedInt(ObjNameIndex);
return(asNamespace.ToArray());
}
}
public override void WriteTo(FlashWriter output)
{
output.Write((byte)Kind);
switch (Kind)
{
case MultinameKind.QName:
case MultinameKind.QNameA:
{
output.WriteInt30(NamespaceIndex);
output.WriteInt30(NameIndex);
break;
}
case MultinameKind.RTQName:
case MultinameKind.RTQNameA:
{
output.WriteInt30(NameIndex);
break;
}
case MultinameKind.RTQNameL:
case MultinameKind.RTQNameLA:
{
/* No data. */
break;
}
case MultinameKind.Multiname:
case MultinameKind.MultinameA:
{
output.WriteInt30(NameIndex);
output.WriteInt30(NamespaceSetIndex);
break;
}
case MultinameKind.MultinameL:
case MultinameKind.MultinameLA:
{
output.WriteInt30(NamespaceSetIndex);
break;
}
case MultinameKind.TypeName:
{
output.WriteInt30(QNameIndex);
output.WriteInt30(TypeIndices.Count);
for (int i = 0; i < TypeIndices.Count; i++)
{
int typeIndex = TypeIndices[i];
output.WriteInt30(typeIndex);
}
break;
}
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Write(FontId);
tag.WriteNullTerminatedString(FontName);
tag.WriteNullTerminatedString(FontCopyright);
return(tag.ToArray());
}
}
protected override byte[] OnConstruct()
{
if (_compressedBitmapData == null)
{
_compressedBitmapData =
ZlibStream.CompressBuffer(_bitmapData);
}
using (var tag =
new FlashWriter(7 + _compressedBitmapData.Length))
{
tag.Write(CharacterId);
tag.Write(BitmapFormat);
tag.Write(BitmapWidth);
tag.Write(BitmapHeight);
tag.Write(_compressedBitmapData);
return(tag.ToArray());
}
}
public byte[] ToByteArray()
{
using (var abcFile = new FlashWriter())
{
abcFile.Write(MinorVersion);
abcFile.Write(MajorVersion);
abcFile.Write(Constants.ToByteArray());
abcFile.Write7BitEncodedInt(Methods.Count);
foreach (ASMethod methodInfo in Methods)
{
abcFile.Write(methodInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Metadata.Count);
foreach (ASMetadata metadataInfo in Metadata)
{
abcFile.Write(metadataInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Instances.Count);
foreach (ASInstance instanceInfo in Instances)
{
abcFile.Write(instanceInfo.ToByteArray());
}
foreach (ASClass classInfo in Classes)
{
abcFile.Write(classInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(Scripts.Count);
foreach (ASScript scriptInfo in Scripts)
{
abcFile.Write(scriptInfo.ToByteArray());
}
abcFile.Write7BitEncodedInt(MethodBodies.Count);
foreach (ASMethodBody methodBodyInfo in MethodBodies)
{
abcFile.Write(methodBodyInfo.ToByteArray());
}
return(abcFile.ToArray());
}
}
protected override byte[] OnConstruct()
{
using (var tag = new FlashWriter())
{
tag.Position = 2;
ushort symbolCount = 0;
foreach (KeyValuePair <ushort, string> symbol in Symbols)
{
string[] symbolNames = symbol.Value.Split(',');
foreach (string symbolName in symbolNames)
{
symbolCount++;
tag.Write(symbol.Key);
tag.WriteNullTerminatedString(symbol.Value);
}
}
tag.Position = 0;
tag.Write(symbolCount);
return(tag.ToArray());
}
}
/// <summary>
/// Reconstructs the Shockwave Flash(SWF) file using the tags from <see cref="Tags"/>.
/// </summary>
public byte[] Reconstruct()
{
using (var flash = new FlashWriter())
{
flash.WriteUTF8SimpleString("FWS");
flash.Write(Version);
flash.Position += 4;
flash.Write(_frameData);
foreach (FlashTag tag in Tags)
{
flash.Write(tag.ToArray());
}
flash.Position = 4;
flash.Write(flash.Length);
_flashData = flash.ToArray();
Reader.ResetBuffer(_flashData);
return(_flashData);
}
}
public byte[] ToByteArray()
{
using (var asTrait = new FlashWriter())
{
var trueKind = (byte)((
(byte)Attributes << 4) + (byte)TraitType);
asTrait.Write7BitEncodedInt(TypeIndex);
asTrait.Write(trueKind);
asTrait.Write(Data.ToByteArray());
if ((Attributes & TraitAttributes.Metadata) != 0)
{
asTrait.Write7BitEncodedInt(MetadataIndices.Count);
foreach (int index in MetadataIndices)
{
asTrait.Write7BitEncodedInt(index);
}
}
return(asTrait.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asMethod = new FlashWriter())
{
asMethod.Write7BitEncodedInt(Parameters.Count);
asMethod.Write7BitEncodedInt(ReturnTypeIndex);
foreach (ASParameter parameter in Parameters)
{
asMethod.Write7BitEncodedInt(parameter.TypeIndex);
}
asMethod.Write7BitEncodedInt(NameIndex);
asMethod.Write7BitEncodedInt((byte)MethodInfo);
if ((MethodInfo & MethodFlags.HasOptional) != 0)
{
int optionalParamCount = 0;
byte[] optionalParamData = null;
using (var opParam = new FlashWriter())
{
for (int i = 0; i < Parameters.Count; i++)
{
if (!Parameters[i].IsOptional)
{
continue;
}
optionalParamCount++;
opParam.Write7BitEncodedInt(Parameters[i].ValueIndex);
opParam.Write((byte)Parameters[i].ValueType);
}
optionalParamData = opParam.ToArray();
}
asMethod.Write7BitEncodedInt(optionalParamCount);
asMethod.Write(optionalParamData);
}
if ((MethodInfo & MethodFlags.HasParamNames) != 0)
{
foreach (ASParameter parameter in Parameters)
{
asMethod.Write7BitEncodedInt(parameter.ObjNameIndex);
}
}
return(asMethod.ToArray());
}
}
protected override void WriteBodyTo(FlashWriter output)
{
output.Write((uint)Product);
output.Write((uint)Edition);
output.Write(MajorVersion);
output.Write(MinorVersion);
output.Write(BuildLow);
output.Write(BuildHigh);
TimeSpan sinceEpoch = (CompilationDate - FlashTools.Epoch);
output.Write((ulong)sinceEpoch.TotalMilliseconds);
}
public byte[] ToByteArray()
{
using (var asScript = new FlashWriter())
{
asScript.Write7BitEncodedInt(FunctionIndex);
asScript.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asScript.Write(trait.ToByteArray());
}
return(asScript.ToArray());
}
}
public byte[] ToByteArray()
{
using (var asClass = new FlashWriter())
{
asClass.Write7BitEncodedInt(ConstructorIndex);
asClass.Write7BitEncodedInt(Traits.Count);
foreach (ASTrait trait in Traits)
{
asClass.Write(trait.ToByteArray());
}
return(asClass.ToArray());
}
}