update main projects

3 files changed, 30 insertions, 143 deletions

diff --git a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
index 50cb68a95..2afc3744f 100644
--- a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
+++ b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunHost.cs
@@ -511,8 +511,8 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             }
 
             // The UDP method is not working reliably on OSX, and on BSD it hasn't been tested yet
-            var enableHttpStream = _environment.OperatingSystem == OperatingSystem.OSX 
-                || _environment.OperatingSystem == OperatingSystem.BSD;
+            var enableHttpStream = _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.OSX 
+                || _environment.OperatingSystem == MediaBrowser.Model.System.OperatingSystem.BSD;
             enableHttpStream = true;
             if (enableHttpStream)
             {
@@ -597,10 +597,12 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                 // Need a way to set the Receive timeout on the socket otherwise this might never timeout?
                 try
                 {
-                    await udpClient.SendAsync(discBytes, discBytes.Length, new IpEndPointInfo(new IpAddressInfo("255.255.255.255", IpAddressFamily.InterNetwork), 65001), cancellationToken);
+                    await udpClient.SendToAsync(discBytes, 0, discBytes.Length, new IpEndPointInfo(new IpAddressInfo("255.255.255.255", IpAddressFamily.InterNetwork), 65001), cancellationToken);
+                    var receiveBuffer = new byte[8192];
+
                     while (!cancellationToken.IsCancellationRequested)
                     {
-                        var response = await udpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                        var response = await udpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                         var deviceIp = response.RemoteEndPoint.IpAddress.Address;
 
                         // check to make sure we have enough bytes received to be a valid message and make sure the 2nd byte is the discover reply byte
diff --git a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunManager.cs b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunManager.cs
index 3202b7313..4dd6e3c71 100644
--- a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunManager.cs
+++ b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunManager.cs
@@ -114,7 +114,7 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             var ipEndPoint = new IpEndPointInfo(remoteIp, HdHomeRunPort);
 
             var lockkeyMsg = CreateGetMessage(tuner, "lockkey");
-            await socket.SendAsync(lockkeyMsg, lockkeyMsg.Length, ipEndPoint, cancellationToken);
+            await socket.SendToAsync(lockkeyMsg, 0, lockkeyMsg.Length, ipEndPoint, cancellationToken);
             var response = await socket.ReceiveAsync(cancellationToken).ConfigureAwait(false);
             string returnVal;
             ParseReturnMessage(response.Buffer, response.ReceivedBytes, out returnVal);
@@ -128,6 +128,8 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             
             using (var tcpClient = _socketFactory.CreateTcpSocket(_remoteIp, HdHomeRunPort))
             {
+                var receiveBuffer = new byte[8192];
+
                 if (!_lockkey.HasValue)
                 {
                     var rand = new Random();
@@ -144,8 +146,8 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                     _activeTuner = i;
                     var lockKeyString = String.Format("{0:d}", _lockkey.Value);
                     var lockkeyMsg = CreateSetMessage(i, "lockkey", lockKeyString, null);
-                    await tcpClient.SendAsync(lockkeyMsg, lockkeyMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
-                    var response = await tcpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                    await tcpClient.SendToAsync(lockkeyMsg, 0, lockkeyMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
+                    var response = await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                     string returnVal;
                     // parse response to make sure it worked
                     if (!ParseReturnMessage(response.Buffer, response.ReceivedBytes, out returnVal))
@@ -155,8 +157,8 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                     foreach(Tuple<string,string> command in commandList)
                     {
                         var channelMsg = CreateSetMessage(i, command.Item1, command.Item2, _lockkey.Value);
-                        await tcpClient.SendAsync(channelMsg, channelMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
-                        response = await tcpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                        await tcpClient.SendToAsync(channelMsg, 0, channelMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
+                        response = await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                         // parse response to make sure it worked
                         if (!ParseReturnMessage(response.Buffer, response.ReceivedBytes, out returnVal))
                         {
@@ -169,8 +171,8 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
                     var targetValue = String.Format("rtp://{0}:{1}", localIp, localPort);
                     var targetMsg = CreateSetMessage(i, "target", targetValue, _lockkey.Value);
 
-                    await tcpClient.SendAsync(targetMsg, targetMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
-                    response = await tcpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                    await tcpClient.SendToAsync(targetMsg, 0, targetMsg.Length, ipEndPoint, cancellationToken).ConfigureAwait(false);
+                    response = await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                     // parse response to make sure it worked
                     if (!ParseReturnMessage(response.Buffer, response.ReceivedBytes, out returnVal))
                     {
@@ -191,11 +193,13 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             using (var tcpClient = _socketFactory.CreateTcpSocket(_remoteIp, HdHomeRunPort))
             {
                 var commandList = commands.GetCommands();
+                var receiveBuffer = new byte[8192];
+
                 foreach (Tuple<string, string> command in commandList)
                 {
                     var channelMsg = CreateSetMessage(_activeTuner, command.Item1, command.Item2, _lockkey.Value);
-                    await tcpClient.SendAsync(channelMsg, channelMsg.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), cancellationToken).ConfigureAwait(false);
-                    var response = await tcpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                    await tcpClient.SendToAsync(channelMsg, 0, channelMsg.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), cancellationToken).ConfigureAwait(false);
+                    var response = await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                     // parse response to make sure it worked
                     string returnVal;
                     if (!ParseReturnMessage(response.Buffer, response.ReceivedBytes, out returnVal))
@@ -220,12 +224,15 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
         private async Task ReleaseLockkey(ISocket tcpClient)
         {
             var releaseTarget = CreateSetMessage(_activeTuner, "target", "none", _lockkey);
-            await tcpClient.SendAsync(releaseTarget, releaseTarget.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), CancellationToken.None).ConfigureAwait(false);
-            await tcpClient.ReceiveAsync(CancellationToken.None).ConfigureAwait(false);
+            await tcpClient.SendToAsync(releaseTarget, 0, releaseTarget.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), CancellationToken.None).ConfigureAwait(false);
+
+            var receiveBuffer = new byte[8192];
+
+            await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, CancellationToken.None).ConfigureAwait(false);
             var releaseKeyMsg = CreateSetMessage(_activeTuner, "lockkey", "none", _lockkey);
             _lockkey = null;
-            await tcpClient.SendAsync(releaseKeyMsg, releaseKeyMsg.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), CancellationToken.None).ConfigureAwait(false);
-            await tcpClient.ReceiveAsync(CancellationToken.None).ConfigureAwait(false);
+            await tcpClient.SendToAsync(releaseKeyMsg, 0, releaseKeyMsg.Length, new IpEndPointInfo(_remoteIp, HdHomeRunPort), CancellationToken.None).ConfigureAwait(false);
+            await tcpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, CancellationToken.None).ConfigureAwait(false);
         }
 
         private static byte[] CreateGetMessage(int tuner, string name)
diff --git a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs
index 7c767c141..97753b3d3 100644
--- a/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs
+++ b/Emby.Server.Implementations/LiveTv/TunerHosts/HdHomerun/HdHomerunUdpStream.cs
@@ -173,11 +173,13 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
         private static int RtpHeaderBytes = 12;
         private async Task CopyTo(ISocket udpClient, Stream outputStream, TaskCompletionSource<bool> openTaskCompletionSource, CancellationToken cancellationToken)
         {
+            var receiveBuffer = new byte[8192];
+
             while (true)
             {
-                var data = await udpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
+                var data = await udpClient.ReceiveAsync(receiveBuffer, 0, receiveBuffer.Length, cancellationToken).ConfigureAwait(false);
                 var bytesRead = data.ReceivedBytes - RtpHeaderBytes;
-
+                
                 await outputStream.WriteAsync(data.Buffer, RtpHeaderBytes, bytesRead, cancellationToken).ConfigureAwait(false);
 
                 if (openTaskCompletionSource != null)
@@ -188,128 +190,4 @@ namespace Emby.Server.Implementations.LiveTv.TunerHosts.HdHomerun
             }
         }
     }
-
-    // This handles the ReadAsync function only of a Stream object
-    // This is used to wrap a UDP socket into a stream for MulticastStream which only uses ReadAsync
-    public class UdpClientStream : Stream
-    {
-        private static int RtpHeaderBytes = 12;
-        private static int PacketSize = 1316;
-        private readonly ISocket _udpClient;
-        bool disposed;
-
-        public UdpClientStream(ISocket udpClient) : base()
-        {
-            _udpClient = udpClient;
-        }
-
-        public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken)
-        {
-            if (buffer == null)
-                throw new ArgumentNullException("buffer");
-
-            if (offset + count < 0)
-                throw new ArgumentOutOfRangeException("offset + count must not be negative", "offset+count");
-
-            if (offset + count > buffer.Length)
-                throw new ArgumentException("offset + count must not be greater than the length of buffer", "offset+count");
-
-            if (disposed)
-                throw new ObjectDisposedException(typeof(UdpClientStream).ToString());
-
-            // This will always receive a 1328 packet size (PacketSize + RtpHeaderSize)
-            // The RTP header will be stripped so see how many reads we need to make to fill the buffer.
-            var numReads = count / PacketSize;
-
-            int totalBytesRead = 0;
-
-            for (int i = 0; i < numReads; ++i)
-            {
-                var data = await _udpClient.ReceiveAsync(cancellationToken).ConfigureAwait(false);
-
-                var bytesRead = data.ReceivedBytes - RtpHeaderBytes;
-
-                // remove rtp header
-                Buffer.BlockCopy(data.Buffer, RtpHeaderBytes, buffer, offset, bytesRead);
-                offset += bytesRead;
-                totalBytesRead += bytesRead;
-            }
-            return totalBytesRead;
-        }
-
-        protected override void Dispose(bool disposing)
-        {
-            disposed = true;
-        }
-
-        public override bool CanRead
-        {
-            get
-            {
-                return true;
-            }
-        }
-
-        public override bool CanSeek
-        {
-            get
-            {
-                return false;
-            }
-        }
-
-        public override bool CanWrite
-        {
-            get
-            {
-                return false;
-            }
-        }
-
-        public override long Length
-        {
-            get
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-        public override long Position
-        {
-            get
-            {
-                throw new NotImplementedException();
-            }
-
-            set
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-        public override void Flush()
-        {
-            throw new NotImplementedException();
-        }
-
-        public override int Read(byte[] buffer, int offset, int count)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override long Seek(long offset, SeekOrigin origin)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override void SetLength(long value)
-        {
-            throw new NotImplementedException();
-        }
-
-        public override void Write(byte[] buffer, int offset, int count)
-        {
-            throw new NotImplementedException();
-        }
-    }
 }
\ No newline at end of file