using System;
using System.Collections;
using System.IO;
using UnityEngine;

namespace Gif.Components
{
	// Token: 0x02000006 RID: 6
	public class GifDecoder
	{
		// Token: 0x06000023 RID: 35 RVA: 0x00002CFC File Offset: 0x000010FC
		public int GetDelay(int n)
		{
			this.delay = -1;
			if (n >= 0 && n < this.frameCount)
			{
				this.delay = ((GifDecoder.GifFrame)this.frames[n]).delay;
			}
			return this.delay;
		}

		// Token: 0x06000024 RID: 36 RVA: 0x00002D50 File Offset: 0x00001150
		public int GetFrameCount()
		{
			return this.frameCount;
		}

		// Token: 0x06000025 RID: 37 RVA: 0x00002D6C File Offset: 0x0000116C
		public Image GetImage()
		{
			return this.GetFrame(0);
		}

		// Token: 0x06000026 RID: 38 RVA: 0x00002D88 File Offset: 0x00001188
		public int GetLoopCount()
		{
			return this.loopCount;
		}

		// Token: 0x06000027 RID: 39 RVA: 0x00002DA4 File Offset: 0x000011A4
		private int[] GetPixels(Image bitmap)
		{
			int[] array = new int[3 * this.image.width * this.image.height];
			int num = 0;
			for (int i = 0; i < this.image.height; i++)
			{
				for (int j = 0; j < this.image.width; j++)
				{
					Color32 color = bitmap[j, i];
					array[num] = (int)color.r;
					num++;
					array[num] = (int)color.g;
					num++;
					array[num] = (int)color.b;
					num++;
				}
			}
			return array;
		}

		// Token: 0x06000028 RID: 40 RVA: 0x00002E50 File Offset: 0x00001250
		private void SetPixels(int[] pixels)
		{
			int num = 0;
			for (int i = 0; i < this.image.height; i++)
			{
				for (int j = 0; j < this.image.width; j++)
				{
					int num2 = pixels[num++];
					byte b = (byte)((num2 >> 16) & 255);
					byte b2 = (byte)((num2 >> 8) & 255);
					byte b3 = (byte)((num2 >> 0) & 255);
					byte b4 = (byte)((num2 >> 24) & 255);
					Color32 color = new Color32(b, b2, b3, b4);
					this.bitmap[j, i] = color;
				}
			}
		}

		// Token: 0x06000029 RID: 41 RVA: 0x00002EF4 File Offset: 0x000012F4
		protected void SetPixels()
		{
			int[] array = this.GetPixels(this.bitmap);
			if (this.lastDispose > 0)
			{
				if (this.lastDispose == 3)
				{
					int num = this.frameCount - 2;
					if (num > 0)
					{
						this.lastImage = this.GetFrame(num - 1);
					}
					else
					{
						this.lastImage = null;
					}
				}
				if (this.lastImage != null)
				{
					int[] array2 = this.GetPixels(this.lastImage);
					Array.Copy(array2, 0, array, 0, this.width * this.height);
					if (this.lastDispose == 2)
					{
						Color32 color = default(Color32);
						if (this.transparency)
						{
							color = new Color32(0, 0, 0, 0);
						}
						else
						{
							int num2 = this.lastBgColor;
							byte b = (byte)((num2 >> 16) & 255);
							byte b2 = (byte)((num2 >> 8) & 255);
							byte b3 = (byte)((num2 >> 0) & 255);
							byte b4 = (byte)((num2 >> 24) & 255);
							color = new Color32(b, b2, b3, b4);
						}
						this.image.Fill(color, this.lastRect.xmin, this.lastRect.ymin, this.lastRect.xmax, this.lastRect.ymax);
					}
				}
			}
			int num3 = 1;
			int num4 = 8;
			int num5 = 0;
			for (int i = 0; i < this.ih; i++)
			{
				int num6 = i;
				if (this.interlace)
				{
					if (num5 >= this.ih)
					{
						num3++;
						if (num3 != 2)
						{
							if (num3 != 3)
							{
								if (num3 == 4)
								{
									num5 = 1;
									num4 = 2;
								}
							}
							else
							{
								num5 = 2;
								num4 = 4;
							}
						}
						else
						{
							num5 = 4;
						}
					}
					num6 = num5;
					num5 += num4;
				}
				num6 += this.iy;
				if (num6 < this.height)
				{
					int num7 = num6 * this.width;
					int j = num7 + this.ix;
					int num8 = j + this.iw;
					if (num7 + this.width < num8)
					{
						num8 = num7 + this.width;
					}
					int num9 = i * this.iw;
					while (j < num8)
					{
						int num10 = (int)(this.pixels[num9++] & byte.MaxValue);
						int num11 = this.act[num10];
						if (num11 != 0)
						{
							array[j] = num11;
						}
						j++;
					}
				}
			}
			this.SetPixels(array);
		}

		// Token: 0x0600002A RID: 42 RVA: 0x00003188 File Offset: 0x00001588
		public Image GetFrame(int n)
		{
			Image image = null;
			if (n >= 0 && n < this.frameCount)
			{
				image = ((GifDecoder.GifFrame)this.frames[n]).image;
			}
			return image;
		}

		// Token: 0x0600002B RID: 43 RVA: 0x000031CC File Offset: 0x000015CC
		public Size GetFrameSize()
		{
			return new Size(this.width, this.height);
		}

		// Token: 0x0600002C RID: 44 RVA: 0x000031F4 File Offset: 0x000015F4
		public int Read(Stream inStream)
		{
			this.Init();
			if (inStream != null)
			{
				this.inStream = inStream;
				this.ReadHeader();
				if (!this.Error())
				{
					this.ReadContents();
					if (this.frameCount < 0)
					{
						this.status = GifDecoder.STATUS_FORMAT_ERROR;
					}
				}
				inStream.Close();
			}
			else
			{
				this.status = GifDecoder.STATUS_OPEN_ERROR;
			}
			return this.status;
		}

		// Token: 0x0600002D RID: 45 RVA: 0x00003270 File Offset: 0x00001670
		public int Read(string name)
		{
			this.status = GifDecoder.STATUS_OK;
			try
			{
				name = name.Trim().ToLower();
				this.status = this.Read(new FileInfo(name).OpenRead());
			}
			catch (IOException ex)
			{
				this.status = GifDecoder.STATUS_OPEN_ERROR;
			}
			return this.status;
		}

		// Token: 0x0600002E RID: 46 RVA: 0x000032E4 File Offset: 0x000016E4
		protected void DecodeImageData()
		{
			int num = -1;
			int num2 = this.iw * this.ih;
			if (this.pixels == null || this.pixels.Length < num2)
			{
				this.pixels = new byte[num2];
			}
			if (this.prefix == null)
			{
				this.prefix = new short[GifDecoder.MaxStackSize];
			}
			if (this.suffix == null)
			{
				this.suffix = new byte[GifDecoder.MaxStackSize];
			}
			if (this.pixelStack == null)
			{
				this.pixelStack = new byte[GifDecoder.MaxStackSize + 1];
			}
			int num3 = this.Read();
			int num4 = 1 << num3;
			int num5 = num4 + 1;
			int num6 = num4 + 2;
			int num7 = num;
			int num8 = num3 + 1;
			int num9 = (1 << num8) - 1;
			for (int i = 0; i < num4; i++)
			{
				this.prefix[i] = 0;
				this.suffix[i] = (byte)i;
			}
			int num16;
			int num15;
			int num14;
			int num13;
			int num12;
			int num11;
			int num10 = (num11 = (num12 = (num13 = (num14 = (num15 = (num16 = 0))))));
			for (int j = 0; j < num2; j++)
			{
				if (num14 == 0)
				{
					if (num10 < num8)
					{
						if (num12 == 0)
						{
							num12 = this.ReadBlock();
							if (num12 <= 0)
							{
								break;
							}
							num16 = 0;
						}
						num11 += (int)(this.block[num16] & byte.MaxValue) << num10;
						num10 += 8;
						num16++;
						num12--;
						continue;
					}
					int i = num11 & num9;
					num11 >>= num8;
					num10 -= num8;
					if (i > num6 || i == num5)
					{
						break;
					}
					if (i == num4)
					{
						num8 = num3 + 1;
						num9 = (1 << num8) - 1;
						num6 = num4 + 2;
						num7 = num;
						continue;
					}
					if (num7 == num)
					{
						this.pixelStack[num14++] = this.suffix[i];
						num7 = i;
						num13 = i;
						continue;
					}
					int num17 = i;
					if (i == num6)
					{
						this.pixelStack[num14++] = (byte)num13;
						i = num7;
					}
					while (i > num4)
					{
						this.pixelStack[num14++] = this.suffix[i];
						i = (int)this.prefix[i];
					}
					num13 = (int)(this.suffix[i] & byte.MaxValue);
					if (num6 >= GifDecoder.MaxStackSize)
					{
						break;
					}
					this.pixelStack[num14++] = (byte)num13;
					this.prefix[num6] = (short)num7;
					this.suffix[num6] = (byte)num13;
					num6++;
					if ((num6 & num9) == 0 && num6 < GifDecoder.MaxStackSize)
					{
						num8++;
						num9 += num6;
					}
					num7 = num17;
				}
				num14--;
				this.pixels[num15++] = this.pixelStack[num14];
			}
			for (int j = num15; j < num2; j++)
			{
				this.pixels[j] = 0;
			}
		}

		// Token: 0x0600002F RID: 47 RVA: 0x000035F0 File Offset: 0x000019F0
		protected bool Error()
		{
			return this.status != GifDecoder.STATUS_OK;
		}

		// Token: 0x06000030 RID: 48 RVA: 0x00003615 File Offset: 0x00001A15
		protected void Init()
		{
			this.status = GifDecoder.STATUS_OK;
			this.frameCount = 0;
			this.frames = new ArrayList();
			this.gct = null;
			this.lct = null;
		}

		// Token: 0x06000031 RID: 49 RVA: 0x00003644 File Offset: 0x00001A44
		protected int Read()
		{
			int num = 0;
			try
			{
				num = this.inStream.ReadByte();
			}
			catch (IOException ex)
			{
				this.status = GifDecoder.STATUS_FORMAT_ERROR;
			}
			return num;
		}

		// Token: 0x06000032 RID: 50 RVA: 0x00003694 File Offset: 0x00001A94
		protected int ReadBlock()
		{
			this.blockSize = this.Read();
			int i = 0;
			if (this.blockSize > 0)
			{
				try
				{
					while (i < this.blockSize)
					{
						int num = this.inStream.Read(this.block, i, this.blockSize - i);
						if (num == -1)
						{
							break;
						}
						i += num;
					}
				}
				catch (IOException ex)
				{
				}
				if (i < this.blockSize)
				{
					this.status = GifDecoder.STATUS_FORMAT_ERROR;
				}
			}
			return i;
		}

		// Token: 0x06000033 RID: 51 RVA: 0x00003740 File Offset: 0x00001B40
		protected int[] ReadColorTable(int ncolors)
		{
			int num = 3 * ncolors;
			int[] array = null;
			byte[] array2 = new byte[num];
			int num2 = 0;
			try
			{
				num2 = this.inStream.Read(array2, 0, array2.Length);
			}
			catch (IOException ex)
			{
			}
			if (num2 < num)
			{
				this.status = GifDecoder.STATUS_FORMAT_ERROR;
			}
			else
			{
				array = new int[256];
				int i = 0;
				int num3 = 0;
				while (i < ncolors)
				{
					int num4 = (int)(array2[num3++] & byte.MaxValue);
					int num5 = (int)(array2[num3++] & byte.MaxValue);
					int num6 = (int)(array2[num3++] & byte.MaxValue);
					array[i++] = (int)((ulong)(-16777216) | (ulong)((long)((long)num4 << 16)) | (ulong)((long)((long)num5 << 8)) | (ulong)((long)num6));
				}
			}
			return array;
		}

		// Token: 0x06000034 RID: 52 RVA: 0x00003828 File Offset: 0x00001C28
		protected void ReadContents()
		{
			bool flag = false;
			while (!flag && !this.Error())
			{
				int num = this.Read();
				if (num != 0)
				{
					if (num != 33)
					{
						if (num != 44)
						{
							if (num != 59)
							{
								this.status = GifDecoder.STATUS_FORMAT_ERROR;
							}
							else
							{
								flag = true;
							}
						}
						else
						{
							this.ReadImage();
						}
					}
					else
					{
						num = this.Read();
						if (num != 249)
						{
							if (num != 255)
							{
								this.Skip();
							}
							else
							{
								this.ReadBlock();
								string text = "";
								for (int i = 0; i < 11; i++)
								{
									text += (char)this.block[i];
								}
								if (text.Equals("NETSCAPE2.0"))
								{
									this.ReadNetscapeExt();
								}
								else
								{
									this.Skip();
								}
							}
						}
						else
						{
							this.ReadGraphicControlExt();
						}
					}
				}
			}
		}

		// Token: 0x06000035 RID: 53 RVA: 0x00003940 File Offset: 0x00001D40
		protected void ReadGraphicControlExt()
		{
			this.Read();
			int num = this.Read();
			this.dispose = (num & 28) >> 2;
			if (this.dispose == 0)
			{
				this.dispose = 1;
			}
			this.transparency = (num & 1) != 0;
			this.delay = this.ReadShort() * 10;
			this.transIndex = this.Read();
			this.Read();
		}

		// Token: 0x06000036 RID: 54 RVA: 0x000039B0 File Offset: 0x00001DB0
		protected void ReadHeader()
		{
			string text = "";
			for (int i = 0; i < 6; i++)
			{
				text += (char)this.Read();
			}
			if (!text.StartsWith("GIF"))
			{
				this.status = GifDecoder.STATUS_FORMAT_ERROR;
			}
			else
			{
				this.ReadLSD();
				if (this.gctFlag && !this.Error())
				{
					this.gct = this.ReadColorTable(this.gctSize);
					this.bgColor = this.gct[this.bgIndex];
				}
			}
		}

		// Token: 0x06000037 RID: 55 RVA: 0x00003A50 File Offset: 0x00001E50
		protected void ReadImage()
		{
			this.ix = this.ReadShort();
			this.iy = this.ReadShort();
			this.iw = this.ReadShort();
			this.ih = this.ReadShort();
			int num = this.Read();
			this.lctFlag = (num & 128) != 0;
			this.interlace = (num & 64) != 0;
			this.lctSize = 2 << (num & 7);
			if (this.lctFlag)
			{
				this.lct = this.ReadColorTable(this.lctSize);
				this.act = this.lct;
			}
			else
			{
				this.act = this.gct;
				if (this.bgIndex == this.transIndex)
				{
					this.bgColor = 0;
				}
			}
			int num2 = 0;
			if (this.transparency)
			{
				num2 = this.act[this.transIndex];
				this.act[this.transIndex] = 0;
			}
			if (this.act == null)
			{
				this.status = GifDecoder.STATUS_FORMAT_ERROR;
			}
			if (!this.Error())
			{
				this.DecodeImageData();
				this.Skip();
				if (!this.Error())
				{
					this.frameCount++;
					this.bitmap = new Image(this.width, this.height);
					this.image = this.bitmap;
					this.SetPixels();
					this.frames.Add(new GifDecoder.GifFrame(this.bitmap, this.delay));
					if (this.transparency)
					{
						this.act[this.transIndex] = num2;
					}
					this.ResetFrame();
				}
			}
		}

		// Token: 0x06000038 RID: 56 RVA: 0x00003C00 File Offset: 0x00002000
		protected void ReadLSD()
		{
			this.width = this.ReadShort();
			this.height = this.ReadShort();
			int num = this.Read();
			this.gctFlag = (num & 128) != 0;
			this.gctSize = 2 << (num & 7);
			this.bgIndex = this.Read();
			this.pixelAspect = this.Read();
		}

		// Token: 0x06000039 RID: 57 RVA: 0x00003C68 File Offset: 0x00002068
		protected void ReadNetscapeExt()
		{
			do
			{
				this.ReadBlock();
				if (this.block[0] == 1)
				{
					int num = (int)(this.block[1] & byte.MaxValue);
					int num2 = (int)(this.block[2] & byte.MaxValue);
					this.loopCount = (num2 << 8) | num;
				}
			}
			while (this.blockSize > 0 && !this.Error());
		}

		// Token: 0x0600003A RID: 58 RVA: 0x00003CD0 File Offset: 0x000020D0
		protected int ReadShort()
		{
			return this.Read() | (this.Read() << 8);
		}

		// Token: 0x0600003B RID: 59 RVA: 0x00003CF4 File Offset: 0x000020F4
		protected void ResetFrame()
		{
			this.lastDispose = this.dispose;
			this.lastRect = new Rectangle
			{
				xmin = this.ix,
				ymin = this.iy,
				xmax = this.ix + this.iw,
				ymax = this.iy + this.ih
			};
			this.lastImage = this.image;
			this.lastBgColor = this.bgColor;
			this.lct = null;
		}

		// Token: 0x0600003C RID: 60 RVA: 0x00003D82 File Offset: 0x00002182
		protected void Skip()
		{
			do
			{
				this.ReadBlock();
			}
			while (this.blockSize > 0 && !this.Error());
		}

		// Token: 0x04000025 RID: 37
		public static readonly int STATUS_OK = 0;

		// Token: 0x04000026 RID: 38
		public static readonly int STATUS_FORMAT_ERROR = 1;

		// Token: 0x04000027 RID: 39
		public static readonly int STATUS_OPEN_ERROR = 2;

		// Token: 0x04000028 RID: 40
		protected Stream inStream;

		// Token: 0x04000029 RID: 41
		protected int status;

		// Token: 0x0400002A RID: 42
		protected int width;

		// Token: 0x0400002B RID: 43
		protected int height;

		// Token: 0x0400002C RID: 44
		protected bool gctFlag;

		// Token: 0x0400002D RID: 45
		protected int gctSize;

		// Token: 0x0400002E RID: 46
		protected int loopCount = 1;

		// Token: 0x0400002F RID: 47
		protected int[] gct;

		// Token: 0x04000030 RID: 48
		protected int[] lct;

		// Token: 0x04000031 RID: 49
		protected int[] act;

		// Token: 0x04000032 RID: 50
		protected int bgIndex;

		// Token: 0x04000033 RID: 51
		protected int bgColor;

		// Token: 0x04000034 RID: 52
		protected int lastBgColor;

		// Token: 0x04000035 RID: 53
		protected int pixelAspect;

		// Token: 0x04000036 RID: 54
		protected bool lctFlag;

		// Token: 0x04000037 RID: 55
		protected bool interlace;

		// Token: 0x04000038 RID: 56
		protected int lctSize;

		// Token: 0x04000039 RID: 57
		protected int ix;

		// Token: 0x0400003A RID: 58
		protected int iy;

		// Token: 0x0400003B RID: 59
		protected int iw;

		// Token: 0x0400003C RID: 60
		protected int ih;

		// Token: 0x0400003D RID: 61
		protected Rectangle lastRect;

		// Token: 0x0400003E RID: 62
		protected Image image;

		// Token: 0x0400003F RID: 63
		protected Image bitmap;

		// Token: 0x04000040 RID: 64
		protected Image lastImage;

		// Token: 0x04000041 RID: 65
		protected byte[] block = new byte[256];

		// Token: 0x04000042 RID: 66
		protected int blockSize = 0;

		// Token: 0x04000043 RID: 67
		protected int dispose = 0;

		// Token: 0x04000044 RID: 68
		protected int lastDispose = 0;

		// Token: 0x04000045 RID: 69
		protected bool transparency = false;

		// Token: 0x04000046 RID: 70
		protected int delay = 0;

		// Token: 0x04000047 RID: 71
		protected int transIndex;

		// Token: 0x04000048 RID: 72
		protected static readonly int MaxStackSize = 4096;

		// Token: 0x04000049 RID: 73
		protected short[] prefix;

		// Token: 0x0400004A RID: 74
		protected byte[] suffix;

		// Token: 0x0400004B RID: 75
		protected byte[] pixelStack;

		// Token: 0x0400004C RID: 76
		protected byte[] pixels;

		// Token: 0x0400004D RID: 77
		protected ArrayList frames;

		// Token: 0x0400004E RID: 78
		protected int frameCount;

		// Token: 0x02000007 RID: 7
		public class GifFrame
		{
			// Token: 0x0600003E RID: 62 RVA: 0x00003DC3 File Offset: 0x000021C3
			public GifFrame(Image im, int del)
			{
				this.image = im;
				this.delay = del;
			}

			// Token: 0x0400004F RID: 79
			public Image image;

			// Token: 0x04000050 RID: 80
			public int delay;
		}
	}
}