Revert progressive texture patch from r8001 until issues can be addressed

5 files changed, 155 insertions, 268 deletions

diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureDownloadModule.cs b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureDownloadModule.cs
index 2f5ea23..6bb61e2 100644
--- a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureDownloadModule.cs
+++ b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureDownloadModule.cs
@@ -204,14 +204,14 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
         /// <param name="e"></param>
         public void TextureRequest(Object sender, TextureRequestArgs e)
         {
-            IClientAPI client = (IClientAPI) sender;
+            IClientAPI client = (IClientAPI)sender;
 
             if (e.Priority == 1016001f) // Preview
             {
                 if (client.Scene is Scene)
                 {
                     Scene scene = (Scene)client.Scene;
-                    
+
                     CachedUserInfo profile = scene.CommsManager.UserProfileCacheService.GetUserDetails(client.AgentId);
                     if (profile == null) // Deny unknown user
                         return;
@@ -241,52 +241,44 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
         {
             ITextureSender sender = null;
 
-//            try
-//            {
+            try
+            {
                 while (true)
                 {
-                    try
+                    sender = m_queueSenders.Dequeue();
+
+                    if (sender.Cancel)
                     {
-                        sender = m_queueSenders.Dequeue();
+                        TextureSent(sender);
 
-                        if (sender.Cancel)
+                        sender.Cancel = false;
+                    }
+                    else
+                    {
+                        bool finished = sender.SendTexturePacket();
+                        if (finished)
                         {
                             TextureSent(sender);
-
-                            sender.Cancel = false;
                         }
                         else
                         {
-                            bool finished = sender.SendTexturePacket();
-                            if (finished)
-                            {
-                                TextureSent(sender);
-                            }
-                            else
-                            {
-                                m_queueSenders.Enqueue(sender);
-                            }
+                            m_queueSenders.Enqueue(sender);
                         }
+                    }
 
-                        // Make sure that any sender we currently have can get garbage collected
-                        sender = null;
+                    // Make sure that any sender we currently have can get garbage collected
+                    sender = null;
 
-                        //m_log.InfoFormat("[TEXTURE] Texture sender queue size: {0}", m_queueSenders.Count());
-                    }
-                    catch(Exception e)
-                    {
-                        m_log.ErrorFormat(
-                            "[TEXTURE]: Texture send thread caught exception. The texture send was aborted. Exception is {0}", e);
-                    }
+                    //m_log.InfoFormat("[TEXTURE] Texture sender queue size: {0}", m_queueSenders.Count());
                 }
-//            }
-//            catch (Exception e)
-//            {
-//                // TODO: Let users in the sim and those entering it and possibly an external watchdog know what has happened
-//                m_log.ErrorFormat(
-//                    "[TEXTURE]: Texture send thread terminating with exception.  PLEASE REBOOT YOUR SIM - TEXTURES WILL NOT BE AVAILABLE UNTIL YOU DO.  Exception is {0}", 
-//                    e);                
-//            }            
+            }
+            catch (Exception e)
+            {
+                // TODO: Let users in the sim and those entering it and possibly an external watchdog know what has happened
+                m_log.ErrorFormat(
+                    "[TEXTURE]: Texture send thread terminating with exception.  PLEASE REBOOT YOUR SIM - TEXTURES WILL NOT BE AVAILABLE UNTIL YOU DO.  Exception is {0}",
+                    e);
+            }
         }
 
         /// <summary>
diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureNotFoundSender.cs b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureNotFoundSender.cs
index 044ee76..34ddee6 100644
--- a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureNotFoundSender.cs
+++ b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/TextureNotFoundSender.cs
@@ -28,6 +28,7 @@
 using System.Reflection;
 using log4net;
 using OpenMetaverse;
+using OpenMetaverse.Packets;
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Interfaces;
 
@@ -38,11 +39,11 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
     /// </summary>
     public class TextureNotFoundSender : ITextureSender
     {
-//        private static readonly log4net.ILog m_log
-//            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
+        //        private static readonly log4net.ILog m_log
+        //            = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
 
-//        private IClientAPI m_client;
-//        private UUID m_textureId;
+        //        private IClientAPI m_client;
+        //        private UUID m_textureId;
 
         public TextureNotFoundSender(IClientAPI client, UUID textureID)
         {
@@ -55,13 +56,13 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
         public bool Sending
         {
             get { return false; }
-            set {}
+            set { }
         }
 
         public bool Cancel
         {
             get { return false; }
-            set {}
+            set { }
         }
 
         // See ITextureSender
@@ -73,13 +74,13 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
         // See ITextureSender
         public bool SendTexturePacket()
         {
-//            m_log.DebugFormat(
-//                "[TEXTURE NOT FOUND SENDER]: Informing the client that texture {0} cannot be found",
-//                m_textureId);
+            //            m_log.DebugFormat(
+            //                "[TEXTURE NOT FOUND SENDER]: Informing the client that texture {0} cannot be found",
+            //                m_textureId);
 
             // XXX Temporarily disabling as this appears to be causing client crashes on at least
             // 1.19.0(5) of the Linden Second Life client.
-//            m_client.SendImageNotFound(m_textureId);
+            //            m_client.SendImageNotFound(m_textureId);
 
             return true;
         }
diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/UserTextureDownloadService.cs b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/UserTextureDownloadService.cs
index aab4ad0..e0790a2 100644
--- a/OpenSim/Region/Environment/Modules/Agent/TextureDownload/UserTextureDownloadService.cs
+++ b/OpenSim/Region/Environment/Modules/Agent/TextureDownload/UserTextureDownloadService.cs
@@ -56,10 +56,11 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
         /// <summary>
         /// We will allow the client to request the same texture n times before dropping further requests
         ///
-        /// This number contains repeated requests for the same texture at different resolutions (which
-        /// are handled since r7368).  However, this situation should be handled in a more sophisticated way.
+        /// This number includes repeated requests for the same texture at different resolutions (which we don't
+        /// currently handle properly as far as I know).  However, this situation should be handled in a more
+        /// sophisticated way.
         /// </summary>
-        private static readonly int MAX_ALLOWED_TEXTURE_REQUESTS = 15;
+        private static readonly int MAX_ALLOWED_TEXTURE_REQUESTS = 5;
 
         /// <summary>
         /// XXX Also going to limit requests for found textures.
@@ -119,13 +120,13 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
                     }
                     else
                     {
-//                        m_log.DebugFormat("[TEXTURE]: Received a request for texture {0}", e.RequestedAssetID);
-                        
+                        //                        m_log.DebugFormat("[TEXTURE]: Received a request for texture {0}", e.RequestedAssetID);
+
                         if (!foundTextureLimitStrategy.AllowRequest(e.RequestedAssetID))
                         {
-//                            m_log.DebugFormat(
-//                                "[TEXTURE]: Refusing request for {0} from client {1}",
-//                                e.RequestedAssetID, m_client.AgentId);
+                            //                            m_log.DebugFormat(
+                            //                                "[TEXTURE]: Refusing request for {0} from client {1}",
+                            //                                e.RequestedAssetID, m_client.AgentId);
 
                             return;
                         }
@@ -138,9 +139,9 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
 
                                 // Commenting out this message for now as it causes too much noise with other
                                 // debug messages.
-//                                m_log.DebugFormat(
-//                                    "[TEXTURE]: Dropping requests for notified missing texture {0} for client {1} since we have received more than {2} requests",
-//                                    e.RequestedAssetID, m_client.AgentId, MAX_ALLOWED_TEXTURE_REQUESTS);
+                                //                                m_log.DebugFormat(
+                                //                                    "[TEXTURE]: Dropping requests for notified missing texture {0} for client {1} since we have received more than {2} requests",
+                                //                                    e.RequestedAssetID, m_client.AgentId, MAX_ALLOWED_TEXTURE_REQUESTS);
                             }
 
                             return;
@@ -148,7 +149,7 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
 
                         m_scene.AddPendingDownloads(1);
 
-                        TextureSender.TextureSender requestHandler = new TextureSender.TextureSender(m_client, e.DiscardLevel, e.PacketNumber, e.Priority);
+                        TextureSender.TextureSender requestHandler = new TextureSender.TextureSender(m_client, e.DiscardLevel, e.PacketNumber);
                         m_textureSenders.Add(e.RequestedAssetID, requestHandler);
 
                         m_scene.AssetCache.GetAsset(e.RequestedAssetID, TextureCallback, true);
@@ -195,9 +196,9 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureDownload
                         {
                             missingTextureLimitStrategy.MonitorRequests(textureID);
 
-//                            m_log.DebugFormat(
-//                                "[TEXTURE]: Queueing first TextureNotFoundSender for {0}, client {1}",
-//                                textureID, m_client.AgentId);
+                            //                            m_log.DebugFormat(
+                            //                                "[TEXTURE]: Queueing first TextureNotFoundSender for {0}, client {1}",
+                            //                                textureID, m_client.AgentId);
                         }
 
                         ITextureSender textureNotFoundSender = new TextureNotFoundSender(m_client, textureID);
diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureSender/Tests/TextureSenderTests.cs b/OpenSim/Region/Environment/Modules/Agent/TextureSender/Tests/TextureSenderTests.cs
index cff215b..4049dfc 100644
--- a/OpenSim/Region/Environment/Modules/Agent/TextureSender/Tests/TextureSenderTests.cs
+++ b/OpenSim/Region/Environment/Modules/Agent/TextureSender/Tests/TextureSenderTests.cs
@@ -53,7 +53,7 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureSender
             agent.startpos = Vector3.Zero;
             agent.CapsPath = "http://wibble.com";
             
-            new TextureSender(new TestClient(agent), 0, 0, 1.0f);
+            new TextureSender(new TestClient(agent), 0, 0);
         }
     }
 }
\ No newline at end of file
diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs b/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs
index 0e34271..a6901b6 100644
--- a/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs
+++ b/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs
@@ -27,188 +27,106 @@
 
 using System;
 using System.Reflection;
+using OpenMetaverse.Packets;
 using log4net;
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Interfaces;
 
 namespace OpenSim.Region.Environment.Modules.Agent.TextureSender
 {
-    public class ImageDownload
+    /// <summary>
+    /// A TextureSender handles the process of receiving a texture requested by the client from the
+    /// AssetCache, and then sending that texture back to the client.
+    /// </summary>
+    public class TextureSender : ITextureSender
     {
-        public const int FIRST_IMAGE_PACKET_SIZE = 600;
-        public const int IMAGE_PACKET_SIZE = 1000;
-
-        public OpenMetaverse.AssetTexture Texture;
-        public int DiscardLevel;
-        public float Priority;
-        public int CurrentPacket;
-        public int StopPacket;
-
-        public ImageDownload(OpenMetaverse.AssetTexture texture, int discardLevel, float priority, int packet)
-        {
-            Texture = texture;
-            Update(discardLevel, priority, packet);
-        }
-
-        /// <summary>
-        /// Updates an image transfer with new information and recalculates
-        /// offsets
-        /// </summary>
-        /// <param name="discardLevel">New requested discard level</param>
-        /// <param name="priority">New requested priority</param>
-        /// <param name="packet">New requested packet offset</param>
-        public void Update(int discardLevel, float priority, int packet)
-        {
-            Priority = priority;
-            DiscardLevel = Clamp(discardLevel, 0, Texture.LayerInfo.Length - 1);
-            StopPacket = GetPacketForBytePosition(Texture.LayerInfo[(Texture.LayerInfo.Length - 1) - DiscardLevel].End);
-            CurrentPacket = Clamp(packet, 1, TexturePacketCount());
-        }
+        private static readonly ILog m_log
+            = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
 
         /// <summary>
-        /// Returns the total number of packets needed to transfer this texture,
-        /// including the first packet of size FIRST_IMAGE_PACKET_SIZE
+        /// Records the number of times texture send has been called.
         /// </summary>
-        /// <returns>Total number of packets needed to transfer this texture</returns>
-        public int TexturePacketCount()
-        {
-            return ((Texture.AssetData.Length - FIRST_IMAGE_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE) + 1;
-        }
+        public int counter = 0;
 
-        /// <summary>
-        /// Returns the current byte offset for this transfer, calculated from
-        /// the CurrentPacket
-        /// </summary>
-        /// <returns>Current byte offset for this transfer</returns>
-        public int CurrentBytePosition()
-        {
-            return FIRST_IMAGE_PACKET_SIZE + (CurrentPacket - 1) * IMAGE_PACKET_SIZE;
-        }
-
-        /// <summary>
-        /// Returns the size, in bytes, of the last packet. This will be somewhere
-        /// between 1 and IMAGE_PACKET_SIZE bytes
-        /// </summary>
-        /// <returns>Size of the last packet in the transfer</returns>
-        public int LastPacketSize()
-        {
-            return Texture.AssetData.Length - (FIRST_IMAGE_PACKET_SIZE + ((TexturePacketCount() - 2) * IMAGE_PACKET_SIZE));
-        }
+        public bool ImageLoaded = false;
 
         /// <summary>
-        /// Find the packet number that contains a given byte position
+        /// Holds the texture asset to send.
         /// </summary>
-        /// <param name="bytePosition">Byte position</param>
-        /// <returns>Packet number that contains the given byte position</returns>
-        int GetPacketForBytePosition(int bytePosition)
-        {
-            return ((bytePosition - FIRST_IMAGE_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE);
-        }
+        private AssetBase m_asset;
 
-        /// <summary>
-        /// Clamp a given value between a range
-        /// </summary>
-        /// <param name="value">Value to clamp</param>
-        /// <param name="min">Minimum allowable value</param>
-        /// <param name="max">Maximum allowable value</param>
-        /// <returns>A value inclusively between lower and upper</returns>
-        static int Clamp(int value, int min, int max)
-        {
-            // First we check to see if we're greater than the max
-            value = (value > max) ? max : value;
+        //public UUID assetID { get { return m_asset.FullID; } }
 
-            // Then we check to see if we're less than the min.
-            value = (value < min) ? min : value;
+        // private bool m_cancel = false;
 
-            // There's no check to see if min > max.
-            return value;
-        }
-    }
+        // See ITextureSender
 
-    /// <summary>
-    /// A TextureSender handles the process of receiving a texture requested by the client from the
-    /// AssetCache, and then sending that texture back to the client.
-    /// </summary>
-    public class TextureSender : ITextureSender
-    {
-        private static readonly ILog m_log
-            = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType);
+        // private bool m_sending = false;
 
-        public bool ImageLoaded = false;
+        /// <summary>
+        /// This is actually the number of extra packets required to send the texture data!  We always assume
+        /// at least one is required.
+        /// </summary>
+        private int NumPackets = 0;
 
         /// <summary>
-        /// Holds the texture asset to send.
+        /// Holds the packet number to send next.  In this case, each packet is 1000 bytes long and starts
+        /// at the 600th byte (0th indexed).
         /// </summary>
-        private AssetBase m_asset;
-        private bool m_cancel = false;
-        private bool m_sending = false;
-        private bool sendFirstPacket = false;
-        private int initialDiscardLevel = 0;
-        private int initialPacketNum = 0;
-        private float initialPriority = 0.0f;
+        private int PacketCounter = 0;
 
-        private ImageDownload download;
+        private int RequestedDiscardLevel = -1;
         private IClientAPI RequestUser;
+        private uint StartPacketNumber = 0;
 
-        public TextureSender(IClientAPI client, int discardLevel, uint packetNumber, float priority)
+        public TextureSender(IClientAPI client, int discardLevel, uint packetNumber)
         {
             RequestUser = client;
-            initialDiscardLevel = discardLevel;
-            initialPacketNum = (int)packetNumber;
-            initialPriority = priority;
+            RequestedDiscardLevel = discardLevel;
+            StartPacketNumber = packetNumber;
         }
 
         #region ITextureSender Members
 
         public bool Cancel
         {
-            get { return m_cancel; }
-            set { m_cancel = value; }
+            get { return false; }
+            set
+            {
+                // m_cancel = value; 
+            }
         }
 
         public bool Sending
         {
-            get { return m_sending; }
-            set { m_sending = value; }
+            get { return false; }
+            set
+            {
+                // m_sending = value; 
+            }
         }
 
         // See ITextureSender
         public void UpdateRequest(int discardLevel, uint packetNumber)
         {
-            if (download == null)
-                return;
-
-            lock (download)
-            {
-                if (discardLevel < download.DiscardLevel)
-                    m_log.DebugFormat("Image download {0} is changing from DiscardLevel {1} to {2}",
-                        m_asset.FullID, download.DiscardLevel, discardLevel);
-
-                if (packetNumber != download.CurrentPacket)
-                    m_log.DebugFormat("Image download {0} is changing from Packet {1} to {2}",
-                        m_asset.FullID, download.CurrentPacket, packetNumber);
-
-                download.Update(discardLevel, download.Priority, (int)packetNumber);
-
-                sendFirstPacket = true;
-            }
+            RequestedDiscardLevel = discardLevel;
+            StartPacketNumber = packetNumber;
+            PacketCounter = (int)StartPacketNumber;
         }
 
         // See ITextureSender
         public bool SendTexturePacket()
         {
-            if (download != null && !m_cancel && (sendFirstPacket || download.CurrentPacket <= download.StopPacket))
-            {
-                SendPacket();
-                return false;
-            }
-            else
+            //m_log.DebugFormat("[TEXTURE SENDER]: Sending packet for {0}", m_asset.FullID);
+
+            SendPacket();
+            counter++;
+            if ((NumPackets == 0) || (RequestedDiscardLevel == -1) || (PacketCounter > NumPackets) ||
+                ((RequestedDiscardLevel > 0) && (counter > 50 + (NumPackets / (RequestedDiscardLevel + 1)))))
             {
-                m_sending = false;
-                m_cancel = true;
-                sendFirstPacket = false;
                 return true;
             }
+            return false;
         }
 
         #endregion
@@ -220,52 +138,9 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureSender
         public void TextureReceived(AssetBase asset)
         {
             m_asset = asset;
-
-            try
-            {
-                OpenMetaverse.AssetTexture texture = new OpenMetaverse.AssetTexture(m_asset.FullID, m_asset.Data);
-                if (texture.DecodeLayerBoundaries())
-                {
-                    bool sane = true;
-
-                    // Sanity check all of the layers
-                    for (int i = 0; i < texture.LayerInfo.Length; i++)
-                    {
-                        if (texture.LayerInfo[i].End > texture.AssetData.Length)
-                        {
-                            sane = false;
-                            break;
-                        }
-                    }
-
-                    if (sane)
-                    {
-                        download = new ImageDownload(texture, initialDiscardLevel, initialPriority, initialPacketNum);
-                        ImageLoaded = true;
-                        m_sending = true;
-                        m_cancel = false;
-                        sendFirstPacket = true;
-                        return;
-                    }
-                    else
-                    {
-                        m_log.Error("JPEG2000 texture decoding succeeded, but sanity check failed for " +
-                            m_asset.FullID.ToString());
-                    }
-                }
-                else
-                {
-                    m_log.Error("JPEG2000 texture decoding failed for " + m_asset.FullID.ToString());
-                }
-            }
-            catch (Exception ex)
-            {
-                m_log.Error("JPEG2000 texture decoding threw an exception for " + m_asset.FullID.ToString(), ex);
-            }
-
-            ImageLoaded = false;
-            m_sending = false;
-            m_cancel = true;
+            NumPackets = CalculateNumPackets(asset.Data.Length);
+            PacketCounter = (int)StartPacketNumber;
+            ImageLoaded = true;
         }
 
         /// <summary>
@@ -273,48 +148,66 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureSender
         /// </summary>
         private void SendPacket()
         {
-            lock (download)
+            if (PacketCounter <= NumPackets)
             {
-                if (sendFirstPacket)
+                if (PacketCounter == 0)
                 {
-                    sendFirstPacket = false;
-
-                    if (m_asset.Data.Length <= ImageDownload.FIRST_IMAGE_PACKET_SIZE)
+                    if (NumPackets == 0)
                     {
                         RequestUser.SendImageFirstPart(1, m_asset.FullID, (uint)m_asset.Data.Length, m_asset.Data, 2);
-                        return;
+                        PacketCounter++;
                     }
                     else
                     {
-                        byte[] firstImageData = new byte[ImageDownload.FIRST_IMAGE_PACKET_SIZE];
-                        try { Buffer.BlockCopy(m_asset.Data, 0, firstImageData, 0, ImageDownload.FIRST_IMAGE_PACKET_SIZE); }
-                        catch (Exception)
-                        {
-                            m_log.Error("Texture data copy failed on first packet for " + m_asset.FullID.ToString());
-                            m_cancel = true;
-                            m_sending = false;
-                            return;
-                        }
-                        RequestUser.SendImageFirstPart((ushort)download.TexturePacketCount(), m_asset.FullID, (uint)m_asset.Data.Length, firstImageData, 2);
+                        byte[] ImageData1 = new byte[600];
+                        Array.Copy(m_asset.Data, 0, ImageData1, 0, 600);
+
+                        RequestUser.SendImageFirstPart(
+                            (ushort)(NumPackets), m_asset.FullID, (uint)m_asset.Data.Length, ImageData1, 2);
+                        PacketCounter++;
                     }
                 }
-
-                int imagePacketSize = (download.CurrentPacket == download.TexturePacketCount() - 1) ?
-                    download.LastPacketSize() : ImageDownload.IMAGE_PACKET_SIZE;
-
-                byte[] imageData = new byte[imagePacketSize];
-                try { Buffer.BlockCopy(m_asset.Data, download.CurrentBytePosition(), imageData, 0, imagePacketSize); }
-                catch (Exception)
+                else
                 {
-                    m_log.Error("Texture data copy failed for " + m_asset.FullID.ToString());
-                    m_cancel = true;
-                    m_sending = false;
-                    return;
+                    int size = m_asset.Data.Length - 600 - (1000 * (PacketCounter - 1));
+                    if (size > 1000) size = 1000;
+                    byte[] imageData = new byte[size];
+                    try
+                    {
+                        Array.Copy(m_asset.Data, 600 + (1000 * (PacketCounter - 1)), imageData, 0, size);
+                    }
+                    catch (ArgumentOutOfRangeException)
+                    {
+                        m_log.Error("[TEXTURE SENDER]: Unable to separate texture into multiple packets: Array bounds failure on asset:" +
+                                    m_asset.FullID.ToString());
+                        return;
+                    }
+
+                    RequestUser.SendImageNextPart((ushort)PacketCounter, m_asset.FullID, imageData);
+                    PacketCounter++;
                 }
+            }
+        }
 
-                RequestUser.SendImageNextPart((ushort)download.CurrentPacket, m_asset.FullID, imageData);
-                ++download.CurrentPacket;
+        /// <summary>
+        /// Calculate the number of packets that will be required to send the texture loaded into this sender
+        /// This is actually the number of 1000 byte packets not including an initial 600 byte packet...
+        /// </summary>
+        /// <param name="length"></param>
+        /// <returns></returns>
+        private int CalculateNumPackets(int length)
+        {
+            int numPackets = 0;
+
+            if (length > 600)
+            {
+                //over 600 bytes so split up file
+                int restData = (length - 600);
+                int restPackets = ((restData + 999) / 1000);
+                numPackets = restPackets;
             }
+
+            return numPackets;
         }
     }
 }