void HandlerData(byte[] data) { DataModel model = DataCodec.Decode(data); switch (model.Type) { case ChatProtocolType.TYPE_NONE: break; case ChatProtocolType.TYPE_MYSQL: mySqlHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_IM: imHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_MESSAGE: messageHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_CHATDATA: videoDataHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_OTHER: HandlerOther(model.Request, model.Message); break; } }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); iterator.Take(); // empty initial frame request.Name = StringCodec.Decode(iterator); request.Key = DataCodec.Decode(iterator); return(request); }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); var initialFrame = iterator.Take(); request.OverflowPolicy = initialFrame.Bytes.ReadIntL(RequestOverflowPolicyFieldOffset); request.Name = StringCodec.Decode(iterator); request.Value = DataCodec.Decode(iterator); return(request); }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); var initialFrame = iterator.Take(); request.ThreadId = initialFrame.Bytes.ReadLongL(RequestThreadIdFieldOffset); request.Name = StringCodec.Decode(iterator); request.Key = DataCodec.Decode(iterator); return(request); }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); var initialFrame = iterator.Take(); request.LocalOnly = initialFrame.Bytes.ReadBoolL(RequestLocalOnlyFieldOffset); request.Name = StringCodec.Decode(iterator); request.Predicate = DataCodec.Decode(iterator); return(request); }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); var initialFrame = iterator.Take(); request.IncludeValue = initialFrame.Bytes.ReadBoolL(RequestIncludeValueFieldOffset); request.ListenerFlags = initialFrame.Bytes.ReadIntL(RequestListenerFlagsFieldOffset); request.LocalOnly = initialFrame.Bytes.ReadBoolL(RequestLocalOnlyFieldOffset); request.Name = StringCodec.Decode(iterator); request.Key = DataCodec.Decode(iterator); return(request); }
public static RequestParameters DecodeRequest(ClientMessage clientMessage) { using var iterator = clientMessage.GetEnumerator(); var request = new RequestParameters(); var initialFrame = iterator.Take(); request.Batch = initialFrame.Bytes.ReadIntL(RequestBatchFieldOffset); request.Name = StringCodec.Decode(iterator); request.IterationPointers = EntryListIntegerIntegerCodec.Decode(iterator); request.Projection = DataCodec.Decode(iterator); request.Predicate = DataCodec.Decode(iterator); return(request); }
// Decodes a texture private byte[] DecodeTexture() { if (m_paletteOffset != -1) // The texture contains an embedded palette { DataCodec.SetPalette(m_encodedData, m_paletteOffset, m_paletteEntries); } if (HasMipmaps) { return(DataCodec.Decode(m_encodedData, m_dataOffset + m_mipmapOffsets[0], TextureWidth, TextureHeight, PixelCodec)); } return(DataCodec.Decode(m_encodedData, m_dataOffset, TextureWidth, TextureHeight, PixelCodec)); }
public static ValueTask HandleEventAsync(ClientMessage clientMessage, HandleTopicEventAsync handleTopicEventAsync, ILoggerFactory loggerFactory) { using var iterator = clientMessage.GetEnumerator(); var messageType = clientMessage.MessageType; if (messageType == EventTopicMessageType) { var initialFrame = iterator.Take(); var publishTime = initialFrame.Bytes.ReadLongL(EventTopicPublishTimeFieldOffset); var uuid = initialFrame.Bytes.ReadGuidL(EventTopicUuidFieldOffset); var item = DataCodec.Decode(iterator); return(handleTopicEventAsync(item, publishTime, uuid)); } loggerFactory.CreateLogger(typeof(EventHandler)).LogDebug("Unknown message type received on event handler :" + messageType); return(default);
// Decodes mipmaps private byte[][] DecodeMipmaps() { if (m_paletteOffset != -1) // The texture contains an embedded palette { DataCodec.SetPalette(m_encodedData, m_paletteOffset, m_paletteEntries); } byte[][] mipmaps = new byte[m_mipmapOffsets.Length][]; for (int i = 0, size = TextureWidth; i < mipmaps.Length; i++, size >>= 1) { mipmaps[i] = DataCodec.Decode(m_encodedData, m_dataOffset + m_mipmapOffsets[i], size, size, PixelCodec); } return(mipmaps); }
public static void HandleEvent(ClientMessage clientMessage, HandleTopicEvent handleTopicEvent) { var messageType = clientMessage.MessageType; var iterator = clientMessage.GetIterator(); if (messageType == EventTopicMessageType) { var initialFrame = iterator.Next(); long publishTime = DecodeLong(initialFrame.Content, EventTopicPublishTimeFieldOffset); Guid uuid = DecodeGuid(initialFrame.Content, EventTopicUuidFieldOffset); IData item = DataCodec.Decode(iterator); handleTopicEvent(item, publishTime, uuid); return; } Logger.GetLogger(typeof(EventHandler)).Finest("Unknown message type received on event handler :" + messageType); }
void HandlerData(byte[] data) { DataModel model = DataCodec.Decode(data); switch (model.Type) { case ChatProtocolType.TYPE_NONE: print("NONE:" + Encoding.UTF8.GetString(model.Message)); break; case ChatProtocolType.TYPE_MYSQL: mySqlHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_IM: imHandler.MessageReceive(model); break; case ChatProtocolType.TYPE_MESSAGE: messageHandler.MessageReceive(model); break; } }
public static Hazelcast.Data.HDictionaryEntry <IData, IData> Decode(IEnumerator <Frame> iterator) { // begin frame iterator.Take(); var initialFrame = iterator.Take(); var cost = initialFrame.Bytes.ReadLongL(CostFieldOffset); var creationTime = initialFrame.Bytes.ReadLongL(CreationTimeFieldOffset); var expirationTime = initialFrame.Bytes.ReadLongL(ExpirationTimeFieldOffset); var hits = initialFrame.Bytes.ReadLongL(HitsFieldOffset); var lastAccessTime = initialFrame.Bytes.ReadLongL(LastAccessTimeFieldOffset); var lastStoredTime = initialFrame.Bytes.ReadLongL(LastStoredTimeFieldOffset); var lastUpdateTime = initialFrame.Bytes.ReadLongL(LastUpdateTimeFieldOffset); var version = initialFrame.Bytes.ReadLongL(VersionFieldOffset); var ttl = initialFrame.Bytes.ReadLongL(TtlFieldOffset); var maxIdle = initialFrame.Bytes.ReadLongL(MaxIdleFieldOffset); var key = DataCodec.Decode(iterator); var @value = DataCodec.Decode(iterator); iterator.SkipToStructEnd(); return(CustomTypeFactory.CreateSimpleEntryView(key, @value, cost, creationTime, expirationTime, hits, lastAccessTime, lastStoredTime, lastUpdateTime, version, ttl, maxIdle)); }
public static Hazelcast.Map.SimpleEntryView <IData, IData> Decode(FrameIterator iterator) { // begin frame iterator.Next(); var initialFrame = iterator.Next(); var cost = DecodeLong(initialFrame.Content, CostFieldOffset); var creationTime = DecodeLong(initialFrame.Content, CreationTimeFieldOffset); var expirationTime = DecodeLong(initialFrame.Content, ExpirationTimeFieldOffset); var hits = DecodeLong(initialFrame.Content, HitsFieldOffset); var lastAccessTime = DecodeLong(initialFrame.Content, LastAccessTimeFieldOffset); var lastStoredTime = DecodeLong(initialFrame.Content, LastStoredTimeFieldOffset); var lastUpdateTime = DecodeLong(initialFrame.Content, LastUpdateTimeFieldOffset); var version = DecodeLong(initialFrame.Content, VersionFieldOffset); var ttl = DecodeLong(initialFrame.Content, TtlFieldOffset); var maxIdle = DecodeLong(initialFrame.Content, MaxIdleFieldOffset); var key = DataCodec.Decode(iterator); var @value = DataCodec.Decode(iterator); CodecUtil.FastForwardToEndFrame(iterator); return(CustomTypeFactory.CreateSimpleEntryView(key, @value, cost, creationTime, expirationTime, hits, lastAccessTime, lastStoredTime, lastUpdateTime, version, ttl, maxIdle)); }
/// <summary> /// Internal read implementation of the sub classes. /// </summary> /// <param name="reader"></param> /// <exception cref="Exception">Expected DDS RGB24 or RGBA32 color format!</exception> /// <exception cref="NotImplementedException">TODO</exception> protected override void _Read(BinaryReader reader) { long baseOffset = reader.BaseStream.Position; int gbixOffset = 0; int pvrtOffset = 0; uint identifier = reader.ReadUInt32(); if (identifier == m_gbix) //"GBIX" { HasGlobalIndex = true; GlobalIndexSize = reader.ReadUInt32(); GlobalIndex = reader.ReadBytes((int)GlobalIndexSize); reader.BaseStream.Seek(4, SeekOrigin.Current); //Skip "PVRT" gbixOffset = 0x00; pvrtOffset = 0x08 + (int)GlobalIndexSize; } else { identifier = reader.ReadUInt32(); if (identifier == m_gbix) { HasGlobalIndex = true; GlobalIndexSize = reader.ReadUInt32(); GlobalIndex = reader.ReadBytes((int)GlobalIndexSize); gbixOffset = 0x04; pvrtOffset = 0x0C + (int)GlobalIndexSize; } else if (identifier == m_pvrt) { gbixOffset = -1; pvrtOffset = 0x04; } else { gbixOffset = -1; pvrtOffset = 0x00; reader.BaseStream.Seek(-4, SeekOrigin.Current); } } // Read information about the texture ContentSize = reader.ReadUInt32(); PixelFormat = (PvrPixelFormat)reader.ReadByte(); DataFormat = (PvrDataFormat)reader.ReadByte(); reader.BaseStream.Seek(2, SeekOrigin.Current); Width = reader.ReadUInt16(); Height = reader.ReadUInt16(); if (DataFormat == PvrDataFormat.DDS || DataFormat == PvrDataFormat.DDS_2) { if (!(PixelFormat == PvrPixelFormat.DDS_DXT1_RGB24 || PixelFormat == PvrPixelFormat.DDS_DXT3_RGBA32)) { throw new Exception("Expected DDS RGB24 or RGBA32 color format!"); } long ddsOffset = reader.BaseStream.Position; DDS_Header header = new DDS_Header(reader.BaseStream); DDSFormatDetails format = new DDSFormatDetails(header.Format, header.DX10_DXGI_AdditionalHeader.dxgiFormat); reader.BaseStream.Seek(ddsOffset, SeekOrigin.Begin); byte[] ddsBuffer = reader.ReadBytes(header.dwPitchOrLinearSize + header.dwSize + 128); MemoryStream memoryStream = new MemoryStream(ddsBuffer, 0, ddsBuffer.Length, true, true); MipMaps = DDSGeneral.LoadDDS(memoryStream, header, 0, format); memoryStream.Close(); Width = header.Width; Height = header.Height; } else { // Get the codecs and make sure we can decode using them PixelCodec = PvrPixelCodec.GetPixelCodec(PixelFormat); DataCodec = PvrDataCodec.GetDataCodec(DataFormat); if (DataCodec != null && PixelCodec != null) { DataCodec.PixelCodec = PixelCodec; } // Set the number of palette entries int paletteEntries = DataCodec.PaletteEntries; if (DataFormat == PvrDataFormat.VECTOR_QUANTIZATION_SMALL || DataFormat == PvrDataFormat.VECTOR_QUANTIZATION_SMALL_MIPMAP) { if (Width <= 16) { paletteEntries = 64; // Actually 16 } else if (Width <= 32) { paletteEntries = 256; // Actually 64 } else if (Width <= 64) { paletteEntries = 512; // Actually 128 } else { paletteEntries = 1024; // Actually 256 } } // Set the palette and data offsets int paletteOffset = 0; int dataOffset = 0; if (paletteEntries == 0 || DataCodec.NeedsExternalPalette) { paletteOffset = -1; dataOffset = pvrtOffset + 0x10; } else { paletteOffset = pvrtOffset + 0x10; dataOffset = paletteOffset + (paletteEntries * (PixelCodec.Bpp >> 3)); } // Get the compression format and determine if we need to decompress this texture reader.BaseStream.Seek(baseOffset, SeekOrigin.Begin); uint first = reader.ReadUInt32(); reader.BaseStream.Seek(baseOffset + pvrtOffset + 4, SeekOrigin.Begin); uint second = reader.ReadUInt32(); if (first == second - pvrtOffset + dataOffset + 8) { CompressionFormat = PvrCompressionFormat.RLE; } else { CompressionFormat = PvrCompressionFormat.NONE; } CompressionCodec = PvrCompressionCodec.GetCompressionCodec(CompressionFormat); if (CompressionFormat != PvrCompressionFormat.NONE && CompressionCodec != null) { //TODO: Convert to stream compatible code throw new NotImplementedException("TODO"); //m_encodedData = CompressionCodec.Decompress(m_encodedData, dataOffset, PixelCodec, DataCodec); // Now place the offsets in the appropiate area if (CompressionFormat == PvrCompressionFormat.RLE) { if (gbixOffset != -1) { gbixOffset -= 4; } pvrtOffset -= 4; if (paletteOffset != -1) { paletteOffset -= 4; } dataOffset -= 4; } } // If the texture contains mipmaps, gets the offsets of them int[] mipmapOffsets; if (DataCodec.HasMipmaps) { int mipmapOffset = 0; mipmapOffsets = new int[(int)Math.Log(Width, 2) + 1]; // Calculate the padding for the first mipmap offset if (DataFormat == PvrDataFormat.SQUARE_TWIDDLED_MIPMAP) { mipmapOffset = (DataCodec.Bpp) >> 3; // A 1x1 mipmap takes up as much space as a 2x1 mipmap } else if (DataFormat == PvrDataFormat.SQUARE_TWIDDLED_MIPMAP_ALT) { mipmapOffset = (3 * DataCodec.Bpp) >> 3; // A 1x1 mipmap takes up as much space as a 2x2 mipmap } for (int i = mipmapOffsets.Length - 1, size = 1; i >= 0; i--, size <<= 1) { mipmapOffsets[i] = mipmapOffset; mipmapOffset += Math.Max((size * size * DataCodec.Bpp) >> 3, 1); } } else { mipmapOffsets = new int[1] { 0 }; } //DecodeMipmaps() if (paletteOffset != -1) // The texture contains an embedded palette { reader.BaseStream.Seek(baseOffset + paletteOffset, SeekOrigin.Begin); DataCodec.SetPalette(reader, paletteEntries); } MipMaps = new List <MipMap>(); if (DataCodec.HasMipmaps) { for (int i = 0, size = Width; i < mipmapOffsets.Length; i++, size >>= 1) { reader.BaseStream.Seek(baseOffset + dataOffset + mipmapOffsets[i], SeekOrigin.Begin); byte[] pixels = DataCodec.Decode(reader, size, size, PixelCodec); MipMaps.Add(new MipMap(pixels, size, size)); } } else { reader.BaseStream.Seek(baseOffset + dataOffset + mipmapOffsets[0], SeekOrigin.Begin); byte[] pixels = DataCodec.Decode(reader, Width, Height, PixelCodec); MipMaps.Add(new MipMap(pixels, Width, Height)); } } if (HasGlobalIndex) { reader.BaseStream.Seek(baseOffset + ContentSize + 0xC, SeekOrigin.Begin); } else { reader.BaseStream.Seek(baseOffset + ContentSize, SeekOrigin.Begin); } }