public void Serialize([NotNull] NetworkWriter writer)
{
writer.WriteUInt16((ushort)Data.Count);
writer.WriteBytes(Data.Array, Data.Offset, Data.Count);
//Recyle array now that it has been serialized
// ReSharper disable once AssignNullToNotNullAttribute (Justification: can't be null)
SerializationBuffers.Put(Data.Array);
}
private void SendUnreliableDataPackets()
{
ArraySegment <byte> buffer;
while (_queuedUnreliableTransmissions.Read(out buffer))
{
SentTraffic.Update(buffer.Count);
SendUnreliable(buffer);
_byteBufferPool.Put(buffer.Array);
}
}
public void Send(float[] frame)
{
if (!_inputQueue.Write(frame))
{
Log.Warn("Failed to write microphone samples into input queue");
//Increment a counter to inform the pipeline that a frame was lost
Interlocked.Increment(ref _droppedFrames);
//We failed to process this frame, recycle the buffer
_inputBufferSource.Put(frame);
}
_threadEvent.Set();
}
private void Recycle([NotNull] byte[] array)
{
if (array == null)
{
throw new ArgumentNullException("array");
}
_sendBufferPool.Put(array);
}
public static void Serialize([NotNull] this NetworkWriter writer, DissonanceNetworkMessage value)
{
writer.WriteUInt16((ushort)value.Data.Count);
writer.WriteBytes(value.Data.Array, value.Data.Offset, value.Data.Count);
//Recyle array now that it has been serialized
// ReSharper disable once AssignNullToNotNullAttribute (Justification: can't be null)
SerializationBuffers.Put(value.Data.Array);
}
protected override void Update()
{
if (IsInitialized)
{
// Network is considered active if all of:
// - Network explicitly claims it is active
// - Server or client explicitly claim they are active
// - Also if the client is active only say we're active once the client is non-null and has a non-null connection
var networkActive = NetworkManager.singleton.isNetworkActive &&
(NetworkServer.active || NetworkClient.active) &&
(!NetworkClient.active || (NetworkManager.singleton.client != null && NetworkManager.singleton.client.connection != null));
if (networkActive)
{
// switch to the appropriate mode if we have not already
var server = NetworkServer.active;
var client = NetworkClient.active;
if (Mode.IsServerEnabled() != server || Mode.IsClientEnabled() != client)
{
if (server && client)
{
RunAsHost(Unit.None, Unit.None);
}
else if (server)
{
RunAsDedicatedServer(Unit.None);
}
else if (client)
{
RunAsClient(Unit.None);
}
}
}
else if (Mode != NetworkMode.None)
{
// stop the network if unet has shut down
Stop();
}
//Send looped back packets
for (var i = 0; i < _loopbackQueue.Count; i++)
{
if (Client != null)
{
Client.NetworkReceivedPacket(_loopbackQueue[i]);
}
// Recycle the packet into the pool of byte buffers
// ReSharper disable once AssignNullToNotNullAttribute (Justification: ArraySegment array is not null)
_loopbackBuffers.Put(_loopbackQueue[i].Array);
}
_loopbackQueue.Clear();
}
base.Update();
}
private void RecycleFrame(VoicePacket packet)
{
// ReSharper disable once AssignNullToNotNullAttribute (Justification: Arr segment internal array is not null)
_bytePool.Put(packet.EncodedAudioFrame.Array);
if (packet.Channels != null)
{
packet.Channels.Clear();
_channelListPool.Put(packet.Channels);
}
}
public void Update()
{
//Reliable traffic to server
using (var locker = _serverReliableQueue.Lock())
{
var q = locker.Value;
for (var i = 0; i < q.Count; i++)
{
var item = q[i];
_client.SendReliable(item);
_tmpRecycleQueue.Add(item.Array);
}
q.Clear();
}
//Unreliable traffic to server
using (var locker = _serverUnreliableQueue.Lock())
{
var q = locker.Value;
for (var i = 0; i < q.Count; i++)
{
var item = q[i];
_client.SendUnreliable(item);
_tmpRecycleQueue.Add(item.Array);
}
q.Clear();
}
//P2P reliable traffic
using (var locker = _reliableP2PQueue.Lock())
{
var q = locker.Value;
for (var i = 0; i < q.Count; i++)
{
var item = q[i];
//Send it
_client.SendReliableP2P(item.Key, item.Value);
//Recycle
_tmpRecycleQueue.Add(item.Value.Array);
item.Key.Clear();
_listPool.Put(item.Key);
}
q.Clear();
}
//P2P reliable traffic
using (var locker = _unreliableP2PQueue.Lock())
{
var q = locker.Value;
for (var i = 0; i < q.Count; i++)
{
var item = q[i];
//Send it
_client.SendUnreliableP2P(item.Key, item.Value);
//Recycle
_tmpRecycleQueue.Add(item.Value.Array);
item.Key.Clear();
_listPool.Put(item.Key);
}
q.Clear();
}
//Recycle all the buffers
using (var locker = _sendBufferPool.Lock())
{
for (var i = 0; i < _tmpRecycleQueue.Count; i++)
{
var v = _tmpRecycleQueue[i];
if (v != null)
{
locker.Value.Put(v);
}
}
}
_tmpRecycleQueue.Clear();
}
public DecoderPipeline(IVoiceDecoder decoder, uint frameSize, Action <DecoderPipeline> completionHandler, bool softClip = true)
{
_completionHandler = completionHandler;
_inputBuffer = new TransferBuffer <EncodedAudio>();
_bytePool = new ConcurrentPool <byte[]>(12, () => new byte[frameSize * decoder.Format.Channels * 4]); // todo wrong frame size (although it should still be large enough)
_frameDuration = TimeSpan.FromSeconds((double)frameSize / decoder.Format.SampleRate);
_firstFrameArrival = null;
_firstFrameSeq = 0;
var source = new BufferedDecoder(decoder, frameSize, decoder.Format, frame => _bytePool.Put(frame.Data.Array));
var ramped = new VolumeRampedFrameSource(source, this);
var samples = new FrameToSampleConverter(ramped);
ISampleSource toResampler = samples;
if (softClip)
{
toResampler = new SoftClipSampleSource(samples);
}
var resampled = new Resampler(toResampler);
_source = source;
_output = resampled;
}
