static AnimationHeader GetAnimationHeader(ByteChunk chunk) { if (chunk.BytesLeft == 0) { throw new Exception("Trying to load animation header with no data, chunk size = 0"); } var header = new AnimationHeader(); header.AnimationType = chunk.ReadUInt32(); header.Unknown0_alwaysOne = chunk.ReadUInt32(); // Always 1? header.FrameRate = chunk.ReadSingle(); var nameLength = chunk.ReadShort(); header.SkeletonName = chunk.ReadFixedLength(nameLength); header.Unknown1_alwaysZero = chunk.ReadUInt32(); // Always 0? padding? if (header.AnimationType == 7) { header.AnimationTotalPlayTimeInSec = chunk.ReadSingle(); // Play time } bool isSupportedAnimationFile = header.AnimationType == 5 || header.AnimationType == 6 || header.AnimationType == 7; if (!isSupportedAnimationFile) { throw new Exception($"Unsuported animation format: {header.AnimationType}"); } return(header); }
// ReSharper disable once UnusedParameter.Local private void ValidateLength(ByteChunk chunk) { if (chunk.Length > MaximumMessageLength) { throw new ArgumentException(""); } }
public void BlockCompressorUowShouldWorkAsExpected() { // Arrange var inputDataBytes = new byte[2]; var inputData = new ByteChunk { Id = 123, Data = inputDataBytes }; var input = MockRepository.GenerateStrictMock <IProducerConsumer <IByteChunk> >(); input.Expect(t => t.Pop()).Repeat.Once().Return(inputData); input.Expect(t => t.Pop()).Repeat.Once().Return(null); var compressedBytes = new byte[1]; var gzip = MockRepository.GenerateMock <IGzipStream>(); gzip.Expect(t => t.Compress(inputDataBytes, JobType.Compress)).Repeat.Once().Return(compressedBytes); var output = MockRepository.GenerateMock <IProducerConsumer <IByteChunk> >(); output.Expect(t => t.Push(Arg <IByteChunk> .Matches(d => d.Id == 123 && d.Data == compressedBytes))).Repeat.Once(); var uow = new BlockCompressorUow(input, output, gzip); // Act uow.CompressAction(JobType.Compress)(); // Assert input.VerifyAllExpectations(); output.VerifyAllExpectations(); gzip.VerifyAllExpectations(); }
public void ShouldInsertPaddingRecordPlusMessageOnBufferWrapWithHeadEqualToTail() { const int length = 200; var recordLength = length + RingBufferDescriptor.HeaderLength; var alignedRecordLength = recordLength.AlignToMultipleOf(RingBufferDescriptor.RecordAlignment); var tail = Capacity - RingBufferDescriptor.HeaderLength; var head = tail; _atomicLong.VolatileRead(Head).Returns(head); _atomicLong.VolatileRead(Tail).Returns(tail); _atomicLong.CompareExchange(Tail, tail + alignedRecordLength + RingBufferDescriptor.RecordAlignment, tail) .Returns(tail); var chunk = new ByteChunk(null, length); Assert.IsTrue(_ringBuffer.Write(MessageTypeId, chunk)); Received.InOrder(() => { // padding first _atomicLong.VolatileWrite(new IntPtr(tail), RingBufferDescriptor.MakeHeader(RingBufferDescriptor.HeaderLength, ManyToOneRingBuffer.PaddingMsgTypeId)); // message then _atomicLong.VolatileWrite(new IntPtr(0), RingBufferDescriptor.MakeHeader(-recordLength, MessageTypeId)); _buffer.Write(RingBufferDescriptor.EncodedMsgOffset(0), chunk); _atomicInt.VolatileWrite(new IntPtr(0), recordLength); }); }
public ByteSlice(ByteChunk chunk) { _chunk = chunk.Pointer; _offset = 0; Count = chunk.Length; _buffer = null; }
public void ShouldWriteToEmptyBuffer() { const int length = 8; var recordLength = length + RingBufferDescriptor.HeaderLength; var alignedRecordLength = recordLength.AlignToMultipleOf(RingBufferDescriptor.RecordAlignment); const int headValue = 0; _atomicLong.VolatileRead(Arg.Is(Head)).Returns(headValue); const int tailValue = 0; _atomicLong.VolatileRead(Arg.Is(Tail)).Returns(tailValue); _atomicLong.CompareExchange(Arg.Is(Tail), Arg.Is(tailValue), Arg.Is(tailValue + alignedRecordLength)) .Returns(tailValue); var block = stackalloc byte[100]; var chunk = new ByteChunk(block, length); Assert.IsTrue(_ringBuffer.Write(MessageTypeId, chunk)); Received.InOrder(() => { _atomicLong.VolatileWrite(CurrentSlot, RingBufferDescriptor.MakeHeader(-recordLength, MessageTypeId)); _buffer.Write(RingBufferDescriptor.EncodedMsgOffset(tailValue), chunk); _buffer.GetAtomicInt(tailValue); _atomicInt.VolatileWrite(CurrentSlot, recordLength); }); }
public void ShouldInsertPaddingRecordPlusMessageOnBufferWrap() { const int length = 200; var recordLength = length + RingBufferDescriptor.HeaderLength; var alignedRecordLength = recordLength.AlignToMultipleOf(RingBufferDescriptor.RecordAlignment); long tail = Capacity - RingBufferDescriptor.HeaderLength; var head = tail - RingBufferDescriptor.RecordAlignment * 4; _atomicLong.VolatileRead(Head).Returns(head); _atomicLong.Read(Tail).Returns(tail); var chunk = new ByteChunk(null, length); Assert.True(_ringBuffer.Write(MessageTypeId, chunk)); Received.InOrder(() => { // padding first _atomicLong.VolatileWrite(new IntPtr(tail), RingBufferDescriptor.MakeHeader(RingBufferDescriptor.HeaderLength, ManyToOneRingBuffer.PaddingMsgTypeId)); // then write from the start _buffer.Write(RingBufferDescriptor.EncodedMsgOffset(0), chunk); _buffer.GetAtomicLong(0); _atomicLong.VolatileWrite(new IntPtr(0), RingBufferDescriptor.MakeHeader(recordLength, MessageTypeId)); }); }
public unsafe void MessageHandler(int messageTypeId, ByteChunk chunk) { Assert.AreEqual(MessageId, messageTypeId); Assert.AreEqual(ChunkLength, chunk.Length); var guid = *(Guid *)chunk.Pointer; Received.Add(guid); }
public UnknownIntArrayTable(ByteChunk data) { var count = data.ReadInt32(); Data = new List <int>(count); for (int i = 0; i < count; i++) { Data.Add(data.ReadInt32()); } }
public StringArrayTable(ByteChunk data) { var count = data.ReadInt32(); Values = new List <string>(count); for (int i = 0; i < count; i++) { Values.Add(data.ReadString()); } }
public AnimationBin(string filename, ByteChunk data) { FileName = filename; TableVersion = data.ReadInt32(); RowCount = data.ReadInt32(); AnimationTableEntries = new List <AnimationBinEntry>(RowCount); for (int i = 0; i < RowCount; i++) { AnimationTableEntries.Add(new AnimationBinEntry(data)); } }
List <AnimationDataFile> FindAllSubFiles(ByteChunk data) { var toalFileCount = data.ReadInt32(); var fileList = new List <AnimationDataFile>(toalFileCount); for (int i = 0; i < toalFileCount; i++) { var file = new AnimationDataFile(data); fileList.Add(file); data.Index += file.Size; } return(fileList); }
List <AnimationBin> GetAnimationBins(List <AnimationDataFile> animationDataFile, ByteChunk data) { var output = new List <AnimationBin>(); var animationBins = animationDataFile.Where(x => x.Name.Contains("tables.bin")).ToList(); foreach (var animBin in animationBins) { var byteChunk = new ByteChunk(data.Buffer, animBin.StartOffset); output.Add(new AnimationBin(animBin.Name, byteChunk)); } return(output); }
public AnimationBinEntry(ByteChunk data) { Name = data.ReadString(); SkeletonName = data.ReadString(); MountName = data.ReadString(); var count = data.ReadInt32(); for (int i = 0; i < count; i++) { FragmentReferences.Add(new FragmentReference(data)); } Unknown = data.ReadShort(); }
private void AddChunk() { ByteChunk newChunk = new ByteChunk(ChunkSize); if (WriteChunk != null) { WriteChunk.Next = newChunk; } else { ReadChunk = WriteChunk = newChunk; } }
public void MessageHandler(int messageTypeId, ByteChunk chunk) { var hash = HashMessageId(messageTypeId); var actors = _messageMap[hash]; for (var i = 0; i < _count; i++) { // invoke only if the mask matches the actors, to limit the overhead of calling unneeded actors if ((GetActorMask(i) & actors) != 0) { _readers[i].MessageHandlerImpl(messageTypeId, chunk); } } }
public unsafe bool Write <TMessage>(ref Envelope envelope, ref TMessage message, IRingBuffer bufferToWrite) where TMessage : struct { if (typeof(TMessage) != typeof(Guid)) { throw new ArgumentException("Guids only!"); } var guid = (Guid)(object)message; var ch1 = new ByteChunk((byte *)&guid, 16); return(bufferToWrite.Write(MessageId, ch1)); }
public void FileWriterUowShouldWorkAsExpected() { // Arrange const string fileName = "fileName"; var input1DataBytes = new byte[1]; var input1Data = new ByteChunk { Id = 0, Data = input1DataBytes }; var input1 = MockRepository.GenerateMock <IProducerConsumer <IByteChunk> >(); input1.Expect(t => t.Peek()).Repeat.Once().Return(input1Data); input1.Expect(t => t.Pop()).Repeat.Once().Return(input1Data); var input2DataBytes = new byte[1]; var input2Data = new ByteChunk { Id = 1, Data = input2DataBytes }; var input2 = MockRepository.GenerateMock <IProducerConsumer <IByteChunk> >(); input2.Expect(t => t.Peek()).Repeat.Once().Return(input2Data); input2.Expect(t => t.Pop()).Repeat.Once().Return(input2Data); var finishPc = MockRepository.GenerateMock <IProducerConsumer <IByteChunk> >(); var finishPcData = new ByteChunk { Id = 2, Data = null }; finishPc.Expect(t => t.Peek()).Repeat.Once().Return(finishPcData); var io = MockRepository.GenerateMock <IIo>(); var outputMs = new MemoryStream(); io.Expect(t => t.FileOpenWrite(fileName)).Repeat.Once().Return(outputMs); var uow = new FileWriterUow(io, new List <IProducerConsumer <IByteChunk> > { input1, input2 }, finishPc); // Act uow.WriteFileAction(fileName)(); // Assert input1.VerifyAllExpectations(); input2.VerifyAllExpectations(); io.VerifyAllExpectations(); finishPc.VerifyAllExpectations(); }
public AnimationFragment(string fileName, ByteChunk data = null) { FileName = fileName; if (data != null) { Skeletons = new StringArrayTable(data); MinSlotId = data.ReadInt32(); MaxSlotId = data.ReadInt32(); var numFragItems = data.ReadInt32(); for (int i = 0; i < numFragItems; i++) { Fragments.Add(new AnimationFragmentEntry(data)); } } }
public MatchedAnimationTableEntry(ByteChunk data) { AttackTable = new UnknownIntArrayTable(data); AttackUnknown0 = data.ReadInt32(); AttackUnknown1 = data.ReadInt32(); AttackUnknown2 = data.ReadInt32(); AttackAnimation = data.ReadString(); MountAnimation = data.ReadString(); DefenceTable = new UnknownIntArrayTable(data); DefenceUnknown0 = data.ReadInt32(); DefenceUnknown1 = data.ReadInt32(); DefenceUnknown2 = data.ReadInt32(); DefenceAnimation = data.ReadString(); Unknown_alwaysEmpty = data.ReadString(); }
public void Enqueue(byte b) { if (WriteChunk == null) { AddChunk(); } if (WritePointer >= ChunkSize) { AddChunk(); WritePointer = 0; WriteChunk = WriteChunk.Next; } m_Length++; WriteChunk.Bytes[WritePointer++] = b; }
public void AHandlerTests() { var counter = Substitute.For <IStructSizeCounter>(); counter.GetSize(typeof(Envelope)).Returns(4); var aHandler = new AHandler(); var reader = new MessageReader(aHandler, counter, GetABId); var bytes = stackalloc byte[10]; var chunk = new ByteChunk(bytes, 10); Assert.AreEqual(0, aHandler.Counter); reader.MessageHandlerImpl(ATypeId, chunk); Assert.AreEqual(1, aHandler.Counter); reader.MessageHandlerImpl(BTypeId, chunk); Assert.AreEqual(1, aHandler.Counter); }
public Action CompressAction(JobType jobType) { return(new Action(() => { var inputTask = _input.Pop(); while (inputTask != null) { var outputTask = new ByteChunk { Id = inputTask.Id, Data = _gzipStream.Compress(inputTask.Data, jobType) }; _output.Push(outputTask); inputTask = _input.Pop(); } })); }
public AnimationFragmentEntry(ByteChunk data) { _id = data.ReadInt32(); _slot = data.ReadInt32(); Slot = AnimationSlotTypeHelper.GetFromId(_slot); AnimationFile = data.ReadString(); MetaDataFile = data.ReadString(); SoundMetaDataFile = data.ReadString(); Skeleton = data.ReadString(); Blend = data.ReadSingle(); Weight = data.ReadSingle(); Unknown0 = data.ReadInt32(); Unknown1 = data.ReadInt32(); Unknown3 = data.ReadString(); Unknown4 = data.ReadBool(); }
public byte Dequeue() { if (ReadPointer >= ChunkSize) { ReadChunk = ReadChunk.Next; ReadPointer = 0; if (ReadChunk == null) { WriteChunk = null; WritePointer = 0; } } if (m_Length == 0) { throw new Exception("ByteQueue is empty"); } m_Length--; return(ReadChunk.Bytes[ReadPointer++]); }
public int IndexOf(byte searchByte) { ByteChunk currentChunk = ReadChunk; int currentPointer = ReadPointer, pos = 0; for (int i = m_Length; i > 0; i--, pos++) { if (currentPointer >= ChunkSize) { currentChunk = currentChunk.Next; currentPointer = 0; } if (currentChunk.Bytes[currentPointer++] == searchByte) { return(pos); } } return(-1); }
private bool TryWriteToSegment(int messagetypeid, ByteChunk chunk, Segment *segment, int neededBytes) { var firstAvailablePosition = (long *)segment->Buffer; if (*firstAvailablePosition + neededBytes <= _segmentLength) { var buffer = segment->Buffer + *firstAvailablePosition; var header = (Header *)buffer; header->MessageTypeId = messagetypeid; header->ChunkLength = chunk.Length; Native.MemcpyUnmanaged(buffer + sizeof(Header), chunk.Pointer, chunk.Length); *firstAvailablePosition += neededBytes; return(true); } return(false); }
protected override void Transform() { while (true && !_cancelled) { var chunk = _transformationQueue.Dequeue(); if (chunk == null) { break; } using (MemoryStream stream = new MemoryStream()) { using (GZipStream gzip = new GZipStream(stream, CompressionMode.Compress)) { gzip.Write(chunk.Bytes, 0, chunk.Bytes.Length); } byte[] buffer = stream.ToArray(); if (chunk.Bytes.Length + 8 < buffer.Length) { byte[] newBuffer = new byte[chunk.Bytes.Length + 8]; BitConverter.GetBytes(newBuffer.Length).CopyTo(newBuffer, 4); chunk.Bytes.CopyTo(newBuffer, _chunkHeaderSize); _writeQueue.Enqueue(new ByteChunk(newBuffer, chunk.ChunkOrder)); } else { BitConverter.GetBytes(buffer.Length).CopyTo(buffer, _chunkSizeBytesCount); var result = new ByteChunk(buffer, chunk.ChunkOrder); _writeQueue.Enqueue(result); } } } }
public void ShouldRejectWriteWhenInsufficientSpace() { const int length = 200; const long head = 0; var tail = head + (Capacity - (length - RingBufferDescriptor.RecordAlignment).AlignToMultipleOf( RingBufferDescriptor.RecordAlignment)); _atomicLong.VolatileRead(Head).Returns(head); _atomicLong.VolatileRead(Tail).Returns(tail); var chunk = new ByteChunk(null, length); Assert.False(_ringBuffer.Write(MessageTypeId, chunk)); _atomicInt.ReceivedWithAnyArgs(0); _atomicLong.DidNotReceiveWithAnyArgs().CompareExchange(IntPtr.Zero, 0, 0); _atomicLong.DidNotReceiveWithAnyArgs().VolatileWrite(IntPtr.Zero, 0); _buffer.DidNotReceiveWithAnyArgs().Write(0, new ByteChunk(null, 0)); }
bool IRingBuffer.Write(int messagetypeid, ByteChunk chunk) { var neededBytes = GetNeededBytes(chunk.Length); var tail = _currentHead->Tail; // ReSharper disable once ConvertIfStatementToNullCoalescingExpression if (tail == null) { tail = _currentHead; } if (TryWriteToSegment(messagetypeid, chunk, tail, neededBytes)) { return(true); } // no write, pop new segment tail->Next = PopNew(); return(TryWriteToSegment(messagetypeid, chunk, tail->Next, neededBytes)); }