/// <summary>
/// Initiate an image download. This is an asynchronous function
/// </summary>
/// <param name="imageID">The image to download</param>
/// <param name="type">Type of the image to download, either a baked
/// avatar texture or a normal texture</param>
/// <param name="priority">Priority level of the download. Default is
/// <code>1,013,000.0f</code></param>
/// <param name="discardLevel">Number of quality layers to discard</param>
public void RequestImage(LLUUID imageID, ImageType type, float priority, int discardLevel)
{
if (!Transfers.ContainsKey(imageID))
{
ImageDownload transfer = new ImageDownload();
//transfer.AssetType = AssetType.Texture // Handled in ImageDataHandler.
transfer.ID = imageID;
transfer.Simulator = Client.Network.CurrentSim;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = (sbyte)discardLevel;
request.RequestImage[0].DownloadPriority = priority;
request.RequestImage[0].Packet = 0;
request.RequestImage[0].Image = imageID;
request.RequestImage[0].Type = (byte)type;
Client.Network.SendPacket(request, transfer.Simulator);
}
else
{
Client.Log("RequestImage() called for an image we are already downloading, ignoring",
Helpers.LogLevel.Info);
}
}
/// <summary>
/// Sends the actual request packet to the simulator
/// </summary>
/// <param name="imageID">The image to download</param>
/// <param name="type">Type of the image to download, either a baked
/// avatar texture or a normal texture</param>
/// <param name="priority">Priority level of the download. Default is
/// <c>1,013,000.0f</c></param>
/// <param name="discardLevel">Number of quality layers to discard.
/// This controls the end marker of the data sent</param>
/// <param name="packetNum">Packet number to start the download at.
/// This controls the start marker of the data sent</param>
/// <remarks>Sending a priority of 0 and a discardlevel of -1 aborts
/// download</remarks>
private void RequestImage(UUID imageID, ImageType type, float priority, int discardLevel, uint packetNum)
{
// Priority == 0 && DiscardLevel == -1 means cancel the transfer
if (priority.Equals(0) && discardLevel.Equals(-1))
{
AbortTextureRequest(imageID);
}
else
{
TaskInfo task;
if (TryGetTransferValue(imageID, out task))
{
if (task.Transfer.Simulator != null)
{
// Already downloading, just updating the priority
float percentComplete = ((float)task.Transfer.Transferred / (float)task.Transfer.Size) * 100f;
if (Single.IsNaN(percentComplete))
{
percentComplete = 0f;
}
if (percentComplete > 0f)
{
Logger.DebugLog(String.Format("Updating priority on image transfer {0} to {1}, {2}% complete",
imageID, task.Transfer.Priority, Math.Round(percentComplete, 2)));
}
}
else
{
ImageDownload transfer = task.Transfer;
transfer.Simulator = _Client.Network.CurrentSim;
}
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket
{
AgentData =
{
AgentID = _Client.Self.AgentID,
SessionID = _Client.Self.SessionID
},
RequestImage = new RequestImagePacket.RequestImageBlock[1]
};
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock
{
DiscardLevel = (sbyte)discardLevel,
DownloadPriority = priority,
Packet = packetNum,
Image = imageID,
Type = (byte)type
};
_Client.Network.SendPacket(request, _Client.Network.CurrentSim);
}
else
{
Logger.Log("Received texture download request for a texture that isn't in the download queue: " + imageID, Helpers.LogLevel.Warning);
}
}
}
public bool GetImage(RequestImagePacket imgPacket)
{
RequestImagePacket.RequestImageBlock[] invImgBlocks = new RequestImagePacket.RequestImageBlock[imgPacket.RequestImage.Length];
for (int i = 0; i < imgPacket.RequestImage.Length; i++)
{
invImgBlocks[i] = imgPacket.RequestImage[i];
lock (textureSenders)
{
if (!textureSenders.ContainsKey(imgPacket.RequestImage[i].Image))
{
TextureSender sender = new TextureSender(this, proxy, imgPacket.RequestImage[i].DiscardLevel, imgPacket.RequestImage[i].Packet);
textureSenders.Add(imgPacket.RequestImage[i].Image, sender);
m_RegionAssetService.Get(imgPacket.RequestImage[i].Image.ToString(), sender, TextureReceived);
//old: assClient.RequestAsset(imgPacket.RequestImage[i].Image, true);
//older: assDownloader.RequestAsset(imgPacket.RequestImage[i].Image, true, AuthToken);
}
else
{
TextureSender sender = textureSenders[imgPacket.RequestImage[i].Image];
sender.UpdateRequest(imgPacket.RequestImage[i].DiscardLevel, imgPacket.RequestImage[i].Packet);
}
}
Console.WriteLine(" >> Image is region asset");
}
// Don't forward
return true;
}
private void RequestImageHandler(Packet packet, LLAgent agent)
{
RequestImagePacket request = (RequestImagePacket)packet;
for (int i = 0; i < request.RequestImage.Length; i++)
{
RequestImagePacket.RequestImageBlock block = request.RequestImage[i];
EnqueueRequest(agent, block.Image, block.DiscardLevel, block.DownloadPriority, block.Packet, packet.Header.Sequence);
}
}
/// <summary>
/// Cancel a pending or in process texture request
/// </summary>
/// <param name="textureID">The texture assets unique ID</param>
public void AbortTextureRequest(UUID textureID)
{
TaskInfo task;
if (!TryGetTransferValue(textureID, out task))
{
return;
}
// this means we've actually got the request assigned to the threadpool
if (task.State == TextureRequestState.Progress)
{
RequestImagePacket request = new RequestImagePacket
{
AgentData =
{
AgentID = _Client.Self.AgentID,
SessionID = _Client.Self.SessionID
},
RequestImage = new RequestImagePacket.RequestImageBlock[1]
};
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock
{
DiscardLevel = -1,
DownloadPriority = 0,
Packet = 0,
Image = textureID,
Type = (byte)task.Type
};
_Client.Network.SendPacket(request);
foreach (var callback in task.Callbacks)
{
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
}
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
task.TokenSource.Cancel();
RemoveTransfer(textureID);
}
else
{
RemoveTransfer(textureID);
foreach (var callback in task.Callbacks)
{
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
}
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
}
}
/// <summary>
/// Cancel a pending or in process texture request
/// </summary>
/// <param name="textureID">The texture assets unique ID</param>
public void AbortTextureRequest(UUID textureID)
{
TaskInfo task;
if (TryGetTransferValue(textureID, out task))
{
// this means we've actually got the request assigned to the threadpool
if (task.State == TextureRequestState.Progress)
{
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = _Client.Self.AgentID;
request.AgentData.SessionID = _Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = -1;
request.RequestImage[0].DownloadPriority = 0;
request.RequestImage[0].Packet = 0;
request.RequestImage[0].Image = textureID;
request.RequestImage[0].Type = (byte)task.Type;
_Client.Network.SendPacket(request);
foreach (TextureDownloadCallback callback in task.Callbacks)
{
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
}
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
resetEvents[task.RequestSlot].Set();
RemoveTransfer(textureID);
}
else
{
RemoveTransfer(textureID);
foreach (TextureDownloadCallback callback in task.Callbacks)
{
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
}
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
}
}
}
/// <summary>
/// Send a packet requesting an image. This will either fail silently, or result in
/// one ImageData packet, along with zero or more ImagePacket packets.
/// </summary>
/// <param name="imageID">LLUUID of the AssetID of an image.</param>
public Packet RequestImage(LLUUID imageID)
{
RequestImagePacket p = new RequestImagePacket();
p.RequestImage = new RequestImagePacket.RequestImageBlock[1];
p.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
p.RequestImage[0].DownloadPriority = (float)1215000.0;
p.RequestImage[0].DiscardLevel = (int)0;
p.RequestImage[0].Packet = (uint)0;
p.RequestImage[0].Image = imageID;
//FIXME: Find out what the appropriate values are here.
p.RequestImage[0].Type = 0;
p.AgentData.AgentID = Client.Network.AgentID;
p.AgentData.SessionID = Client.Network.SessionID;
return p;
}
/// <summary>
/// Send a packet requesting an image. This will either fail silently, or result in
/// one ImageData packet, along with zero or more ImagePacket packets.
/// </summary>
/// <param name="imageID">LLUUID of the AssetID of an image.</param>
public Packet RequestImage(LLUUID imageID)
{
RequestImagePacket p = new RequestImagePacket();
p.RequestImage = new RequestImagePacket.RequestImageBlock[1];
p.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
p.RequestImage[0].DownloadPriority = (float)1215000.0;
p.RequestImage[0].DiscardLevel = (int)0;
p.RequestImage[0].Packet = (uint)0;
p.RequestImage[0].Image = imageID;
//FIXME: Find out what the appropriate values are here.
p.RequestImage[0].Type = 0;
p.AgentData.AgentID = Client.Network.AgentID;
p.AgentData.SessionID = Client.Network.SessionID;
return(p);
}
/// <summary>
/// Requests multiple Images
/// </summary>
/// <param name="Images">List of requested images</param>
public void RequestImages(List <ImageRequest> Images)
{
for (int iri = Images.Count; iri > 0; --iri)
{
if (Transfers.ContainsKey(Images[iri].ImageID))
{
Images.RemoveAt(iri);
}
}
if (Images.Count > 0)
{
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[Images.Count];
for (int iru = 0; iru < Images.Count; ++iru)
{
ImageDownload transfer = new ImageDownload();
//transfer.AssetType = AssetType.Texture // Handled in ImageDataHandler.
transfer.ID = Images[iru].ImageID;
transfer.Simulator = Client.Network.CurrentSim;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
request.RequestImage[iru] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[iru].DiscardLevel = (sbyte)Images[iru].DiscardLevel;
request.RequestImage[iru].DownloadPriority = Images[iru].Priority;
request.RequestImage[iru].Packet = 0;
request.RequestImage[iru].Image = Images[iru].ImageID;
request.RequestImage[iru].Type = (byte)Images[iru].Type;
}
Client.Network.SendPacket(request, Client.Network.CurrentSim);
}
else
{
Client.Log("RequestImages() called for an image(s) we are already downloading or an empty list, ignoring",
Helpers.LogLevel.Info);
}
}
/// <summary>
/// Requests multiple Images
/// </summary>
/// <param name="Images">List of requested images</param>
public void RequestImages(List<ImageRequest> Images)
{
for (int iri = 0; iri < Images.Count; iri++)
{
if (Transfers.ContainsKey(Images[iri].ImageID))
Images.RemoveAt(iri);
}
if (Images.Count > 0)
{
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[Images.Count];
for (int iru = 0; iru < Images.Count; ++iru)
{
ImageDownload transfer = new ImageDownload();
//transfer.AssetType = AssetType.Texture // Handled in ImageDataHandler.
transfer.ID = Images[iru].ImageID;
transfer.Simulator = Client.Network.CurrentSim;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
request.RequestImage[iru] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[iru].DiscardLevel = (sbyte)Images[iru].DiscardLevel;
request.RequestImage[iru].DownloadPriority = Images[iru].Priority;
request.RequestImage[iru].Packet = 0;
request.RequestImage[iru].Image = Images[iru].ImageID;
request.RequestImage[iru].Type = (byte)Images[iru].Type;
}
Client.Network.SendPacket(request, Client.Network.CurrentSim);
}
else
{
Client.Log("RequestImages() called for an image(s) we are already downloading or an empty list, ignoring",
Helpers.LogLevel.Info);
}
}
/// <summary>
/// Initiate an image download. This is an asynchronous function
/// </summary>
/// <param name="imageID">The image to download</param>
/// <param name="type">Type of the image to download, either a baked
/// avatar texture or a normal texture</param>
/// <param name="priority">Priority level of the download. Default is
/// <c>1,013,000.0f</c></param>
/// <param name="discardLevel">Number of quality layers to discard</param>
/// <remarks>Sending a priority of 0, and a discardlevel of -1 aborts
/// download</remarks>
public void RequestImage(LLUUID imageID, ImageType type, float priority, int discardLevel)
{
// allows aborting of download
if (Transfers.ContainsKey(imageID) && priority.Equals(0) && discardLevel.Equals(-1))
Transfers.Remove(imageID);
if (!Transfers.ContainsKey(imageID) && !priority.Equals(0) && !discardLevel.Equals(-1))
{
ImageDownload transfer = new ImageDownload();
//transfer.AssetType = AssetType.Texture // Handled in ImageDataHandler.
transfer.ID = imageID;
transfer.Simulator = Client.Network.CurrentSim;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = (sbyte)discardLevel;
request.RequestImage[0].DownloadPriority = priority;
request.RequestImage[0].Packet = 0;
request.RequestImage[0].Image = imageID;
request.RequestImage[0].Type = (byte)type;
Client.Network.SendPacket(request, transfer.Simulator);
}
else
{
Client.Log("RequestImage() called for an image we are already downloading, ignoring",
Helpers.LogLevel.Info);
}
}
/// <summary>
/// Cancel a pending or in process texture request
/// </summary>
/// <param name="textureID">The texture assets unique ID</param>
public void AbortTextureRequest(UUID textureID)
{
TaskInfo task;
if (TryGetTransferValue(textureID, out task))
{
// this means we've actually got the request assigned to the threadpool
if (task.State == TextureRequestState.Progress)
{
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = _Client.Self.AgentID;
request.AgentData.SessionID = _Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = -1;
request.RequestImage[0].DownloadPriority = 0;
request.RequestImage[0].Packet = 0;
request.RequestImage[0].Image = textureID;
request.RequestImage[0].Type = (byte)task.Type;
_Client.Network.SendPacket(request);
foreach (TextureDownloadCallback callback in task.Callbacks)
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
resetEvents[task.RequestSlot].Set();
RemoveTransfer(textureID);
}
else
{
RemoveTransfer(textureID);
foreach (TextureDownloadCallback callback in task.Callbacks)
callback(TextureRequestState.Aborted, new AssetTexture(textureID, Utils.EmptyBytes));
_Client.Assets.FireImageProgressEvent(task.RequestID, task.Transfer.Transferred, task.Transfer.Size);
}
}
}
/// <summary>
/// Sends the actual request packet to the simulator
/// </summary>
/// <param name="imageID">The image to download</param>
/// <param name="type">Type of the image to download, either a baked
/// avatar texture or a normal texture</param>
/// <param name="priority">Priority level of the download. Default is
/// <c>1,013,000.0f</c></param>
/// <param name="discardLevel">Number of quality layers to discard.
/// This controls the end marker of the data sent</param>
/// <param name="packetNum">Packet number to start the download at.
/// This controls the start marker of the data sent</param>
/// <remarks>Sending a priority of 0 and a discardlevel of -1 aborts
/// download</remarks>
private void RequestImage(UUID imageID, ImageType type, float priority, int discardLevel, uint packetNum)
{
// Priority == 0 && DiscardLevel == -1 means cancel the transfer
if (priority.Equals(0) && discardLevel.Equals(-1))
{
AbortTextureRequest(imageID);
}
else
{
TaskInfo task;
if (TryGetTransferValue(imageID, out task))
{
if (task.Transfer.Simulator != null)
{
// Already downloading, just updating the priority
float percentComplete = ((float)task.Transfer.Transferred / (float)task.Transfer.Size) * 100f;
if (Single.IsNaN(percentComplete))
percentComplete = 0f;
if (percentComplete > 0f)
Logger.DebugLog(String.Format("Updating priority on image transfer {0} to {1}, {2}% complete",
imageID, task.Transfer.Priority, Math.Round(percentComplete, 2)));
}
else
{
ImageDownload transfer = task.Transfer;
transfer.Simulator = _Client.Network.CurrentSim;
}
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = _Client.Self.AgentID;
request.AgentData.SessionID = _Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = (sbyte)discardLevel;
request.RequestImage[0].DownloadPriority = priority;
request.RequestImage[0].Packet = packetNum;
request.RequestImage[0].Image = imageID;
request.RequestImage[0].Type = (byte)type;
_Client.Network.SendPacket(request, _Client.Network.CurrentSim);
}
else
{
Logger.Log("Received texture download request for a texture that isn't in the download queue: " + imageID, Helpers.LogLevel.Warning);
}
}
}
/// <summary>
/// Requests multiple Images
/// </summary>
/// <param name="Images">List of requested images</param>
public void RequestImages(List<ImageRequest> Images)
{
for (int iri = 0; iri < Images.Count; iri++)
{
if (Transfers.ContainsKey(Images[iri].ImageID))
{
Images.RemoveAt(iri);
}
if (Cache.HasImage(Images[iri].ImageID))
{
ImageDownload transfer = Cache.GetCachedImage(Images[iri].ImageID);
if (null != transfer)
{
if (null != OnImageReceived)
{
AssetTexture asset = new AssetTexture(transfer.ID, transfer.AssetData);
try { OnImageReceived(transfer, asset); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
Images.RemoveAt(iri);
}
}
}
if (Images.Count > 0)
{
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[Images.Count];
for (int iru = 0; iru < Images.Count; ++iru)
{
ImageDownload transfer = new ImageDownload();
//transfer.AssetType = AssetType.Texture // Handled in ImageDataHandler.
transfer.ID = Images[iru].ImageID;
transfer.Simulator = Client.Network.CurrentSim;
transfer.ImageType = Images[iru].Type;
transfer.DiscardLevel = Images[iru].DiscardLevel;
transfer.Priority = Images[iru].Priority;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
request.RequestImage[iru] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[iru].DiscardLevel = (sbyte)Images[iru].DiscardLevel;
request.RequestImage[iru].DownloadPriority = Images[iru].Priority;
request.RequestImage[iru].Packet = 0;
request.RequestImage[iru].Image = Images[iru].ImageID;
request.RequestImage[iru].Type = (byte)Images[iru].Type;
}
Client.Network.SendPacket(request, Client.Network.CurrentSim);
}
else
{
Logger.Log("RequestImages() called for an image(s) we are already downloading or an empty list, ignoring",
Helpers.LogLevel.Info, Client);
}
}
/// <summary>
/// Initiate an image download. This is an asynchronous function
/// </summary>
/// <param name="imageID">The image to download</param>
/// <param name="type">Type of the image to download, either a baked
/// avatar texture or a normal texture</param>
/// <param name="priority">Priority level of the download. Default is
/// <c>1,013,000.0f</c></param>
/// <param name="discardLevel">Number of quality layers to discard.
/// This controls the end marker of the data sent</param>
/// <param name="packetNum">Packet number to start the download at.
/// This controls the start marker of the data sent</param>
/// <remarks>Sending a priority of 0 and a discardlevel of -1 aborts
/// download</remarks>
public void RequestImage(UUID imageID, ImageType type, float priority, int discardLevel, uint packetNum)
{
if (Cache.HasImage(imageID))
{
ImageDownload transfer = Cache.GetCachedImage(imageID);
transfer.ImageType = type;
if (null != transfer)
{
if (null != OnImageReceived)
{
AssetTexture asset = new AssetTexture(transfer.ID, transfer.AssetData);
try { OnImageReceived(transfer, asset); }
catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
}
return;
}
}
// Priority == 0 && DiscardLevel == -1 means cancel the transfer
if (priority.Equals(0) && discardLevel.Equals(-1))
{
if (Transfers.ContainsKey(imageID))
Transfers.Remove(imageID);
RequestImagePacket cancel = new RequestImagePacket();
cancel.AgentData.AgentID = Client.Self.AgentID;
cancel.AgentData.SessionID = Client.Self.SessionID;
cancel.RequestImage = new RequestImagePacket.RequestImageBlock[1];
cancel.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
cancel.RequestImage[0].DiscardLevel = -1;
cancel.RequestImage[0].DownloadPriority = 0;
cancel.RequestImage[0].Packet = 0;
cancel.RequestImage[0].Image = imageID;
cancel.RequestImage[0].Type = 0;
}
else
{
Simulator currentSim = Client.Network.CurrentSim;
if (!Transfers.ContainsKey(imageID))
{
// New download
ImageDownload transfer = new ImageDownload();
transfer.ID = imageID;
transfer.Simulator = currentSim;
transfer.ImageType = type;
transfer.DiscardLevel = discardLevel;
transfer.Priority = priority;
// Add this transfer to the dictionary
lock (Transfers) Transfers[transfer.ID] = transfer;
Logger.DebugLog("Adding image " + imageID.ToString() + " to the download queue");
}
else
{
// Already downloading, just updating the priority
Transfer transfer = Transfers[imageID];
float percentComplete = ((float)transfer.Transferred / (float)transfer.Size) * 100f;
if (Single.IsNaN(percentComplete))
percentComplete = 0f;
Logger.DebugLog(String.Format("Updating priority on image transfer {0}, {1}% complete",
imageID, Math.Round(percentComplete, 2)));
}
// Build and send the request packet
RequestImagePacket request = new RequestImagePacket();
request.AgentData.AgentID = Client.Self.AgentID;
request.AgentData.SessionID = Client.Self.SessionID;
request.RequestImage = new RequestImagePacket.RequestImageBlock[1];
request.RequestImage[0] = new RequestImagePacket.RequestImageBlock();
request.RequestImage[0].DiscardLevel = (sbyte)discardLevel;
request.RequestImage[0].DownloadPriority = priority;
request.RequestImage[0].Packet = packetNum;
request.RequestImage[0].Image = imageID;
request.RequestImage[0].Type = (byte)type;
Client.Network.SendPacket(request, currentSim);
}
}
public bool GetImage(RequestImagePacket imgPacket)
{
RequestImagePacket.RequestImageBlock[] invImgBlocks = new RequestImagePacket.RequestImageBlock[imgPacket.RequestImage.Length];
for (int i = 0; i < imgPacket.RequestImage.Length; i++)
{
invImgBlocks[i] = imgPacket.RequestImage[i];
lock (textureSenders)
{
if (!textureSenders.ContainsKey(imgPacket.RequestImage[i].Image))
{
lock (textureSenders)
textureSenders.Add(imgPacket.RequestImage[i].Image, new TextureSender(proxy, imgPacket.RequestImage[i].DiscardLevel, imgPacket.RequestImage[i].Packet));
assClient.RequestAsset(imgPacket.RequestImage[i].Image, true);
//assDownloader.RequestAsset(imgPacket.RequestImage[i].Image, true, AuthToken);
}
}
Console.WriteLine(" >> Image is region asset");
}
// Don't forward
return true;
}
void RequestImageHandler(Packet packet, Agent agent)
{
RequestImagePacket request = (RequestImagePacket)packet;
for (int i = 0; i < request.RequestImage.Length; i++)
{
RequestImagePacket.RequestImageBlock block = request.RequestImage[i];
ImageDownload download;
bool downloadFound = CurrentDownloads.TryGetValue(block.Image, out download);
if (downloadFound)
{
lock (download)
{
if (block.DiscardLevel == -1 && block.DownloadPriority == 0.0f)
{
Logger.DebugLog(String.Format("Image download {0} is aborting", block.Image));
}
else
{
if (block.DiscardLevel < download.DiscardLevel)
{
Logger.DebugLog(String.Format("Image download {0} is changing from DiscardLevel {1} to {2}",
block.Image, download.DiscardLevel, block.DiscardLevel));
}
if (block.DownloadPriority != download.Priority)
{
Logger.DebugLog(String.Format("Image download {0} is changing from Priority {1} to {2}",
block.Image, download.Priority, block.DownloadPriority));
}
if (block.Packet != download.CurrentPacket)
{
Logger.DebugLog(String.Format("Image download {0} is changing from Packet {1} to {2}",
block.Image, download.CurrentPacket, block.Packet));
}
}
// Update download
download.Update(block.DiscardLevel, block.DownloadPriority, (int)block.Packet);
}
}
else if (block.DiscardLevel == -1 && block.DownloadPriority == 0.0f)
{
// Aborting a download we are not tracking, ignore
Logger.DebugLog(String.Format("Aborting an image download for untracked image " + block.Image.ToString()));
}
else
{
bool bake = ((ImageType)block.Type == ImageType.Baked);
// New download, check if we have this image
Asset asset;
if (server.Assets.TryGetAsset(block.Image, out asset) && asset is AssetTexture)
{
download = new ImageDownload((AssetTexture)asset, block.DiscardLevel, block.DownloadPriority,
(int)block.Packet);
Logger.DebugLog(String.Format(
"Starting new download for {0}, DiscardLevel: {1}, Priority: {2}, Start: {3}, End: {4}, Total: {5}",
block.Image, block.DiscardLevel, block.DownloadPriority, download.CurrentPacket, download.StopPacket,
download.TexturePacketCount()));
// Send initial data
ImageDataPacket data = new ImageDataPacket();
data.ImageID.Codec = (byte)ImageCodec.J2C;
data.ImageID.ID = download.Texture.AssetID;
data.ImageID.Packets = (ushort)download.TexturePacketCount();
data.ImageID.Size = (uint)download.Texture.AssetData.Length;
// The first bytes of the image are always sent in the ImageData packet
data.ImageData = new ImageDataPacket.ImageDataBlock();
int imageDataSize = (download.Texture.AssetData.Length >= ImageDownload.FIRST_IMAGE_PACKET_SIZE) ?
ImageDownload.FIRST_IMAGE_PACKET_SIZE : download.Texture.AssetData.Length;
data.ImageData.Data = new byte[imageDataSize];
Buffer.BlockCopy(download.Texture.AssetData, 0, data.ImageData.Data, 0, imageDataSize);
server.UDP.SendPacket(agent.AgentID, data, PacketCategory.Texture);
// Check if ImagePacket packets need to be sent to complete this transfer
if (download.CurrentPacket <= download.StopPacket)
{
// Insert this download into the dictionary
lock (CurrentDownloads)
CurrentDownloads[block.Image] = download;
// Send all of the remaining packets
ThreadPool.QueueUserWorkItem(
delegate(object obj)
{
while (download.CurrentPacket <= download.StopPacket)
{
if (download.Priority == 0.0f && download.DiscardLevel == -1)
{
break;
}
lock (download)
{
int imagePacketSize = (download.CurrentPacket == download.TexturePacketCount() - 1) ?
download.LastPacketSize() : ImageDownload.IMAGE_PACKET_SIZE;
ImagePacketPacket transfer = new ImagePacketPacket();
transfer.ImageID.ID = block.Image;
transfer.ImageID.Packet = (ushort)download.CurrentPacket;
transfer.ImageData.Data = new byte[imagePacketSize];
Buffer.BlockCopy(download.Texture.AssetData, download.CurrentBytePosition(),
transfer.ImageData.Data, 0, imagePacketSize);
server.UDP.SendPacket(agent.AgentID, transfer, PacketCategory.Texture);
++download.CurrentPacket;
}
}
Logger.DebugLog("Completed image transfer for " + block.Image.ToString());
// Transfer is complete, remove the reference
lock (CurrentDownloads)
CurrentDownloads.Remove(block.Image);
}
);
}
}
else
{
Logger.Log("Request for a missing texture " + block.Image.ToString(), Helpers.LogLevel.Warning);
ImageNotInDatabasePacket notfound = new ImageNotInDatabasePacket();
notfound.ImageID.ID = block.Image;
server.UDP.SendPacket(agent.AgentID, notfound, PacketCategory.Texture);
}
}
}
}
protected virtual void ProcessInPacket(Packet Pack)
{
ack_pack(Pack);
if (debug)
{
if (Pack.Type != PacketType.AgentUpdate)
{
Console.WriteLine(Pack.Type.ToString());
}
}
if (this.ProcessPacketMethod(Pack))
{
//there is a handler registered that handled this packet type
return;
}
else
{
System.Text.Encoding _enc = System.Text.Encoding.ASCII;
switch (Pack.Type)
{
case PacketType.CompleteAgentMovement:
if (this.m_child)
{
this.UpgradeClient();
}
ClientAvatar.CompleteMovement(m_world);
ClientAvatar.SendInitialPosition();
break;
case PacketType.RegionHandshakeReply:
m_world.SendLayerData(this);
break;
case PacketType.AgentWearablesRequest:
ClientAvatar.SendInitialAppearance();
foreach (SimClient client in m_clientThreads.Values)
{
if (client.AgentID != this.AgentID)
{
ObjectUpdatePacket objupdate = client.ClientAvatar.CreateUpdatePacket();
this.OutPacket(objupdate);
client.ClientAvatar.SendAppearanceToOtherAgent(this);
}
}
m_world.GetInitialPrims(this);
break;
case PacketType.AgentIsNowWearing:
AgentIsNowWearingPacket wear = (AgentIsNowWearingPacket)Pack;
//Console.WriteLine(Pack.ToString());
break;
case PacketType.AgentSetAppearance:
AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack;
// Console.WriteLine(appear.ToString());
this.ClientAvatar.SetAppearance(appear);
break;
case PacketType.ObjectAdd:
m_world.AddNewPrim((ObjectAddPacket)Pack, this);
break;
case PacketType.ObjectLink:
OpenSim.Framework.Console.MainConsole.Instance.WriteLine(Pack.ToString());
ObjectLinkPacket link = (ObjectLinkPacket)Pack;
uint parentprimid = 0;
OpenSim.world.Primitive parentprim = null;
if (link.ObjectData.Length > 1)
{
parentprimid = link.ObjectData[0].ObjectLocalID;
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == parentprimid)
{
parentprim = (OpenSim.world.Primitive)ent;
}
}
for (int i = 1; i < link.ObjectData.Length; i++)
{
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == link.ObjectData[i].ObjectLocalID)
{
((OpenSim.world.Primitive)ent).MakeParent(parentprim);
}
}
}
}
break;
case PacketType.ObjectScale:
OpenSim.Framework.Console.MainConsole.Instance.WriteLine(Pack.ToString());
break;
case PacketType.ObjectShape:
ObjectShapePacket shape = (ObjectShapePacket)Pack;
for (int i = 0; i < shape.ObjectData.Length; i++)
{
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == shape.ObjectData[i].ObjectLocalID)
{
((OpenSim.world.Primitive)ent).UpdateShape(shape.ObjectData[i]);
}
}
}
break;
case PacketType.RequestImage:
RequestImagePacket imageRequest = (RequestImagePacket)Pack;
for (int i = 0; i < imageRequest.RequestImage.Length; i++)
{
m_assetCache.AddTextureRequest(this, imageRequest.RequestImage[i].Image);
}
break;
case PacketType.TransferRequest:
//Console.WriteLine("OpenSimClient.cs:ProcessInPacket() - Got transfer request");
TransferRequestPacket transfer = (TransferRequestPacket)Pack;
m_assetCache.AddAssetRequest(this, transfer);
break;
case PacketType.AgentUpdate:
ClientAvatar.HandleUpdate((AgentUpdatePacket)Pack);
break;
case PacketType.ObjectImage:
ObjectImagePacket imagePack = (ObjectImagePacket)Pack;
for (int i = 0; i < imagePack.ObjectData.Length; i++)
{
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == imagePack.ObjectData[i].ObjectLocalID)
{
((OpenSim.world.Primitive)ent).UpdateTexture(imagePack.ObjectData[i].TextureEntry);
}
}
}
break;
case PacketType.ObjectFlagUpdate:
ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == flags.AgentData.ObjectLocalID)
{
((OpenSim.world.Primitive)ent).UpdateObjectFlags(flags);
}
}
break;
case PacketType.AssetUploadRequest:
AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
this.UploadAssets.HandleUploadPacket(request, request.AssetBlock.TransactionID.Combine(this.SecureSessionID));
break;
case PacketType.RequestXfer:
//Console.WriteLine(Pack.ToString());
break;
case PacketType.SendXferPacket:
this.UploadAssets.HandleXferPacket((SendXferPacketPacket)Pack);
break;
case PacketType.CreateInventoryFolder:
CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;
m_inventoryCache.CreateNewInventoryFolder(this, invFolder.FolderData.FolderID, (ushort)invFolder.FolderData.Type, Util.FieldToString(invFolder.FolderData.Name), invFolder.FolderData.ParentID);
//Console.WriteLine(Pack.ToString());
break;
case PacketType.CreateInventoryItem:
//Console.WriteLine(Pack.ToString());
CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;
if (createItem.InventoryBlock.TransactionID != LLUUID.Zero)
{
this.UploadAssets.CreateInventoryItem(createItem);
}
else
{
// Console.Write(Pack.ToString());
this.CreateInventoryItem(createItem);
}
break;
case PacketType.FetchInventory:
//Console.WriteLine("fetch item packet");
FetchInventoryPacket FetchInventory = (FetchInventoryPacket)Pack;
m_inventoryCache.FetchInventory(this, FetchInventory);
break;
case PacketType.FetchInventoryDescendents:
FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;
m_inventoryCache.FetchInventoryDescendents(this, Fetch);
break;
case PacketType.UpdateInventoryItem:
UpdateInventoryItemPacket update = (UpdateInventoryItemPacket)Pack;
//Console.WriteLine(Pack.ToString());
for (int i = 0; i < update.InventoryData.Length; i++)
{
if (update.InventoryData[i].TransactionID != LLUUID.Zero)
{
AssetBase asset = m_assetCache.GetAsset(update.InventoryData[i].TransactionID.Combine(this.SecureSessionID));
if (asset != null)
{
// Console.WriteLine("updating inventory item, found asset" + asset.FullID.ToStringHyphenated() + " already in cache");
m_inventoryCache.UpdateInventoryItemAsset(this, update.InventoryData[i].ItemID, asset);
}
else
{
asset = this.UploadAssets.AddUploadToAssetCache(update.InventoryData[i].TransactionID);
if (asset != null)
{
//Console.WriteLine("updating inventory item, adding asset" + asset.FullID.ToStringHyphenated() + " to cache");
m_inventoryCache.UpdateInventoryItemAsset(this, update.InventoryData[i].ItemID, asset);
}
else
{
//Console.WriteLine("trying to update inventory item, but asset is null");
}
}
}
else
{
m_inventoryCache.UpdateInventoryItemDetails(this, update.InventoryData[i].ItemID, update.InventoryData[i]);;
}
}
break;
case PacketType.ViewerEffect:
ViewerEffectPacket viewer = (ViewerEffectPacket)Pack;
foreach (SimClient client in m_clientThreads.Values)
{
if (client.AgentID != this.AgentID)
{
viewer.AgentData.AgentID = client.AgentID;
viewer.AgentData.SessionID = client.SessionID;
client.OutPacket(viewer);
}
}
break;
case PacketType.RequestTaskInventory:
// Console.WriteLine(Pack.ToString());
RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;
ReplyTaskInventoryPacket replytask = new ReplyTaskInventoryPacket();
bool foundent = false;
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == requesttask.InventoryData.LocalID)
{
replytask.InventoryData.TaskID = ent.uuid;
replytask.InventoryData.Serial = 0;
replytask.InventoryData.Filename = new byte[0];
foundent = true;
}
}
if (foundent)
{
this.OutPacket(replytask);
}
break;
case PacketType.UpdateTaskInventory:
// Console.WriteLine(Pack.ToString());
UpdateTaskInventoryPacket updatetask = (UpdateTaskInventoryPacket)Pack;
AgentInventory myinventory = this.m_inventoryCache.GetAgentsInventory(this.AgentID);
if (myinventory != null)
{
if (updatetask.UpdateData.Key == 0)
{
if (myinventory.InventoryItems[updatetask.InventoryData.ItemID] != null)
{
if (myinventory.InventoryItems[updatetask.InventoryData.ItemID].Type == 7)
{
LLUUID noteaid = myinventory.InventoryItems[updatetask.InventoryData.ItemID].AssetID;
AssetBase assBase = this.m_assetCache.GetAsset(noteaid);
if (assBase != null)
{
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == updatetask.UpdateData.LocalID)
{
if (ent is OpenSim.world.Primitive)
{
this.m_world.AddScript(ent, Util.FieldToString(assBase.Data));
}
}
}
}
}
}
}
}
break;
case PacketType.AgentAnimation:
if (!m_child)
{
AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack;
for (int i = 0; i < AgentAni.AnimationList.Length; i++)
{
if (AgentAni.AnimationList[i].StartAnim)
{
ClientAvatar.current_anim = AgentAni.AnimationList[i].AnimID;
ClientAvatar.anim_seq = 1;
ClientAvatar.SendAnimPack();
}
}
}
break;
case PacketType.ObjectSelect:
ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;
for (int i = 0; i < incomingselect.ObjectData.Length; i++)
{
foreach (Entity ent in m_world.Entities.Values)
{
if (ent.localid == incomingselect.ObjectData[i].ObjectLocalID)
{
((OpenSim.world.Primitive)ent).GetProperites(this);
break;
}
}
}
break;
}
}
}
public bool GetImage(RequestImagePacket imgPacket)
{
if (imgPacket.AgentData.AgentID.Equals(libOwner))
// Tell grid surfer to forward request to region, because the Library is served from there (!)
return false;
RequestImagePacket.RequestImageBlock[] invImgBlocks = new RequestImagePacket.RequestImageBlock[imgPacket.RequestImage.Length];
int count = 0;
for (int i = 0; i < imgPacket.RequestImage.Length; i++)
{
//Console.WriteLine(" >> Requested image " + imgPacket.RequestImage[i].Image);
if (IsInventoryAsset(imgPacket.RequestImage[i].Image))
{
if (connected)
{
invImgBlocks[i] = imgPacket.RequestImage[i];
InventoryItemBase item = GetInventoryItem(imgPacket.RequestImage[i].Image);
if (item != null)
{
lock (textureSenders)
{
if (!textureSenders.ContainsKey(imgPacket.RequestImage[i].Image))
{
lock (textureSenders)
textureSenders.Add(imgPacket.RequestImage[i].Image, new TextureSender(this, proxy, imgPacket.RequestImage[i].DiscardLevel, imgPacket.RequestImage[i].Packet));
assDownloader.RequestAsset(item, true);
}
}
}
count++;
Console.WriteLine(" >> Image is inventory item");
}
}
else
invImgBlocks[i] = null;
}
if (count == imgPacket.RequestImage.Length)
{
// They were all inventory images
Console.WriteLine(" >> All images were inventory items");
return true;
}
else if (count == 0)
{
// None of them were inventory items
Console.WriteLine(" >> No images were inventory items");
return false;
}
else
{
RequestImagePacket.RequestImageBlock[] iblocks = new RequestImagePacket.RequestImageBlock[imgPacket.RequestImage.Length - count];
int j = 0;
for (int i = 0; i < invImgBlocks.Length; i++)
{
if (invImgBlocks[i] != null)
iblocks[j++] = imgPacket.RequestImage[i];
}
imgPacket.RequestImage = iblocks;
Console.WriteLine(" >> Some images were inventory items " + (imgPacket.RequestImage.Length - count));
// Forward this altered packet
return false;
}
}
