public AudioOutStream CreatePCMStream(AudioApplication application, int?bitrate, int bufferMillis, int packetLoss)
{
var outputStream = new OutputStream(ApiClient); //Ignores header
var sodiumEncrypter = new SodiumEncryptStream(outputStream, this); //Passes header
var rtpWriter = new RTPWriteStream(sodiumEncrypter, _ssrc); //Consumes header, passes
var bufferedStream = new BufferedWriteStream(rtpWriter, this, bufferMillis, _connection.CancelToken, _audioLogger); //Ignores header, generates header
return(new OpusEncodeStream(bufferedStream, bitrate ?? (96 * 1024), application, packetLoss)); //Generates header
}
public AudioOutStream CreatePCMStream(AudioApplication application, int?bitrate, int bufferMillis)
{
var outputStream = new OutputStream(ApiClient);
var sodiumEncrypter = new SodiumEncryptStream(outputStream, this);
var rtpWriter = new RTPWriteStream(sodiumEncrypter, _ssrc);
var bufferedStream = new BufferedWriteStream(rtpWriter, this, bufferMillis, _connection.CancelToken, _audioLogger);
return(new OpusEncodeStream(bufferedStream, bitrate ?? (96 * 1024), application));
}
public async Task WriteStreamDoesNotOverflowOnMoreThan2GB()
{
// This test should never fail with OverflowException
var storage = new byte[4096];
using (var writeStream = new BufferedWriteStream(storage, (buffer, start, end) => Task.CompletedTask))
{
var data = new byte["1 GB".ToSize()];
await writeStream.WriteAsync(data, 0, data.Length);
await writeStream.WriteAsync(data, 0, data.Length);
await writeStream.WriteAsync(data, 0, data.Length);
}
}
public async Task SendAudioAsync(IGuild guild, IMessageChannel channel, string path, CancellationToken token)
{
if (!File.Exists(path) || !_connectedChannels.TryGetValue(guild.Id, out IAudioClient client))
{
return;
}
using (var ffmpeg = CreateProcess(path))
using (var stream = client.CreatePCMStream(AudioApplication.Music))
using (var bws = new BufferedWriteStream(stream, client, 500, token))
{
try
{
var output = ffmpeg.StandardOutput.BaseStream;
await ffmpeg.StandardOutput.BaseStream.CopyToAsync(stream);
}
catch (Exception e)
{
await stream.FlushAsync();
}
}
}
private void PacketSendingThread()
{
try
{
while (_running)
{
var send = false;
while (_sendPacketQueue.Count != 0 || _importantPacketQueue.Count != 0)
{
IPacket packet = null;
var flag = false;
lock (_importantPacketQueue)
{
if (_importantPacketQueue.Count != 0)
{
packet = _importantPacketQueue.Peek();
flag = false;
#if LogSendReceivePacket
_logger.Error($"Sent important packet 0x{Convert.ToString(packet.PacketId, 16).PadLeft(2, '0')}, {packet.GetType().FullName}");
#endif
}
}
if (packet == null)
{
lock (_sendPacketQueue)
{
//Debug.Assert(_sendPacketQueue.Peek() != null);
//something wrong here
packet = _sendPacketQueue.Peek();
flag = true;
#if LogSendReceivePacket
_logger.Warn($"Sent packet 0x{Convert.ToString(packet.PacketId, 16).PadLeft(2, '0')}, {packet.GetType().FullName}");
#endif
if (packet == null)
{
continue;
}
}
}
var dataPacket = new DataPacket(DefaultCodec);
dataPacket.ReadFromPacket(packet);
dataPacket.ResetPosition();
dataPacket.WriteToStream(_rawWriteCodec, () => CompressThreshold);
send = true;
if (!flag)
{
_importantPacketQueue.Dequeue();
}
else
{
_sendPacketQueue.Dequeue();
}
}
if (send)
{
BufferedWriteStream.Flush();
lock (_sendPacketQueue)
{
if (_waitSendCount != 0)
{
Monitor.PulseAll(_sendPacketQueue);
}
_waitSendCount = 0;
}
}
Thread.Sleep(1); // cpu break
}
}
catch (Exception ex)
{
_logger.Error(ex);
ExceptionOccurred?.Invoke(this, ex);
}
finally
{
_running = false;
State = ProtocolState.Closed;
}
}
