diff options
author | Dahlia Trimble | 2009-01-10 01:46:47 +0000 |
---|---|---|
committer | Dahlia Trimble | 2009-01-10 01:46:47 +0000 |
commit | 3bdd4db3fd7eddb9e4f017cc45aa3eb2b3921111 (patch) | |
tree | 517b9986d705c99a6c0e5dc57899127fca10288e /OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs | |
parent | minor: remove mono compiler warning (diff) | |
download | opensim-SC_OLD-3bdd4db3fd7eddb9e4f017cc45aa3eb2b3921111.zip opensim-SC_OLD-3bdd4db3fd7eddb9e4f017cc45aa3eb2b3921111.tar.gz opensim-SC_OLD-3bdd4db3fd7eddb9e4f017cc45aa3eb2b3921111.tar.bz2 opensim-SC_OLD-3bdd4db3fd7eddb9e4f017cc45aa3eb2b3921111.tar.xz |
Thanks jhurliman for a patch that implements progressive texture downloading - Mantis #2655
Diffstat (limited to 'OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs')
-rw-r--r-- | OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs | 307 |
1 files changed, 207 insertions, 100 deletions
diff --git a/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs b/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs index 57129dd..0e34271 100644 --- a/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs +++ b/OpenSim/Region/Environment/Modules/Agent/TextureSender/TextureSender.cs | |||
@@ -27,106 +27,188 @@ | |||
27 | 27 | ||
28 | using System; | 28 | using System; |
29 | using System.Reflection; | 29 | using System.Reflection; |
30 | using OpenMetaverse.Packets; | ||
31 | using log4net; | 30 | using log4net; |
32 | using OpenSim.Framework; | 31 | using OpenSim.Framework; |
33 | using OpenSim.Region.Environment.Interfaces; | 32 | using OpenSim.Region.Environment.Interfaces; |
34 | 33 | ||
35 | namespace OpenSim.Region.Environment.Modules.Agent.TextureSender | 34 | namespace OpenSim.Region.Environment.Modules.Agent.TextureSender |
36 | { | 35 | { |
37 | /// <summary> | 36 | public class ImageDownload |
38 | /// A TextureSender handles the process of receiving a texture requested by the client from the | ||
39 | /// AssetCache, and then sending that texture back to the client. | ||
40 | /// </summary> | ||
41 | public class TextureSender : ITextureSender | ||
42 | { | 37 | { |
43 | private static readonly ILog m_log | 38 | public const int FIRST_IMAGE_PACKET_SIZE = 600; |
44 | = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | 39 | public const int IMAGE_PACKET_SIZE = 1000; |
45 | 40 | ||
46 | /// <summary> | 41 | public OpenMetaverse.AssetTexture Texture; |
47 | /// Records the number of times texture send has been called. | 42 | public int DiscardLevel; |
48 | /// </summary> | 43 | public float Priority; |
49 | public int counter = 0; | 44 | public int CurrentPacket; |
45 | public int StopPacket; | ||
50 | 46 | ||
51 | public bool ImageLoaded = false; | 47 | public ImageDownload(OpenMetaverse.AssetTexture texture, int discardLevel, float priority, int packet) |
48 | { | ||
49 | Texture = texture; | ||
50 | Update(discardLevel, priority, packet); | ||
51 | } | ||
52 | 52 | ||
53 | /// <summary> | 53 | /// <summary> |
54 | /// Holds the texture asset to send. | 54 | /// Updates an image transfer with new information and recalculates |
55 | /// offsets | ||
55 | /// </summary> | 56 | /// </summary> |
56 | private AssetBase m_asset; | 57 | /// <param name="discardLevel">New requested discard level</param> |
58 | /// <param name="priority">New requested priority</param> | ||
59 | /// <param name="packet">New requested packet offset</param> | ||
60 | public void Update(int discardLevel, float priority, int packet) | ||
61 | { | ||
62 | Priority = priority; | ||
63 | DiscardLevel = Clamp(discardLevel, 0, Texture.LayerInfo.Length - 1); | ||
64 | StopPacket = GetPacketForBytePosition(Texture.LayerInfo[(Texture.LayerInfo.Length - 1) - DiscardLevel].End); | ||
65 | CurrentPacket = Clamp(packet, 1, TexturePacketCount()); | ||
66 | } | ||
57 | 67 | ||
58 | //public UUID assetID { get { return m_asset.FullID; } } | 68 | /// <summary> |
69 | /// Returns the total number of packets needed to transfer this texture, | ||
70 | /// including the first packet of size FIRST_IMAGE_PACKET_SIZE | ||
71 | /// </summary> | ||
72 | /// <returns>Total number of packets needed to transfer this texture</returns> | ||
73 | public int TexturePacketCount() | ||
74 | { | ||
75 | return ((Texture.AssetData.Length - FIRST_IMAGE_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE) + 1; | ||
76 | } | ||
59 | 77 | ||
60 | // private bool m_cancel = false; | 78 | /// <summary> |
79 | /// Returns the current byte offset for this transfer, calculated from | ||
80 | /// the CurrentPacket | ||
81 | /// </summary> | ||
82 | /// <returns>Current byte offset for this transfer</returns> | ||
83 | public int CurrentBytePosition() | ||
84 | { | ||
85 | return FIRST_IMAGE_PACKET_SIZE + (CurrentPacket - 1) * IMAGE_PACKET_SIZE; | ||
86 | } | ||
61 | 87 | ||
62 | // See ITextureSender | 88 | /// <summary> |
89 | /// Returns the size, in bytes, of the last packet. This will be somewhere | ||
90 | /// between 1 and IMAGE_PACKET_SIZE bytes | ||
91 | /// </summary> | ||
92 | /// <returns>Size of the last packet in the transfer</returns> | ||
93 | public int LastPacketSize() | ||
94 | { | ||
95 | return Texture.AssetData.Length - (FIRST_IMAGE_PACKET_SIZE + ((TexturePacketCount() - 2) * IMAGE_PACKET_SIZE)); | ||
96 | } | ||
63 | 97 | ||
64 | // private bool m_sending = false; | 98 | /// <summary> |
99 | /// Find the packet number that contains a given byte position | ||
100 | /// </summary> | ||
101 | /// <param name="bytePosition">Byte position</param> | ||
102 | /// <returns>Packet number that contains the given byte position</returns> | ||
103 | int GetPacketForBytePosition(int bytePosition) | ||
104 | { | ||
105 | return ((bytePosition - FIRST_IMAGE_PACKET_SIZE + IMAGE_PACKET_SIZE - 1) / IMAGE_PACKET_SIZE); | ||
106 | } | ||
65 | 107 | ||
66 | /// <summary> | 108 | /// <summary> |
67 | /// This is actually the number of extra packets required to send the texture data! We always assume | 109 | /// Clamp a given value between a range |
68 | /// at least one is required. | ||
69 | /// </summary> | 110 | /// </summary> |
70 | private int NumPackets = 0; | 111 | /// <param name="value">Value to clamp</param> |
112 | /// <param name="min">Minimum allowable value</param> | ||
113 | /// <param name="max">Maximum allowable value</param> | ||
114 | /// <returns>A value inclusively between lower and upper</returns> | ||
115 | static int Clamp(int value, int min, int max) | ||
116 | { | ||
117 | // First we check to see if we're greater than the max | ||
118 | value = (value > max) ? max : value; | ||
119 | |||
120 | // Then we check to see if we're less than the min. | ||
121 | value = (value < min) ? min : value; | ||
122 | |||
123 | // There's no check to see if min > max. | ||
124 | return value; | ||
125 | } | ||
126 | } | ||
127 | |||
128 | /// <summary> | ||
129 | /// A TextureSender handles the process of receiving a texture requested by the client from the | ||
130 | /// AssetCache, and then sending that texture back to the client. | ||
131 | /// </summary> | ||
132 | public class TextureSender : ITextureSender | ||
133 | { | ||
134 | private static readonly ILog m_log | ||
135 | = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
136 | |||
137 | public bool ImageLoaded = false; | ||
71 | 138 | ||
72 | /// <summary> | 139 | /// <summary> |
73 | /// Holds the packet number to send next. In this case, each packet is 1000 bytes long and starts | 140 | /// Holds the texture asset to send. |
74 | /// at the 600th byte (0th indexed). | ||
75 | /// </summary> | 141 | /// </summary> |
76 | private int PacketCounter = 0; | 142 | private AssetBase m_asset; |
143 | private bool m_cancel = false; | ||
144 | private bool m_sending = false; | ||
145 | private bool sendFirstPacket = false; | ||
146 | private int initialDiscardLevel = 0; | ||
147 | private int initialPacketNum = 0; | ||
148 | private float initialPriority = 0.0f; | ||
77 | 149 | ||
78 | private int RequestedDiscardLevel = -1; | 150 | private ImageDownload download; |
79 | private IClientAPI RequestUser; | 151 | private IClientAPI RequestUser; |
80 | private uint StartPacketNumber = 0; | ||
81 | 152 | ||
82 | public TextureSender(IClientAPI client, int discardLevel, uint packetNumber) | 153 | public TextureSender(IClientAPI client, int discardLevel, uint packetNumber, float priority) |
83 | { | 154 | { |
84 | RequestUser = client; | 155 | RequestUser = client; |
85 | RequestedDiscardLevel = discardLevel; | 156 | initialDiscardLevel = discardLevel; |
86 | StartPacketNumber = packetNumber; | 157 | initialPacketNum = (int)packetNumber; |
158 | initialPriority = priority; | ||
87 | } | 159 | } |
88 | 160 | ||
89 | #region ITextureSender Members | 161 | #region ITextureSender Members |
90 | 162 | ||
91 | public bool Cancel | 163 | public bool Cancel |
92 | { | 164 | { |
93 | get { return false; } | 165 | get { return m_cancel; } |
94 | set | 166 | set { m_cancel = value; } |
95 | { | ||
96 | // m_cancel = value; | ||
97 | } | ||
98 | } | 167 | } |
99 | 168 | ||
100 | public bool Sending | 169 | public bool Sending |
101 | { | 170 | { |
102 | get { return false; } | 171 | get { return m_sending; } |
103 | set | 172 | set { m_sending = value; } |
104 | { | ||
105 | // m_sending = value; | ||
106 | } | ||
107 | } | 173 | } |
108 | 174 | ||
109 | // See ITextureSender | 175 | // See ITextureSender |
110 | public void UpdateRequest(int discardLevel, uint packetNumber) | 176 | public void UpdateRequest(int discardLevel, uint packetNumber) |
111 | { | 177 | { |
112 | RequestedDiscardLevel = discardLevel; | 178 | if (download == null) |
113 | StartPacketNumber = packetNumber; | 179 | return; |
114 | PacketCounter = (int) StartPacketNumber; | 180 | |
181 | lock (download) | ||
182 | { | ||
183 | if (discardLevel < download.DiscardLevel) | ||
184 | m_log.DebugFormat("Image download {0} is changing from DiscardLevel {1} to {2}", | ||
185 | m_asset.FullID, download.DiscardLevel, discardLevel); | ||
186 | |||
187 | if (packetNumber != download.CurrentPacket) | ||
188 | m_log.DebugFormat("Image download {0} is changing from Packet {1} to {2}", | ||
189 | m_asset.FullID, download.CurrentPacket, packetNumber); | ||
190 | |||
191 | download.Update(discardLevel, download.Priority, (int)packetNumber); | ||
192 | |||
193 | sendFirstPacket = true; | ||
194 | } | ||
115 | } | 195 | } |
116 | 196 | ||
117 | // See ITextureSender | 197 | // See ITextureSender |
118 | public bool SendTexturePacket() | 198 | public bool SendTexturePacket() |
119 | { | 199 | { |
120 | //m_log.DebugFormat("[TEXTURE SENDER]: Sending packet for {0}", m_asset.FullID); | 200 | if (download != null && !m_cancel && (sendFirstPacket || download.CurrentPacket <= download.StopPacket)) |
121 | 201 | { | |
122 | SendPacket(); | 202 | SendPacket(); |
123 | counter++; | 203 | return false; |
124 | if ((NumPackets == 0) || (RequestedDiscardLevel == -1) || (PacketCounter > NumPackets) || | 204 | } |
125 | ((RequestedDiscardLevel > 0) && (counter > 50 + (NumPackets / (RequestedDiscardLevel + 1))))) | 205 | else |
126 | { | 206 | { |
207 | m_sending = false; | ||
208 | m_cancel = true; | ||
209 | sendFirstPacket = false; | ||
127 | return true; | 210 | return true; |
128 | } | 211 | } |
129 | return false; | ||
130 | } | 212 | } |
131 | 213 | ||
132 | #endregion | 214 | #endregion |
@@ -138,76 +220,101 @@ namespace OpenSim.Region.Environment.Modules.Agent.TextureSender | |||
138 | public void TextureReceived(AssetBase asset) | 220 | public void TextureReceived(AssetBase asset) |
139 | { | 221 | { |
140 | m_asset = asset; | 222 | m_asset = asset; |
141 | NumPackets = CalculateNumPackets(asset.Data.Length); | ||
142 | PacketCounter = (int) StartPacketNumber; | ||
143 | ImageLoaded = true; | ||
144 | } | ||
145 | 223 | ||
146 | /// <summary> | 224 | try |
147 | /// Sends a texture packet to the client. | ||
148 | /// </summary> | ||
149 | private void SendPacket() | ||
150 | { | ||
151 | if (PacketCounter <= NumPackets) | ||
152 | { | 225 | { |
153 | if (PacketCounter == 0) | 226 | OpenMetaverse.AssetTexture texture = new OpenMetaverse.AssetTexture(m_asset.FullID, m_asset.Data); |
227 | if (texture.DecodeLayerBoundaries()) | ||
154 | { | 228 | { |
155 | if (NumPackets == 0) | 229 | bool sane = true; |
230 | |||
231 | // Sanity check all of the layers | ||
232 | for (int i = 0; i < texture.LayerInfo.Length; i++) | ||
156 | { | 233 | { |
157 | RequestUser.SendImageFirstPart(1, m_asset.FullID, (uint)m_asset.Data.Length, m_asset.Data, 2); | 234 | if (texture.LayerInfo[i].End > texture.AssetData.Length) |
158 | PacketCounter++; | 235 | { |
236 | sane = false; | ||
237 | break; | ||
238 | } | ||
239 | } | ||
240 | |||
241 | if (sane) | ||
242 | { | ||
243 | download = new ImageDownload(texture, initialDiscardLevel, initialPriority, initialPacketNum); | ||
244 | ImageLoaded = true; | ||
245 | m_sending = true; | ||
246 | m_cancel = false; | ||
247 | sendFirstPacket = true; | ||
248 | return; | ||
159 | } | 249 | } |
160 | else | 250 | else |
161 | { | 251 | { |
162 | byte[] ImageData1 = new byte[600]; | 252 | m_log.Error("JPEG2000 texture decoding succeeded, but sanity check failed for " + |
163 | Array.Copy(m_asset.Data, 0, ImageData1, 0, 600); | 253 | m_asset.FullID.ToString()); |
164 | |||
165 | RequestUser.SendImageFirstPart( | ||
166 | (ushort)(NumPackets), m_asset.FullID, (uint)m_asset.Data.Length, ImageData1, 2); | ||
167 | PacketCounter++; | ||
168 | } | 254 | } |
169 | } | 255 | } |
170 | else | 256 | else |
171 | { | 257 | { |
172 | int size = m_asset.Data.Length - 600 - (1000 * (PacketCounter - 1)); | 258 | m_log.Error("JPEG2000 texture decoding failed for " + m_asset.FullID.ToString()); |
173 | if (size > 1000) size = 1000; | ||
174 | byte[] imageData = new byte[size]; | ||
175 | try | ||
176 | { | ||
177 | Array.Copy(m_asset.Data, 600 + (1000 * (PacketCounter - 1)), imageData, 0, size); | ||
178 | } | ||
179 | catch (ArgumentOutOfRangeException) | ||
180 | { | ||
181 | m_log.Error("[TEXTURE SENDER]: Unable to separate texture into multiple packets: Array bounds failure on asset:" + | ||
182 | m_asset.FullID.ToString()); | ||
183 | return; | ||
184 | } | ||
185 | |||
186 | RequestUser.SendImageNextPart((ushort)PacketCounter, m_asset.FullID, imageData); | ||
187 | PacketCounter++; | ||
188 | } | 259 | } |
189 | } | 260 | } |
261 | catch (Exception ex) | ||
262 | { | ||
263 | m_log.Error("JPEG2000 texture decoding threw an exception for " + m_asset.FullID.ToString(), ex); | ||
264 | } | ||
265 | |||
266 | ImageLoaded = false; | ||
267 | m_sending = false; | ||
268 | m_cancel = true; | ||
190 | } | 269 | } |
191 | 270 | ||
192 | /// <summary> | 271 | /// <summary> |
193 | /// Calculate the number of packets that will be required to send the texture loaded into this sender | 272 | /// Sends a texture packet to the client. |
194 | /// This is actually the number of 1000 byte packets not including an initial 600 byte packet... | ||
195 | /// </summary> | 273 | /// </summary> |
196 | /// <param name="length"></param> | 274 | private void SendPacket() |
197 | /// <returns></returns> | ||
198 | private int CalculateNumPackets(int length) | ||
199 | { | 275 | { |
200 | int numPackets = 0; | 276 | lock (download) |
201 | |||
202 | if (length > 600) | ||
203 | { | 277 | { |
204 | //over 600 bytes so split up file | 278 | if (sendFirstPacket) |
205 | int restData = (length - 600); | 279 | { |
206 | int restPackets = ((restData + 999) / 1000); | 280 | sendFirstPacket = false; |
207 | numPackets = restPackets; | ||
208 | } | ||
209 | 281 | ||
210 | return numPackets; | 282 | if (m_asset.Data.Length <= ImageDownload.FIRST_IMAGE_PACKET_SIZE) |
283 | { | ||
284 | RequestUser.SendImageFirstPart(1, m_asset.FullID, (uint)m_asset.Data.Length, m_asset.Data, 2); | ||
285 | return; | ||
286 | } | ||
287 | else | ||
288 | { | ||
289 | byte[] firstImageData = new byte[ImageDownload.FIRST_IMAGE_PACKET_SIZE]; | ||
290 | try { Buffer.BlockCopy(m_asset.Data, 0, firstImageData, 0, ImageDownload.FIRST_IMAGE_PACKET_SIZE); } | ||
291 | catch (Exception) | ||
292 | { | ||
293 | m_log.Error("Texture data copy failed on first packet for " + m_asset.FullID.ToString()); | ||
294 | m_cancel = true; | ||
295 | m_sending = false; | ||
296 | return; | ||
297 | } | ||
298 | RequestUser.SendImageFirstPart((ushort)download.TexturePacketCount(), m_asset.FullID, (uint)m_asset.Data.Length, firstImageData, 2); | ||
299 | } | ||
300 | } | ||
301 | |||
302 | int imagePacketSize = (download.CurrentPacket == download.TexturePacketCount() - 1) ? | ||
303 | download.LastPacketSize() : ImageDownload.IMAGE_PACKET_SIZE; | ||
304 | |||
305 | byte[] imageData = new byte[imagePacketSize]; | ||
306 | try { Buffer.BlockCopy(m_asset.Data, download.CurrentBytePosition(), imageData, 0, imagePacketSize); } | ||
307 | catch (Exception) | ||
308 | { | ||
309 | m_log.Error("Texture data copy failed for " + m_asset.FullID.ToString()); | ||
310 | m_cancel = true; | ||
311 | m_sending = false; | ||
312 | return; | ||
313 | } | ||
314 | |||
315 | RequestUser.SendImageNextPart((ushort)download.CurrentPacket, m_asset.FullID, imageData); | ||
316 | ++download.CurrentPacket; | ||
317 | } | ||
211 | } | 318 | } |
212 | } | 319 | } |
213 | } | 320 | } |