Пример #1
0
 internal async Task CreateInputStreamAsync(ulong userId)
 {
     //Assume Thread-safe
     if (!_streams.ContainsKey(userId))
     {
         var readerStream = new InputStream();                         //Consumes header
         var opusDecoder  = new OpusDecodeStream(readerStream);        //Passes header
         //var jitterBuffer = new JitterBuffer(opusDecoder, _audioLogger);
         var rtpReader     = new RTPReadStream(opusDecoder);           //Generates header
         var decryptStream = new SodiumDecryptStream(rtpReader, this); //No header
         _streams.TryAdd(userId, new StreamPair(readerStream, decryptStream));
         await _streamCreatedEvent.InvokeAsync(userId, readerStream);
     }
 }
Пример #2
0
        private async Task ProcessPacketAsync(byte[] packet)
        {
            try
            {
                if (_connection.State == ConnectionState.Connecting)
                {
                    if (packet.Length != 70)
                    {
                        await _audioLogger.DebugAsync("Malformed Packet").ConfigureAwait(false);

                        return;
                    }
                    string ip;
                    int    port;
                    try
                    {
                        ip   = Encoding.UTF8.GetString(packet, 4, 70 - 6).TrimEnd('\0');
                        port = (packet[69] << 8) | packet[68];
                    }
                    catch (Exception ex)
                    {
                        await _audioLogger.DebugAsync("Malformed Packet", ex).ConfigureAwait(false);

                        return;
                    }

                    await _audioLogger.DebugAsync("Received Discovery").ConfigureAwait(false);

                    await ApiClient.SendSelectProtocol(ip, port).ConfigureAwait(false);
                }
                else if (_connection.State == ConnectionState.Connected)
                {
                    if (packet.Length == 8)
                    {
                        await _audioLogger.DebugAsync("Received Keepalive").ConfigureAwait(false);

                        ulong value =
                            ((ulong)packet[0] >> 0) |
                            ((ulong)packet[1] >> 8) |
                            ((ulong)packet[2] >> 16) |
                            ((ulong)packet[3] >> 24) |
                            ((ulong)packet[4] >> 32) |
                            ((ulong)packet[5] >> 40) |
                            ((ulong)packet[6] >> 48) |
                            ((ulong)packet[7] >> 56);

                        while (_keepaliveTimes.TryDequeue(out var pair))
                        {
                            if (pair.Key == value)
                            {
                                int latency = Environment.TickCount - pair.Value;
                                int before  = UdpLatency;
                                UdpLatency = latency;

                                await _udpLatencyUpdatedEvent.InvokeAsync(before, latency).ConfigureAwait(false);

                                break;
                            }
                        }
                    }
                    else
                    {
                        if (!RTPReadStream.TryReadSsrc(packet, 0, out var ssrc))
                        {
                            await _audioLogger.DebugAsync("Malformed Frame").ConfigureAwait(false);

                            return;
                        }
                        if (!_ssrcMap.TryGetValue(ssrc, out var userId))
                        {
                            await _audioLogger.DebugAsync($"Unknown SSRC {ssrc}").ConfigureAwait(false);

                            return;
                        }
                        if (!_streams.TryGetValue(userId, out var pair))
                        {
                            await _audioLogger.DebugAsync($"Unknown User {userId}").ConfigureAwait(false);

                            return;
                        }
                        try
                        {
                            await pair.Writer.WriteAsync(packet, 0, packet.Length).ConfigureAwait(false);
                        }
                        catch (Exception ex)
                        {
                            await _audioLogger.DebugAsync("Malformed Frame", ex).ConfigureAwait(false);

                            return;
                        }
                        //await _audioLogger.DebugAsync($"Received {packet.Length} bytes from user {userId}").ConfigureAwait(false);
                    }
                }
            }
            catch (Exception ex)
            {
                await _audioLogger.WarningAsync("Failed to process UDP packet", ex).ConfigureAwait(false);

                return;
            }
        }