3 files changed, 580 insertions, 327 deletions

diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
index 05a2a63..43c3c7c 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLClientView.cs
@@ -51,6 +51,44 @@ using Nini.Config;
 
 namespace OpenSim.Region.ClientStack.LindenUDP
 {
+    #region Enums
+
+    /// <summary>
+    /// Specifies the fields that have been changed when sending a prim or
+    /// avatar update
+    /// </summary>
+    [Flags]
+    public enum PrimUpdateFlags : uint
+    {
+        None = 0,
+        AttachmentPoint = 1 << 0,
+        Material = 1 << 1,
+        ClickAction = 1 << 2,
+        Scale = 1 << 3,
+        ParentID = 1 << 4,
+        PrimFlags = 1 << 5,
+        PrimData = 1 << 6,
+        MediaURL = 1 << 7,
+        ScratchPad = 1 << 8,
+        Textures = 1 << 9,
+        TextureAnim = 1 << 10,
+        NameValue = 1 << 11,
+        Position = 1 << 12,
+        Rotation = 1 << 13,
+        Velocity = 1 << 14,
+        Acceleration = 1 << 15,
+        AngularVelocity = 1 << 16,
+        CollisionPlane = 1 << 17,
+        Text = 1 << 18,
+        Particles = 1 << 19,
+        ExtraData = 1 << 20,
+        Sound = 1 << 21,
+        Joint = 1 << 22,
+        FullUpdate = UInt32.MaxValue
+    }
+
+    #endregion Enums
+
     public delegate bool PacketMethod(IClientAPI simClient, Packet packet);
 
     /// <summary>
@@ -282,12 +320,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         private readonly IGroupsModule m_GroupsModule;
 
         private int m_cachedTextureSerial;
-        private Timer m_avatarTerseUpdateTimer;
-        private List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_avatarTerseUpdates = new List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
-        private Timer m_primTerseUpdateTimer;
-        private List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_primTerseUpdates = new List<ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
-        private Timer m_primFullUpdateTimer;
-        private List<ObjectUpdatePacket.ObjectDataBlock> m_primFullUpdates = new List<ObjectUpdatePacket.ObjectDataBlock>();
+        private PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_avatarTerseUpdates =
+            new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
+        private PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock> m_primTerseUpdates =
+            new PriorityQueue<double, ImprovedTerseObjectUpdatePacket.ObjectDataBlock>();
+        private PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock> m_primFullUpdates =
+            new PriorityQueue<double, ObjectUpdatePacket.ObjectDataBlock>();
         private int m_moneyBalance;
         private int m_animationSequenceNumber = 1;
         private bool m_SendLogoutPacketWhenClosing = true;
@@ -309,13 +347,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         protected Dictionary<UUID,ulong> m_groupPowers = new Dictionary<UUID, ulong>();
         protected int m_terrainCheckerCount;
 
-        // LL uses these limits, apparently. Compressed terse would be 23, but we don't have that yet
-        protected int m_primTerseUpdatesPerPacket = 10;
-        protected int m_primFullUpdatesPerPacket = 14;
-        protected int m_primTerseUpdateRate = 10;
-        protected int m_primFullUpdateRate = 14;
-        protected int m_avatarTerseUpdateRate = 50;
-        protected int m_avatarTerseUpdatesPerPacket = 5;
+        // These numbers are guesses at a decent tradeoff between responsiveness
+        // of the interest list and throughput. Lower is more responsive, higher
+        // is better throughput
+        protected int m_primTerseUpdatesPerPacket = 25;
+        protected int m_primFullUpdatesPerPacket = 100;
+        protected int m_avatarTerseUpdatesPerPacket = 10;
         /// <summary>Number of texture packets to put on the queue each time the
         /// OnQueueEmpty event is triggered for the texture category</summary>
         protected int m_textureSendLimit = 20;
@@ -438,25 +475,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // Remove ourselves from the scene
             m_scene.RemoveClient(AgentId);
 
-            // Shut down timers. Thread Context of this method is murky.   Lock all timers
-            if (m_avatarTerseUpdateTimer.Enabled)
-                lock (m_avatarTerseUpdateTimer)
-                    m_avatarTerseUpdateTimer.Stop();
-            if (m_primTerseUpdateTimer.Enabled)
-                lock (m_primTerseUpdateTimer)
-                    m_primTerseUpdateTimer.Stop();
-            if (m_primFullUpdateTimer.Enabled)
-                lock (m_primFullUpdateTimer)
-                    m_primFullUpdateTimer.Stop();
-
             // We can't reach into other scenes and close the connection
             // We need to do this over grid communications
             //m_scene.CloseAllAgents(CircuitCode);
 
-            m_avatarTerseUpdateTimer.Dispose();
-            m_primTerseUpdateTimer.Dispose();
-            m_primFullUpdateTimer.Dispose();
-
             // Disable UDP handling for this client
             m_udpClient.Shutdown();
 
@@ -483,18 +505,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public void Stop()
         {
-            // Shut down timers.  Thread Context is Murky, lock all timers!
-            if (m_avatarTerseUpdateTimer.Enabled)
-                lock (m_avatarTerseUpdateTimer)
-                    m_avatarTerseUpdateTimer.Stop();
-
-            if (m_primTerseUpdateTimer.Enabled)
-                lock (m_primTerseUpdateTimer)
-                    m_primTerseUpdateTimer.Stop();
 
-            if (m_primFullUpdateTimer.Enabled)
-                lock (m_primFullUpdateTimer)
-                    m_primFullUpdateTimer.Stop();
         }
 
         #endregion Client Methods
@@ -590,18 +601,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         public virtual void Start()
         {
-            m_avatarTerseUpdateTimer = new Timer(m_avatarTerseUpdateRate);
-            m_avatarTerseUpdateTimer.Elapsed += new ElapsedEventHandler(ProcessAvatarTerseUpdates);
-            m_avatarTerseUpdateTimer.AutoReset = false;
-
-            m_primTerseUpdateTimer = new Timer(m_primTerseUpdateRate);
-            m_primTerseUpdateTimer.Elapsed += new ElapsedEventHandler(ProcessPrimTerseUpdates);
-            m_primTerseUpdateTimer.AutoReset = false;
-
-            m_primFullUpdateTimer = new Timer(m_primFullUpdateRate);
-            m_primFullUpdateTimer.Elapsed += new ElapsedEventHandler(ProcessPrimFullUpdates);
-            m_primFullUpdateTimer.AutoReset = false;
-
             m_scene.AddNewClient(this);
 
             RefreshGroupMembership();
@@ -3127,7 +3126,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
             avp.Sender.IsTrial = false;
             avp.Sender.ID = agentID;
-            OutPacket(avp, ThrottleOutPacketType.State);
+            OutPacket(avp, ThrottleOutPacketType.Task);
         }
 
         public void SendAnimations(UUID[] animations, int[] seqs, UUID sourceAgentId, UUID[] objectIDs)
@@ -3159,33 +3158,221 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
         #endregion
 
+        #region Prim/Avatar Updates
+
+        /*void SendObjectUpdate(SceneObjectPart obj, PrimFlags creatorFlags, PrimUpdateFlags updateFlags)
+        {
+            bool canUseCompressed, canUseImproved;
+            UpdateFlagsToPacketType(creatorFlags, updateFlags, out canUseCompressed, out canUseImproved);
+
+            if (!canUseImproved && !canUseCompressed)
+                SendFullObjectUpdate(obj, creatorFlags, updateFlags);
+            else if (!canUseImproved)
+                SendObjectUpdateCompressed(obj, creatorFlags, updateFlags);
+            else
+                SendImprovedTerseObjectUpdate(obj, creatorFlags, updateFlags);
+        }
+
+        void SendFullObjectUpdate(SceneObjectPart obj, PrimFlags creatorFlags, PrimUpdateFlags updateFlags)
+        {
+            IClientAPI owner;
+            if (m_scene.ClientManager.TryGetValue(obj.OwnerID, out owner) && owner is LLClientView)
+            {
+                LLClientView llOwner = (LLClientView)owner;
+
+                // Send an update out to the owner
+                ObjectUpdatePacket updateToOwner = new ObjectUpdatePacket();
+                updateToOwner.RegionData.RegionHandle = obj.RegionHandle;
+                //updateToOwner.RegionData.TimeDilation = (ushort)(timeDilation * (float)UInt16.MaxValue);
+                updateToOwner.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
+                updateToOwner.ObjectData[0] = BuildUpdateBlock(obj, obj.Flags | creatorFlags | PrimFlags.ObjectYouOwner, 0);
+
+                m_udpServer.SendPacket(llOwner.UDPClient, updateToOwner, ThrottleOutPacketType.State, true);
+            }
+
+            // Send an update out to everyone else
+            ObjectUpdatePacket updateToOthers = new ObjectUpdatePacket();
+            updateToOthers.RegionData.RegionHandle = obj.RegionHandle;
+            //updateToOthers.RegionData.TimeDilation = (ushort)(timeDilation * (float)UInt16.MaxValue);
+            updateToOthers.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
+            updateToOthers.ObjectData[0] = BuildUpdateBlock(obj, obj.Flags, 0);
+
+            m_scene.ClientManager.ForEach(
+                delegate(IClientAPI client)
+                {
+                    if (client.AgentId != obj.OwnerID && client is LLClientView)
+                    {
+                        LLClientView llClient = (LLClientView)client;
+                        m_udpServer.SendPacket(llClient.UDPClient, updateToOthers, ThrottleOutPacketType.State, true);
+                    }
+                }
+            );
+        }
+
+        void SendObjectUpdateCompressed(SceneObjectPart obj, PrimFlags creatorFlags, PrimUpdateFlags updateFlags)
+        {
+        }
+
+        void SendImprovedTerseObjectUpdate(SceneObjectPart obj, PrimFlags creatorFlags, PrimUpdateFlags updateFlags)
+        {
+        }
+
+        void UpdateFlagsToPacketType(PrimFlags creatorFlags, PrimUpdateFlags updateFlags, out bool canUseCompressed, out bool canUseImproved)
+        {
+            canUseCompressed = true;
+            canUseImproved = true;
+
+            if ((updateFlags & PrimUpdateFlags.FullUpdate) == PrimUpdateFlags.FullUpdate || creatorFlags != PrimFlags.None)
+            {
+                canUseCompressed = false;
+                canUseImproved = false;
+            }
+            else
+            {
+                if ((updateFlags & PrimUpdateFlags.Velocity) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Acceleration) != 0 ||
+                    (updateFlags & PrimUpdateFlags.CollisionPlane) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Joint) != 0)
+                {
+                    canUseCompressed = false;
+                }
+
+                if ((updateFlags & PrimUpdateFlags.PrimFlags) != 0 ||
+                    (updateFlags & PrimUpdateFlags.ParentID) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Scale) != 0 ||
+                    (updateFlags & PrimUpdateFlags.PrimData) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Text) != 0 ||
+                    (updateFlags & PrimUpdateFlags.NameValue) != 0 ||
+                    (updateFlags & PrimUpdateFlags.ExtraData) != 0 ||
+                    (updateFlags & PrimUpdateFlags.TextureAnim) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Sound) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Particles) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Material) != 0 ||
+                    (updateFlags & PrimUpdateFlags.ClickAction) != 0 ||
+                    (updateFlags & PrimUpdateFlags.MediaURL) != 0 ||
+                    (updateFlags & PrimUpdateFlags.Joint) != 0)
+                {
+                    canUseImproved = false;
+                }
+            }
+        }
+
+        static ObjectUpdatePacket.ObjectDataBlock BuildUpdateBlockFromPrim(SceneObjectPart prim, UUID assetID, PrimFlags flags, uint crc)
+        {
+            byte[] objectData = new byte[60];
+            prim.OffsetPosition.ToBytes(objectData, 0);
+            prim.Velocity.ToBytes(objectData, 12);
+            prim.Acceleration.ToBytes(objectData, 24);
+            prim.RotationOffset.ToBytes(objectData, 36);
+            prim.AngularVelocity.ToBytes(objectData, 48);
+
+            ObjectUpdatePacket.ObjectDataBlock update = new ObjectUpdatePacket.ObjectDataBlock();
+            update.ClickAction = (byte)prim.ClickAction;
+            update.CRC = crc;
+            update.ExtraParams = prim.Shape.ExtraParams ?? Utils.EmptyBytes;
+            update.Flags = (byte)flags;
+            update.FullID = prim.UUID;
+            update.ID = prim.LocalId;
+            //update.JointAxisOrAnchor = Vector3.Zero; // These are deprecated
+            //update.JointPivot = Vector3.Zero;
+            //update.JointType = 0;
+            update.Material = prim.Material;
+            update.MediaURL = Utils.EmptyBytes; // FIXME: Support this in OpenSim
+            if (prim.IsAttachment)
+                update.NameValue = Util.StringToBytes256("AttachItemID STRING RW SV " + assetID);
+            else
+                update.NameValue = Utils.EmptyBytes;
+            update.ObjectData = objectData;
+            update.ParentID = prim.ParentID;
+            update.PathBegin = prim.Shape.PathBegin;
+            update.PathCurve = prim.Shape.PathCurve;
+            update.PathEnd = prim.Shape.PathEnd;
+            update.PathRadiusOffset = prim.Shape.PathRadiusOffset;
+            update.PathRevolutions = prim.Shape.PathRevolutions;
+            update.PathScaleX = prim.Shape.PathScaleX;
+            update.PathScaleY = prim.Shape.PathScaleY;
+            update.PathShearX = prim.Shape.PathShearX;
+            update.PathShearY = prim.Shape.PathShearY;
+            update.PathSkew = prim.Shape.PathSkew;
+            update.PathTaperX = prim.Shape.PathTaperX;
+            update.PathTaperY = prim.Shape.PathTaperY;
+            update.PathTwist = prim.Shape.PathTwist;
+            update.PathTwistBegin = prim.Shape.PathTwistBegin;
+            update.PCode = prim.Shape.PCode;
+            update.ProfileBegin = prim.Shape.ProfileBegin;
+            update.ProfileCurve = prim.Shape.ProfileCurve;
+            update.ProfileEnd = prim.Shape.ProfileEnd;
+            update.ProfileHollow = prim.Shape.ProfileHollow;
+            update.PSBlock = prim.ParticleSystem ?? Utils.EmptyBytes;
+            update.TextColor = new Color4(prim.Color).GetBytes(true);
+            update.TextureAnim = prim.TextureAnimation ?? Utils.EmptyBytes;
+            update.TextureEntry = prim.Shape.TextureEntry ?? Utils.EmptyBytes;
+            update.Scale = prim.Scale;
+            update.State = prim.Shape.State;
+            update.Text = Util.StringToBytes256(prim.Text);
+            update.UpdateFlags = (uint)flags;
+
+            if (prim.Sound != UUID.Zero)
+            {
+                update.Sound = prim.Sound;
+                update.OwnerID = prim.OwnerID;
+                update.Gain = (float)prim.SoundGain;
+                update.Radius = (float)prim.SoundRadius;
+            }
+
+            switch ((PCode)prim.Shape.PCode)
+            {
+                case PCode.Grass:
+                case PCode.Tree:
+                case PCode.NewTree:
+                    update.Data = new byte[] { prim.Shape.State };
+                    break;
+                default:
+                    // TODO: Support ScratchPad
+                    //if (prim.ScratchPad != null)
+                    //{
+                    //    update.Data = new byte[prim.ScratchPad.Length];
+                    //    Buffer.BlockCopy(prim.ScratchPad, 0, update.Data, 0, update.Data.Length);
+                    //}
+                    //else
+                    //{
+                    //    update.Data = Utils.EmptyBytes;
+                    //}
+                    update.Data = Utils.EmptyBytes;
+                    break;
+            }
+
+            return update;
+        }*/
+
+        #endregion Prim/Avatar Updates
+
         #region Avatar Packet/data sending Methods
 
         /// <summary>
         /// send a objectupdate packet with information about the clients avatar
         /// </summary>
-        public void SendAvatarData(ulong regionHandle, string firstName, string lastName, string grouptitle, UUID avatarID,
-                                   uint avatarLocalID, Vector3 Pos, byte[] textureEntry, uint parentID, Quaternion rotation)
+        public void SendAvatarData(SendAvatarData data)
         {
             ObjectUpdatePacket objupdate = (ObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ObjectUpdate);
             // TODO: don't create new blocks if recycling an old packet
-            objupdate.RegionData.RegionHandle = regionHandle;
+            objupdate.RegionData.RegionHandle = data.regionHandle;
             objupdate.RegionData.TimeDilation = ushort.MaxValue;
             objupdate.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[1];
-            objupdate.ObjectData[0] = CreateDefaultAvatarPacket(textureEntry);
+            objupdate.ObjectData[0] = CreateDefaultAvatarPacket(data.textureEntry);
 
             //give this avatar object a local id and assign the user a name
-            objupdate.ObjectData[0].ID = avatarLocalID;
-            objupdate.ObjectData[0].FullID = avatarID;
-            objupdate.ObjectData[0].ParentID = parentID;
+            objupdate.ObjectData[0].ID = data.avatarLocalID;
+            objupdate.ObjectData[0].FullID = data.avatarID;
+            objupdate.ObjectData[0].ParentID = data.parentID;
             objupdate.ObjectData[0].NameValue =
-                Utils.StringToBytes("FirstName STRING RW SV " + firstName + "\nLastName STRING RW SV " + lastName + "\nTitle STRING RW SV " + grouptitle);
+                Utils.StringToBytes("FirstName STRING RW SV " + data.firstName + "\nLastName STRING RW SV " + data.lastName + "\nTitle STRING RW SV " + data.grouptitle);
 
-            Vector3 pos2 = new Vector3(Pos.X, Pos.Y, Pos.Z);
+            Vector3 pos2 = new Vector3(data.Pos.X, data.Pos.Y, data.Pos.Z);
             byte[] pb = pos2.GetBytes();
             Array.Copy(pb, 0, objupdate.ObjectData[0].ObjectData, 16, pb.Length);
 
-            byte[] rot = rotation.GetBytes();
+            byte[] rot = data.rotation.GetBytes();
             Array.Copy(rot, 0, objupdate.ObjectData[0].ObjectData, 52, rot.Length);
 
             objupdate.Header.Zerocoded = true;
@@ -3196,38 +3383,31 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         /// Send a terse positional/rotation/velocity update about an avatar
         /// to the client.  This avatar can be that of the client itself.
         /// </summary>
-        public virtual void SendAvatarTerseUpdate(ulong regionHandle,
-                ushort timeDilation, uint localID, Vector3 position,
-                Vector3 velocity, Quaternion rotation, UUID agentid)
+        public virtual void SendAvatarTerseUpdate(SendAvatarTerseData data)
         {
+            if (data.priority == double.NaN)
+            {
+                m_log.Error("[LLClientView] SendAvatarTerseUpdate received a NaN priority, dropping update");
+                return;
+            }
+
+            Quaternion rotation = data.rotation;
+
             if (rotation.X == rotation.Y &&
                 rotation.Y == rotation.Z &&
                 rotation.Z == rotation.W && rotation.W == 0)
                 rotation = Quaternion.Identity;
 
             ImprovedTerseObjectUpdatePacket.ObjectDataBlock terseBlock =
-                CreateAvatarImprovedBlock(localID, position, velocity,rotation);
+                CreateAvatarImprovedBlock(data.localID, data.position, data.velocity, rotation);
                 
-            lock (m_avatarTerseUpdates)
-            {
-                m_avatarTerseUpdates.Add(terseBlock);
-
-                // If packet is full or own movement packet, send it.
-                if (m_avatarTerseUpdates.Count >= m_avatarTerseUpdatesPerPacket)
-                {
-                    ProcessAvatarTerseUpdates(this, null);
-                }
-                else if (m_avatarTerseUpdates.Count == 1)
-                {
-                    lock (m_avatarTerseUpdateTimer)
-                        m_avatarTerseUpdateTimer.Start();
-                }
-            }
+            lock (m_avatarTerseUpdates.SyncRoot)
+                m_avatarTerseUpdates.Enqueue(data.priority, terseBlock, data.localID);
         }
 
-        private void ProcessAvatarTerseUpdates(object sender, ElapsedEventArgs e)
+        private void ProcessAvatarTerseUpdates()
         {
-            lock (m_avatarTerseUpdates)
+            lock (m_avatarTerseUpdates.SyncRoot)
             {
                 ImprovedTerseObjectUpdatePacket terse = (ImprovedTerseObjectUpdatePacket)PacketPool.Instance.GetPacket(PacketType.ImprovedTerseObjectUpdate);
 
@@ -3237,44 +3417,16 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 terse.RegionData.TimeDilation =
                         (ushort)(Scene.TimeDilation * ushort.MaxValue);
 
-                int max = m_avatarTerseUpdatesPerPacket;
-                if (max > m_avatarTerseUpdates.Count)
-                    max = m_avatarTerseUpdates.Count;
-
-                int count = 0;
-                int size = 0;
-
-                byte[] zerobuffer = new byte[1024];
-                byte[] blockbuffer = new byte[1024];
-
-                for (count = 0 ; count < max ; count++)
-                {
-                    int length = 0;
-                    m_avatarTerseUpdates[count].ToBytes(blockbuffer, ref length);
-                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > Packet.MTU)
-                        break;
-                    size += length;
-                }
+                int count = Math.Min(m_avatarTerseUpdates.Count, m_avatarTerseUpdatesPerPacket);
 
                 terse.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count];
-
-                for (int i = 0 ; i < count ; i++)
-                {
-                    terse.ObjectData[i] = m_avatarTerseUpdates[0];
-                    m_avatarTerseUpdates.RemoveAt(0);
-                }
+                for (int i = 0; i < count; i++)
+                    terse.ObjectData[i] = m_avatarTerseUpdates.Dequeue();
 
                 terse.Header.Reliable = false;
                 terse.Header.Zerocoded = true;
-                // FIXME: Move this to ThrottleOutPacketType.State when the real prioritization code is committed
-                OutPacket(terse, ThrottleOutPacketType.Task);
 
-                if (m_avatarTerseUpdates.Count == 0)
-                {
-                    lock (m_avatarTerseUpdateTimer)
-                        m_avatarTerseUpdateTimer.Stop();
-                }
+                OutPacket(terse, ThrottleOutPacketType.Task);
             }
         }
 
@@ -3342,54 +3494,42 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             OutPacket(attach, ThrottleOutPacketType.Task);
         }
 
-        public void SendPrimitiveToClient(
-                                          ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
-                                          Vector3 pos, Vector3 vel, Vector3 acc, Quaternion rotation, Vector3 rvel,
-                                          uint flags, UUID objectID, UUID ownerID, string text, byte[] color,
-                                          uint parentID, byte[] particleSystem, byte clickAction, byte material)
+        public void SendPrimitiveToClient(SendPrimitiveData data)
         {
-            byte[] textureanim = new byte[0];
-
-            SendPrimitiveToClient(regionHandle, timeDilation, localID, primShape, pos, vel,
-                                  acc, rotation, rvel, flags,
-                                  objectID, ownerID, text, color, parentID, particleSystem,
-                                  clickAction, material, textureanim, false, 0, UUID.Zero, UUID.Zero, 0, 0, 0);
-        }
+            if (data.priority == double.NaN)
+            {
+                m_log.Error("[LLClientView] SendPrimitiveToClient received a NaN priority, dropping update");
+                return;
+            }
 
-        public void SendPrimitiveToClient(
-            ulong regionHandle, ushort timeDilation, uint localID, PrimitiveBaseShape primShape,
-            Vector3 pos, Vector3 velocity, Vector3 acceleration, Quaternion rotation, Vector3 rotational_velocity,
-            uint flags,
-            UUID objectID, UUID ownerID, string text, byte[] color, uint parentID, byte[] particleSystem,
-            byte clickAction, byte material, byte[] textureanim, bool attachment, uint AttachPoint, UUID AssetId, UUID SoundId, double SoundGain, byte SoundFlags, double SoundRadius)
-        {
+            Quaternion rotation = data.rotation;
 
-            if (AttachPoint > 30 && ownerID != AgentId) // Someone else's HUD
+            if (data.AttachPoint > 30 && data.ownerID != AgentId) // Someone else's HUD
                 return;
-            if (primShape.PCode == 9 && primShape.State != 0 && parentID == 0)
+            if (data.primShape.PCode == 9 && data.primShape.State != 0 && data.parentID == 0)
                 return;
-
-            if (rotation.X == rotation.Y && rotation.Y == rotation.Z && rotation.Z == rotation.W && rotation.W == 0)
+            
+            if (rotation.X == rotation.Y && rotation.Y == rotation.Z && rotation.Z == rotation.W && rotation.W == 0.0f)
                 rotation = Quaternion.Identity;
 
-            ObjectUpdatePacket.ObjectDataBlock objectData = CreatePrimUpdateBlock(primShape, flags);
-
-            objectData.ID = localID;
-            objectData.FullID = objectID;
-            objectData.OwnerID = ownerID;
-
-            objectData.Text = Util.StringToBytes256(text);
-            objectData.TextColor[0] = color[0];
-            objectData.TextColor[1] = color[1];
-            objectData.TextColor[2] = color[2];
-            objectData.TextColor[3] = color[3];
-            objectData.ParentID = parentID;
-            objectData.PSBlock = particleSystem;
-            objectData.ClickAction = clickAction;
-            objectData.Material = material;
+            ObjectUpdatePacket.ObjectDataBlock objectData = CreatePrimUpdateBlock(data.primShape, data.flags);
+
+            objectData.ID = data.localID;
+            objectData.FullID = data.objectID;
+            objectData.OwnerID = data.ownerID;
+
+            objectData.Text = Util.StringToBytes256(data.text);
+            objectData.TextColor[0] = data.color[0];
+            objectData.TextColor[1] = data.color[1];
+            objectData.TextColor[2] = data.color[2];
+            objectData.TextColor[3] = data.color[3];
+            objectData.ParentID = data.parentID;
+            objectData.PSBlock = data.particleSystem;
+            objectData.ClickAction = data.clickAction;
+            objectData.Material = data.material;
             objectData.Flags = 0;
 
-            if (attachment)
+            if (data.attachment)
             {
                 // Necessary???
                 objectData.JointAxisOrAnchor = new Vector3(0, 0, 2);
@@ -3397,14 +3537,14 @@ namespace OpenSim.Region.ClientStack.LindenUDP
 
                 // Item from inventory???
                 objectData.NameValue =
-                    Utils.StringToBytes("AttachItemID STRING RW SV " + AssetId.Guid);
-                objectData.State = (byte)((AttachPoint % 16) * 16 + (AttachPoint / 16));
+                    Utils.StringToBytes("AttachItemID STRING RW SV " + data.AssetId.Guid);
+                objectData.State = (byte)((data.AttachPoint % 16) * 16 + (data.AttachPoint / 16));
             }
 
             // Xantor 20080528: Send sound info as well
             // Xantor 20080530: Zero out everything if there's no SoundId, so zerocompression will work again
-            objectData.Sound = SoundId;
-            if (SoundId == UUID.Zero)
+            objectData.Sound = data.SoundId;
+            if (data.SoundId == UUID.Zero)
             {
                 objectData.OwnerID = UUID.Zero;
                 objectData.Gain = 0.0f;
@@ -3413,48 +3553,68 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             }
             else
             {
-                objectData.OwnerID = ownerID;
-                objectData.Gain = (float)SoundGain;
-                objectData.Radius = (float)SoundRadius;
-                objectData.Flags = SoundFlags;
+                objectData.OwnerID = data.ownerID;
+                objectData.Gain = (float)data.SoundVolume;
+                objectData.Radius = (float)data.SoundRadius;
+                objectData.Flags = data.SoundFlags;
             }
 
-            byte[] pb = pos.GetBytes();
-            Array.Copy(pb, 0, objectData.ObjectData, 0, pb.Length);
+            byte[] pb = data.pos.GetBytes();
+            Buffer.BlockCopy(pb, 0, objectData.ObjectData, 0, pb.Length);
 
-            byte[] vel = velocity.GetBytes();
-            Array.Copy(vel, 0, objectData.ObjectData, pb.Length, vel.Length);
+            byte[] vel = data.vel.GetBytes();
+            Buffer.BlockCopy(vel, 0, objectData.ObjectData, pb.Length, vel.Length);
 
             byte[] rot = rotation.GetBytes();
-            Array.Copy(rot, 0, objectData.ObjectData, 36, rot.Length);
+            Buffer.BlockCopy(rot, 0, objectData.ObjectData, 36, rot.Length);
 
-            byte[] rvel = rotational_velocity.GetBytes();
-            Array.Copy(rvel, 0, objectData.ObjectData, 36 + rot.Length, rvel.Length);
+            byte[] rvel = data.rvel.GetBytes();
+            Buffer.BlockCopy(rvel, 0, objectData.ObjectData, 36 + rot.Length, rvel.Length);
 
-            if (textureanim.Length > 0)
+            if (data.textureanim.Length > 0)
             {
-                objectData.TextureAnim = textureanim;
+                objectData.TextureAnim = data.textureanim;
             }
 
-            lock (m_primFullUpdates)
-            {
-                if (m_primFullUpdates.Count == 0)
-                    m_primFullUpdateTimer.Start();
-
-                m_primFullUpdates.Add(objectData);
-
-                if (m_primFullUpdates.Count >= m_primFullUpdatesPerPacket)
-                    ProcessPrimFullUpdates(this, null);
-            }
+            lock (m_primFullUpdates.SyncRoot)
+                m_primFullUpdates.Enqueue(data.priority, objectData, data.localID);
         }
 
         void HandleQueueEmpty(ThrottleOutPacketType queue)
         {
+            int count = 0;
+
             switch (queue)
             {
                 case ThrottleOutPacketType.Texture:
                     ProcessTextureRequests();
                     break;
+                case ThrottleOutPacketType.Task:
+                    lock (m_avatarTerseUpdates.SyncRoot)
+                        count = m_avatarTerseUpdates.Count;
+                    if (count > 0)
+                    {
+                        ProcessAvatarTerseUpdates();
+                        return;
+                    }
+                    break;
+                case ThrottleOutPacketType.State:
+                    lock (m_primFullUpdates.SyncRoot)
+                        count = m_primFullUpdates.Count;
+                    if (count > 0)
+                    {
+                        ProcessPrimFullUpdates();
+                        return;
+                    }
+
+                    lock (m_primTerseUpdates.SyncRoot)
+                        count = m_primTerseUpdates.Count;
+                    if (count > 0)
+                    {
+                        ProcessPrimTerseUpdates();
+                        return;
+                    }
+                    break;
             }
         }
 
@@ -3464,18 +3624,10 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 m_imageManager.ProcessImageQueue(m_textureSendLimit);
         }
 
-        void ProcessPrimFullUpdates(object sender, ElapsedEventArgs e)
+        void ProcessPrimFullUpdates()
         {
-            lock (m_primFullUpdates)
+            lock (m_primFullUpdates.SyncRoot)
             {
-                if (m_primFullUpdates.Count == 0 && m_primFullUpdateTimer.Enabled)
-                {
-                    lock (m_primFullUpdateTimer)
-                        m_primFullUpdateTimer.Stop();
-
-                    return;
-                }
-
                 ObjectUpdatePacket outPacket =
                         (ObjectUpdatePacket)PacketPool.Instance.GetPacket(
                         PacketType.ObjectUpdate);
@@ -3485,84 +3637,50 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 outPacket.RegionData.TimeDilation =
                         (ushort)(Scene.TimeDilation * ushort.MaxValue);
 
-                int max = m_primFullUpdates.Count;
-                if (max > m_primFullUpdatesPerPacket)
-                    max = m_primFullUpdatesPerPacket;
-
-                int count = 0;
-                int size = 0;
-
-                byte[] zerobuffer = new byte[1024];
-                byte[] blockbuffer = new byte[1024];
+                int count = Math.Min(m_primFullUpdates.Count, m_primFullUpdatesPerPacket);
 
-                for (count = 0 ; count < max ; count++)
-                {
-                    int length = 0;
-                    m_primFullUpdates[count].ToBytes(blockbuffer, ref length);
-                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > Packet.MTU)
-                        break;
-                    size += length;
-                }
-
-                outPacket.ObjectData =
-                        new ObjectUpdatePacket.ObjectDataBlock[count];
-
-                for (int index = 0 ; index < count ; index++)
-                {
-                    outPacket.ObjectData[index] = m_primFullUpdates[0];
-                    m_primFullUpdates.RemoveAt(0);
-                }
+                outPacket.ObjectData = new ObjectUpdatePacket.ObjectDataBlock[count];
+                for (int i = 0; i < count; i++)
+                    outPacket.ObjectData[i] = m_primFullUpdates.Dequeue();
 
                 outPacket.Header.Zerocoded = true;
                 OutPacket(outPacket, ThrottleOutPacketType.State);
-
-                if (m_primFullUpdates.Count == 0 && m_primFullUpdateTimer.Enabled)
-                    lock (m_primFullUpdateTimer)
-                        m_primFullUpdateTimer.Stop();
             }
         }
 
         /// <summary>
         ///
         /// </summary>
-        public void SendPrimTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position,
-                                        Quaternion rotation, Vector3 velocity, Vector3 rotationalvelocity, byte state, UUID AssetId, UUID ownerID, int attachPoint)
+        //public void SendPrimTerseUpdate(ulong regionHandle, ushort timeDilation, uint localID, Vector3 position,
+        //                                Quaternion rotation, Vector3 velocity, Vector3 rotationalvelocity, byte state, UUID AssetId, UUID ownerID, int attachPoint)
+        public void SendPrimTerseUpdate(SendPrimitiveTerseData data)
         {
-            if (attachPoint > 30 && ownerID != AgentId) // Someone else's HUD
+            if (data.priority == double.NaN)
+            {
+                m_log.Error("[LLClientView] SendPrimTerseUpdate received a NaN priority, dropping update");
+                return;
+            }
+
+            Quaternion rotation = data.rotation;
+
+            if (data.attachPoint > 30 && data.owner != AgentId) // Someone else's HUD
                 return;
 
             if (rotation.X == rotation.Y && rotation.Y == rotation.Z && rotation.Z == rotation.W && rotation.W == 0)
                 rotation = Quaternion.Identity;
 
             ImprovedTerseObjectUpdatePacket.ObjectDataBlock objectData =
-                    CreatePrimImprovedBlock(localID, position, rotation,
-                    velocity, rotationalvelocity, state);
-
-            lock (m_primTerseUpdates)
-            {
-                if (m_primTerseUpdates.Count == 0)
-                    m_primTerseUpdateTimer.Start();
-
-                m_primTerseUpdates.Add(objectData);
+                    CreatePrimImprovedBlock(data.localID, data.position, rotation,
+                    data.velocity, data.rotationalvelocity, data.state);
 
-                if (m_primTerseUpdates.Count >= m_primTerseUpdatesPerPacket)
-                    ProcessPrimTerseUpdates(this, null);
-            }
+            lock (m_primTerseUpdates.SyncRoot)
+                m_primTerseUpdates.Enqueue(data.priority, objectData, data.localID);
         }
 
-        void ProcessPrimTerseUpdates(object sender, ElapsedEventArgs e)
+        void ProcessPrimTerseUpdates()
         {
-            lock (m_primTerseUpdates)
+            lock (m_primTerseUpdates.SyncRoot)
             {
-                if (m_primTerseUpdates.Count == 0)
-                {
-                    lock (m_primTerseUpdateTimer)
-                        m_primTerseUpdateTimer.Stop();
-
-                    return;
-                }
-
                 ImprovedTerseObjectUpdatePacket outPacket =
                         (ImprovedTerseObjectUpdatePacket)
                         PacketPool.Instance.GetPacket(
@@ -3573,43 +3691,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 outPacket.RegionData.TimeDilation =
                         (ushort)(Scene.TimeDilation * ushort.MaxValue);
 
-                int max = m_primTerseUpdates.Count;
-                if (max > m_primTerseUpdatesPerPacket)
-                    max = m_primTerseUpdatesPerPacket;
-
-                int count = 0;
-                int size = 0;
+                int count = Math.Min(m_primTerseUpdates.Count, m_primTerseUpdatesPerPacket);
 
-                byte[] zerobuffer = new byte[1024];
-                byte[] blockbuffer = new byte[1024];
-
-                for (count = 0 ; count < max ; count++)
-                {
-                    int length = 0;
-                    m_primTerseUpdates[count].ToBytes(blockbuffer, ref length);
-                    length = Helpers.ZeroEncode(blockbuffer, length, zerobuffer);
-                    if (size + length > Packet.MTU)
-                        break;
-                    size += length;
-                }
-
-                outPacket.ObjectData =
-                        new ImprovedTerseObjectUpdatePacket.
-                        ObjectDataBlock[count];
-
-                for (int index = 0 ; index < count ; index++)
-                {
-                    outPacket.ObjectData[index] = m_primTerseUpdates[0];
-                    m_primTerseUpdates.RemoveAt(0);
-                }
+                outPacket.ObjectData = new ImprovedTerseObjectUpdatePacket.ObjectDataBlock[count];
+                for (int i = 0; i < count; i++)
+                    outPacket.ObjectData[i] = m_primTerseUpdates.Dequeue();
 
                 outPacket.Header.Reliable = false;
                 outPacket.Header.Zerocoded = true;
                 OutPacket(outPacket, ThrottleOutPacketType.State);
-
-                if (m_primTerseUpdates.Count == 0)
-                    lock (m_primTerseUpdateTimer)
-                        m_primTerseUpdateTimer.Stop();
             }
         }
 
@@ -3617,15 +3707,15 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             while (m_primFullUpdates.Count > 0)
             {
-                ProcessPrimFullUpdates(this, null);
+                ProcessPrimFullUpdates();
             }
             while (m_primTerseUpdates.Count > 0)
             {
-                ProcessPrimTerseUpdates(this, null);
+                ProcessPrimTerseUpdates();
             }
             while (m_avatarTerseUpdates.Count > 0)
             {
-                ProcessAvatarTerseUpdates(this, null);
+                ProcessAvatarTerseUpdates();
             }
         }
 
@@ -10371,5 +10461,136 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             pack.TextureData.TextureID = textureID;
             OutPacket(pack, ThrottleOutPacketType.Task);
         }
+
+        #region PriorityQueue
+        private class PriorityQueue<TPriority, TValue>
+        {
+            private MinHeap<MinHeapItem>[] heaps = new MinHeap<MinHeapItem>[1];
+            private Dictionary<uint, LookupItem> lookup_table = new Dictionary<uint, LookupItem>();
+            private Comparison<TPriority> comparison;
+            private object sync_root = new object();
+
+            internal PriorityQueue() :
+                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, Comparer<TPriority>.Default) { }
+            internal PriorityQueue(int capacity) :
+                this(capacity, Comparer<TPriority>.Default) { }
+            internal PriorityQueue(IComparer<TPriority> comparer) :
+                this(new Comparison<TPriority>(comparer.Compare)) { }
+            internal PriorityQueue(Comparison<TPriority> comparison) :
+                this(MinHeap<MinHeapItem>.DEFAULT_CAPACITY, comparison) { }
+            internal PriorityQueue(int capacity, IComparer<TPriority> comparer) :
+                this(capacity, new Comparison<TPriority>(comparer.Compare)) { }
+            internal PriorityQueue(int capacity, Comparison<TPriority> comparison)
+            {
+                for (int i = 0; i < heaps.Length; ++i)
+                    heaps[i] = new MinHeap<MinHeapItem>(capacity);
+                this.comparison = comparison;
+            }
+
+            internal object SyncRoot { get { return this.sync_root; } }
+            internal int Count
+            {
+                get
+                {
+                    int count = 0;
+                    for (int i = 0; i < heaps.Length; ++i)
+                        count = heaps[i].Count;
+                    return count;
+                }
+            }
+
+            internal bool Enqueue(TPriority priority, TValue value, uint local_id)
+            {
+                LookupItem item;
+
+                if (lookup_table.TryGetValue(local_id, out item))
+                {
+                    item.Heap[item.Handle] = new MinHeapItem(priority, value, local_id, this.comparison);
+                    return false;
+                }
+                else
+                {
+                    item.Heap = heaps[0];
+                    item.Heap.Add(new MinHeapItem(priority, value, local_id, this.comparison), ref item.Handle);
+                    lookup_table.Add(local_id, item);
+                    return true;
+                }
+            }
+
+            internal TValue Peek()
+            {
+                for (int i = 0; i < heaps.Length; ++i)
+                    if (heaps[i].Count > 0)
+                        return heaps[i].Min().Value;
+                throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString()));
+            }
+
+            internal TValue Dequeue()
+            {
+                for (int i = 0; i < heaps.Length; ++i)
+                {
+                    if (heaps[i].Count > 0)
+                    {
+                        MinHeapItem item = heaps[i].RemoveMin();
+                        lookup_table.Remove(item.LocalID);
+                        return item.Value;
+                    }
+                }
+                throw new InvalidOperationException(string.Format("The {0} is empty", this.GetType().ToString()));
+            }
+
+            #region MinHeapItem
+            private struct MinHeapItem : IComparable<MinHeapItem>
+            {
+                private TPriority priority;
+                private TValue value;
+                private uint local_id;
+                private Comparison<TPriority> comparison;
+
+                internal MinHeapItem(TPriority priority, TValue value, uint local_id) :
+                    this(priority, value, local_id, Comparer<TPriority>.Default) { }
+                internal MinHeapItem(TPriority priority, TValue value, uint local_id, IComparer<TPriority> comparer) :
+                    this(priority, value, local_id, new Comparison<TPriority>(comparer.Compare)) { }
+                internal MinHeapItem(TPriority priority, TValue value, uint local_id, Comparison<TPriority> comparison)
+                {
+                    this.priority = priority;
+                    this.value = value;
+                    this.local_id = local_id;
+                    this.comparison = comparison;
+                }
+
+                internal TPriority Priority { get { return this.priority; } }
+                internal TValue Value { get { return this.value; } }
+                internal uint LocalID { get { return this.local_id; } }
+
+                public override string ToString()
+                {
+                    StringBuilder sb = new StringBuilder();
+                    sb.Append("[");
+                    if (this.priority != null)
+                        sb.Append(this.priority.ToString());
+                    sb.Append(",");
+                    if (this.value != null)
+                        sb.Append(this.value.ToString());
+                    sb.Append("]");
+                    return sb.ToString();
+                }
+
+                public int CompareTo(MinHeapItem other)
+                {
+                    return this.comparison(this.priority, other.priority);
+                }
+            }
+            #endregion
+
+            #region LookupItem
+            private struct LookupItem {
+                internal MinHeap<MinHeapItem> Heap;
+                internal IHandle Handle;
+            }
+            #endregion
+        }
+        #endregion
+
     }
 }
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
index 4eee6b6..9476eed 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPClient.cs
@@ -170,7 +170,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             {
                 ThrottleOutPacketType type = (ThrottleOutPacketType)i;
 
+                // Initialize the packet outboxes, where packets sit while they are waiting for tokens
                 m_packetOutboxes[i] = new OpenSim.Framework.LocklessQueue<OutgoingPacket>();
+                // Initialize the token buckets that control the throttling for each category
                 m_throttleCategories[i] = new TokenBucket(m_throttle, rates.GetLimit(type), rates.GetRate(type));
             }
 
@@ -293,36 +295,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             int state = (int)((float)task * STATE_TASK_PERCENTAGE);
             task -= state;
 
-            int ceiling = Int32.MaxValue;
-            if (m_defaultThrottleRates.Total != 0)
-            {
-                ceiling = m_defaultThrottleRates.Total;
-                if (ceiling < Packet.MTU) ceiling = Packet.MTU;
-            }
-
-            resend = Utils.Clamp(resend, Packet.MTU, ceiling);
-            land = Utils.Clamp(land, Packet.MTU, ceiling);
-            wind = Utils.Clamp(wind, Packet.MTU, ceiling);
-            cloud = Utils.Clamp(cloud, Packet.MTU, ceiling);
-            task = Utils.Clamp(task, Packet.MTU, ceiling);
-            texture = Utils.Clamp(texture, Packet.MTU, ceiling);
-            asset = Utils.Clamp(asset, Packet.MTU, ceiling);
-            state = Utils.Clamp(state, Packet.MTU, ceiling);
+            // Make sure none of the throttles are set below our packet MTU,
+            // otherwise a throttle could become permanently clogged
+            resend = Math.Max(resend, LLUDPServer.MTU);
+            land = Math.Max(land, LLUDPServer.MTU);
+            wind = Math.Max(wind, LLUDPServer.MTU);
+            cloud = Math.Max(cloud, LLUDPServer.MTU);
+            task = Math.Max(task, LLUDPServer.MTU);
+            texture = Math.Max(texture, LLUDPServer.MTU);
+            asset = Math.Max(asset, LLUDPServer.MTU);
+            state = Math.Max(state, LLUDPServer.MTU);
 
             int total = resend + land + wind + cloud + task + texture + asset + state;
-            int taskTotal = task + state;
 
             m_log.DebugFormat("[LLUDPCLIENT]: {0} is setting throttles. Resend={1}, Land={2}, Wind={3}, Cloud={4}, Task={5}, Texture={6}, Asset={7}, State={8}, Total={9}",
                 AgentID, resend, land, wind, cloud, task, texture, asset, state, total);
 
-            SetThrottle(ThrottleOutPacketType.Resend, resend, resend);
-            SetThrottle(ThrottleOutPacketType.Land, land, land);
-            SetThrottle(ThrottleOutPacketType.Wind, wind, wind);
-            SetThrottle(ThrottleOutPacketType.Cloud, cloud, cloud);
-            SetThrottle(ThrottleOutPacketType.Task, task, taskTotal);
-            SetThrottle(ThrottleOutPacketType.Texture, texture, texture);
-            SetThrottle(ThrottleOutPacketType.Asset, asset, asset);
-            SetThrottle(ThrottleOutPacketType.State, state, taskTotal);
+            // Update the token buckets with new throttle values
+            TokenBucket bucket;
+
+            bucket = m_throttle;
+            bucket.MaxBurst = total;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Resend];
+            bucket.DripRate = bucket.MaxBurst = resend;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Land];
+            bucket.DripRate = bucket.MaxBurst = land;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Wind];
+            bucket.DripRate = bucket.MaxBurst = wind;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Cloud];
+            bucket.DripRate = bucket.MaxBurst = cloud;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Asset];
+            bucket.DripRate = bucket.MaxBurst = asset;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Task];
+            bucket.DripRate = task + state + texture;
+            bucket.MaxBurst = task + state + texture;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.State];
+            bucket.DripRate = state + texture;
+            bucket.MaxBurst = state + texture;
+
+            bucket = m_throttleCategories[(int)ThrottleOutPacketType.Texture];
+            bucket.DripRate = texture;
+            bucket.MaxBurst = texture;
         }
 
         public byte[] GetThrottlesPacked()
@@ -342,17 +362,6 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             return data;
         }
 
-        public void SetThrottle(ThrottleOutPacketType category, int rate, int maxBurst)
-        {
-            int i = (int)category;
-            if (i >= 0 && i < m_throttleCategories.Length)
-            {
-                TokenBucket bucket = m_throttleCategories[(int)category];
-                bucket.DripRate = rate;
-                bucket.MaxBurst = maxBurst;
-            }
-        }
-
         public bool EnqueueOutgoing(OutgoingPacket packet)
         {
             int category = (int)packet.Category;
@@ -395,9 +404,12 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             TokenBucket bucket;
             bool packetSent = false;
 
+            //string queueDebugOutput = String.Empty; // Serious debug business
+
             for (int i = 0; i < THROTTLE_CATEGORY_COUNT; i++)
             {
                 bucket = m_throttleCategories[i];
+                //queueDebugOutput += m_packetOutboxes[i].Count + " ";  // Serious debug business
 
                 if (m_nextPackets[i] != null)
                 {
@@ -449,6 +461,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
                 }
             }
 
+            //m_log.Info("[LLUDPCLIENT]: Queues: " + queueDebugOutput); // Serious debug business
             return packetSent;
         }
 
diff --git a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
index 545a0bc..8bfab6a 100644
--- a/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
+++ b/OpenSim/Region/ClientStack/LindenUDP/LLUDPServer.cs
@@ -89,6 +89,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
     /// </summary>
     public class LLUDPServer : OpenSimUDPBase
     {
+        /// <summary>Maximum transmission unit, or UDP packet size, for the LLUDP protocol</summary>
+        public const int MTU = 1400;
+
         private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>Handlers for incoming packets</summary>
@@ -267,38 +270,54 @@ namespace OpenSim.Region.ClientStack.LindenUDP
         {
             int dataLength = data.Length;
             bool doZerocode = (data[0] & Helpers.MSG_ZEROCODED) != 0;
+            bool doCopy = true;
 
             // Frequency analysis of outgoing packet sizes shows a large clump of packets at each end of the spectrum.
             // The vast majority of packets are less than 200 bytes, although due to asset transfers and packet splitting
             // there are a decent number of packets in the 1000-1140 byte range. We allocate one of two sizes of data here
             // to accomodate for both common scenarios and provide ample room for ACK appending in both
-            int bufferSize = (dataLength > 180) ? Packet.MTU : 200;
+            int bufferSize = (dataLength > 180) ? LLUDPServer.MTU : 200;
 
             UDPPacketBuffer buffer = new UDPPacketBuffer(udpClient.RemoteEndPoint, bufferSize);
 
             // Zerocode if needed
             if (doZerocode)
             {
-                try { dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data); }
+                try
+                {
+                    dataLength = Helpers.ZeroEncode(data, dataLength, buffer.Data);
+                    doCopy = false;
+                }
                 catch (IndexOutOfRangeException)
                 {
                     // The packet grew larger than the bufferSize while zerocoding.
                     // Remove the MSG_ZEROCODED flag and send the unencoded data
                     // instead
-                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". Removing MSG_ZEROCODED flag");
+                    m_log.Debug("[LLUDPSERVER]: Packet exceeded buffer size during zerocoding for " + type + ". DataLength=" + dataLength +
+                        " and BufferLength=" + buffer.Data.Length + ". Removing MSG_ZEROCODED flag");
                     data[0] = (byte)(data[0] & ~Helpers.MSG_ZEROCODED);
-                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
                 }
             }
-            else
+
+            // If the packet data wasn't already copied during zerocoding, copy it now
+            if (doCopy)
             {
-                Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                if (dataLength <= buffer.Data.Length)
+                {
+                    Buffer.BlockCopy(data, 0, buffer.Data, 0, dataLength);
+                }
+                else
+                {
+                    m_log.Error("[LLUDPSERVER]: Packet exceeded buffer size! This could be an indication of packet assembly not obeying the MTU. Type=" +
+                        type + ", DataLength=" + dataLength + ", BufferLength=" + buffer.Data.Length + ". Dropping packet");
+                    return;
+                }
             }
+
             buffer.DataLength = dataLength;
 
             #region Queue or Send
 
-            // Look up the UDPClient this is going to
             OutgoingPacket outgoingPacket = new OutgoingPacket(udpClient, buffer, category);
 
             if (!outgoingPacket.Client.EnqueueOutgoing(outgoingPacket))
@@ -513,7 +532,7 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             IClientAPI client;
             if (!m_scene.ClientManager.TryGetValue(address, out client) || !(client is LLClientView))
             {
-                m_log.Warn("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address +
+                m_log.Debug("[LLUDPSERVER]: Received a " + packet.Type + " packet from an unrecognized source: " + address +
                     " in " + m_scene.RegionInfo.RegionName + ", currently tracking " + m_scene.ClientManager.Count + " clients");
                 return;
             }
@@ -568,9 +587,9 @@ namespace OpenSim.Region.ClientStack.LindenUDP
             // client.BytesSinceLastACK. Lockless thread safety
             int bytesSinceLastACK = Interlocked.Exchange(ref udpClient.BytesSinceLastACK, 0);
             bytesSinceLastACK += buffer.DataLength;
-            if (bytesSinceLastACK > Packet.MTU * 2)
+            if (bytesSinceLastACK > LLUDPServer.MTU * 2)
             {
-                bytesSinceLastACK -= Packet.MTU * 2;
+                bytesSinceLastACK -= LLUDPServer.MTU * 2;
                 SendAcks(udpClient);
             }
             Interlocked.Add(ref udpClient.BytesSinceLastACK, bytesSinceLastACK);