4 files changed, 170 insertions, 61 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 4780701..e7ce2e0 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -792,16 +792,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        public void SendGenericMessage(string method, List<string> message)
+        public void SendGenericMessage(string method, List<byte[]> message)
         {
             GenericMessagePacket gmp = new GenericMessagePacket();
             gmp.MethodData.Method = Util.StringToBytes256(method);
             gmp.ParamList = new GenericMessagePacket.ParamListBlock[message.Count];
             int i = 0;
-            foreach (string val in message)
+            foreach (byte[] val in message)
             {
                 gmp.ParamList[i] = new GenericMessagePacket.ParamListBlock();
-                gmp.ParamList[i++].Parameter = Util.StringToBytes256(val);
+                gmp.ParamList[i++].Parameter = val;
             }
             OutPacket(gmp, ThrottleOutPacketType.Task);
         }
@@ -813,6 +813,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public virtual void SendLayerData(float[] map)
         {
             Util.FireAndForget(DoSendLayerData, map);
+
+            // Send it sync, and async. It's not that much data
+            // and it improves user experience just so much!
+            DoSendLayerData(map);
         }
 
         /// <summary>
@@ -825,16 +829,13 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             try
             {
-                //for (int y = 0; y < 16; y++)
-                //{
-                //    for (int x = 0; x < 16; x++)
-                //    {
-                //        SendLayerData(x, y, map);
-                //    }
-                //}
-
-                // Send LayerData in a spiral pattern. Fun!
-                SendLayerTopRight(map, 0, 0, 15, 15);
+                for (int y = 0; y < 16; y++)
+                {
+                    for (int x = 0; x < 16; x+=4)
+                    {
+                        SendLayerPacket(x, y, map);
+                    }
+                }
             }
             catch (Exception e)
             {
@@ -842,51 +843,35 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
         }
 
-        private void SendLayerTopRight(float[] map, int x1, int y1, int x2, int y2)
-        {
-            // Row
-            for (int i = x1; i <= x2; i++)
-                SendLayerData(i, y1, map);
-
-            // Column
-            for (int j = y1 + 1; j <= y2; j++)
-                SendLayerData(x2, j, map);
-
-            if (x2 - x1 > 0)
-                SendLayerBottomLeft(map, x1, y1 + 1, x2 - 1, y2);
-        }
-
-        void SendLayerBottomLeft(float[] map, int x1, int y1, int x2, int y2)
-        {
-            // Row in reverse
-            for (int i = x2; i >= x1; i--)
-                SendLayerData(i, y2, map);
-
-            // Column in reverse
-            for (int j = y2 - 1; j >= y1; j--)
-                SendLayerData(x1, j, map);
-
-            if (x2 - x1 > 0)
-                SendLayerTopRight(map, x1 + 1, y1, x2, y2 - 1);
-        }
-
         /// <summary>
         /// Sends a set of four patches (x, x+1, ..., x+3) to the client
         /// </summary>
         /// <param name="map">heightmap</param>
         /// <param name="px">X coordinate for patches 0..12</param>
         /// <param name="py">Y coordinate for patches 0..15</param>
-        // private void SendLayerPacket(float[] map, int y, int x)
-        // {
-        //     int[] patches = new int[4];
-        //     patches[0] = x + 0 + y * 16;
-        //     patches[1] = x + 1 + y * 16;
-        //     patches[2] = x + 2 + y * 16;
-        //     patches[3] = x + 3 + y * 16;
-
-        //     Packet layerpack = LLClientView.TerrainManager.CreateLandPacket(map, patches);
-        //     OutPacket(layerpack, ThrottleOutPacketType.Land);
-        // }
+        private void SendLayerPacket(int x, int y, float[] map)
+        {
+            int[] patches = new int[4];
+            patches[0] = x + 0 + y * 16;
+            patches[1] = x + 1 + y * 16;
+            patches[2] = x + 2 + y * 16;
+            patches[3] = x + 3 + y * 16;
+
+            float[] heightmap = (map.Length == 65536) ?
+                map :
+                LLHeightFieldMoronize(map);
+
+            try
+            {
+                Packet layerpack = TerrainCompressor.CreateLandPacket(heightmap, patches);
+                OutPacket(layerpack, ThrottleOutPacketType.Land);
+            }
+            catch
+            {
+                for (int px = x ; px < x + 4 ; px++)
+                    SendLayerData(px, y, map);
+            }
+        }
 
         /// <summary>
         /// Sends a specified patch to a client
@@ -3164,7 +3149,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
             objupdate.ObjectData[0] = CreateAvatarUpdateBlock(data);
-
             OutPacket(objupdate, ThrottleOutPacketType.Task);
         }
 
@@ -3215,8 +3199,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                     terse.ObjectData[i] = m_avatarTerseUpdates.Dequeue();
             }
 
-            // HACK: Using the task category until the tiered reprioritization code is in
-            OutPacket(terse, ThrottleOutPacketType.Task);
+            OutPacket(terse, ThrottleOutPacketType.State);
         }
 
         public void SendCoarseLocationUpdate(List<UUID> users, List<Vector3> CoarseLocations)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 3c4fa72..4d9f58f 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -402,6 +402,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             #region Queue or Send
 
             OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
+            outgoingPacket.Type = type;
 
             if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
                 SendPacketFinal(outgoingPacket);
@@ -513,6 +514,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             byte flags = buffer.Data[0];
             bool isResend = (flags & Helpers.MSG_RESENT) != 0;
             bool isReliable = (flags & Helpers.MSG_RELIABLE) != 0;
+            bool sendSynchronous = false;
             LLUDPClient udpClient = outgoingPacket.Client;
 
             if (!udpClient.IsConnected)
@@ -568,9 +570,28 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             if (isReliable)
                 Interlocked.Add(ref udpClient.UnackedBytes, outgoingPacket.Buffer.DataLength);
 
-            // Put the UDP payload on the wire
-            AsyncBeginSend(buffer);
+            //Some packet types need to be sent synchonously.
+            //Sorry, i know it's not optimal, but until the LL client
+            //manages packets correctly and re-orders them as required, this is necessary.
 
+            
+            // Put the UDP payload on the wire
+            if (outgoingPacket.Type == PacketType.ImprovedTerseObjectUpdate)
+            {
+                SyncBeginPrioritySend(buffer, 2); // highest priority
+            }
+            else if (outgoingPacket.Type == PacketType.ObjectUpdate
+                || outgoingPacket.Type == PacketType.LayerData)
+            {
+                SyncBeginPrioritySend(buffer, 1); // medium priority
+            }
+            else
+            {
+                SyncBeginPrioritySend(buffer, 0); // normal priority
+            }
+            
+            //AsyncBeginSend(buffer);
+            
             // Keep track of when this packet was sent out (right now)
             outgoingPacket.TickCount = Environment.TickCount & Int32.MaxValue;
         }
@@ -851,7 +872,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             Buffer.BlockCopy(packetData, 0, buffer.Data, 0, length);
 
-            AsyncBeginSend(buffer);
+            SyncBeginPrioritySend(buffer, 1); //Setting this to a medium priority should help minimise resends
         }
 
         private bool IsClientAuthorized(UseCircuitCodePacket useCircuitCode, out AuthenticateResponse sessionInfo)
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
index d2779ba..de2cd24 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OpenSimUDPBase.cs
@@ -29,6 +29,7 @@ using System;
 using System.Net;
 using System.Net.Sockets;
 using System.Threading;
+using System.Collections.Generic;
 using log4net;
 
 namespace OpenMetaverse
@@ -52,12 +53,30 @@ namespace OpenMetaverse
         /// <summary>Local IP address to bind to in server mode</summary>
         protected IPAddress m_localBindAddress;
 
+        /// <summary>
+        /// Standard queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_standardQueue = new List<UDPPacketBuffer>();
+
+        /// <summary>
+        /// Medium priority queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_mediumPriorityQueue = new List<UDPPacketBuffer>();
+
+        /// <summary>
+        /// Prioritised queue for our outgoing SyncBeginPrioritySend
+        /// </summary>
+        private List<UDPPacketBuffer> m_priorityQueue = new List<UDPPacketBuffer>();
+
         /// <summary>UDP socket, used in either client or server mode</summary>
         private Socket m_udpSocket;
 
         /// <summary>Flag to process packets asynchronously or synchronously</summary>
         private bool m_asyncPacketHandling;
 
+        /// <summary>Are we currently sending data asynchronously?</summary>
+        private volatile bool m_sendingData = false;
+
         /// <summary>The all important shutdown flag</summary>
         private volatile bool m_shutdownFlag = true;
 
@@ -246,7 +265,51 @@ namespace OpenMetaverse
             }
         }
 
-        public void AsyncBeginSend(UDPPacketBuffer buf)
+        public void SyncBeginPrioritySend(UDPPacketBuffer buf, int Priority)
+        {
+            if (!m_shutdownFlag)
+            {
+                if (!m_sendingData)
+                {
+                    m_sendingData = true;
+                    try
+                    {
+                        AsyncBeginSend(buf);
+                    }
+                    catch (SocketException) { }
+                    catch (ObjectDisposedException) { }
+                }
+                else
+                {
+                    if (Priority == 2)
+                    {
+                        lock (m_priorityQueue)
+                        {
+                            m_priorityQueue.Add(buf);
+                        }
+                    }
+                    else
+                    {
+                        if (Priority != 0)
+                        {
+                            lock (m_mediumPriorityQueue)
+                            {
+                                m_mediumPriorityQueue.Add(buf);
+                            }
+                        }
+                        else
+                        {
+                            lock (m_standardQueue)
+                            {
+                                m_standardQueue.Add(buf);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        private void AsyncBeginSend(UDPPacketBuffer buf)
         {
             if (!m_shutdownFlag)
             {
@@ -270,8 +333,48 @@ namespace OpenMetaverse
         {
             try
             {
-//                UDPPacketBuffer buf = (UDPPacketBuffer)result.AsyncState;
                 m_udpSocket.EndSendTo(result);
+
+                if (m_sendingData)
+                {
+                    lock (m_priorityQueue)
+                    {
+                        if (m_priorityQueue.Count > 0)
+                        {
+                            UDPPacketBuffer buf = m_priorityQueue[0];
+                            m_priorityQueue.RemoveAt(0);
+                            AsyncBeginSend(buf);
+                        }
+                        else
+                        {
+                            lock (m_mediumPriorityQueue)
+                            {
+                                if (m_mediumPriorityQueue.Count > 0)
+                                {
+                                    UDPPacketBuffer buf = m_mediumPriorityQueue[0];
+                                    m_mediumPriorityQueue.RemoveAt(0);
+                                    AsyncBeginSend(buf);
+                                }
+                                else
+                                {
+                                    lock (m_standardQueue)
+                                    {
+                                        if (m_standardQueue.Count > 0)
+                                        {
+                                            UDPPacketBuffer buf = m_standardQueue[0];
+                                            m_standardQueue.RemoveAt(0);
+                                            AsyncBeginSend(buf);
+                                        }
+                                        else
+                                        {
+                                            m_sendingData = false;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
             }
             catch (SocketException) { }
             catch (ObjectDisposedException) { }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs b/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
index 1a1a1cb..7dc42d3 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/OutgoingPacket.cs
@@ -28,6 +28,7 @@
 using System;
 using OpenSim.Framework;
 using OpenMetaverse;
+using OpenMetaverse.Packets;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
@@ -52,7 +53,8 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         public int TickCount;
         /// <summary>Category this packet belongs to</summary>
         public ThrottleOutPacketType Category;
-
+        /// <summary>The type of packet so its delivery method can be determined</summary>
+        public PacketType Type;
         /// <summary>
         /// Default constructor
         /// </summary>