libremetaverse/libsecondlife-cs/AssetSystem/ImageManager.cs

/*
 * Copyright (c) 2006, Second Life Reverse Engineering Team
 * All rights reserved.
 *
 * - Redistribution and use in source and binary forms, with or without 
 *   modification, are permitted provided that the following conditions are met:
 *
 * - Redistributions of source code must retain the above copyright notice, this
 *   list of conditions and the following disclaimer.
 * - Neither the name of the Second Life Reverse Engineering Team nor the names 
 *   of its contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.IO;

using libsecondlife;
using libsecondlife.Packets;

using libsecondlife.InventorySystem;

namespace libsecondlife.AssetSystem
{
    public delegate void ImageRetrievedCallback(LLUUID id, byte[] data); //this delegate is called when an image completed.

    /// <summary>
	/// Manages the uploading and downloading of Images from SecondLife
	/// </summary>
	public class ImageManager
	{
		private SecondLife slClient;

        public enum CacheTypes {None, Memory, Disk};
        private CacheTypes CacheType;
        private string CacheDirectory = "ImageCache";
        private Dictionary<LLUUID, Byte[]> CacheTable = new Dictionary<LLUUID, byte[]>();

        private ImagePacketHelpers ImagePacketHelper;

		private Dictionary<LLUUID, TransferRequest> htDownloadRequests = new Dictionary<LLUUID,TransferRequest>();

        public ImageRetrievedCallback OnImageRetrieved;

		private class TransferRequest
		{
			public bool Completed;
			public bool Status;
			public string StatusMsg;

			public uint Size;
			public uint Received;
			public uint LastPacket;
			public byte[] AssetData;

            public int BaseDataReceived;

			public TransferRequest()
			{
				Completed = false;

				Status		= false;
				StatusMsg	= "";

				AssetData	= null;
                BaseDataReceived = 0;
			}
		}

        /// <summary>
        /// </summary>
        /// <param name="client"></param>
        public ImageManager(SecondLife client)
		{
            Init(client, CacheTypes.None, null);
        }

        /// <summary>
        /// </summary>
        /// <param name="client"></param>
        /// <param name="ctype">The type of Cache system to use for images.</param>
        public ImageManager(SecondLife client, CacheTypes ctype)
        {
            Init(client, ctype, null);
        }

        /// <summary>
        /// </summary>
        /// <param name="client"></param>
        /// <param name="ctype">The type of Cache system to use for images.</param>
        /// <param name="directory">The directory to use for disk based caching.</param>
        public ImageManager(SecondLife client, CacheTypes ctype, String directory)
        {
            Init(client, ctype, directory);
        }

        /// <summary>
        /// </summary>
        /// <param name="client"></param>
        /// <param name="ctype">The type of Cache system to use for images.</param>
        /// <param name="directory">The directory to use for disk based caching.</param>
        private void Init(SecondLife client, CacheTypes ctype, string directory)
        {
            slClient = client;

            // Setup Image Caching
            CacheType = ctype;
            if (ctype == CacheTypes.Disk)
            {
                if (directory != null)
                {
                    CacheDirectory = directory;
                }

                try
                {
                    if (!Directory.Exists(CacheDirectory))
                    {
                        Directory.CreateDirectory(CacheDirectory);
                    }
                }
                catch (Exception e)
                {
                    Console.WriteLine("ERROR: Disk Cache directory could not be established, defaulting to Memory Cache.");
                    Console.WriteLine(e.Message);

                    CacheType = CacheTypes.Memory;
                }

            }

            // Image Packet Helpers
            ImagePacketHelper = new ImagePacketHelpers(client.Network.AgentID, client.Network.SessionID);

            // Image Callbacks
            slClient.Network.RegisterCallback(PacketType.ImageData, new PacketCallback(ImageDataCallbackHandler));
            slClient.Network.RegisterCallback(PacketType.ImagePacket, new PacketCallback(ImagePacketCallbackHandler));
            slClient.Network.RegisterCallback(PacketType.ImageNotInDatabase, new PacketCallback(ImageNotInDatabaseCallbackHandler));
        }

        private void CacheImage(LLUUID ImageID, byte[] ImageData)
        {
            switch (CacheType)
            {
                case CacheTypes.Memory:
                    CacheTable[ImageID] = ImageData;
                    break;
                case CacheTypes.Disk:
                    String filepath = Path.Combine(CacheDirectory, ImageID.ToStringHyphenated());
                    File.WriteAllBytes(filepath, ImageData);
                    break;
                default:
                    break;
            }
        }

        private byte[] CachedImage(LLUUID ImageID)
        {
            switch (CacheType)
            {
                case CacheTypes.Memory:
                    if (CacheTable.ContainsKey(ImageID))
                    {
                        return CacheTable[ImageID];
                    }
                    else
                    {
                        return null;
                    }
                    

                case CacheTypes.Disk:
                    String filepath = Path.Combine(CacheDirectory, ImageID.ToStringHyphenated());
                    if (File.Exists(filepath))
                    {
                        return File.ReadAllBytes(filepath);
                    }
                    else
                    {
                        return null;
                    }

                default:
                    return null;
            }
        }

        public bool isDownloadingImages()
        {
            return htDownloadRequests.Count > 0;
        }

        /// <summary>
        /// Requests an image from SecondLife and blocks until it's received.
        /// </summary>
        /// <param name="ImageID">The Image's AssetID</param>
        public byte[] RequestImage(LLUUID ImageID)
		{
            byte[] imgData = CachedImage(ImageID);
            if (imgData != null)
            {
                return imgData;
            }

			TransferRequest tr = new TransferRequest();
			tr.Completed  = false;
			tr.Size		  = int.MaxValue; // Number of bytes expected
			tr.Received   = 0; // Number of bytes received
			tr.LastPacket = Helpers.GetUnixTime(); // last time we recevied a packet for this request

			htDownloadRequests[ImageID] = tr;

            Packet packet = ImagePacketHelper.RequestImage(ImageID);
			slClient.Network.SendPacket(packet);

			while( tr.Completed == false )
			{
				slClient.Tick();
			}

			if( tr.Status == true )
			{
                CacheImage(ImageID, tr.AssetData);
				return tr.AssetData;
			} 
			else 
			{
				throw new Exception( "RequestImage: " + tr.StatusMsg );
			}
		}

        /// <summary>
        /// Requests an image from SecondLife.
        /// </summary>
        /// <param name="ImageID">The Image's AssetID</param>
        public void RequestImageAsync(LLUUID ImageID)
        {
            byte[] imgData = CachedImage(ImageID);
            if (imgData != null)
            {
                FireImageRetrieved(ImageID, imgData);
            }

            TransferRequest tr = new TransferRequest();
            tr.Completed = false;
            tr.Size = int.MaxValue; // Number of bytes expected
            tr.Received = 0; // Number of bytes received
            tr.LastPacket = Helpers.GetUnixTime(); // last time we recevied a packet for this request

            htDownloadRequests[ImageID] = tr;

            Packet packet = ImagePacketHelper.RequestImage(ImageID);
            slClient.Network.SendPacket(packet);
        }


        /// <summary>
        /// Handles the Image Data packet, which includes the ID, and Size of the image, 
        /// along with the first block of data for the image.  If the image is small enough
        /// there will be no additional packets.
        /// </summary>
        /// <param name="packet"></param>
        /// <param name="simulator"></param>
        public void ImageDataCallbackHandler(Packet packet, Simulator simulator)
		{
            ImageDataPacket reply = (ImageDataPacket)packet;

			LLUUID ImageID = reply.ImageID.ID;
			ushort Packets = reply.ImageID.Packets;
			uint   Size    = reply.ImageID.Size;
			byte[] Data    = reply.ImageData.Data;

            // Lookup the request that this packet is for
			TransferRequest tr = htDownloadRequests[ImageID];
			if( tr == null )
			{
                // Received a packet for an image we didn't request...
				return;
			}

            // Initialize the request so that it's data buffer is the right size for the image
			tr.Size = Size;
			tr.AssetData = new byte[tr.Size];
            tr.BaseDataReceived = Data.Length;

            // Copy the first block of image data into the request.
			Array.Copy(Data, 0, tr.AssetData, tr.Received, Data.Length);
			tr.Received += (uint)Data.Length;

			// If we've gotten all the data, mark it completed.
			if( tr.Received >= tr.Size )
			{
				tr.Status	 = true;
                tr.Completed = true;

                // Fire off image downloaded event
                FireImageRetrieved(ImageID, tr.AssetData);
			}
		}

        /// <summary>
        /// Handles the remaining Image data that did not fit in the initial ImageData packet
        /// </summary>
        /// <param name="packet"></param>
        /// <param name="simulator"></param>
        public void ImagePacketCallbackHandler(Packet packet, Simulator simulator)
		{
            ImagePacketPacket reply = (ImagePacketPacket)packet;
            
            LLUUID ImageID = reply.ImageID.ID;

            // Lookup the request for this packet
            TransferRequest tr = (TransferRequest)htDownloadRequests[ImageID];
			if( tr == null )
			{
                // Received a packet that doesn't belong to any requests in our queue, strange...
				return;
			}


            // TODO: Received data should probably be put into a temporary collection that's indected by ImageID.Packet
            // then once we've received all data packets, it should be re-assembled into a complete array and marked
            // completed.


            // Add this packet's data to the request.
            Array.Copy(reply.ImageData.Data, 0, tr.AssetData, tr.BaseDataReceived + (1000 * (reply.ImageID.Packet - 1)), reply.ImageData.Data.Length);
            tr.Received += (uint)reply.ImageData.Data.Length;

			// If we've gotten all the data, mark it completed.
			if( tr.Received >= tr.Size )
			{
                tr.Status = true;
                tr.Completed = true;

                // Fire off image downloaded event
                FireImageRetrieved(ImageID, tr.AssetData);
			}		
		}

        /// <summary>
        ///
        /// </summary>
        public void ImageNotInDatabaseCallbackHandler(Packet packet, Simulator simulator)
        {
            ImageNotInDatabasePacket reply = (ImageNotInDatabasePacket)packet;

            LLUUID ImageID = reply.ImageID.ID;

            // Lookup the request for this packet
			TransferRequest tr = (TransferRequest)htDownloadRequests[ImageID];
			if( tr == null )
			{
                // Received a packet that doesn't belong to any requests in our queue, strange...
				return;
			}

            tr.Status = false;
            tr.StatusMsg = "Image not in database";
            tr.Completed = true;

            // Fire off image downloaded event
            FireImageRetrieved(ImageID, null);
        }

        private void FireImageRetrieved(LLUUID ImageID, byte[] ImageData)
        {
            if (OnImageRetrieved != null)
            {
                OnImageRetrieved(ImageID, ImageData);
            }
        }

    }
}