// Methods
public override void Load(Stream fileStream)
{
// Header
var reader = new ExtendedBinaryReader(fileStream, Encoding.ASCII, false);
string sig = reader.ReadSignature();
if (sig != Signature)
{
throw new InvalidSignatureException(Signature, sig);
}
// Textures
uint totalFrameCount = reader.ReadUInt32();
byte textureCount = reader.ReadByte();
for (int i = 0; i < textureCount; ++i)
{
Textures.Add(new Texture()
{
FilePath = reader.ReadString(),
Unknown1 = reader.ReadByte()
});
}
// Animations
ushort animCount = reader.ReadUInt16();
for (int i2 = 0; i2 < animCount; ++i2)
{
var anim = new Animation()
{
Name = reader.ReadString()
};
ushort frameCount = reader.ReadUInt16();
anim.Unknown1 = reader.ReadInt16();
anim.Unknown2 = reader.ReadInt16();
// Animation Frames
for (int i3 = 0; i3 < frameCount; ++i3)
{
anim.Frames.Add(new Frame()
{
TextureIndex = reader.ReadByte(),
Unknown1 = reader.ReadInt16(),
Unknown2 = reader.ReadInt16(),
X = reader.ReadUInt16(),
Y = reader.ReadUInt16(),
Width = reader.ReadUInt16(),
Height = reader.ReadUInt16(),
OriginX = reader.ReadInt16(),
OriginY = reader.ReadInt16()
});
}
Animations.Add(anim);
}
}
public override void Read(ExtendedBinaryReader reader, Action <Color> synchronizationCallback)
{
byte r = reader.ReadByte();
byte g = reader.ReadByte();
byte b = reader.ReadByte();
byte a = reader.ReadByte();
synchronizationCallback(Color.FromNonPremultiplied(r, g, b, a));
}
public override void Deserialize(ExtendedBinaryReader reader, Action <Color> valueFixup)
{
byte r = reader.ReadByte();
byte g = reader.ReadByte();
byte b = reader.ReadByte();
byte a = reader.ReadByte();
valueFixup(Color.FromNonPremultiplied(r, g, b, a));
}
public static Phenotype ReadPhenotype(ExtendedBinaryReader reader)
{
var mimNumber = reader.ReadOptInt32();
var phenotype = reader.ReadAsciiString();
var mapping = (Mapping)reader.ReadByte();
var comments = (Comments)reader.ReadByte();
var inheritance = reader.ReadOptArray(reader.ReadAsciiString);
var inheritances = inheritance == null ? null : new HashSet <string>(inheritance);
return(new Phenotype(mimNumber, phenotype, mapping, comments, inheritances));
}
protected override Subtitle ReadSubtitle(ExtendedBinaryReader input)
{
var offset = input.ReadUInt16();
var returnPos = input.Position;
input.Seek(offset, SeekOrigin.Begin);
using (var ms = new MemoryStream())
{
var subtitle = new Subtitle {
Offset = offset
};
var b = input.ReadByte();
while (b != 0x00)
{
switch (b)
{
case 0x07: // Color
{
var b2 = input.ReadByte();
var buffer = this.FileEncoding.GetBytes($"<Color: {b2:X2}>");
ms.Write(buffer, 0, buffer.Length);
break;
}
case 0x1F: // Item
{
var id = input.ReadUInt16();
var buffer = this.FileEncoding.GetBytes($"<Item: {id:X4}>");
ms.Write(buffer, 0, buffer.Length);
break;
}
default:
{
ms.WriteByte(b); // Es el encoding quien se encarga de sustituirlo si es necesario
break;
}
}
b = input.Position == input.Length ? (byte)0x00 : input.ReadByte();
}
var text = FileEncoding.GetString(ms.ToArray());
subtitle.Text = text;
subtitle.Translation = text;
subtitle.Loaded = text;
input.Seek(returnPos, SeekOrigin.Begin);
return(subtitle);
}
}
protected override IList <TF.Core.TranslationEntities.Subtitle> GetSubtitles()
{
var result = new List <TF.Core.TranslationEntities.Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding, Endianness.BigEndian))
{
input.Skip(3);
var count = input.ReadByte();
input.Skip(4);
var pointer1 = input.ReadInt32();
var countPointer1 = input.ReadInt16();
var numTalkers = input.ReadInt16();
var pointerTalkers = input.ReadInt32();
var pointerRemainder = input.ReadInt32();
for (var i = 0; i < count; i++)
{
input.Skip(4);
var groupOffset = input.ReadInt32();
input.Skip(1);
var stringCount = input.ReadByte();
input.Skip(6);
var subs = ReadSubtitles(input, groupOffset, stringCount);
if (subs.Count > 0)
{
result.AddRange(subs);
}
}
if (pointerTalkers > 0 && result.Count > 0)
{
input.Seek(pointerTalkers, SeekOrigin.Begin);
for (var i = 0; i < numTalkers; i++)
{
var offset = input.ReadInt32();
var subtitle = ReadSubtitle(input, offset, true);
if (subtitle != null)
{
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
}
}
}
LoadChanges(result);
return(result);
}
public override void Rebuild(string outputFolder)
{
var outputPath = System.IO.Path.Combine(outputFolder, RelativePath);
Directory.CreateDirectory(System.IO.Path.GetDirectoryName(outputPath));
var subtitles = GetSubtitles();
using (var fsInput = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fsInput, FileEncoding, Endianness.LittleEndian))
using (var fsOutput = new FileStream(outputPath, FileMode.Create))
using (var output = new ExtendedBinaryWriter(fsOutput, FileEncoding, Endianness.LittleEndian))
{
var outputOffset = 0;
while (input.Position < input.Length)
{
var inputNextOffset = input.ReadInt16();
var sectionName = input.ReadString(Encoding.UTF8);
using (var tempMemoryStream = new MemoryStream())
using (var temp = new ExtendedBinaryWriter(tempMemoryStream, FileEncoding, Endianness.LittleEndian))
{
temp.WriteString(sectionName);
var aux = input.PeekInt16();
while (aux != -1)
{
var index = input.ReadByte();
temp.Write(index);
var size = input.ReadByte();
var offset = (int)input.Position;
WriteSubtitle(temp, subtitles, offset);
input.ReadString();
aux = input.PeekInt16();
}
input.Skip(2);
temp.Write((short)-1);
var bytes = tempMemoryStream.ToArray();
output.Write((short)(outputOffset + 2 + bytes.Length));
output.Write(bytes);
outputOffset = outputOffset + 2 + bytes.Length;
}
}
}
}
public NsiReader(Stream stream)
{
_stream = stream;
var compressData = new byte[MaxStreamLength];
int length = stream.Read(compressData, 0, MaxStreamLength);
//uncompress
var zstd = new Zstandard();
var decompressedLength = zstd.GetDecompressedLength(compressData, length);
var decompressedData = new byte[decompressedLength];
zstd.Decompress(compressData, length, decompressedData, decompressedLength);
using (var memStream = new MemoryStream(decompressedData, 0, decompressedLength))
using (var memReader = new ExtendedBinaryReader(memStream))
{
Version = DataSourceVersion.Read(memReader);
Assembly = (GenomeAssembly)memReader.ReadByte();
JsonKey = memReader.ReadAsciiString();
ReportFor = (ReportFor)memReader.ReadByte();
int schemaVersion = memReader.ReadOptInt32();
if (schemaVersion != SaCommon.SchemaVersion)
{
throw new UserErrorException($"Schema version mismatch!! Expected {SaCommon.SchemaVersion}, observed {schemaVersion} for {JsonKey}");
}
int count = memReader.ReadOptInt32();
var suppIntervals = new Dictionary <ushort, List <Interval <string> > >();
for (var i = 0; i < count; i++)
{
var saInterval = new SuppInterval(memReader);
if (suppIntervals.TryGetValue(saInterval.Chromosome.Index, out var intervals))
{
intervals.Add(new Interval <string>(saInterval.Start, saInterval.End, saInterval.GetJsonString()));
}
else
{
suppIntervals[saInterval.Chromosome.Index] = new List <Interval <string> > {
new Interval <string>(saInterval.Start, saInterval.End, saInterval.GetJsonString())
}
};
}
_intervalArrays = new Dictionary <ushort, IntervalArray <string> >(suppIntervals.Count);
foreach ((ushort chromIndex, List <Interval <string> > intervals) in suppIntervals)
{
_intervalArrays[chromIndex] = new IntervalArray <string>(intervals.ToArray());
}
}
}
public Tuple <int, int> GetCopyInfo()
{
if (_mode == WorkMode.Write)
{
throw new NotImplementedException("Esta función no es válida para comprimir");
}
var copyFlags = (ushort)(_input.ReadByte() | _input.ReadByte() << 8);
var copyDistance = 1 + (copyFlags >> 4);
var copyCount = 3 + (copyFlags & 0xF);
return(new Tuple <int, int>(copyDistance, copyCount));
}
public static byte[] Decompress(byte[] compressedData)
{
using (var input = new ExtendedBinaryReader(new MemoryStream(compressedData), Encoding.GetEncoding(1252), Endianness.BigEndian))
using (var output = new MemoryStream())
{
var magic = input.ReadUInt32();
var endianness = input.ReadByte();
input.Endianness = endianness == 0 ? Endianness.LittleEndian : Endianness.BigEndian;
var version = input.ReadByte();
var headerSize = input.ReadUInt16();
var uncompressedSize = input.ReadUInt32();
var compressedSize = input.ReadUInt32();
var block = new byte[18];
var manager = new BitManager(input);
while (input.Position < input.Length)
{
var type = manager.GetFlagType();
switch (type)
{
case FlagType.Literal:
output.WriteByte(input.ReadByte());
break;
case FlagType.Copy:
var(copyPosition, copyCount) = manager.GetCopyInfo();
output.Seek(-copyPosition, SeekOrigin.End);
output.Read(block, 0, copyCount);
output.Seek(0, SeekOrigin.End);
output.Write(block, 0, copyCount);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(output.ToArray());
}
}
private void ReadHeader()
{
var header = _reader.ReadString();
if (header != SaDataBaseCommon.DataHeader)
{
throw new FormatException("Unrecognized header in this database");
}
// ReSharper disable UnusedVariable
var dataVersion = _reader.ReadUInt16();
var schema = _reader.ReadUInt16();
if (schema != SaDataBaseCommon.SchemaVersion)
{
throw new UserErrorException($"Gene database schema mismatch. Expected {SaDataBaseCommon.SchemaVersion}, observed {schema}");
}
var genomeAssembly = (GenomeAssembly)_reader.ReadByte();
var creationTime = _reader.ReadInt64();
// ReSharper restore UnusedVariable
var dataSourseVersionsCount = _reader.ReadOptInt32();
for (var i = 0; i < dataSourseVersionsCount; i++)
{
DataSourceVersions.Add(DataSourceVersion.Read(_reader));
}
CheckGuard();
}
private void ReadSourceCommands(ExtendedBinaryReader reader)
{
int count = reader.Read7BitEncodedInt();
for (var i = 0; i < count; i++)
{
var action = (NotifyCollectionChangedAction)reader.ReadByte();
switch (action)
{
case NotifyCollectionChangedAction.Add:
_sourceCommands.Add(new SourceAddCommand(reader, _keySerializer, _valueSerializer));
break;
case NotifyCollectionChangedAction.Replace:
_sourceCommands.Add(new SourceReplaceCommand(reader, _keySerializer, _valueSerializer));
break;
case NotifyCollectionChangedAction.Reset:
_sourceCommands.Add(new SourceClearCommand(reader, _keySerializer, _valueSerializer));
break;
case NotifyCollectionChangedAction.Remove:
_sourceCommands.Add(new SourceRemoveCommand(reader, _keySerializer));
break;
}
}
}
public IoCommandStartEvent ReadIoCommandStartEvent(ExtendedBinaryReader reader)
{
var evt = new IoCommandStartEvent
{
Uid = reader.Read7BitEncodedInt(),
ProcessInvocationUid = reader.Read7BitEncodedInt(),
Kind = (IoCommandKind)reader.ReadByte(),
Location = GetTextById(reader.Read7BitEncodedInt()),
Path = GetTextById(reader.Read7BitEncodedInt()),
TimeoutSeconds = reader.ReadNullableInt32(),
Command = reader.ReadNullableString(),
TransactionId = GetTextById(reader.Read7BitEncodedInt()),
};
var argCount = reader.Read7BitEncodedInt();
if (argCount > 0)
{
evt.Arguments = new KeyValuePair <string, object> [argCount];
for (var i = 0; i < argCount; i++)
{
var name = GetTextById(reader.Read7BitEncodedInt());
var value = reader.ReadObject();
evt.Arguments[i] = new KeyValuePair <string, object>(name, value);
}
}
return(evt);
}
public LogEvent ReadLogEvent(ExtendedBinaryReader reader)
{
var evt = new LogEvent
{
TransactionId = GetTextById(reader.Read7BitEncodedInt()),
Text = reader.ReadString(),
Severity = (LogSeverity)reader.ReadByte(),
ProcessInvocationUID = reader.ReadNullableInt32()
};
var argCount = reader.Read7BitEncodedInt();
if (argCount > 0)
{
evt.Arguments = new KeyValuePair <string, object> [argCount];
for (var i = 0; i < argCount; i++)
{
var key = GetTextById(reader.Read7BitEncodedInt());
var value = reader.ReadObject();
evt.Arguments[i] = new KeyValuePair <string, object>(key, value);
}
}
return(evt);
}
public static Entry ReadEntry(ExtendedBinaryReader reader)
{
double score = reader.ReadDouble();
byte enumIndex = reader.ReadByte();
return(new Entry(score, enumIndex));
}
public NsaIndex(Stream stream)
{
using (var memStream = new MemoryStream())
using (var memReader = new ExtendedBinaryReader(memStream))
{
stream.CopyTo(memStream);//reading all bytes in stream to memStream
memStream.Position = 0;
Assembly = (GenomeAssembly)memReader.ReadByte();
Version = DataSourceVersion.Read(memReader);
JsonKey = memReader.ReadAsciiString();
MatchByAllele = memReader.ReadBoolean();
IsArray = memReader.ReadBoolean();
SchemaVersion = memReader.ReadOptInt32();
IsPositional = memReader.ReadBoolean();
var chromCount = memReader.ReadOptInt32();
_chromBlocks = new Dictionary <ushort, List <NsaIndexBlock> >(chromCount);
for (var i = 0; i < chromCount; i++)
{
var chromIndex = memReader.ReadOptUInt16();
var chunkCount = memReader.ReadOptInt32();
_chromBlocks[chromIndex] = new List <NsaIndexBlock>(chunkCount);
for (var j = 0; j < chunkCount; j++)
{
_chromBlocks[chromIndex].Add(new NsaIndexBlock(memReader));
}
}
}
}
public ChunkedIndex(Stream stream)
{
//reading the index in one shot
var buffer = new byte[1048576];
var indexLength = stream.Read(buffer, 0, 1048576);
using (var memStream = new MemoryStream(buffer, 0, indexLength))
using (var memReader = new ExtendedBinaryReader(memStream))
{
Assembly = (GenomeAssembly)memReader.ReadByte();
Version = DataSourceVersion.Read(memReader);
JsonKey = memReader.ReadAsciiString();
MatchByAllele = memReader.ReadBoolean();
IsArray = memReader.ReadBoolean();
SchemaVersion = memReader.ReadOptInt32();
IsPositional = memReader.ReadBoolean();
var chromCount = memReader.ReadOptInt32();
_chromChunks = new Dictionary <ushort, List <Chunk> >(chromCount);
for (var i = 0; i < chromCount; i++)
{
var chromIndex = memReader.ReadOptUInt16();
var chunkCount = memReader.ReadOptInt32();
_chromChunks[chromIndex] = new List <Chunk>(chunkCount);
for (var j = 0; j < chunkCount; j++)
{
_chromChunks[chromIndex].Add(new Chunk(memReader));
}
}
}
}
public sealed override void Read(ExtendedBinaryReader reader)
{
SubscribeToEndRead();
var commandCount = reader.Read7BitEncodedInt();
for (var i = 0; i < commandCount; i++)
{
var action = (NotifyCollectionChangedAction)reader.ReadByte();
switch (action)
{
case NotifyCollectionChangedAction.Add:
_sourceCommands.Add(new SourceAddCommand(reader, _itemSerializer));
break;
case NotifyCollectionChangedAction.Replace:
_sourceCommands.Add(new SourceReplaceCommand(reader, _itemSerializer));
break;
case NotifyCollectionChangedAction.Reset:
_sourceCommands.Add(new SourceClearCommand(reader, _itemSerializer));
break;
case NotifyCollectionChangedAction.Remove:
_sourceCommands.Add(new SourceRemoveCommand(reader, _itemSerializer));
break;
}
}
}
/// <summary>
/// reads the transcript from the binary reader
/// </summary>
public static Transcript Read(ExtendedBinaryReader reader, Gene[] cacheGenes, SimpleInterval[] cacheIntrons,
SimpleInterval[] cacheMirnas, string[] cachePeptideSeqs)
{
// transcript
var referenceIndex = reader.ReadUInt16();
var start = reader.ReadOptInt32();
var end = reader.ReadOptInt32();
var id = CompactId.Read(reader);
// gene
var geneIndex = reader.ReadOptInt32();
var gene = cacheGenes[geneIndex];
// encoded data
var encoded = new EncodedTranscriptData(reader.ReadUInt16(), reader.ReadByte());
// exons & introns
var introns = encoded.HasIntrons ? ReadIndices(reader, cacheIntrons) : null;
var cdnaMaps = encoded.HasCdnaMaps ? ReadCdnaMaps(reader) : null;
// protein function predictions
int siftIndex = encoded.HasSift ? reader.ReadOptInt32() : -1;
int polyphenIndex = encoded.HasPolyPhen ? reader.ReadOptInt32() : -1;
// translation
var translation = encoded.HasTranslation ? Translation.Read(reader, cachePeptideSeqs) : null;
// attributes
var mirnas = encoded.HasMirnas ? ReadIndices(reader, cacheMirnas) : null;
return(new Transcript(referenceIndex, start, end, id, encoded.Version, translation, encoded.BioType,
gene, TranscriptUtilities.GetTotalExonLength(cdnaMaps), encoded.StartExonPhase, encoded.IsCanonical,
introns, mirnas, cdnaMaps, siftIndex, polyphenIndex, encoded.TranscriptSource));
}
private static object ReadValueType(Type valueType, ExtendedBinaryReader br, bool noAlign = false)
{
if (!noAlign)
{
br.AlignStream();
}
if (valueType == typeof(string))
{
return(br.ReadAlignedString());
}
else if (valueType == typeof(Int32))
{
return(br.ReadInt32());
}
else if (valueType == typeof(UInt32))
{
return(br.ReadUInt32());
}
else if (valueType == typeof(Int64))
{
return(br.ReadInt64());
}
else if (valueType == typeof(UInt64))
{
return(br.ReadUInt64());
}
else if (valueType == typeof(Int16))
{
return(br.ReadInt16());
}
else if (valueType == typeof(UInt16))
{
return(br.ReadUInt16());
}
else if (valueType == typeof(Byte))
{
return(br.ReadByte());
}
else if (valueType == typeof(SByte))
{
return(br.ReadSByte());
}
else if (valueType == typeof(Boolean))
{
return(br.ReadBoolean());
}
else if (valueType == typeof(Double))
{
return(br.ReadDouble());
}
else if (valueType == typeof(Single))
{
return(br.ReadSingle());
}
else
{
throw new ArgumentException($"{valueType} is not a value type");
}
}
/// <summary>
/// checks if the header is good
/// </summary>
private static SupplementaryAnnotationHeader GetHeader(ExtendedBinaryReader reader, out long intervalsPosition, string saPath = null)
{
// check the header and data version
var header = System.Text.Encoding.ASCII.GetString(reader.ReadBytes(SupplementaryAnnotationCommon.DataHeader.Length));
var dataVersion = reader.ReadUInt16();
var schemaVersion = reader.ReadUInt16();
var genomeAssembly = (GenomeAssembly)reader.ReadByte();
if (header != SupplementaryAnnotationCommon.DataHeader || schemaVersion != SupplementaryAnnotationCommon.SchemaVersion)
{
throw new UserErrorException($"The header check failed for the supplementary annotation file ({saPath ?? "(resource)"}): ID: exp: {SupplementaryAnnotationCommon.DataHeader} obs: {header}, schema version: exp:{SupplementaryAnnotationCommon.SchemaVersion} obs: {schemaVersion}");
}
var creationTimeTicks = reader.ReadInt64();
var referenceSequenceName = reader.ReadString();
// skip over the offsets since they're not currently used
reader.ReadInt64(); // _dataSourceVersionsOffset
reader.ReadInt64(); // _dataOffset
intervalsPosition = reader.ReadInt64();
reader.ReadInt64(); // _eofOffset
// load the data source versions
var numDataSourceVersions = reader.ReadOptInt32();
var dataSourceVersions = new List <DataSourceVersion>();
for (var i = 0; i < numDataSourceVersions; i++)
{
dataSourceVersions.Add(DataSourceVersion.Read(reader));
}
return(new SupplementaryAnnotationHeader(referenceSequenceName, creationTimeTicks, dataVersion,
dataSourceVersions, genomeAssembly));
}
private void LoadHeader()
{
// grab the index and masked intervals offsets
_indexOffset = _reader.ReadInt64();
_reader.ReadInt64();
// skip the creation time
_reader.ReadOptInt64();
// grab the reference metadata
NumRefSeqs = (ushort)_reader.ReadOptInt32();
for (ushort i = 0; i < NumRefSeqs; i++)
{
var metadata = ReferenceMetadata.Read(_reader);
ReferenceMetadataList.Add(metadata);
AddReferenceName(metadata.EnsemblName, metadata.UcscName, i);
}
// read the cytogenetic bands
CytogeneticBands = Genome.CytogeneticBands.Read(_reader);
// read the genome assembly
Sequence.Assembly = (GenomeAssembly)_reader.ReadByte();
// grab the data start tag
ulong dataStartTag = _reader.ReadUInt64();
if (dataStartTag != CompressedSequenceCommon.DataStartTag)
{
throw new InvalidFileFormatException($"The data start tag does not match the expected values: Obs: {dataStartTag} vs Exp: {CompressedSequenceCommon.DataStartTag}");
}
}
public static CompactId Read(ExtendedBinaryReader reader)
{
var id = (IdType)reader.ReadByte();
var info = reader.ReadOptInt32();
return(new CompactId(id, info));
}
/// <summary>
/// Reads a list of nodes from the underlying stream, where the number of
/// nodes is determined by the LEB128 encoded integer prefix.
/// </summary>
/// <param name="reader">Reader used for reading from the underlying stream.</param>
public override void ReadValue(ExtendedBinaryReader reader)
{
var count = reader.Read7BitEncodedInt();
for (var i = 0; i < count; i++)
{
var type = (BsfType)reader.ReadByte();
if (type == BsfType.Null)
{
_list.Add(null);
}
else
{
if (ElementType == BsfType.Null)
{
ElementType = type;
}
if (type != ElementType)
{
throw new InvalidOperationException($"List contains elements of both type '{ElementType}' and '{type}");
}
var node = Create(ElementType);
node.ReadValue(reader);
_list.Add(node);
}
}
}
public static EncodedTranscriptData Read(ExtendedBinaryReader reader)
{
var info = reader.ReadUInt16();
var contents = reader.ReadByte();
return(new EncodedTranscriptData(info, contents));
}
public virtual Instruction Read(ExtendedBinaryReader reader)
{
var instruction = new Instruction(Name, ArgTypes);
if (ArgTypes == null)
{
return(instruction);
}
for (int i = 0; i < ArgTypes.Length; ++i)
{
if (ArgTypes[i] == AT_PointerArray)
{
int[] pointers = new int[reader.ReadByte()];
for (int i2 = 0; i2 < pointers.Length; ++i2)
{
pointers[i] = reader.ReadInt32();
}
Arguments.Add(pointers);
}
else
{
instruction.Arguments.Add(ReadByType(reader, ArgTypes[i]));
}
}
return(instruction);
}
protected override IList <Subtitle> GetSubtitles()
{
var result = new List <Subtitle>();
using (var fs = new FileStream(Path, FileMode.Open))
using (var input = new ExtendedBinaryReader(fs, FileEncoding))
{
var patternPos = new List <int>();
var pos = input.FindPattern(SearchPattern);
while (pos != -1)
{
patternPos.Add(pos);
pos = input.FindPattern(SearchPattern);
}
if (patternPos.Count > 0)
{
input.Seek(patternPos[patternPos.Count - 1] + 3, SeekOrigin.Begin);
var count = input.ReadByte();
for (var i = 0; i < count; i++)
{
input.Skip(0x1C);
var txt = ReadSubtitle(input);
if (!string.IsNullOrWhiteSpace(txt.Text))
{
txt.PropertyChanged += SubtitlePropertyChanged;
result.Add(txt);
}
txt = ReadSubtitle(input);
if (!string.IsNullOrWhiteSpace(txt.Text))
{
txt.PropertyChanged += SubtitlePropertyChanged;
result.Add(txt);
}
}
input.Skip(4);
var subtitle = ReadSubtitle(input);
if (!string.IsNullOrWhiteSpace(subtitle.Text))
{
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
subtitle = ReadSubtitle(input);
if (!string.IsNullOrWhiteSpace(subtitle.Text))
{
subtitle.PropertyChanged += SubtitlePropertyChanged;
result.Add(subtitle);
}
}
}
LoadChanges(result);
return(result);
}
public static byte[] ReadAndDecompress(ExtendedBinaryReader reader)
{
var stream = new MemoryStream();
uint decompressedSize = reader.ReadUInt32();
uint compressedSize = reader.ReadUInt32();
byte copyByte = reader.ReadByte();
reader.JumpAhead(3);
uint dataStartOffset = (uint)reader.BaseStream.Position;
while (stream.Position < decompressedSize)
{
byte b = reader.ReadByte();
if (b == copyByte)
{
byte returnByte = reader.ReadByte();
if (returnByte == copyByte)
{
stream.WriteByte(returnByte);
continue;
}
if (returnByte >= copyByte)
{
returnByte--;
}
uint offset = (uint)stream.Position - returnByte;
byte length = reader.ReadByte();
uint currentPosition = (uint)stream.Position;
stream.Position = offset;
byte[] buffer = new byte[length];
stream.Read(buffer, 0, length);
stream.Position = currentPosition;
stream.Write(buffer, 0, length);
}
else
{
stream.WriteByte(b);
}
}
return(stream.ToArray());
}
// Methods
public static void Read(HavokFile h, ExtendedBinaryReader reader)
{
// Header
reader.JumpAhead(0x10);
// A lot of this was gathered from the Max Havok exporter.
byte bytesInPointer = reader.ReadByte();
reader.IsBigEndian = !reader.ReadBoolean();
byte reusePaddingOpt = reader.ReadByte();
byte emptyBaseClassOpt = reader.ReadByte();
// We jump around a lot here, but there's not really a much cleaner way to do it.
reader.JumpTo(8, true);
h.UserTag = reader.ReadUInt32();
h.ClassVersion = reader.ReadInt32();
reader.JumpAhead(4);
uint sectionsCount = reader.ReadUInt32();
uint unknown1 = reader.ReadUInt32();
ulong padding1 = reader.ReadUInt64();
uint unknown2 = reader.ReadUInt32();
h.ContentsVersion = reader.ReadNullTerminatedString();
reader.JumpAhead(9); // Seems to be padding
// Sections
for (uint i = 0; i < sectionsCount; ++i)
{
string sectionName = new string(reader.ReadChars(0x10));
sectionName = sectionName.Replace("\0", string.Empty);
// TODO
reader.JumpAhead(0x20);
}
// Padding Checks
if (padding1 != 0)
{
Console.WriteLine($"WARNING: Padding1 != 0 ({padding1})");
}
// TODO
throw new NotImplementedException();
}
public override void Load(ExtendedBinaryReader reader, bool keepOpen = false)
{
// Check if file has a signature
string sig = reader.ReadSignature();
if (sig == "STSC")
{ // Newer script format
uint headerSize = reader.ReadUInt32();
Version = reader.ReadUInt32();
switch (Version)
{
case 4: // Date A Live: Twin Edition Rio Reincarnation (PSV)
ScriptID = reader.ReadUInt16();
break;
case 7: // Date A Live: Rio Reincarnation (PC)
ScriptName = reader.ReadNullTerminatedString();
reader.JumpAhead((uint)(0x20 - (ScriptName.Length + 1)));
reader.JumpAhead(12);
ScriptID = reader.ReadUInt32();
break;
}
}
else
{ // Older script format
// Jump back as older scripts have much smaller headers
reader.JumpBehind(4);
ScriptID = reader.ReadUInt16();
}
// Stupid workaround to find the end of the code segment
reader.Offset = (uint)reader.BaseStream.Length;
while (true)
{
byte opcode = reader.ReadByte();
if (opcode >= 0x94)
{
throw new STSCDisassembleException(this,
$"Got opcode 0x{opcode:X2} at 0x{reader.BaseStream.Position - 1:X8} in \"{ScriptName}\"" +
" There is no opcodes larger than 0x93!");
}
// Check if its a known instruction
if (STSCInstructions.DALRRInstructions[opcode] == null)
{
throw new STSCDisassembleException(this,
$"Got opcode 0x{opcode:X2} at 0x{reader.BaseStream.Position - 1:X8} in \"{ScriptName}\"" +
" This opcode is unknown!");
}
var instruction = STSCInstructions.DALRRInstructions[opcode].Read(reader);
Instructions.Add(instruction);
if (reader.BaseStream.Position >= reader.Offset)
{
break;
}
}
}
public static FragmentRunEntry Parse(ExtendedBinaryReader br)
{
var entry = new FragmentRunEntry();
entry.FirstFragment= br.ReadUInt32();
entry.FirstFragmentTimestamp = br.ReadUInt64();
entry.FragmentDuration = br.ReadUInt32();
if(entry.FragmentDuration == 0)
entry.DiscontinuityIndicator = br.ReadByte();
else
entry.DiscontinuityIndicator = null;
return entry;
}
public override void Parse(ExtendedBinaryReader br)
{
base.Parse(br);
Version = br.ReadByte();
Flags = br.ReadUInt24();
TimeScale = br.ReadUInt32();
QualityEntryCount = br.ReadByte();
QualitySegmentUrlModifiers = Enumerable.Range(0, QualityEntryCount).Select(i => br.ReadNullTerminatedString()).ToArray();
FragmentRunEntryCount = br.ReadUInt32();
FragmentRunEntryTable = new FragmentRunEntry[FragmentRunEntryCount];
for (uint i = 0; i < FragmentRunEntryCount; i++)
FragmentRunEntryTable[i] = FragmentRunEntry.Parse(br);
}
public override void Parse(ExtendedBinaryReader br)
{
base.Parse(br);
Version = br.ReadByte();
Flags = br.ReadUInt24();
BootstrapinfoVersion = br.ReadUInt32();
var b = br.ReadByte();
Profile = (new byte[] { 0x80, 0x40 }).Select(i => (i & b) != 0).ToArray();
Live = (0x02 & b) != 0;
Update = (0x01 & b) != 0;
Reserved = (new byte[] { 0x08, 0x04, 0x02, 0x01 }).Select(i => (i & b) != 0).ToArray();
TimeScale = br.ReadUInt32();
CurrentMediaTime = br.ReadUInt64();
SmpteTimeCodeOffset = br.ReadUInt64();
MovieIdentifier = br.ReadNullTerminatedString();
ServerEntryCount = br.ReadByte();
ServerEntryTable = new ServerEntry[ServerEntryCount];
for (int i = 0; i < ServerEntryCount; i++)
ServerEntryTable[i] = ServerEntry.Parse(br);
QualityEntryCount = br.ReadByte();
QualityEntryTable = new QualityEntry[QualityEntryCount];
for (int i = 0; i < QualityEntryCount; i++)
QualityEntryTable[i] = QualityEntry.Parse(br);
DrmData = br.ReadNullTerminatedString();
MetaData = br.ReadNullTerminatedString();
SegmentRunTableCount = br.ReadByte();
SegmentRunTableEntries = new SegmentRunTableBox[SegmentRunTableCount];
for (int i = 0; i < SegmentRunTableCount; i++)
{
SegmentRunTableEntries[i] = new SegmentRunTableBox();
SegmentRunTableEntries[i].Parse(br);
}
FragmentRunTableCount = br.ReadByte();
FragmentRunTableEntries = new FragmentRunTableBox[FragmentRunTableCount];
for (int i = 0; i < FragmentRunTableCount; i++)
{
FragmentRunTableEntries[i] = new FragmentRunTableBox();
FragmentRunTableEntries[i].Parse(br);
}
}
public static FLVTag Parse(ExtendedBinaryReader br)
{
var b = br.ReadByte();
var tag = new FLVTag
{
Reserved = (byte)(b & 0xc0),
Filter = (b & 0x20) == 0,
TagType = (TagType)(b & 0x1f),
DataSize = br.ReadUInt24(),
TimeStamp = br.ReadUInt24(),
TimestampExtended = br.ReadByte(),
StreamID = br.ReadUInt24()
};
tag.HeaderAndBody = br.ReadBytes((tag.TimestampExtended << 24) + (int)tag.TimeStamp);
return tag;
}
