/// <summary> /// * /// </summary> public override void read_scalefactor(Bitstream stream, Header header) { if (allocation != 0) scalefactor = ScaleFactors[stream.GetBitsFromBuffer(6)]; if (channel2_allocation != 0) channel2_scalefactor = ScaleFactors[stream.GetBitsFromBuffer(6)]; }
public float UnpackFloat(PropertyInfo info, Bitstream stream) { var flags = info.Flags; if (flags.HasFlag(PropertyInfo.MultiFlag.Coord)) { return UnpackFloatCoord(stream); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMp)) { return UnpackFloatCoordMp(stream, FloatType.None); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMpLowPrecision)) { return UnpackFloatCoordMp(stream, FloatType.LowPrecision); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CoordMpIntegral)) { return UnpackFloatCoordMp(stream, FloatType.Integral); } else if (flags.HasFlag(PropertyInfo.MultiFlag.NoScale)) { return UnpackFloatNoScale(stream); } else if (flags.HasFlag(PropertyInfo.MultiFlag.Normal)) { return UnpackFloatNormal(stream); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoord)) { return UnpackFloatCellCoord(info, stream, FloatType.None); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoordLowPrecision)) { return UnpackFloatCellCoord(info, stream, FloatType.LowPrecision); } else if (flags.HasFlag(PropertyInfo.MultiFlag.CellCoordIntegral)) { return UnpackFloatCellCoord(info, stream, FloatType.Integral); } else { uint dividend = stream.ReadBits(info.NumBits); uint divisor = (uint) (1 << info.NumBits) - 1; float f = ((float) dividend) / divisor; float range = info.HighValue - info.LowValue; return f * range + info.LowValue; } }
public void Update(Bitstream stream, uint baseline, bool updateBaseline, uint updated, bool isDelta) { uint id = UInt32.MaxValue; uint found = 0; while (found < updated) { var flags = ReadHeader(ref id, stream); if (flags.HasFlag(UpdateFlag.EnterPvs)) { ReadEnterPvs(id, baseline, updateBaseline, stream); } else if (flags.HasFlag(UpdateFlag.LeavePvs)) { if (flags.HasFlag(UpdateFlag.Delete)) { Delete(id); } } else { ReadUpdate(id, stream); } ++found; } if (isDelta) { while (stream.ReadBool()) { id = stream.ReadBits(11); Delete(id); } } }
private UpdateFlag ReadHeader(ref uint id, Bitstream stream) { uint value = stream.ReadBits(6); if ((value & 0x30) > 0) { uint a = (value >> 4) & 3; uint b = (uint) ((a == 3) ? 16 : 0); value = (stream.ReadBits((byte) (4 * a + b)) << 4) | (value & 0xF); } id = unchecked(id + value + 1); var flags = UpdateFlag.None; if (!stream.ReadBool()) { if (stream.ReadBool()) { flags |= UpdateFlag.EnterPvs; } } else { flags |= UpdateFlag.LeavePvs; if (stream.ReadBool()) { flags |= UpdateFlag.Delete; } } return flags; }
private float UnpackFloatCoord(Bitstream stream) { bool hasInteger = stream.ReadBool(); bool hasFraction = stream.ReadBool(); if (hasInteger || hasFraction) { bool sign = stream.ReadBool(); uint integer = 0; if (hasInteger) { integer = stream.ReadBits(COORD_INTEGER_BITS) + 1; } uint fraction = 0; if (hasFraction) { fraction = stream.ReadBits(COORD_FRACTIONAL_BITS); } float f = (float) (integer + fraction * COORD_RESOLUTION); if (sign) { f *= -1; } return f; } else { return 0; } }
private string ReadKeyIfIncluded(Bitstream stream, List<string> keyHistory) { bool has_key = stream.ReadBool(); if (!has_key) { return null; } bool is_substring = stream.ReadBool(); string key; if (!is_substring) { key = stream.ReadString(); } else { int fromIndex = (int) stream.ReadBits(5); int fromLength = (int) stream.ReadBits(5); key = keyHistory[fromIndex].Substring(0, fromLength); key += stream.ReadString(); } Preconditions.CheckArgument(key.Length <= MAX_KEY_SIZE); if (keyHistory.Count == KEY_HISTORY_SIZE) { keyHistory.RemoveAt(0); } keyHistory.Add(key); return key; }
/// <summary> /// * /// </summary> public override void ReadScaleFactor(Bitstream stream, Header header) { if (allocation != 0) { base.ReadScaleFactor(stream, header); switch (channel2_scfsi) { case 0: channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 1: channel2_scalefactor1 = channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 2: channel2_scalefactor1 = channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 3: channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; } } }
/// <summary> /// * /// </summary> public override void ReadScaleFactor(Bitstream stream, Header header) { base.ReadScaleFactor(stream, header); if (channel2_allocation != 0) { switch (channel2_scfsi) { case 0: channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 1: channel2_scalefactor1 = channel2_scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 2: channel2_scalefactor1 = channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 3: channel2_scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; channel2_scalefactor2 = channel2_scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; } prepare_sample_reading(header, channel2_allocation, 1, channel2_factor, channel2_codelength, channel2_c, channel2_d); } }
public override void Deserialize(Bitstream msg) { var count = msg.ReadUInt16(); count = (ushort)Math.Max((int)count, 0); count = (ushort)Math.Min((int)count, 100); State = new List<PlayerStateData>(count); if (count > 0) { ushort objType = msg.ReadByte(); PlayerId = msg.ReadVariableUInt32(); if (_ownerType == null) { _ownerType = ObjectMapper.LookupType(objType); _lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo()); } } NetworkObject pState = PlayerId > 0 ? ObjectMapper.GetCurrentPlayerState(PlayerId) : null; for (int i = 0; i < count; ++i) { NetworkObject data = Activator.CreateInstance(_ownerType) as NetworkObject; DataObjectPacket.ReadNetObject(_lookupItem, msg, data, pState); pState = data; State.Add(data as PlayerStateData); } if (State.Count > 0 && PlayerId > 0) ObjectMapper.SetCurrentPlayerState(PlayerId, State.Last()); }
/// <summary> /// * /// </summary> public override bool read_sampledata(Bitstream stream) { bool returnvalue = base.read_sampledata(stream); if (channel2_allocation != 0) { channel2_sample = stream.GetBitsFromBuffer(channel2_samplelength); } return (returnvalue); }
public override void Serialize(Bitstream msg) { msg.Write(Name); msg.WriteVariableUInt32(EntityId); msg.Write(Parameters.Count); foreach (var p in Parameters) { WriteParam(p, msg); } }
public virtual void Create(Bitstream stream0, Header header0, SynthesisFilter filtera, SynthesisFilter filterb, ABuffer buffer0, int whichCh0) { stream = stream0; header = header0; filter1 = filtera; filter2 = filterb; buffer = buffer0; which_channels = whichCh0; }
/// <summary> /// * /// </summary> public override void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc) { int length = get_allocationlength(header); allocation = stream.GetBitsFromBuffer(length); channel2_allocation = stream.GetBitsFromBuffer(length); if (crc != null) { crc.add_bits(allocation, length); crc.add_bits(channel2_allocation, length); } }
public static uint Compute32(Bitstream stream) { uint crc = 0xFFFFFFFF; while (!stream.Eof) { byte index = (byte)(((crc) & 0xFF) ^ stream.ReadByte(true)); crc = (uint)((crc >> 8) ^ table[index]); } return ~crc; }
public Nullable<Message> Receive(Bitstream stream) { bool hasData = stream.ReadBool(); if (!hasData) { return null; } if (stream.ReadBool()) { return ReadChunk(stream); } else { return ReadSingle(stream); } }
/// <summary> /// * /// </summary> public override void read_scalefactor_selection(Bitstream stream, Crc16 crc) { if (allocation != 0) { scfsi = stream.GetBitsFromBuffer(2); channel2_scfsi = stream.GetBitsFromBuffer(2); if (crc != null) { crc.add_bits(scfsi, 2); crc.add_bits(channel2_scfsi, 2); } } }
public override void Deserialize(Bitstream msg) { Name = msg.ReadString(); EntityId = msg.ReadVariableUInt32(); int count = msg.ReadInt32(); Parameters = new List<object>(count); for(int i=0; i < count; ++i) { var p = ReadParam(msg); Parameters.Add(p); } RPCManager._Call(Name, EntityId, Parameters); }
public override void Deserialize(Bitstream msg) { SnapId = msg.ReadUInt32(); BaselineId = msg.ReadUInt32(); ushort count = msg.ReadByte(); Dictionary<int, NetworkObject> state = new Dictionary<int, NetworkObject>(); int addDeltaCount = 0; for (int i=0; i < count; ++i) { ushort objTypeId = msg.ReadByte(); var entId = msg.ReadVariableUInt32(); NetworkObject obj = ObjectMapper.Lookup(entId, objTypeId, true); if (obj == null) { obj = ObjectMapper.Create(entId, objTypeId); } NetworkObject realObj = ObjectMapper.Lookup(entId, objTypeId, false); var realHash = 0; if (realObj != null) realHash = realObj.GetHashCode(); NetworkObject baseline = null; var usebaseLine = msg.ReadBool(); uint bOffset = 0; if (usebaseLine) { byte offset = msg.ReadByte(); var objBaselineId = BaselineId - (uint)offset; bOffset = objBaselineId; baseline = ObjectMapper.GetBaseline(objBaselineId, realHash); } var ownerType = obj.GetType().GetTypeInfo(); var dItem = DataLookupTable.Get(ownerType); ReadNetObject(dItem, msg, obj, baseline); ObjectMapper.AddDeltaState(realHash, SnapId, obj); if (BaselineId != 0 && realHash != 0) addDeltaCount++; } if (addDeltaCount == count) ObjectMapper.LastSimId = BaselineId; }
/// <summary> /// * /// </summary> public override void read_allocation(Bitstream stream, Header header, Crc16 crc) { if ((allocation = stream.GetBitsFromBuffer(4)) == 15) { } // cerr << "WARNING: stream contains an illegal allocation!\n"; // MPEG-stream is corrupted! if (crc != null) crc.add_bits(allocation, 4); if (allocation != 0) { samplelength = allocation + 1; factor = TableFactor[allocation]; offset = TableOffset[allocation]; } }
private Nullable<Message> ReadChunk(Bitstream stream) { uint offset = stream.ReadBits(18); uint count = stream.ReadBits(3); log.DebugFormat("chunk start = {0} end = {1}", offset, count); if (offset == 0) { Preconditions.CheckArgument(!Receiving); ReadChunkHeader(stream); } else { Preconditions.CheckArgument(Receiving); } uint byteOffset = offset * Connection.BYTES_PER_CHUNK; uint byteCount; if (offset + count < header.ChunkCount) { byteCount = count * Connection.BYTES_PER_CHUNK; } else { byteCount = header.ByteLength - byteOffset; } stream.Read(dataIn, (int)byteOffset, (int)byteCount); for (uint i = offset; i < offset + count; ++i) { if (!dataReceived[i]) { dataReceived[i] = true; ++countReceived; } } if (countReceived == header.ChunkCount) { log.Debug("chunk complete"); Receiving = false; return new Message { IsCompressed = header.IsCompressed, DecompressedLength = header.DecompressedLength, Data = dataIn, }; } else { log.DebugFormat("chunk has {0}/{1}", countReceived, header.ChunkCount); return null; } }
private static void WriteParam(object o, Bitstream msg) { var t = o.GetType(); var dsitem = new DataSerializationProperty(null, t); msg.Write(t.FullName); switch (dsitem.Type) { case DataTypes.BOOL: msg.Write((bool)o); break; case DataTypes.UBYTE: msg.Write((byte)o); break; case DataTypes.UINT: msg.WriteVariableUInt32((uint)o); break; case DataTypes.BYTE: msg.Write((sbyte)o); break; case DataTypes.INT: msg.WriteVariableInt32((int)o); break; case DataTypes.ULONG: msg.Write((ulong)o); break; case DataTypes.LONG: msg.Write((long)o); break; case DataTypes.FLOAT: msg.Write((float)o); break; case DataTypes.DOUBLE: msg.Write((double)o); break; case DataTypes.STRING: msg.Write((string)o); break; case DataTypes.VECTOR2: msg.Write((Vector2)o); break; default: throw new ArgumentException("Invalid RPC paramter type."); } }
public uint UnpackInt(PropertyInfo info, Bitstream stream) { var flags = info.Flags; if (flags.HasFlag(PropertyInfo.MultiFlag.EncodedAgainstTickcount)) { if (flags.HasFlag(PropertyInfo.MultiFlag.Unsigned)) { return stream.ReadVarUInt(); } else { uint value = stream.ReadVarUInt(); return unchecked((uint) ((-(value & 1)) ^ (value >> 1))); } } else { byte numBits = info.NumBits; uint isUnsigned = Convert.ToUInt32(flags.HasFlag(PropertyInfo.MultiFlag.Unsigned)); uint signer = (0x80000000 >> (32 - numBits)) & unchecked((uint) (isUnsigned - 1)); uint value = stream.ReadBits(numBits) ^ signer; return value - signer; } }
/// <summary> /// * /// </summary> public override void read_allocation(Bitstream stream, Header header, Crc16 crc) { allocation = stream.GetBitsFromBuffer(4); channel2_allocation = stream.GetBitsFromBuffer(4); if (crc != null) { crc.add_bits(allocation, 4); crc.add_bits(channel2_allocation, 4); } if (allocation != 0) { samplelength = allocation + 1; factor = TableFactor[allocation]; offset = TableOffset[allocation]; } if (channel2_allocation != 0) { channel2_samplelength = channel2_allocation + 1; channel2_factor = TableFactor[channel2_allocation]; channel2_offset = TableOffset[channel2_allocation]; } }
public override void Serialize(Bitstream msg) { var count = State.Count; msg.Write((ushort)State.Count); if (count > 0 && _ownerType == null) { _ownerType = State[0].GetType(); _lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo()); } if (count > 0) { ushort objTypeId = ObjectMapper.LookupType(_ownerType); msg.Write((byte)objTypeId); msg.WriteVariableUInt32(PlayerId); } PlayerStateData pState = PreviousState; foreach (var o in State) { DataObjectPacket.WriteNetObject(_lookupItem, msg, o, pState); pState = o; } }
private void ReadChunkHeader(Bitstream stream) { header = new ChunkedHeader(); header.IsFile = stream.ReadBool(); if (header.IsFile) { uint filenameLength = stream.ReadUInt32(); byte[] filename = new byte[filenameLength + 1]; // semantically wrong. should be // 0x104 stream.Read(filename, 0, (int)filenameLength); // and then read to end of string filename[filenameLength] = 0; // whatever header.Filename = Encoding.UTF8.GetString(filename); log.ErrorFormat("read filename: \"{0}\" ({1})", filenameLength, header.Filename); throw new NotImplementedException(); } header.IsCompressed = stream.ReadBool(); if (header.IsCompressed) { header.DecompressedLength = stream.ReadBits(26); log.DebugFormat( "chunkheader compressed: decompressed len {0}", header.DecompressedLength); } header.ByteLength = stream.ReadBits(26); header.ChunkCount = (header.ByteLength + Connection.BYTES_PER_CHUNK - 1) / Connection.BYTES_PER_CHUNK; log.DebugFormat( "chunkheader len {0} expecting {1} chunks", header.ByteLength, header.ChunkCount); Receiving = true; dataIn = new byte[header.ByteLength]; dataReceived = new bool[header.ChunkCount]; countReceived = 0; }
public abstract void ReadScaleFactor(Bitstream stream, Header header);
public abstract void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc);
/// <summary> /// * /// </summary> public override bool read_sampledata(Bitstream stream) { return(base.read_sampledata(stream)); }
/// <summary> /// * /// </summary> public override void read_allocation(Bitstream stream, Header header, Crc16 crc) { base.read_allocation(stream, header, crc); }
private void ProcessPacket(byte[] bytes, int length) { using (var stream = Bitstream.CreateWith(bytes, length)) { var seq = stream.ReadUInt32(); var ack = stream.ReadUInt32(); var flags = stream.ReadByte(); var checksum = stream.ReadUInt16(); var at = stream.Position; var computed = CrcUtils.Compute16(stream); stream.Position = at; if (checksum != computed) { return; } var reliableState = stream.ReadByte(); if (seq < sequenceIn) { // We no longer care. return; } for (byte i = 0; i < subchannels.Length; ++i) { var channel = subchannels[i]; var mask = 1 << i; if ((reliableStateOut & mask) == (reliableState & mask)) { if (channel.Blocked) { channel.Clear(); } } else { if (channel.Blocked && channel.SentIn < ack) { reliableStateOut = Flip(reliableStateOut, i); channel.Requeue(); } } } if ((flags & (uint)PacketFlags.IsReliable) != 0) { var bit = stream.ReadBits(3); reliableStateIn = Flip(reliableStateIn, bit); for (var i = 0; i < streams.Length; ++i) { var message = streams[i].Receive(stream); if (message.HasValue) { ProcessMessage(message.Value); } } } while (stream.HasByte()) { HandleMessage(stream); } if (!stream.Eof) { var remain = (byte)stream.Remain; var expect = (1 << remain) - 1; var expectedTru = stream.ReadBits(remain) == expect; // if false then probably something wrong } lastAckRecv = ack; sequenceIn = seq; } }
private float UnpackFloatNoScale(Bitstream stream) { var data = stream.ReadManyBits(32); return(BitConverter.ToSingle(data, 0)); }
/// <summary> /// * /// </summary> public override bool read_sampledata(Bitstream stream) { return base.read_sampledata(stream); }
/// <summary> /// * /// </summary> public override void ReadBitAllocation(Bitstream stream, Header header, Crc16 crc) { base.ReadBitAllocation(stream, header, crc); }
private void ReadUpdate(uint id, Bitstream stream) { var entity = state.Slots[id].Entity; ReadAndUnpackFields(entity, stream); }
public void UnpackArray(uint tick, List <Property> elements, PropertyInfo info, Bitstream stream) { var countBits = MiscMath.Log2(info.NumElements + 1); var count = stream.ReadBits(countBits); if (elements.Count > count) { elements.RemoveRange(0, elements.Count - (int)count); } else { while (elements.Count < count) { elements.Add(Property.For(info.ArrayProp)); } } foreach (var element in elements) { element.Update(tick, this, stream); } }
/// <summary> /// Connect to the game server. Will use existing lobby on default. /// </summary> /// <param name="lobb"></param> public void Connect(CSODOTALobby lobb = null) { if (_connectDetails != null) { Disconnect(); } lobb = lobb ?? DotaGc.Lobby; if (lobb == null) { Log("No lobby so not connecting."); return; } _connectLobby = lobb; if (_appOwnershipTicket == null) { Log("Waiting for ownership ticket..."); _waitingForAuthTicket = true; FetchAppTicket(); return; } _authTicket = AuthTicket.CreateAuthTicket(_gameConnectTokens.Dequeue(), publicIP); var ver = new CMsgAuthTicket { gameid = (uint)DotaGc.GameID, h_steam_pipe = 327684, ticket = _authTicket }; using (var stream = Bitstream.CreateWith(_authTicket)) ver.ticket_crc = CrcUtils.Compute32(stream); _connectDetails = new DOTAConnectDetails { AuthTicket = _authTicket, ServerAuthTicket = AuthTicket.CreateServerTicket(DotaGc.SteamClient.SteamID, _authTicket, _appOwnershipTicket), ConnectInfo = lobb.connect, ConnectID = _connectAttempt++, AuthTicketCRC = ver.ticket_crc, Name = DotaGc.SteamClient.GetHandler <SteamFriends>().GetPersonaName(), PassKey = lobb.pass_key, SteamId = DotaGc.SteamClient.SteamID.ConvertToUInt64() }; var msg = new ClientMsgProtobuf <CMsgClientAuthList>(EMsg.ClientAuthList) { Body = { tokens_left = (uint)_gameConnectTokens.Count, app_ids = { (uint)DotaGc.GameID }, tickets = { ver }, message_sequence = 2 // Second in sequence. } }; DotaGc.SteamClient.Send(msg); Log("Sent crc ticket auth list, hash: " + ver.ticket_crc + "."); }
/// <summary> /// * /// </summary> public override bool ReadSampleData(Bitstream stream) { return(base.ReadSampleData(stream)); }
public abstract bool ReadSampleData(Bitstream stream);
/// <summary> /// * /// </summary> public override void ReadScaleFactor(Bitstream stream, Header header) { if (allocation != 0) { switch (scfsi) { case 0: scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 1: scalefactor1 = scalefactor2 = ScaleFactors[stream.GetBitsFromBuffer(6)]; scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 2: scalefactor1 = scalefactor2 = scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; case 3: scalefactor1 = ScaleFactors[stream.GetBitsFromBuffer(6)]; scalefactor2 = scalefactor3 = ScaleFactors[stream.GetBitsFromBuffer(6)]; break; } prepare_sample_reading(header, allocation, 0, factor, codelength, c, d); } }
// Read the next word from the bitstream "wvbits" and return the value. This // function can be used for hybrid or lossless streams, but since an // optimized version is available for lossless this function would normally // be used for hybrid only. If a hybrid lossless stream is being read then // the "correction" offset is written at the specified pointer. A return value // of WORD_EOF indicates that the end of the bitstream was reached (all 1s) or // some other error occurred. internal static int get_words(long nsamples, long flags, words_data w, Bitstream bs, int[] buffer, int bufferStartPos) { entropy_data[] c = w.c; int csamples; int buffer_counter = bufferStartPos; int entidx = 1; if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) == 0) // if not mono { nsamples *= 2; } else { // it is mono entidx = 0; } for (csamples = 0; csamples < nsamples; ++csamples) { long ones_count, low, high, mid; if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) == 0) // if not mono { if (entidx == 1) { entidx = 0; } else { entidx = 1; } } if ((w.c[0].median[0] & ~1) == 0 && w.holding_zero == 0 && w.holding_one == 0 && (w.c[1].median[0] & ~1) == 0) { long mask; int cbits; if (w.zeros_acc > 0) { --w.zeros_acc; if (w.zeros_acc > 0) { c[entidx].slow_level -= ((c[entidx].slow_level + SLO) >> SLS); buffer[buffer_counter] = 0; buffer_counter++; continue; } } else { cbits = 0; bs = BitsUtils.getbit(bs); while (cbits < 33 && bs.bitval > 0) { cbits++; bs = BitsUtils.getbit(bs); } if (cbits == 33) { break; } if (cbits < 2) { w.zeros_acc = cbits; } else { --cbits; for (mask = 1, w.zeros_acc = 0; cbits > 0; mask <<= 1) { bs = BitsUtils.getbit(bs); if (bs.bitval > 0) { w.zeros_acc |= mask; } cbits--; } w.zeros_acc |= mask; } if (w.zeros_acc > 0) { c[entidx].slow_level -= ((c[entidx].slow_level + SLO) >> SLS); w.c[0].median[0] = 0; w.c[0].median[1] = 0; w.c[0].median[2] = 0; w.c[1].median[0] = 0; w.c[1].median[1] = 0; w.c[1].median[2] = 0; buffer[buffer_counter] = 0; buffer_counter++; continue; } } } if (w.holding_zero > 0) { ones_count = w.holding_zero = 0; } else { int next8; int uns_buf; if (bs.bc < 8) { bs.ptr++; bs.buf_index++; if (bs.ptr == bs.end) { bs = BitsUtils.bs_read(bs); } uns_buf = (int)(bs.buf[bs.buf_index] & 0xff); bs.sr = bs.sr | (uns_buf << bs.bc); // values in buffer must be unsigned next8 = (int)(bs.sr & 0xff); bs.bc += 8; } else { next8 = (int)(bs.sr & 0xff); } if (next8 == 0xff) { bs.bc -= 8; bs.sr >>= 8; ones_count = 8; bs = BitsUtils.getbit(bs); while (ones_count < (LIMIT_ONES + 1) && bs.bitval > 0) { ones_count++; bs = BitsUtils.getbit(bs); } if (ones_count == (LIMIT_ONES + 1)) { break; } if (ones_count == LIMIT_ONES) { int mask; int cbits; cbits = 0; bs = BitsUtils.getbit(bs); while (cbits < 33 && bs.bitval > 0) { cbits++; bs = BitsUtils.getbit(bs); } if (cbits == 33) { break; } if (cbits < 2) { ones_count = cbits; } else { for (mask = 1, ones_count = 0; --cbits > 0; mask <<= 1) { bs = BitsUtils.getbit(bs); if (bs.bitval > 0) { ones_count |= mask; } } ones_count |= mask; } ones_count += LIMIT_ONES; } } else { bs.bc = (int)(bs.bc - ((ones_count = ones_count_table[next8]) + 1)); bs.sr = bs.sr >> (int)(ones_count + 1); // needs to be unsigned } if (w.holding_one > 0) { w.holding_one = ones_count & 1; ones_count = (ones_count >> 1) + 1; } else { w.holding_one = ones_count & 1; ones_count >>= 1; } w.holding_zero = (int)(~w.holding_one & 1); } if ((flags & Defines.HYBRID_FLAG) > 0 && ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) > 0 || (csamples & 1) == 0)) { w = update_error_limit(w, flags); } if (ones_count == 0) { low = 0; high = (((c[entidx].median[0]) >> 4) + 1) - 1; // for c# I replace the division by DIV0 with >> 7 c[entidx].median[0] -= (((c[entidx].median[0] + (DIV0 - 2)) >> 7) * 2); } else { low = (((c[entidx].median[0]) >> 4) + 1); // for c# I replace the division by DIV0 with >> 7 c[entidx].median[0] += ((c[entidx].median[0] + DIV0) >> 7) * 5; if (ones_count == 1) { high = low + (((c[entidx].median[1]) >> 4) + 1) - 1; // for c# I replace the division by DIV1 with >> 6 c[entidx].median[1] -= ((c[entidx].median[1] + (DIV1 - 2)) >> 6) * 2; } else { low += (((c[entidx].median[1]) >> 4) + 1); // for c# I replace the division by DIV1 with >> 6 c[entidx].median[1] += ((c[entidx].median[1] + DIV1) >> 6) * 5; if (ones_count == 2) { high = low + (((c[entidx].median[2]) >> 4) + 1) - 1; // for c# I replace the division by DIV2 with >> 5 c[entidx].median[2] -= ((c[entidx].median[2] + (DIV2 - 2)) >> 5) * 2; } else { low += (ones_count - 2) * (((c[entidx].median[2]) >> 4) + 1); high = low + (((c[entidx].median[2]) >> 4) + 1) - 1; // for c# I replace the division by DIV2 with >> 5 c[entidx].median[2] += ((c[entidx].median[2] + DIV2) >> 5) * 5; } } } mid = (high + low + 1) >> 1; if (c[entidx].error_limit == 0) { mid = read_code(bs, high - low); mid = mid + low; } else { while (high - low > c[entidx].error_limit) { bs = BitsUtils.getbit(bs); if (bs.bitval > 0) { mid = (high + (low = mid) + 1) >> 1; } else { mid = ((high = mid - 1) + low + 1) >> 1; } } } bs = BitsUtils.getbit(bs); if (bs.bitval > 0) { buffer[buffer_counter] = (int)~mid; } else { buffer[buffer_counter] = (int)mid; } buffer_counter++; if ((flags & Defines.HYBRID_BITRATE) > 0) { c[entidx].slow_level = c[entidx].slow_level - ((c[entidx].slow_level + SLO) >> SLS) + mylog2(mid); } } w.c = c; if ((flags & (Defines.MONO_FLAG | Defines.FALSE_STEREO)) != 0) { return(csamples); } else { return(csamples / 2); } }
private void ReceivePacket(byte[] bytes, int length) { ++receivedTotal; using (var stream = Bitstream.CreateWith(bytes, length)) { var type = stream.ReadUInt32(); if (type == COMPRESSED_PACKET) { var method = stream.ReadUInt32(); var compressed = new byte[length - 8]; stream.Read(compressed, 0, compressed.Length); var decompressed = Lzss.Decompress(compressed); ProcessPacket(decompressed, decompressed.Length); } else if (type == SPLIT_PACKET) { var request = stream.ReadUInt32(); var total = stream.ReadByte(); var index = stream.ReadByte(); var size = stream.ReadUInt16(); SplitPacket split; if (!splitPackets.ContainsKey(request)) { split = new SplitPacket { Request = request, Total = total, Received = 0, Data = new byte[total][], Present = new bool[total] }; splitPackets[request] = split; } else { split = splitPackets[request]; } var buffer = new byte[Math.Min(size, (stream.Remain + 7) / 8)]; stream.Read(buffer, 0, buffer.Length); split.Data[index] = buffer; if (!split.Present[index]) { ++split.Received; split.Present[index] = true; } if (split.Received == split.Total) { var full = split.Data.SelectMany(b => b).ToArray(); ReceivePacket(full, full.Length); splitPackets.Remove(request); } } else if (type == OOB_PACKET) { var data = new byte[stream.Length - 4]; stream.Read(data, 0, data.Length); receivedOutOfBand.Enqueue(data); } else { ProcessPacket(bytes, length); } } }
private float UnpackFloatCoordMp(Bitstream stream, FloatType type) { throw new NotImplementedException(); }
public abstract bool read_sampledata(Bitstream stream);
private void WriteUserCmd(UserCmd cmd, UserCmd last, Bitstream stream) { if (cmd.Command != last.Command + 1) { stream.WriteBool(true); stream.WriteUInt32(cmd.Command); } else { stream.WriteBool(false); } if (cmd.Tick != last.Tick + 1) { stream.WriteBool(true); stream.WriteUInt32(cmd.Tick); } else { stream.WriteBool(false); } if (cmd.ViewAngles.X != last.ViewAngles.X) { stream.WriteBool(true); stream.WriteFloat(cmd.ViewAngles.X); } else { stream.WriteBool(false); } if (cmd.ViewAngles.X != last.ViewAngles.X) { stream.WriteBool(true); stream.WriteFloat(cmd.ViewAngles.X); } else { stream.WriteBool(false); } if (cmd.ViewAngles.Z != last.ViewAngles.Z) { stream.WriteBool(true); stream.WriteFloat(cmd.ViewAngles.Z); } else { stream.WriteBool(false); } if (cmd.ForwardMove != last.ForwardMove) { stream.WriteBool(true); stream.WriteFloat(cmd.ForwardMove); } else { stream.WriteBool(false); } if (cmd.SideMove != last.SideMove) { stream.WriteBool(true); stream.WriteFloat(cmd.SideMove); } else { stream.WriteBool(false); } if (cmd.UpMove != last.UpMove) { stream.WriteBool(true); stream.WriteFloat(cmd.UpMove); } else { stream.WriteBool(false); } if (cmd.Buttons != last.Buttons) { stream.WriteBool(true); stream.WriteUInt32(cmd.Buttons); } else { stream.WriteBool(false); } if (cmd.Impulse != last.Impulse) { stream.WriteBool(true); stream.WriteByte(cmd.Impulse); } else { stream.WriteBool(false); } if (cmd.CrosshairTrace != last.CrosshairTrace) { stream.WriteBool(true); stream.WriteBitVec3Coord(cmd.CrosshairTrace); } else { stream.WriteBool(false); } if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex) { stream.WriteBool(true); stream.WriteBits(cmd.CursorUnitEntIndex, 11); } else { stream.WriteBool(false); } if (cmd.QueryEntIndex != last.QueryEntIndex) { stream.WriteBool(true); stream.WriteBits(cmd.QueryEntIndex, 11); } else { stream.WriteBool(false); } if (cmd.CursorUnitEntIndex != last.CursorUnitEntIndex) { stream.WriteBool(true); stream.WriteBits(cmd.CursorUnitEntIndex, 11); if (cmd.QueryEntIndex != last.QueryEntIndex) { stream.WriteBool(true); stream.WriteBits(cmd.QueryEntIndex, 11); } else { stream.WriteBool(false); } } else { stream.WriteBool(false); } if (cmd.MouseDx != last.MouseDx) { stream.WriteBool(true); stream.WriteUInt16(cmd.MouseDx); } else { stream.WriteBool(false); } if (cmd.MouseDy != last.MouseDy) { stream.WriteBool(true); stream.WriteUInt16(cmd.MouseDy); } else { stream.WriteBool(false); } if (cmd.Offset3c != last.Offset3c) { stream.WriteBool(true); stream.WriteUInt16(cmd.Offset3c); } else { stream.WriteBool(false); } // 0x44 to 0x74 inclusive if (cmd.OrderId != last.OrderId) { stream.WriteBool(true); stream.WriteInt16(cmd.OrderId); stream.WriteInt16((short)cmd.Order.Value.SelectedUnits.Length); foreach (var entity in cmd.Order.Value.SelectedUnits) { stream.WriteBits(entity, 11); } stream.WriteInt16(cmd.Order.Value.OrderType); stream.WriteInt16(cmd.Order.Value.EntityIndex1); stream.WriteBitVec3Coord(cmd.Order.Value.PreparedOrderPoint); stream.WriteBits(cmd.Order.Value.BaseNpcHandle, 11); stream.WriteBool(cmd.Order.Value.QueueOrder); } else { stream.WriteBool(false); } if (cmd.CameraX != last.CameraX || cmd.CameraY != last.CameraY) { stream.WriteBool(true); stream.WriteUInt16(cmd.CameraX); stream.WriteUInt16(cmd.CameraY); } else { stream.WriteBool(false); } if (cmd.ClickBehavior != last.ClickBehavior) { stream.WriteBool(true); stream.WriteByte(cmd.ClickBehavior); } else { stream.WriteBool(false); } if (cmd.SpectatorStatsSomething != last.SpectatorStatsSomething) { stream.WriteBool(true); stream.WriteByte(cmd.SpectatorStatsSomething); } else { stream.WriteBool(false); } if (cmd.ShopModeSomething != last.ShopModeSomething) { stream.WriteBool(true); stream.WriteByte(cmd.ShopModeSomething); } else { stream.WriteBool(false); } if (cmd.HudStatsDropdownCategoryIndex != last.HudStatsDropdownCategoryIndex) { stream.WriteBool(true); stream.WriteByte(cmd.HudStatsDropdownCategoryIndex); } else { stream.WriteBool(false); } if (cmd.HudStatsDropdownSortMethod != last.HudStatsDropdownSortMethod) { stream.WriteBool(true); stream.WriteByte(cmd.HudStatsDropdownSortMethod); } else { stream.WriteBool(false); } }
/// <summary> /// * /// </summary> public virtual void read_scalefactor_selection(Bitstream stream, Crc16 crc) { if (allocation != 0) { scfsi = stream.GetBitsFromBuffer(2); if (crc != null) crc.add_bits(scfsi, 2); } }
public abstract void read_allocation(Bitstream stream, Header header, Crc16 crc);
/// <summary> /// * /// </summary> public override bool ReadSampleData(Bitstream stream) { if (allocation != 0) if (groupingtable[0] != null) { int samplecode = stream.GetBitsFromBuffer(codelength[0]); // create requantized samples: samplecode += samplecode << 1; float[] target = samples; float[] source = groupingtable[0]; /* int tmp = 0; int temp = 0; target[tmp++] = source[samplecode + temp]; temp++; target[tmp++] = source[samplecode + temp]; temp++; target[tmp] = source[samplecode + temp]; */ //Bugfix: int tmp = 0; int temp = samplecode; if (temp > source.Length - 3) temp = source.Length - 3; target[tmp] = source[temp]; temp++; tmp++; target[tmp] = source[temp]; temp++; tmp++; target[tmp] = source[temp]; // memcpy (samples, groupingtable + samplecode, 3 * sizeof (real)); } else { samples[0] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0); samples[1] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0); samples[2] = (float)((stream.GetBitsFromBuffer(codelength[0])) * factor[0] - 1.0); } samplenumber = 0; if (++groupnumber == 12) return true; return false; }
public abstract void read_scalefactor(Bitstream stream, Header header);