scripts
This commit is contained in:
niko
@@ -0,0 +1,35 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000007 RID: 7
|
||||
public class ChunkCopyBehaviour
|
||||
{
|
||||
// Token: 0x0400002B RID: 43
|
||||
public static readonly int COPY_NONE = 0;
|
||||
|
||||
// Token: 0x0400002C RID: 44
|
||||
public static readonly int COPY_PALETTE = 1;
|
||||
|
||||
// Token: 0x0400002D RID: 45
|
||||
public static readonly int COPY_ALL_SAFE = 4;
|
||||
|
||||
// Token: 0x0400002E RID: 46
|
||||
public static readonly int COPY_ALL = 8;
|
||||
|
||||
// Token: 0x0400002F RID: 47
|
||||
public static readonly int COPY_PHYS = 16;
|
||||
|
||||
// Token: 0x04000030 RID: 48
|
||||
public static readonly int COPY_TEXTUAL = 32;
|
||||
|
||||
// Token: 0x04000031 RID: 49
|
||||
public static readonly int COPY_TRANSPARENCY = 64;
|
||||
|
||||
// Token: 0x04000032 RID: 50
|
||||
public static readonly int COPY_UNKNOWN = 128;
|
||||
|
||||
// Token: 0x04000033 RID: 51
|
||||
public static readonly int COPY_ALMOSTALL = 256;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,294 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using Hjg.Pngcs.Zlib;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000002 RID: 2
|
||||
public class ChunkHelper
|
||||
{
|
||||
// Token: 0x06000001 RID: 1 RVA: 0x00002050 File Offset: 0x00000250
|
||||
public static byte[] ToBytes(string x)
|
||||
{
|
||||
return PngHelperInternal.charsetLatin1.GetBytes(x);
|
||||
}
|
||||
|
||||
// Token: 0x06000002 RID: 2 RVA: 0x0000205D File Offset: 0x0000025D
|
||||
public static string ToString(byte[] x)
|
||||
{
|
||||
return PngHelperInternal.charsetLatin1.GetString(x);
|
||||
}
|
||||
|
||||
// Token: 0x06000003 RID: 3 RVA: 0x0000206A File Offset: 0x0000026A
|
||||
public static string ToString(byte[] x, int offset, int len)
|
||||
{
|
||||
return PngHelperInternal.charsetLatin1.GetString(x, offset, len);
|
||||
}
|
||||
|
||||
// Token: 0x06000004 RID: 4 RVA: 0x00002079 File Offset: 0x00000279
|
||||
public static byte[] ToBytesUTF8(string x)
|
||||
{
|
||||
return PngHelperInternal.charsetUtf8.GetBytes(x);
|
||||
}
|
||||
|
||||
// Token: 0x06000005 RID: 5 RVA: 0x00002086 File Offset: 0x00000286
|
||||
public static string ToStringUTF8(byte[] x)
|
||||
{
|
||||
return PngHelperInternal.charsetUtf8.GetString(x);
|
||||
}
|
||||
|
||||
// Token: 0x06000006 RID: 6 RVA: 0x00002093 File Offset: 0x00000293
|
||||
public static string ToStringUTF8(byte[] x, int offset, int len)
|
||||
{
|
||||
return PngHelperInternal.charsetUtf8.GetString(x, offset, len);
|
||||
}
|
||||
|
||||
// Token: 0x06000007 RID: 7 RVA: 0x000020A2 File Offset: 0x000002A2
|
||||
public static void WriteBytesToStream(Stream stream, byte[] bytes)
|
||||
{
|
||||
stream.Write(bytes, 0, bytes.Length);
|
||||
}
|
||||
|
||||
// Token: 0x06000008 RID: 8 RVA: 0x000020AF File Offset: 0x000002AF
|
||||
public static bool IsCritical(string id)
|
||||
{
|
||||
return char.IsUpper(id[0]);
|
||||
}
|
||||
|
||||
// Token: 0x06000009 RID: 9 RVA: 0x000020BD File Offset: 0x000002BD
|
||||
public static bool IsPublic(string id)
|
||||
{
|
||||
return char.IsUpper(id[1]);
|
||||
}
|
||||
|
||||
// Token: 0x0600000A RID: 10 RVA: 0x000020CB File Offset: 0x000002CB
|
||||
public static bool IsSafeToCopy(string id)
|
||||
{
|
||||
return !char.IsUpper(id[3]);
|
||||
}
|
||||
|
||||
// Token: 0x0600000B RID: 11 RVA: 0x000020DC File Offset: 0x000002DC
|
||||
public static bool IsUnknown(PngChunk chunk)
|
||||
{
|
||||
return chunk is PngChunkUNKNOWN;
|
||||
}
|
||||
|
||||
// Token: 0x0600000C RID: 12 RVA: 0x000020E8 File Offset: 0x000002E8
|
||||
public static int PosNullByte(byte[] bytes)
|
||||
{
|
||||
for (int i = 0; i < bytes.Length; i++)
|
||||
{
|
||||
if (bytes[i] == 0)
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Token: 0x0600000D RID: 13 RVA: 0x0000210C File Offset: 0x0000030C
|
||||
public static bool ShouldLoad(string id, ChunkLoadBehaviour behav)
|
||||
{
|
||||
if (ChunkHelper.IsCritical(id))
|
||||
{
|
||||
return true;
|
||||
}
|
||||
bool flag = PngChunk.isKnown(id);
|
||||
switch (behav)
|
||||
{
|
||||
case ChunkLoadBehaviour.LOAD_CHUNK_NEVER:
|
||||
return false;
|
||||
case ChunkLoadBehaviour.LOAD_CHUNK_KNOWN:
|
||||
return flag;
|
||||
case ChunkLoadBehaviour.LOAD_CHUNK_IF_SAFE:
|
||||
return flag || ChunkHelper.IsSafeToCopy(id);
|
||||
case ChunkLoadBehaviour.LOAD_CHUNK_ALWAYS:
|
||||
return true;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600000E RID: 14 RVA: 0x00002157 File Offset: 0x00000357
|
||||
internal static byte[] compressBytes(byte[] ori, bool compress)
|
||||
{
|
||||
return ChunkHelper.compressBytes(ori, 0, ori.Length, compress);
|
||||
}
|
||||
|
||||
// Token: 0x0600000F RID: 15 RVA: 0x00002164 File Offset: 0x00000364
|
||||
internal static byte[] compressBytes(byte[] ori, int offset, int len, bool compress)
|
||||
{
|
||||
byte[] array2;
|
||||
try
|
||||
{
|
||||
MemoryStream memoryStream = new MemoryStream(ori, offset, len);
|
||||
Stream stream = memoryStream;
|
||||
if (!compress)
|
||||
{
|
||||
stream = ZlibStreamFactory.createZlibInputStream(memoryStream);
|
||||
}
|
||||
MemoryStream memoryStream2 = new MemoryStream();
|
||||
Stream stream2 = memoryStream2;
|
||||
if (compress)
|
||||
{
|
||||
stream2 = ZlibStreamFactory.createZlibOutputStream(memoryStream2);
|
||||
}
|
||||
ChunkHelper.shovelInToOut(stream, stream2);
|
||||
stream.Close();
|
||||
stream2.Close();
|
||||
byte[] array = memoryStream2.ToArray();
|
||||
array2 = array;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
throw new PngjException(ex);
|
||||
}
|
||||
return array2;
|
||||
}
|
||||
|
||||
// Token: 0x06000010 RID: 16 RVA: 0x000021D8 File Offset: 0x000003D8
|
||||
private static void shovelInToOut(Stream inx, Stream outx)
|
||||
{
|
||||
byte[] array = new byte[1024];
|
||||
int num;
|
||||
while ((num = inx.Read(array, 0, 1024)) > 0)
|
||||
{
|
||||
outx.Write(array, 0, num);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000011 RID: 17 RVA: 0x0000220D File Offset: 0x0000040D
|
||||
internal static bool maskMatch(int v, int mask)
|
||||
{
|
||||
return (v & mask) != 0;
|
||||
}
|
||||
|
||||
// Token: 0x06000012 RID: 18 RVA: 0x00002218 File Offset: 0x00000418
|
||||
public static List<PngChunk> FilterList(List<PngChunk> list, ChunkPredicate predicateKeep)
|
||||
{
|
||||
List<PngChunk> list2 = new List<PngChunk>();
|
||||
foreach (PngChunk pngChunk in list)
|
||||
{
|
||||
if (predicateKeep.Matches(pngChunk))
|
||||
{
|
||||
list2.Add(pngChunk);
|
||||
}
|
||||
}
|
||||
return list2;
|
||||
}
|
||||
|
||||
// Token: 0x06000013 RID: 19 RVA: 0x00002278 File Offset: 0x00000478
|
||||
public static int TrimList(List<PngChunk> list, ChunkPredicate predicateRemove)
|
||||
{
|
||||
int num = 0;
|
||||
for (int i = list.Count - 1; i >= 0; i--)
|
||||
{
|
||||
if (predicateRemove.Matches(list[i]))
|
||||
{
|
||||
list.RemoveAt(i);
|
||||
num++;
|
||||
}
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x06000014 RID: 20 RVA: 0x000022B8 File Offset: 0x000004B8
|
||||
public static bool Equivalent(PngChunk c1, PngChunk c2)
|
||||
{
|
||||
if (c1 == c2)
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (c1 == null || c2 == null || !c1.Id.Equals(c2.Id))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (c1.GetType() != c2.GetType())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
if (!c2.AllowsMultiple())
|
||||
{
|
||||
return true;
|
||||
}
|
||||
if (c1 is PngChunkTextVar)
|
||||
{
|
||||
return ((PngChunkTextVar)c1).GetKey().Equals(((PngChunkTextVar)c2).GetKey());
|
||||
}
|
||||
return c1 is PngChunkSPLT && ((PngChunkSPLT)c1).PalName.Equals(((PngChunkSPLT)c2).PalName);
|
||||
}
|
||||
|
||||
// Token: 0x06000015 RID: 21 RVA: 0x00002349 File Offset: 0x00000549
|
||||
public static bool IsText(PngChunk c)
|
||||
{
|
||||
return c is PngChunkTextVar;
|
||||
}
|
||||
|
||||
// Token: 0x04000001 RID: 1
|
||||
internal const string IHDR = "IHDR";
|
||||
|
||||
// Token: 0x04000002 RID: 2
|
||||
internal const string PLTE = "PLTE";
|
||||
|
||||
// Token: 0x04000003 RID: 3
|
||||
internal const string IDAT = "IDAT";
|
||||
|
||||
// Token: 0x04000004 RID: 4
|
||||
internal const string IEND = "IEND";
|
||||
|
||||
// Token: 0x04000005 RID: 5
|
||||
internal const string cHRM = "cHRM";
|
||||
|
||||
// Token: 0x04000006 RID: 6
|
||||
internal const string gAMA = "gAMA";
|
||||
|
||||
// Token: 0x04000007 RID: 7
|
||||
internal const string iCCP = "iCCP";
|
||||
|
||||
// Token: 0x04000008 RID: 8
|
||||
internal const string sBIT = "sBIT";
|
||||
|
||||
// Token: 0x04000009 RID: 9
|
||||
internal const string sRGB = "sRGB";
|
||||
|
||||
// Token: 0x0400000A RID: 10
|
||||
internal const string bKGD = "bKGD";
|
||||
|
||||
// Token: 0x0400000B RID: 11
|
||||
internal const string hIST = "hIST";
|
||||
|
||||
// Token: 0x0400000C RID: 12
|
||||
internal const string tRNS = "tRNS";
|
||||
|
||||
// Token: 0x0400000D RID: 13
|
||||
internal const string pHYs = "pHYs";
|
||||
|
||||
// Token: 0x0400000E RID: 14
|
||||
internal const string sPLT = "sPLT";
|
||||
|
||||
// Token: 0x0400000F RID: 15
|
||||
internal const string tIME = "tIME";
|
||||
|
||||
// Token: 0x04000010 RID: 16
|
||||
internal const string iTXt = "iTXt";
|
||||
|
||||
// Token: 0x04000011 RID: 17
|
||||
internal const string tEXt = "tEXt";
|
||||
|
||||
// Token: 0x04000012 RID: 18
|
||||
internal const string zTXt = "zTXt";
|
||||
|
||||
// Token: 0x04000013 RID: 19
|
||||
internal static readonly byte[] b_IHDR = ChunkHelper.ToBytes("IHDR");
|
||||
|
||||
// Token: 0x04000014 RID: 20
|
||||
internal static readonly byte[] b_PLTE = ChunkHelper.ToBytes("PLTE");
|
||||
|
||||
// Token: 0x04000015 RID: 21
|
||||
internal static readonly byte[] b_IDAT = ChunkHelper.ToBytes("IDAT");
|
||||
|
||||
// Token: 0x04000016 RID: 22
|
||||
internal static readonly byte[] b_IEND = ChunkHelper.ToBytes("IEND");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000004 RID: 4
|
||||
public enum ChunkLoadBehaviour
|
||||
{
|
||||
// Token: 0x04000021 RID: 33
|
||||
LOAD_CHUNK_NEVER,
|
||||
// Token: 0x04000022 RID: 34
|
||||
LOAD_CHUNK_KNOWN,
|
||||
// Token: 0x04000023 RID: 35
|
||||
LOAD_CHUNK_IF_SAFE,
|
||||
// Token: 0x04000024 RID: 36
|
||||
LOAD_CHUNK_ALWAYS
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000008 RID: 8
|
||||
public interface ChunkPredicate
|
||||
{
|
||||
// Token: 0x06000039 RID: 57
|
||||
bool Matches(PngChunk chunk);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200000B RID: 11
|
||||
internal class ChunkPredicateEquiv : ChunkPredicate
|
||||
{
|
||||
// Token: 0x0600003E RID: 62 RVA: 0x00002B73 File Offset: 0x00000D73
|
||||
public ChunkPredicateEquiv(PngChunk chunk)
|
||||
{
|
||||
this.chunk = chunk;
|
||||
}
|
||||
|
||||
// Token: 0x0600003F RID: 63 RVA: 0x00002B82 File Offset: 0x00000D82
|
||||
public bool Matches(PngChunk c)
|
||||
{
|
||||
return ChunkHelper.Equivalent(c, this.chunk);
|
||||
}
|
||||
|
||||
// Token: 0x04000037 RID: 55
|
||||
private readonly PngChunk chunk;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000009 RID: 9
|
||||
internal class ChunkPredicateId : ChunkPredicate
|
||||
{
|
||||
// Token: 0x0600003A RID: 58 RVA: 0x00002AD2 File Offset: 0x00000CD2
|
||||
public ChunkPredicateId(string id)
|
||||
{
|
||||
this.id = id;
|
||||
}
|
||||
|
||||
// Token: 0x0600003B RID: 59 RVA: 0x00002AE1 File Offset: 0x00000CE1
|
||||
public bool Matches(PngChunk c)
|
||||
{
|
||||
return c.Id.Equals(this.id);
|
||||
}
|
||||
|
||||
// Token: 0x04000034 RID: 52
|
||||
private readonly string id;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200000A RID: 10
|
||||
internal class ChunkPredicateId2 : ChunkPredicate
|
||||
{
|
||||
// Token: 0x0600003C RID: 60 RVA: 0x00002AF4 File Offset: 0x00000CF4
|
||||
public ChunkPredicateId2(string id, string inner)
|
||||
{
|
||||
this.id = id;
|
||||
this.innerid = inner;
|
||||
}
|
||||
|
||||
// Token: 0x0600003D RID: 61 RVA: 0x00002B0C File Offset: 0x00000D0C
|
||||
public bool Matches(PngChunk c)
|
||||
{
|
||||
return c.Id.Equals(this.id) && (!(c is PngChunkTextVar) || ((PngChunkTextVar)c).GetKey().Equals(this.innerid)) && (!(c is PngChunkSPLT) || ((PngChunkSPLT)c).PalName.Equals(this.innerid));
|
||||
}
|
||||
|
||||
// Token: 0x04000035 RID: 53
|
||||
private readonly string id;
|
||||
|
||||
// Token: 0x04000036 RID: 54
|
||||
private readonly string innerid;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
using Hjg.Pngcs.Zlib;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000005 RID: 5
|
||||
public class ChunkRaw
|
||||
{
|
||||
// Token: 0x06000025 RID: 37 RVA: 0x000025C0 File Offset: 0x000007C0
|
||||
internal ChunkRaw(int length, byte[] idbytes, bool alloc)
|
||||
{
|
||||
this.IdBytes = new byte[4];
|
||||
this.Data = null;
|
||||
this.crcval = 0;
|
||||
this.Length = length;
|
||||
Array.Copy(idbytes, 0, this.IdBytes, 0, 4);
|
||||
if (alloc)
|
||||
{
|
||||
this.AllocData();
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000026 RID: 38 RVA: 0x0000260C File Offset: 0x0000080C
|
||||
private int ComputeCrc()
|
||||
{
|
||||
CRC32 crc = PngHelperInternal.GetCRC();
|
||||
crc.Reset();
|
||||
crc.Update(this.IdBytes, 0, 4);
|
||||
if (this.Length > 0)
|
||||
{
|
||||
crc.Update(this.Data, 0, this.Length);
|
||||
}
|
||||
return (int)crc.GetValue();
|
||||
}
|
||||
|
||||
// Token: 0x06000027 RID: 39 RVA: 0x00002658 File Offset: 0x00000858
|
||||
internal void WriteChunk(Stream os)
|
||||
{
|
||||
if (this.IdBytes.Length != 4)
|
||||
{
|
||||
throw new PngjOutputException("bad chunkid [" + ChunkHelper.ToString(this.IdBytes) + "]");
|
||||
}
|
||||
this.crcval = this.ComputeCrc();
|
||||
PngHelperInternal.WriteInt4(os, this.Length);
|
||||
PngHelperInternal.WriteBytes(os, this.IdBytes);
|
||||
if (this.Length > 0)
|
||||
{
|
||||
PngHelperInternal.WriteBytes(os, this.Data, 0, this.Length);
|
||||
}
|
||||
PngHelperInternal.WriteInt4(os, this.crcval);
|
||||
}
|
||||
|
||||
// Token: 0x06000028 RID: 40 RVA: 0x000026DC File Offset: 0x000008DC
|
||||
internal int ReadChunkData(Stream stream, bool checkCrc)
|
||||
{
|
||||
PngHelperInternal.ReadBytes(stream, this.Data, 0, this.Length);
|
||||
this.crcval = PngHelperInternal.ReadInt4(stream);
|
||||
if (checkCrc)
|
||||
{
|
||||
int num = this.ComputeCrc();
|
||||
if (num != this.crcval)
|
||||
{
|
||||
throw new PngjBadCrcException(string.Concat(new object[]
|
||||
{
|
||||
"crc invalid for chunk ",
|
||||
this.ToString(),
|
||||
" calc=",
|
||||
num,
|
||||
" read=",
|
||||
this.crcval
|
||||
}));
|
||||
}
|
||||
}
|
||||
return this.Length + 4;
|
||||
}
|
||||
|
||||
// Token: 0x06000029 RID: 41 RVA: 0x0000276E File Offset: 0x0000096E
|
||||
internal MemoryStream GetAsByteStream()
|
||||
{
|
||||
return new MemoryStream(this.Data);
|
||||
}
|
||||
|
||||
// Token: 0x0600002A RID: 42 RVA: 0x0000277B File Offset: 0x0000097B
|
||||
private void AllocData()
|
||||
{
|
||||
if (this.Data == null || this.Data.Length < this.Length)
|
||||
{
|
||||
this.Data = new byte[this.Length];
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600002B RID: 43 RVA: 0x000027A8 File Offset: 0x000009A8
|
||||
public override string ToString()
|
||||
{
|
||||
return string.Concat(new object[]
|
||||
{
|
||||
"chunkid=",
|
||||
ChunkHelper.ToString(this.IdBytes),
|
||||
" len=",
|
||||
this.Length
|
||||
});
|
||||
}
|
||||
|
||||
// Token: 0x04000025 RID: 37
|
||||
public readonly int Length;
|
||||
|
||||
// Token: 0x04000026 RID: 38
|
||||
public readonly byte[] IdBytes;
|
||||
|
||||
// Token: 0x04000027 RID: 39
|
||||
public byte[] Data;
|
||||
|
||||
// Token: 0x04000028 RID: 40
|
||||
private int crcval;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.Text;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000003 RID: 3
|
||||
public class ChunksList
|
||||
{
|
||||
// Token: 0x06000018 RID: 24 RVA: 0x0000239A File Offset: 0x0000059A
|
||||
internal ChunksList(ImageInfo imfinfo)
|
||||
{
|
||||
this.chunks = new List<PngChunk>();
|
||||
this.imageInfo = imfinfo;
|
||||
}
|
||||
|
||||
// Token: 0x06000019 RID: 25 RVA: 0x000023B4 File Offset: 0x000005B4
|
||||
public Dictionary<string, int> GetChunksKeys()
|
||||
{
|
||||
Dictionary<string, int> dictionary = new Dictionary<string, int>();
|
||||
foreach (PngChunk pngChunk in this.chunks)
|
||||
{
|
||||
dictionary[pngChunk.Id] = (dictionary.ContainsKey(pngChunk.Id) ? (dictionary[pngChunk.Id] + 1) : 1);
|
||||
}
|
||||
return dictionary;
|
||||
}
|
||||
|
||||
// Token: 0x0600001A RID: 26 RVA: 0x00002434 File Offset: 0x00000634
|
||||
public List<PngChunk> GetChunks()
|
||||
{
|
||||
return new List<PngChunk>(this.chunks);
|
||||
}
|
||||
|
||||
// Token: 0x0600001B RID: 27 RVA: 0x00002441 File Offset: 0x00000641
|
||||
internal static List<PngChunk> GetXById(List<PngChunk> list, string id, string innerid)
|
||||
{
|
||||
if (innerid == null)
|
||||
{
|
||||
return ChunkHelper.FilterList(list, new ChunkPredicateId(id));
|
||||
}
|
||||
return ChunkHelper.FilterList(list, new ChunkPredicateId2(id, innerid));
|
||||
}
|
||||
|
||||
// Token: 0x0600001C RID: 28 RVA: 0x00002460 File Offset: 0x00000660
|
||||
public void AppendReadChunk(PngChunk chunk, int chunkGroup)
|
||||
{
|
||||
chunk.ChunkGroup = chunkGroup;
|
||||
this.chunks.Add(chunk);
|
||||
}
|
||||
|
||||
// Token: 0x0600001D RID: 29 RVA: 0x00002475 File Offset: 0x00000675
|
||||
public List<PngChunk> GetById(string id)
|
||||
{
|
||||
return this.GetById(id, null);
|
||||
}
|
||||
|
||||
// Token: 0x0600001E RID: 30 RVA: 0x0000247F File Offset: 0x0000067F
|
||||
public List<PngChunk> GetById(string id, string innerid)
|
||||
{
|
||||
return ChunksList.GetXById(this.chunks, id, innerid);
|
||||
}
|
||||
|
||||
// Token: 0x0600001F RID: 31 RVA: 0x0000248E File Offset: 0x0000068E
|
||||
public PngChunk GetById1(string id)
|
||||
{
|
||||
return this.GetById1(id, false);
|
||||
}
|
||||
|
||||
// Token: 0x06000020 RID: 32 RVA: 0x00002498 File Offset: 0x00000698
|
||||
public PngChunk GetById1(string id, bool failIfMultiple)
|
||||
{
|
||||
return this.GetById1(id, null, failIfMultiple);
|
||||
}
|
||||
|
||||
// Token: 0x06000021 RID: 33 RVA: 0x000024A4 File Offset: 0x000006A4
|
||||
public PngChunk GetById1(string id, string innerid, bool failIfMultiple)
|
||||
{
|
||||
List<PngChunk> byId = this.GetById(id, innerid);
|
||||
if (byId.Count == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (byId.Count > 1 && (failIfMultiple || !byId[0].AllowsMultiple()))
|
||||
{
|
||||
throw new PngjException("unexpected multiple chunks id=" + id);
|
||||
}
|
||||
return byId[byId.Count - 1];
|
||||
}
|
||||
|
||||
// Token: 0x06000022 RID: 34 RVA: 0x000024FD File Offset: 0x000006FD
|
||||
public List<PngChunk> GetEquivalent(PngChunk chunk)
|
||||
{
|
||||
return ChunkHelper.FilterList(this.chunks, new ChunkPredicateEquiv(chunk));
|
||||
}
|
||||
|
||||
// Token: 0x06000023 RID: 35 RVA: 0x00002510 File Offset: 0x00000710
|
||||
public override string ToString()
|
||||
{
|
||||
return "ChunkList: read: " + this.chunks.Count;
|
||||
}
|
||||
|
||||
// Token: 0x06000024 RID: 36 RVA: 0x0000252C File Offset: 0x0000072C
|
||||
public string ToStringFull()
|
||||
{
|
||||
StringBuilder stringBuilder = new StringBuilder(this.ToString());
|
||||
stringBuilder.Append("\n Read:\n");
|
||||
foreach (PngChunk pngChunk in this.chunks)
|
||||
{
|
||||
stringBuilder.Append(pngChunk).Append(" G=" + pngChunk.ChunkGroup + "\n");
|
||||
}
|
||||
return stringBuilder.ToString();
|
||||
}
|
||||
|
||||
// Token: 0x04000017 RID: 23
|
||||
internal const int CHUNK_GROUP_0_IDHR = 0;
|
||||
|
||||
// Token: 0x04000018 RID: 24
|
||||
internal const int CHUNK_GROUP_1_AFTERIDHR = 1;
|
||||
|
||||
// Token: 0x04000019 RID: 25
|
||||
internal const int CHUNK_GROUP_2_PLTE = 2;
|
||||
|
||||
// Token: 0x0400001A RID: 26
|
||||
internal const int CHUNK_GROUP_3_AFTERPLTE = 3;
|
||||
|
||||
// Token: 0x0400001B RID: 27
|
||||
internal const int CHUNK_GROUP_4_IDAT = 4;
|
||||
|
||||
// Token: 0x0400001C RID: 28
|
||||
internal const int CHUNK_GROUP_5_AFTERIDAT = 5;
|
||||
|
||||
// Token: 0x0400001D RID: 29
|
||||
internal const int CHUNK_GROUP_6_END = 6;
|
||||
|
||||
// Token: 0x0400001E RID: 30
|
||||
protected List<PngChunk> chunks;
|
||||
|
||||
// Token: 0x0400001F RID: 31
|
||||
internal readonly ImageInfo imageInfo;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,152 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000006 RID: 6
|
||||
public class ChunksListForWrite : ChunksList
|
||||
{
|
||||
// Token: 0x0600002C RID: 44 RVA: 0x000027EE File Offset: 0x000009EE
|
||||
internal ChunksListForWrite(ImageInfo info)
|
||||
: base(info)
|
||||
{
|
||||
this.queuedChunks = new List<PngChunk>();
|
||||
this.alreadyWrittenKeys = new Dictionary<string, int>();
|
||||
}
|
||||
|
||||
// Token: 0x0600002D RID: 45 RVA: 0x0000280D File Offset: 0x00000A0D
|
||||
public List<PngChunk> GetQueuedById(string id)
|
||||
{
|
||||
return this.GetQueuedById(id, null);
|
||||
}
|
||||
|
||||
// Token: 0x0600002E RID: 46 RVA: 0x00002817 File Offset: 0x00000A17
|
||||
public List<PngChunk> GetQueuedById(string id, string innerid)
|
||||
{
|
||||
return ChunksList.GetXById(this.queuedChunks, id, innerid);
|
||||
}
|
||||
|
||||
// Token: 0x0600002F RID: 47 RVA: 0x00002828 File Offset: 0x00000A28
|
||||
public PngChunk GetQueuedById1(string id, string innerid, bool failIfMultiple)
|
||||
{
|
||||
List<PngChunk> queuedById = this.GetQueuedById(id, innerid);
|
||||
if (queuedById.Count == 0)
|
||||
{
|
||||
return null;
|
||||
}
|
||||
if (queuedById.Count > 1 && (failIfMultiple || !queuedById[0].AllowsMultiple()))
|
||||
{
|
||||
throw new PngjException("unexpected multiple chunks id=" + id);
|
||||
}
|
||||
return queuedById[queuedById.Count - 1];
|
||||
}
|
||||
|
||||
// Token: 0x06000030 RID: 48 RVA: 0x00002881 File Offset: 0x00000A81
|
||||
public PngChunk GetQueuedById1(string id, bool failIfMultiple)
|
||||
{
|
||||
return this.GetQueuedById1(id, null, failIfMultiple);
|
||||
}
|
||||
|
||||
// Token: 0x06000031 RID: 49 RVA: 0x0000288C File Offset: 0x00000A8C
|
||||
public PngChunk GetQueuedById1(string id)
|
||||
{
|
||||
return this.GetQueuedById1(id, false);
|
||||
}
|
||||
|
||||
// Token: 0x06000032 RID: 50 RVA: 0x00002896 File Offset: 0x00000A96
|
||||
public bool RemoveChunk(PngChunk c)
|
||||
{
|
||||
return this.queuedChunks.Remove(c);
|
||||
}
|
||||
|
||||
// Token: 0x06000033 RID: 51 RVA: 0x000028A4 File Offset: 0x00000AA4
|
||||
public bool Queue(PngChunk chunk)
|
||||
{
|
||||
this.queuedChunks.Add(chunk);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x06000034 RID: 52 RVA: 0x000028B4 File Offset: 0x00000AB4
|
||||
private static bool shouldWrite(PngChunk c, int currentGroup)
|
||||
{
|
||||
if (currentGroup == 2)
|
||||
{
|
||||
return c.Id.Equals("PLTE");
|
||||
}
|
||||
if (currentGroup % 2 == 0)
|
||||
{
|
||||
throw new PngjOutputException("bad chunk group?");
|
||||
}
|
||||
int num2;
|
||||
int num;
|
||||
if (c.mustGoBeforePLTE())
|
||||
{
|
||||
num = (num2 = 1);
|
||||
}
|
||||
else if (c.mustGoBeforeIDAT())
|
||||
{
|
||||
num = 3;
|
||||
num2 = (c.mustGoAfterPLTE() ? 3 : 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
num = 5;
|
||||
num2 = 1;
|
||||
}
|
||||
int num3 = num;
|
||||
if (c.Priority)
|
||||
{
|
||||
num3 = num2;
|
||||
}
|
||||
if (ChunkHelper.IsUnknown(c) && c.ChunkGroup > 0)
|
||||
{
|
||||
num3 = c.ChunkGroup;
|
||||
}
|
||||
return currentGroup == num3 || (currentGroup > num3 && currentGroup <= num);
|
||||
}
|
||||
|
||||
// Token: 0x06000035 RID: 53 RVA: 0x00002948 File Offset: 0x00000B48
|
||||
internal int writeChunks(Stream os, int currentGroup)
|
||||
{
|
||||
List<int> list = new List<int>();
|
||||
for (int i = 0; i < this.queuedChunks.Count; i++)
|
||||
{
|
||||
PngChunk pngChunk = this.queuedChunks[i];
|
||||
if (ChunksListForWrite.shouldWrite(pngChunk, currentGroup))
|
||||
{
|
||||
if (ChunkHelper.IsCritical(pngChunk.Id) && !pngChunk.Id.Equals("PLTE"))
|
||||
{
|
||||
throw new PngjOutputException("bad chunk queued: " + pngChunk);
|
||||
}
|
||||
if (this.alreadyWrittenKeys.ContainsKey(pngChunk.Id) && !pngChunk.AllowsMultiple())
|
||||
{
|
||||
throw new PngjOutputException("duplicated chunk does not allow multiple: " + pngChunk);
|
||||
}
|
||||
pngChunk.write(os);
|
||||
this.chunks.Add(pngChunk);
|
||||
this.alreadyWrittenKeys[pngChunk.Id] = (this.alreadyWrittenKeys.ContainsKey(pngChunk.Id) ? (this.alreadyWrittenKeys[pngChunk.Id] + 1) : 1);
|
||||
list.Add(i);
|
||||
pngChunk.ChunkGroup = currentGroup;
|
||||
}
|
||||
}
|
||||
for (int j = list.Count - 1; j >= 0; j--)
|
||||
{
|
||||
this.queuedChunks.RemoveAt(list[j]);
|
||||
}
|
||||
return list.Count;
|
||||
}
|
||||
|
||||
// Token: 0x06000036 RID: 54 RVA: 0x00002A72 File Offset: 0x00000C72
|
||||
internal List<PngChunk> GetQueuedChunks()
|
||||
{
|
||||
return this.queuedChunks;
|
||||
}
|
||||
|
||||
// Token: 0x04000029 RID: 41
|
||||
private List<PngChunk> queuedChunks;
|
||||
|
||||
// Token: 0x0400002A RID: 42
|
||||
private Dictionary<string, int> alreadyWrittenKeys;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,298 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
using System.IO;
|
||||
using System.Reflection;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200000C RID: 12
|
||||
public abstract class PngChunk
|
||||
{
|
||||
// Token: 0x17000001 RID: 1
|
||||
// (get) Token: 0x06000040 RID: 64 RVA: 0x00002B90 File Offset: 0x00000D90
|
||||
// (set) Token: 0x06000041 RID: 65 RVA: 0x00002B98 File Offset: 0x00000D98
|
||||
public bool Priority { get; set; }
|
||||
|
||||
// Token: 0x17000002 RID: 2
|
||||
// (get) Token: 0x06000042 RID: 66 RVA: 0x00002BA1 File Offset: 0x00000DA1
|
||||
// (set) Token: 0x06000043 RID: 67 RVA: 0x00002BA9 File Offset: 0x00000DA9
|
||||
public int ChunkGroup { get; set; }
|
||||
|
||||
// Token: 0x17000003 RID: 3
|
||||
// (get) Token: 0x06000044 RID: 68 RVA: 0x00002BB2 File Offset: 0x00000DB2
|
||||
// (set) Token: 0x06000045 RID: 69 RVA: 0x00002BBA File Offset: 0x00000DBA
|
||||
public int Length { get; set; }
|
||||
|
||||
// Token: 0x17000004 RID: 4
|
||||
// (get) Token: 0x06000046 RID: 70 RVA: 0x00002BC3 File Offset: 0x00000DC3
|
||||
// (set) Token: 0x06000047 RID: 71 RVA: 0x00002BCB File Offset: 0x00000DCB
|
||||
public long Offset { get; set; }
|
||||
|
||||
// Token: 0x06000048 RID: 72 RVA: 0x00002BD4 File Offset: 0x00000DD4
|
||||
protected PngChunk(string id, ImageInfo imgInfo)
|
||||
{
|
||||
this.Id = id;
|
||||
this.ImgInfo = imgInfo;
|
||||
this.Crit = ChunkHelper.IsCritical(id);
|
||||
this.Pub = ChunkHelper.IsPublic(id);
|
||||
this.Safe = ChunkHelper.IsSafeToCopy(id);
|
||||
this.Priority = false;
|
||||
this.ChunkGroup = -1;
|
||||
this.Length = -1;
|
||||
this.Offset = 0L;
|
||||
}
|
||||
|
||||
// Token: 0x06000049 RID: 73 RVA: 0x00002C38 File Offset: 0x00000E38
|
||||
private static Dictionary<string, Type> initFactory()
|
||||
{
|
||||
return new Dictionary<string, Type>
|
||||
{
|
||||
{
|
||||
"IDAT",
|
||||
typeof(PngChunkIDAT)
|
||||
},
|
||||
{
|
||||
"IHDR",
|
||||
typeof(PngChunkIHDR)
|
||||
},
|
||||
{
|
||||
"PLTE",
|
||||
typeof(PngChunkPLTE)
|
||||
},
|
||||
{
|
||||
"IEND",
|
||||
typeof(PngChunkIEND)
|
||||
},
|
||||
{
|
||||
"tEXt",
|
||||
typeof(PngChunkTEXT)
|
||||
},
|
||||
{
|
||||
"iTXt",
|
||||
typeof(PngChunkITXT)
|
||||
},
|
||||
{
|
||||
"zTXt",
|
||||
typeof(PngChunkZTXT)
|
||||
},
|
||||
{
|
||||
"bKGD",
|
||||
typeof(PngChunkBKGD)
|
||||
},
|
||||
{
|
||||
"gAMA",
|
||||
typeof(PngChunkGAMA)
|
||||
},
|
||||
{
|
||||
"pHYs",
|
||||
typeof(PngChunkPHYS)
|
||||
},
|
||||
{
|
||||
"iCCP",
|
||||
typeof(PngChunkICCP)
|
||||
},
|
||||
{
|
||||
"tIME",
|
||||
typeof(PngChunkTIME)
|
||||
},
|
||||
{
|
||||
"tRNS",
|
||||
typeof(PngChunkTRNS)
|
||||
},
|
||||
{
|
||||
"cHRM",
|
||||
typeof(PngChunkCHRM)
|
||||
},
|
||||
{
|
||||
"sBIT",
|
||||
typeof(PngChunkSBIT)
|
||||
},
|
||||
{
|
||||
"sRGB",
|
||||
typeof(PngChunkSRGB)
|
||||
},
|
||||
{
|
||||
"hIST",
|
||||
typeof(PngChunkHIST)
|
||||
},
|
||||
{
|
||||
"sPLT",
|
||||
typeof(PngChunkSPLT)
|
||||
},
|
||||
{
|
||||
"oFFs",
|
||||
typeof(PngChunkOFFS)
|
||||
},
|
||||
{
|
||||
"sTER",
|
||||
typeof(PngChunkSTER)
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x0600004A RID: 74 RVA: 0x00002DF0 File Offset: 0x00000FF0
|
||||
public static void FactoryRegister(string chunkId, Type type)
|
||||
{
|
||||
PngChunk.factoryMap.Add(chunkId, type);
|
||||
}
|
||||
|
||||
// Token: 0x0600004B RID: 75 RVA: 0x00002DFE File Offset: 0x00000FFE
|
||||
internal static bool isKnown(string id)
|
||||
{
|
||||
return PngChunk.factoryMap.ContainsKey(id);
|
||||
}
|
||||
|
||||
// Token: 0x0600004C RID: 76 RVA: 0x00002E0B File Offset: 0x0000100B
|
||||
internal bool mustGoBeforePLTE()
|
||||
{
|
||||
return this.GetOrderingConstraint() == PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600004D RID: 77 RVA: 0x00002E18 File Offset: 0x00001018
|
||||
internal bool mustGoBeforeIDAT()
|
||||
{
|
||||
PngChunk.ChunkOrderingConstraint orderingConstraint = this.GetOrderingConstraint();
|
||||
return orderingConstraint == PngChunk.ChunkOrderingConstraint.BEFORE_IDAT || orderingConstraint == PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT || orderingConstraint == PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600004E RID: 78 RVA: 0x00002E3A File Offset: 0x0000103A
|
||||
internal bool mustGoAfterPLTE()
|
||||
{
|
||||
return this.GetOrderingConstraint() == PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600004F RID: 79 RVA: 0x00002E48 File Offset: 0x00001048
|
||||
internal static PngChunk Factory(ChunkRaw chunk, ImageInfo info)
|
||||
{
|
||||
PngChunk pngChunk = PngChunk.FactoryFromId(ChunkHelper.ToString(chunk.IdBytes), info);
|
||||
pngChunk.Length = chunk.Length;
|
||||
pngChunk.ParseFromRaw(chunk);
|
||||
return pngChunk;
|
||||
}
|
||||
|
||||
// Token: 0x06000050 RID: 80 RVA: 0x00002E7C File Offset: 0x0000107C
|
||||
internal static PngChunk FactoryFromId(string cid, ImageInfo info)
|
||||
{
|
||||
PngChunk pngChunk = null;
|
||||
if (PngChunk.factoryMap == null)
|
||||
{
|
||||
PngChunk.initFactory();
|
||||
}
|
||||
if (PngChunk.isKnown(cid))
|
||||
{
|
||||
Type type = PngChunk.factoryMap[cid];
|
||||
if (type == null)
|
||||
{
|
||||
Console.Error.WriteLine("What?? " + cid);
|
||||
}
|
||||
ConstructorInfo constructor = type.GetConstructor(new Type[] { typeof(ImageInfo) });
|
||||
object obj = constructor.Invoke(new object[] { info });
|
||||
pngChunk = (PngChunk)obj;
|
||||
}
|
||||
if (pngChunk == null)
|
||||
{
|
||||
pngChunk = new PngChunkUNKNOWN(cid, info);
|
||||
}
|
||||
return pngChunk;
|
||||
}
|
||||
|
||||
// Token: 0x06000051 RID: 81 RVA: 0x00002F0C File Offset: 0x0000110C
|
||||
public ChunkRaw createEmptyChunk(int len, bool alloc)
|
||||
{
|
||||
return new ChunkRaw(len, ChunkHelper.ToBytes(this.Id), alloc);
|
||||
}
|
||||
|
||||
// Token: 0x06000052 RID: 82 RVA: 0x00002F30 File Offset: 0x00001130
|
||||
public static T CloneChunk<T>(T chunk, ImageInfo info) where T : PngChunk
|
||||
{
|
||||
PngChunk pngChunk = PngChunk.FactoryFromId(chunk.Id, info);
|
||||
if (pngChunk.GetType() != chunk.GetType())
|
||||
{
|
||||
throw new PngjException(string.Concat(new object[]
|
||||
{
|
||||
"bad class cloning chunk: ",
|
||||
pngChunk.GetType(),
|
||||
" ",
|
||||
chunk.GetType()
|
||||
}));
|
||||
}
|
||||
pngChunk.CloneDataFromRead(chunk);
|
||||
return (T)((object)pngChunk);
|
||||
}
|
||||
|
||||
// Token: 0x06000053 RID: 83 RVA: 0x00002FB4 File Offset: 0x000011B4
|
||||
internal void write(Stream os)
|
||||
{
|
||||
ChunkRaw chunkRaw = this.CreateRawChunk();
|
||||
if (chunkRaw == null)
|
||||
{
|
||||
throw new PngjException("null chunk ! creation failed for " + this);
|
||||
}
|
||||
chunkRaw.WriteChunk(os);
|
||||
}
|
||||
|
||||
// Token: 0x06000054 RID: 84 RVA: 0x00002FE4 File Offset: 0x000011E4
|
||||
public override string ToString()
|
||||
{
|
||||
return string.Concat(new object[]
|
||||
{
|
||||
"chunk id= ",
|
||||
this.Id,
|
||||
" (len=",
|
||||
this.Length,
|
||||
" off=",
|
||||
this.Offset,
|
||||
") c=",
|
||||
base.GetType().Name
|
||||
});
|
||||
}
|
||||
|
||||
// Token: 0x06000055 RID: 85
|
||||
public abstract ChunkRaw CreateRawChunk();
|
||||
|
||||
// Token: 0x06000056 RID: 86
|
||||
public abstract void ParseFromRaw(ChunkRaw c);
|
||||
|
||||
// Token: 0x06000057 RID: 87
|
||||
public abstract void CloneDataFromRead(PngChunk other);
|
||||
|
||||
// Token: 0x06000058 RID: 88
|
||||
public abstract bool AllowsMultiple();
|
||||
|
||||
// Token: 0x06000059 RID: 89
|
||||
public abstract PngChunk.ChunkOrderingConstraint GetOrderingConstraint();
|
||||
|
||||
// Token: 0x04000038 RID: 56
|
||||
public readonly string Id;
|
||||
|
||||
// Token: 0x04000039 RID: 57
|
||||
public readonly bool Crit;
|
||||
|
||||
// Token: 0x0400003A RID: 58
|
||||
public readonly bool Pub;
|
||||
|
||||
// Token: 0x0400003B RID: 59
|
||||
public readonly bool Safe;
|
||||
|
||||
// Token: 0x0400003C RID: 60
|
||||
protected readonly ImageInfo ImgInfo;
|
||||
|
||||
// Token: 0x0400003D RID: 61
|
||||
private static Dictionary<string, Type> factoryMap = PngChunk.initFactory();
|
||||
|
||||
// Token: 0x0200000D RID: 13
|
||||
public enum ChunkOrderingConstraint
|
||||
{
|
||||
// Token: 0x04000043 RID: 67
|
||||
NONE,
|
||||
// Token: 0x04000044 RID: 68
|
||||
BEFORE_PLTE_AND_IDAT,
|
||||
// Token: 0x04000045 RID: 69
|
||||
AFTER_PLTE_BEFORE_IDAT,
|
||||
// Token: 0x04000046 RID: 70
|
||||
BEFORE_IDAT,
|
||||
// Token: 0x04000047 RID: 71
|
||||
NA
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,153 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000023 RID: 35
|
||||
public class PngChunkBKGD : PngChunkSingle
|
||||
{
|
||||
// Token: 0x0600013B RID: 315 RVA: 0x00005F9F File Offset: 0x0000419F
|
||||
public PngChunkBKGD(ImageInfo info)
|
||||
: base("bKGD", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600013C RID: 316 RVA: 0x00005FAD File Offset: 0x000041AD
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600013D RID: 317 RVA: 0x00005FB0 File Offset: 0x000041B0
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw;
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(2, true);
|
||||
PngHelperInternal.WriteInt2tobytes(this.gray, chunkRaw.Data, 0);
|
||||
}
|
||||
else if (this.ImgInfo.Indexed)
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(1, true);
|
||||
chunkRaw.Data[0] = (byte)this.paletteIndex;
|
||||
}
|
||||
else
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(6, true);
|
||||
PngHelperInternal.WriteInt2tobytes(this.red, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt2tobytes(this.green, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt2tobytes(this.blue, chunkRaw.Data, 0);
|
||||
}
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x0600013E RID: 318 RVA: 0x00006050 File Offset: 0x00004250
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
this.gray = PngHelperInternal.ReadInt2fromBytes(c.Data, 0);
|
||||
return;
|
||||
}
|
||||
if (this.ImgInfo.Indexed)
|
||||
{
|
||||
this.paletteIndex = (int)(c.Data[0] & byte.MaxValue);
|
||||
return;
|
||||
}
|
||||
this.red = PngHelperInternal.ReadInt2fromBytes(c.Data, 0);
|
||||
this.green = PngHelperInternal.ReadInt2fromBytes(c.Data, 2);
|
||||
this.blue = PngHelperInternal.ReadInt2fromBytes(c.Data, 4);
|
||||
}
|
||||
|
||||
// Token: 0x0600013F RID: 319 RVA: 0x000060D8 File Offset: 0x000042D8
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkBKGD pngChunkBKGD = (PngChunkBKGD)other;
|
||||
this.gray = pngChunkBKGD.gray;
|
||||
this.red = pngChunkBKGD.red;
|
||||
this.green = pngChunkBKGD.red;
|
||||
this.blue = pngChunkBKGD.red;
|
||||
this.paletteIndex = pngChunkBKGD.paletteIndex;
|
||||
}
|
||||
|
||||
// Token: 0x06000140 RID: 320 RVA: 0x00006128 File Offset: 0x00004328
|
||||
public void SetGray(int gray)
|
||||
{
|
||||
if (!this.ImgInfo.Greyscale)
|
||||
{
|
||||
throw new PngjException("only gray images support this");
|
||||
}
|
||||
this.gray = gray;
|
||||
}
|
||||
|
||||
// Token: 0x06000141 RID: 321 RVA: 0x00006149 File Offset: 0x00004349
|
||||
public int GetGray()
|
||||
{
|
||||
if (!this.ImgInfo.Greyscale)
|
||||
{
|
||||
throw new PngjException("only gray images support this");
|
||||
}
|
||||
return this.gray;
|
||||
}
|
||||
|
||||
// Token: 0x06000142 RID: 322 RVA: 0x00006169 File Offset: 0x00004369
|
||||
public void SetPaletteIndex(int index)
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed (pallete) images support this");
|
||||
}
|
||||
this.paletteIndex = index;
|
||||
}
|
||||
|
||||
// Token: 0x06000143 RID: 323 RVA: 0x0000618A File Offset: 0x0000438A
|
||||
public int GetPaletteIndex()
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed (pallete) images support this");
|
||||
}
|
||||
return this.paletteIndex;
|
||||
}
|
||||
|
||||
// Token: 0x06000144 RID: 324 RVA: 0x000061AA File Offset: 0x000043AA
|
||||
public void SetRGB(int r, int g, int b)
|
||||
{
|
||||
if (this.ImgInfo.Greyscale || this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only rgb or rgba images support this");
|
||||
}
|
||||
this.red = r;
|
||||
this.green = g;
|
||||
this.blue = b;
|
||||
}
|
||||
|
||||
// Token: 0x06000145 RID: 325 RVA: 0x000061E8 File Offset: 0x000043E8
|
||||
public int[] GetRGB()
|
||||
{
|
||||
if (this.ImgInfo.Greyscale || this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only rgb or rgba images support this");
|
||||
}
|
||||
return new int[] { this.red, this.green, this.blue };
|
||||
}
|
||||
|
||||
// Token: 0x040000AE RID: 174
|
||||
public const string ID = "bKGD";
|
||||
|
||||
// Token: 0x040000AF RID: 175
|
||||
private int gray;
|
||||
|
||||
// Token: 0x040000B0 RID: 176
|
||||
private int red;
|
||||
|
||||
// Token: 0x040000B1 RID: 177
|
||||
private int green;
|
||||
|
||||
// Token: 0x040000B2 RID: 178
|
||||
private int blue;
|
||||
|
||||
// Token: 0x040000B3 RID: 179
|
||||
private int paletteIndex;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,112 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000016 RID: 22
|
||||
public class PngChunkCHRM : PngChunkSingle
|
||||
{
|
||||
// Token: 0x060000A1 RID: 161 RVA: 0x00003BC7 File Offset: 0x00001DC7
|
||||
public PngChunkCHRM(ImageInfo info)
|
||||
: base("cHRM", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000A2 RID: 162 RVA: 0x00003BD5 File Offset: 0x00001DD5
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x060000A3 RID: 163 RVA: 0x00003BD8 File Offset: 0x00001DD8
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(32, true);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.whitex), chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.whitey), chunkRaw.Data, 4);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.redx), chunkRaw.Data, 8);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.redy), chunkRaw.Data, 12);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.greenx), chunkRaw.Data, 16);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.greeny), chunkRaw.Data, 20);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.bluex), chunkRaw.Data, 24);
|
||||
PngHelperInternal.WriteInt4tobytes(PngHelperInternal.DoubleToInt100000(this.bluey), chunkRaw.Data, 28);
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060000A4 RID: 164 RVA: 0x00003CB0 File Offset: 0x00001EB0
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (c.Length != 32)
|
||||
{
|
||||
throw new PngjException("bad chunk " + c);
|
||||
}
|
||||
this.whitex = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 0));
|
||||
this.whitey = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 4));
|
||||
this.redx = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 8));
|
||||
this.redy = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 12));
|
||||
this.greenx = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 16));
|
||||
this.greeny = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 20));
|
||||
this.bluex = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 24));
|
||||
this.bluey = PngHelperInternal.IntToDouble100000(PngHelperInternal.ReadInt4fromBytes(c.Data, 28));
|
||||
}
|
||||
|
||||
// Token: 0x060000A5 RID: 165 RVA: 0x00003D98 File Offset: 0x00001F98
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkCHRM pngChunkCHRM = (PngChunkCHRM)other;
|
||||
this.whitex = pngChunkCHRM.whitex;
|
||||
this.whitey = pngChunkCHRM.whitex;
|
||||
this.redx = pngChunkCHRM.redx;
|
||||
this.redy = pngChunkCHRM.redy;
|
||||
this.greenx = pngChunkCHRM.greenx;
|
||||
this.greeny = pngChunkCHRM.greeny;
|
||||
this.bluex = pngChunkCHRM.bluex;
|
||||
this.bluey = pngChunkCHRM.bluey;
|
||||
}
|
||||
|
||||
// Token: 0x060000A6 RID: 166 RVA: 0x00003E0C File Offset: 0x0000200C
|
||||
public void SetChromaticities(double whitex, double whitey, double redx, double redy, double greenx, double greeny, double bluex, double bluey)
|
||||
{
|
||||
this.whitex = whitex;
|
||||
this.redx = redx;
|
||||
this.greenx = greenx;
|
||||
this.bluex = bluex;
|
||||
this.whitey = whitey;
|
||||
this.redy = redy;
|
||||
this.greeny = greeny;
|
||||
this.bluey = bluey;
|
||||
}
|
||||
|
||||
// Token: 0x060000A7 RID: 167 RVA: 0x00003E4C File Offset: 0x0000204C
|
||||
public double[] GetChromaticities()
|
||||
{
|
||||
return new double[] { this.whitex, this.whitey, this.redx, this.redy, this.greenx, this.greeny, this.bluex, this.bluey };
|
||||
}
|
||||
|
||||
// Token: 0x04000056 RID: 86
|
||||
public const string ID = "cHRM";
|
||||
|
||||
// Token: 0x04000057 RID: 87
|
||||
private double whitex;
|
||||
|
||||
// Token: 0x04000058 RID: 88
|
||||
private double whitey;
|
||||
|
||||
// Token: 0x04000059 RID: 89
|
||||
private double redx;
|
||||
|
||||
// Token: 0x0400005A RID: 90
|
||||
private double redy;
|
||||
|
||||
// Token: 0x0400005B RID: 91
|
||||
private double greenx;
|
||||
|
||||
// Token: 0x0400005C RID: 92
|
||||
private double greeny;
|
||||
|
||||
// Token: 0x0400005D RID: 93
|
||||
private double bluex;
|
||||
|
||||
// Token: 0x0400005E RID: 94
|
||||
private double bluey;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000024 RID: 36
|
||||
public class PngChunkGAMA : PngChunkSingle
|
||||
{
|
||||
// Token: 0x06000146 RID: 326 RVA: 0x0000623D File Offset: 0x0000443D
|
||||
public PngChunkGAMA(ImageInfo info)
|
||||
: base("gAMA", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000147 RID: 327 RVA: 0x0000624B File Offset: 0x0000444B
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x06000148 RID: 328 RVA: 0x00006250 File Offset: 0x00004450
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(4, true);
|
||||
int num = (int)(this.gamma * 100000.0 + 0.5);
|
||||
PngHelperInternal.WriteInt4tobytes(num, chunkRaw.Data, 0);
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000149 RID: 329 RVA: 0x00006290 File Offset: 0x00004490
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
if (chunk.Length != 4)
|
||||
{
|
||||
throw new PngjException("bad chunk " + chunk);
|
||||
}
|
||||
int num = PngHelperInternal.ReadInt4fromBytes(chunk.Data, 0);
|
||||
this.gamma = (double)num / 100000.0;
|
||||
}
|
||||
|
||||
// Token: 0x0600014A RID: 330 RVA: 0x000062D6 File Offset: 0x000044D6
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
this.gamma = ((PngChunkGAMA)other).gamma;
|
||||
}
|
||||
|
||||
// Token: 0x0600014B RID: 331 RVA: 0x000062E9 File Offset: 0x000044E9
|
||||
public double GetGamma()
|
||||
{
|
||||
return this.gamma;
|
||||
}
|
||||
|
||||
// Token: 0x0600014C RID: 332 RVA: 0x000062F1 File Offset: 0x000044F1
|
||||
public void SetGamma(double gamma)
|
||||
{
|
||||
this.gamma = gamma;
|
||||
}
|
||||
|
||||
// Token: 0x040000B4 RID: 180
|
||||
public const string ID = "gAMA";
|
||||
|
||||
// Token: 0x040000B5 RID: 181
|
||||
private double gamma;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000015 RID: 21
|
||||
public class PngChunkHIST : PngChunkSingle
|
||||
{
|
||||
// Token: 0x06000099 RID: 153 RVA: 0x00003A7E File Offset: 0x00001C7E
|
||||
public PngChunkHIST(ImageInfo info)
|
||||
: base(PngChunkHIST.ID, info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600009A RID: 154 RVA: 0x00003A98 File Offset: 0x00001C98
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600009B RID: 155 RVA: 0x00003A9C File Offset: 0x00001C9C
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed images accept a HIST chunk");
|
||||
}
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(this.hist.Length * 2, true);
|
||||
for (int i = 0; i < this.hist.Length; i++)
|
||||
{
|
||||
PngHelperInternal.WriteInt2tobytes(this.hist[i], chunkRaw.Data, i * 2);
|
||||
}
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x0600009C RID: 156 RVA: 0x00003B00 File Offset: 0x00001D00
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed images accept a HIST chunk");
|
||||
}
|
||||
int num = c.Data.Length / 2;
|
||||
this.hist = new int[num];
|
||||
for (int i = 0; i < this.hist.Length; i++)
|
||||
{
|
||||
this.hist[i] = PngHelperInternal.ReadInt2fromBytes(c.Data, i * 2);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600009D RID: 157 RVA: 0x00003B68 File Offset: 0x00001D68
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkHIST pngChunkHIST = (PngChunkHIST)other;
|
||||
this.hist = new int[pngChunkHIST.hist.Length];
|
||||
Array.Copy(pngChunkHIST.hist, 0, this.hist, 0, pngChunkHIST.hist.Length);
|
||||
}
|
||||
|
||||
// Token: 0x0600009E RID: 158 RVA: 0x00003BAA File Offset: 0x00001DAA
|
||||
public int[] GetHist()
|
||||
{
|
||||
return this.hist;
|
||||
}
|
||||
|
||||
// Token: 0x0600009F RID: 159 RVA: 0x00003BB2 File Offset: 0x00001DB2
|
||||
public void SetHist(int[] hist)
|
||||
{
|
||||
this.hist = hist;
|
||||
}
|
||||
|
||||
// Token: 0x04000054 RID: 84
|
||||
public static readonly string ID = "hIST";
|
||||
|
||||
// Token: 0x04000055 RID: 85
|
||||
private int[] hist = new int[0];
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,95 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000025 RID: 37
|
||||
public class PngChunkICCP : PngChunkSingle
|
||||
{
|
||||
// Token: 0x0600014D RID: 333 RVA: 0x000062FA File Offset: 0x000044FA
|
||||
public PngChunkICCP(ImageInfo info)
|
||||
: base("iCCP", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600014E RID: 334 RVA: 0x00006308 File Offset: 0x00004508
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600014F RID: 335 RVA: 0x0000630C File Offset: 0x0000450C
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(this.profileName.Length + this.compressedProfile.Length + 2, true);
|
||||
Array.Copy(ChunkHelper.ToBytes(this.profileName), 0, chunkRaw.Data, 0, this.profileName.Length);
|
||||
chunkRaw.Data[this.profileName.Length] = 0;
|
||||
chunkRaw.Data[this.profileName.Length + 1] = 0;
|
||||
Array.Copy(this.compressedProfile, 0, chunkRaw.Data, this.profileName.Length + 2, this.compressedProfile.Length);
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000150 RID: 336 RVA: 0x000063AC File Offset: 0x000045AC
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
int num = ChunkHelper.PosNullByte(chunk.Data);
|
||||
this.profileName = PngHelperInternal.charsetLatin1.GetString(chunk.Data, 0, num);
|
||||
int num2 = (int)(chunk.Data[num + 1] & byte.MaxValue);
|
||||
if (num2 != 0)
|
||||
{
|
||||
throw new Exception("bad compression for ChunkTypeICCP");
|
||||
}
|
||||
int num3 = chunk.Data.Length - (num + 2);
|
||||
this.compressedProfile = new byte[num3];
|
||||
Array.Copy(chunk.Data, num + 2, this.compressedProfile, 0, num3);
|
||||
}
|
||||
|
||||
// Token: 0x06000151 RID: 337 RVA: 0x0000642C File Offset: 0x0000462C
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkICCP pngChunkICCP = (PngChunkICCP)other;
|
||||
this.profileName = pngChunkICCP.profileName;
|
||||
this.compressedProfile = new byte[pngChunkICCP.compressedProfile.Length];
|
||||
Array.Copy(pngChunkICCP.compressedProfile, this.compressedProfile, this.compressedProfile.Length);
|
||||
}
|
||||
|
||||
// Token: 0x06000152 RID: 338 RVA: 0x00006478 File Offset: 0x00004678
|
||||
public void SetProfileNameAndContent(string name, string profile)
|
||||
{
|
||||
this.SetProfileNameAndContent(name, ChunkHelper.ToBytes(this.profileName));
|
||||
}
|
||||
|
||||
// Token: 0x06000153 RID: 339 RVA: 0x0000648C File Offset: 0x0000468C
|
||||
public void SetProfileNameAndContent(string name, byte[] profile)
|
||||
{
|
||||
this.profileName = name;
|
||||
this.compressedProfile = ChunkHelper.compressBytes(profile, true);
|
||||
}
|
||||
|
||||
// Token: 0x06000154 RID: 340 RVA: 0x000064A2 File Offset: 0x000046A2
|
||||
public string GetProfileName()
|
||||
{
|
||||
return this.profileName;
|
||||
}
|
||||
|
||||
// Token: 0x06000155 RID: 341 RVA: 0x000064AA File Offset: 0x000046AA
|
||||
public byte[] GetProfile()
|
||||
{
|
||||
return ChunkHelper.compressBytes(this.compressedProfile, false);
|
||||
}
|
||||
|
||||
// Token: 0x06000156 RID: 342 RVA: 0x000064B8 File Offset: 0x000046B8
|
||||
public string GetProfileAsString()
|
||||
{
|
||||
return ChunkHelper.ToString(this.GetProfile());
|
||||
}
|
||||
|
||||
// Token: 0x040000B6 RID: 182
|
||||
public const string ID = "iCCP";
|
||||
|
||||
// Token: 0x040000B7 RID: 183
|
||||
private string profileName;
|
||||
|
||||
// Token: 0x040000B8 RID: 184
|
||||
private byte[] compressedProfile;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,41 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000026 RID: 38
|
||||
public class PngChunkIDAT : PngChunkMultiple
|
||||
{
|
||||
// Token: 0x06000157 RID: 343 RVA: 0x000064C5 File Offset: 0x000046C5
|
||||
public PngChunkIDAT(ImageInfo i, int len, long offset)
|
||||
: base("IDAT", i)
|
||||
{
|
||||
base.Length = len;
|
||||
base.Offset = offset;
|
||||
}
|
||||
|
||||
// Token: 0x06000158 RID: 344 RVA: 0x000064E1 File Offset: 0x000046E1
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NA;
|
||||
}
|
||||
|
||||
// Token: 0x06000159 RID: 345 RVA: 0x000064E4 File Offset: 0x000046E4
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
// Token: 0x0600015A RID: 346 RVA: 0x000064E7 File Offset: 0x000046E7
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600015B RID: 347 RVA: 0x000064E9 File Offset: 0x000046E9
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x040000B9 RID: 185
|
||||
public const string ID = "IDAT";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,39 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000027 RID: 39
|
||||
public class PngChunkIEND : PngChunkSingle
|
||||
{
|
||||
// Token: 0x0600015C RID: 348 RVA: 0x000064EB File Offset: 0x000046EB
|
||||
public PngChunkIEND(ImageInfo info)
|
||||
: base("IEND", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600015D RID: 349 RVA: 0x000064F9 File Offset: 0x000046F9
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NA;
|
||||
}
|
||||
|
||||
// Token: 0x0600015E RID: 350 RVA: 0x000064FC File Offset: 0x000046FC
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
return new ChunkRaw(0, ChunkHelper.b_IEND, false);
|
||||
}
|
||||
|
||||
// Token: 0x0600015F RID: 351 RVA: 0x00006517 File Offset: 0x00004717
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000160 RID: 352 RVA: 0x00006519 File Offset: 0x00004719
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x040000BA RID: 186
|
||||
public const string ID = "IEND";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000028 RID: 40
|
||||
public class PngChunkIHDR : PngChunkSingle
|
||||
{
|
||||
// Token: 0x17000020 RID: 32
|
||||
// (get) Token: 0x06000161 RID: 353 RVA: 0x0000651B File Offset: 0x0000471B
|
||||
// (set) Token: 0x06000162 RID: 354 RVA: 0x00006523 File Offset: 0x00004723
|
||||
public int Cols { get; set; }
|
||||
|
||||
// Token: 0x17000021 RID: 33
|
||||
// (get) Token: 0x06000163 RID: 355 RVA: 0x0000652C File Offset: 0x0000472C
|
||||
// (set) Token: 0x06000164 RID: 356 RVA: 0x00006534 File Offset: 0x00004734
|
||||
public int Rows { get; set; }
|
||||
|
||||
// Token: 0x17000022 RID: 34
|
||||
// (get) Token: 0x06000165 RID: 357 RVA: 0x0000653D File Offset: 0x0000473D
|
||||
// (set) Token: 0x06000166 RID: 358 RVA: 0x00006545 File Offset: 0x00004745
|
||||
public int Bitspc { get; set; }
|
||||
|
||||
// Token: 0x17000023 RID: 35
|
||||
// (get) Token: 0x06000167 RID: 359 RVA: 0x0000654E File Offset: 0x0000474E
|
||||
// (set) Token: 0x06000168 RID: 360 RVA: 0x00006556 File Offset: 0x00004756
|
||||
public int Colormodel { get; set; }
|
||||
|
||||
// Token: 0x17000024 RID: 36
|
||||
// (get) Token: 0x06000169 RID: 361 RVA: 0x0000655F File Offset: 0x0000475F
|
||||
// (set) Token: 0x0600016A RID: 362 RVA: 0x00006567 File Offset: 0x00004767
|
||||
public int Compmeth { get; set; }
|
||||
|
||||
// Token: 0x17000025 RID: 37
|
||||
// (get) Token: 0x0600016B RID: 363 RVA: 0x00006570 File Offset: 0x00004770
|
||||
// (set) Token: 0x0600016C RID: 364 RVA: 0x00006578 File Offset: 0x00004778
|
||||
public int Filmeth { get; set; }
|
||||
|
||||
// Token: 0x17000026 RID: 38
|
||||
// (get) Token: 0x0600016D RID: 365 RVA: 0x00006581 File Offset: 0x00004781
|
||||
// (set) Token: 0x0600016E RID: 366 RVA: 0x00006589 File Offset: 0x00004789
|
||||
public int Interlaced { get; set; }
|
||||
|
||||
// Token: 0x0600016F RID: 367 RVA: 0x00006592 File Offset: 0x00004792
|
||||
public PngChunkIHDR(ImageInfo info)
|
||||
: base("IHDR", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000170 RID: 368 RVA: 0x000065A0 File Offset: 0x000047A0
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NA;
|
||||
}
|
||||
|
||||
// Token: 0x06000171 RID: 369 RVA: 0x000065A4 File Offset: 0x000047A4
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = new ChunkRaw(13, ChunkHelper.b_IHDR, true);
|
||||
int num = 0;
|
||||
PngHelperInternal.WriteInt4tobytes(this.Cols, chunkRaw.Data, num);
|
||||
num += 4;
|
||||
PngHelperInternal.WriteInt4tobytes(this.Rows, chunkRaw.Data, num);
|
||||
num += 4;
|
||||
chunkRaw.Data[num++] = (byte)this.Bitspc;
|
||||
chunkRaw.Data[num++] = (byte)this.Colormodel;
|
||||
chunkRaw.Data[num++] = (byte)this.Compmeth;
|
||||
chunkRaw.Data[num++] = (byte)this.Filmeth;
|
||||
chunkRaw.Data[num++] = (byte)this.Interlaced;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000172 RID: 370 RVA: 0x00006650 File Offset: 0x00004850
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (c.Length != 13)
|
||||
{
|
||||
throw new PngjException("Bad IDHR len " + c.Length);
|
||||
}
|
||||
MemoryStream asByteStream = c.GetAsByteStream();
|
||||
this.Cols = PngHelperInternal.ReadInt4(asByteStream);
|
||||
this.Rows = PngHelperInternal.ReadInt4(asByteStream);
|
||||
this.Bitspc = PngHelperInternal.ReadByte(asByteStream);
|
||||
this.Colormodel = PngHelperInternal.ReadByte(asByteStream);
|
||||
this.Compmeth = PngHelperInternal.ReadByte(asByteStream);
|
||||
this.Filmeth = PngHelperInternal.ReadByte(asByteStream);
|
||||
this.Interlaced = PngHelperInternal.ReadByte(asByteStream);
|
||||
}
|
||||
|
||||
// Token: 0x06000173 RID: 371 RVA: 0x000066E0 File Offset: 0x000048E0
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkIHDR pngChunkIHDR = (PngChunkIHDR)other;
|
||||
this.Cols = pngChunkIHDR.Cols;
|
||||
this.Rows = pngChunkIHDR.Rows;
|
||||
this.Bitspc = pngChunkIHDR.Bitspc;
|
||||
this.Colormodel = pngChunkIHDR.Colormodel;
|
||||
this.Compmeth = pngChunkIHDR.Compmeth;
|
||||
this.Filmeth = pngChunkIHDR.Filmeth;
|
||||
this.Interlaced = pngChunkIHDR.Interlaced;
|
||||
}
|
||||
|
||||
// Token: 0x040000BB RID: 187
|
||||
public const string ID = "IHDR";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,147 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200002B RID: 43
|
||||
public class PngChunkITXT : PngChunkTextVar
|
||||
{
|
||||
// Token: 0x0600017A RID: 378 RVA: 0x0000677D File Offset: 0x0000497D
|
||||
public PngChunkITXT(ImageInfo info)
|
||||
: base("iTXt", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600017B RID: 379 RVA: 0x000067A4 File Offset: 0x000049A4
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
if (this.key.Length == 0)
|
||||
{
|
||||
throw new PngjException("Text chunk key must be non empty");
|
||||
}
|
||||
MemoryStream memoryStream = new MemoryStream();
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, ChunkHelper.ToBytes(this.key));
|
||||
memoryStream.WriteByte(0);
|
||||
memoryStream.WriteByte(this.compressed ? 1 : 0);
|
||||
memoryStream.WriteByte(0);
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, ChunkHelper.ToBytes(this.langTag));
|
||||
memoryStream.WriteByte(0);
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, ChunkHelper.ToBytesUTF8(this.translatedTag));
|
||||
memoryStream.WriteByte(0);
|
||||
byte[] array = ChunkHelper.ToBytesUTF8(this.val);
|
||||
if (this.compressed)
|
||||
{
|
||||
array = ChunkHelper.compressBytes(array, true);
|
||||
}
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, array);
|
||||
byte[] array2 = memoryStream.ToArray();
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(array2.Length, false);
|
||||
chunkRaw.Data = array2;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x0600017C RID: 380 RVA: 0x00006870 File Offset: 0x00004A70
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
int num = 0;
|
||||
int[] array = new int[3];
|
||||
for (int i = 0; i < c.Data.Length; i++)
|
||||
{
|
||||
if (c.Data[i] == 0)
|
||||
{
|
||||
array[num] = i;
|
||||
num++;
|
||||
if (num == 1)
|
||||
{
|
||||
i += 2;
|
||||
}
|
||||
if (num == 3)
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (num != 3)
|
||||
{
|
||||
throw new PngjException("Bad formed PngChunkITXT chunk");
|
||||
}
|
||||
this.key = ChunkHelper.ToString(c.Data, 0, array[0]);
|
||||
int num2 = array[0] + 1;
|
||||
this.compressed = c.Data[num2] != 0;
|
||||
num2++;
|
||||
if (this.compressed && c.Data[num2] != 0)
|
||||
{
|
||||
throw new PngjException("Bad formed PngChunkITXT chunk - bad compression method ");
|
||||
}
|
||||
this.langTag = ChunkHelper.ToString(c.Data, num2, array[1] - num2);
|
||||
this.translatedTag = ChunkHelper.ToStringUTF8(c.Data, array[1] + 1, array[2] - array[1] - 1);
|
||||
num2 = array[2] + 1;
|
||||
if (this.compressed)
|
||||
{
|
||||
byte[] array2 = ChunkHelper.compressBytes(c.Data, num2, c.Data.Length - num2, false);
|
||||
this.val = ChunkHelper.ToStringUTF8(array2);
|
||||
return;
|
||||
}
|
||||
this.val = ChunkHelper.ToStringUTF8(c.Data, num2, c.Data.Length - num2);
|
||||
}
|
||||
|
||||
// Token: 0x0600017D RID: 381 RVA: 0x000069A0 File Offset: 0x00004BA0
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkITXT pngChunkITXT = (PngChunkITXT)other;
|
||||
this.key = pngChunkITXT.key;
|
||||
this.val = pngChunkITXT.val;
|
||||
this.compressed = pngChunkITXT.compressed;
|
||||
this.langTag = pngChunkITXT.langTag;
|
||||
this.translatedTag = pngChunkITXT.translatedTag;
|
||||
}
|
||||
|
||||
// Token: 0x0600017E RID: 382 RVA: 0x000069F0 File Offset: 0x00004BF0
|
||||
public bool IsCompressed()
|
||||
{
|
||||
return this.compressed;
|
||||
}
|
||||
|
||||
// Token: 0x0600017F RID: 383 RVA: 0x000069F8 File Offset: 0x00004BF8
|
||||
public void SetCompressed(bool compressed)
|
||||
{
|
||||
this.compressed = compressed;
|
||||
}
|
||||
|
||||
// Token: 0x06000180 RID: 384 RVA: 0x00006A01 File Offset: 0x00004C01
|
||||
public string GetLangtag()
|
||||
{
|
||||
return this.langTag;
|
||||
}
|
||||
|
||||
// Token: 0x06000181 RID: 385 RVA: 0x00006A09 File Offset: 0x00004C09
|
||||
public void SetLangtag(string langtag)
|
||||
{
|
||||
this.langTag = langtag;
|
||||
}
|
||||
|
||||
// Token: 0x06000182 RID: 386 RVA: 0x00006A12 File Offset: 0x00004C12
|
||||
public string GetTranslatedTag()
|
||||
{
|
||||
return this.translatedTag;
|
||||
}
|
||||
|
||||
// Token: 0x06000183 RID: 387 RVA: 0x00006A1A File Offset: 0x00004C1A
|
||||
public void SetTranslatedTag(string translatedTag)
|
||||
{
|
||||
this.translatedTag = translatedTag;
|
||||
}
|
||||
|
||||
// Token: 0x040000D8 RID: 216
|
||||
public const string ID = "iTXt";
|
||||
|
||||
// Token: 0x040000D9 RID: 217
|
||||
private bool compressed;
|
||||
|
||||
// Token: 0x040000DA RID: 218
|
||||
private string langTag = "";
|
||||
|
||||
// Token: 0x040000DB RID: 219
|
||||
private string translatedTag = "";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200000E RID: 14
|
||||
public abstract class PngChunkMultiple : PngChunk
|
||||
{
|
||||
// Token: 0x0600005B RID: 91 RVA: 0x0000305D File Offset: 0x0000125D
|
||||
internal PngChunkMultiple(string id, ImageInfo imgInfo)
|
||||
: base(id, imgInfo)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600005C RID: 92 RVA: 0x00003067 File Offset: 0x00001267
|
||||
public sealed override bool AllowsMultiple()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000013 RID: 19
|
||||
public class PngChunkOFFS : PngChunkSingle
|
||||
{
|
||||
// Token: 0x06000082 RID: 130 RVA: 0x000035E8 File Offset: 0x000017E8
|
||||
public PngChunkOFFS(ImageInfo info)
|
||||
: base("oFFs", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000083 RID: 131 RVA: 0x000035F6 File Offset: 0x000017F6
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x06000084 RID: 132 RVA: 0x000035FC File Offset: 0x000017FC
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(9, true);
|
||||
PngHelperInternal.WriteInt4tobytes((int)this.posX, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt4tobytes((int)this.posY, chunkRaw.Data, 4);
|
||||
chunkRaw.Data[8] = (byte)this.units;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000085 RID: 133 RVA: 0x0000364C File Offset: 0x0000184C
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
if (chunk.Length != 9)
|
||||
{
|
||||
throw new PngjException("bad chunk length " + chunk);
|
||||
}
|
||||
this.posX = (long)PngHelperInternal.ReadInt4fromBytes(chunk.Data, 0);
|
||||
if (this.posX < 0L)
|
||||
{
|
||||
this.posX += 4294967296L;
|
||||
}
|
||||
this.posY = (long)PngHelperInternal.ReadInt4fromBytes(chunk.Data, 4);
|
||||
if (this.posY < 0L)
|
||||
{
|
||||
this.posY += 4294967296L;
|
||||
}
|
||||
this.units = PngHelperInternal.ReadInt1fromByte(chunk.Data, 8);
|
||||
}
|
||||
|
||||
// Token: 0x06000086 RID: 134 RVA: 0x000036EC File Offset: 0x000018EC
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkOFFS pngChunkOFFS = (PngChunkOFFS)other;
|
||||
this.posX = pngChunkOFFS.posX;
|
||||
this.posY = pngChunkOFFS.posY;
|
||||
this.units = pngChunkOFFS.units;
|
||||
}
|
||||
|
||||
// Token: 0x06000087 RID: 135 RVA: 0x00003724 File Offset: 0x00001924
|
||||
public int GetUnits()
|
||||
{
|
||||
return this.units;
|
||||
}
|
||||
|
||||
// Token: 0x06000088 RID: 136 RVA: 0x0000372C File Offset: 0x0000192C
|
||||
public void SetUnits(int units)
|
||||
{
|
||||
this.units = units;
|
||||
}
|
||||
|
||||
// Token: 0x06000089 RID: 137 RVA: 0x00003735 File Offset: 0x00001935
|
||||
public long GetPosX()
|
||||
{
|
||||
return this.posX;
|
||||
}
|
||||
|
||||
// Token: 0x0600008A RID: 138 RVA: 0x0000373D File Offset: 0x0000193D
|
||||
public void SetPosX(long posX)
|
||||
{
|
||||
this.posX = posX;
|
||||
}
|
||||
|
||||
// Token: 0x0600008B RID: 139 RVA: 0x00003746 File Offset: 0x00001946
|
||||
public long GetPosY()
|
||||
{
|
||||
return this.posY;
|
||||
}
|
||||
|
||||
// Token: 0x0600008C RID: 140 RVA: 0x0000374E File Offset: 0x0000194E
|
||||
public void SetPosY(long posY)
|
||||
{
|
||||
this.posY = posY;
|
||||
}
|
||||
|
||||
// Token: 0x0400004C RID: 76
|
||||
public const string ID = "oFFs";
|
||||
|
||||
// Token: 0x0400004D RID: 77
|
||||
private long posX;
|
||||
|
||||
// Token: 0x0400004E RID: 78
|
||||
private long posY;
|
||||
|
||||
// Token: 0x0400004F RID: 79
|
||||
private int units;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,117 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200002D RID: 45
|
||||
public class PngChunkPHYS : PngChunkSingle
|
||||
{
|
||||
// Token: 0x17000027 RID: 39
|
||||
// (get) Token: 0x0600018C RID: 396 RVA: 0x00006AC8 File Offset: 0x00004CC8
|
||||
// (set) Token: 0x0600018D RID: 397 RVA: 0x00006AD0 File Offset: 0x00004CD0
|
||||
public long PixelsxUnitX { get; set; }
|
||||
|
||||
// Token: 0x17000028 RID: 40
|
||||
// (get) Token: 0x0600018E RID: 398 RVA: 0x00006AD9 File Offset: 0x00004CD9
|
||||
// (set) Token: 0x0600018F RID: 399 RVA: 0x00006AE1 File Offset: 0x00004CE1
|
||||
public long PixelsxUnitY { get; set; }
|
||||
|
||||
// Token: 0x17000029 RID: 41
|
||||
// (get) Token: 0x06000190 RID: 400 RVA: 0x00006AEA File Offset: 0x00004CEA
|
||||
// (set) Token: 0x06000191 RID: 401 RVA: 0x00006AF2 File Offset: 0x00004CF2
|
||||
public int Units { get; set; }
|
||||
|
||||
// Token: 0x06000192 RID: 402 RVA: 0x00006AFB File Offset: 0x00004CFB
|
||||
public PngChunkPHYS(ImageInfo info)
|
||||
: base("pHYs", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000193 RID: 403 RVA: 0x00006B09 File Offset: 0x00004D09
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x06000194 RID: 404 RVA: 0x00006B0C File Offset: 0x00004D0C
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(9, true);
|
||||
PngHelperInternal.WriteInt4tobytes((int)this.PixelsxUnitX, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt4tobytes((int)this.PixelsxUnitY, chunkRaw.Data, 4);
|
||||
chunkRaw.Data[8] = (byte)this.Units;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000195 RID: 405 RVA: 0x00006B5C File Offset: 0x00004D5C
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkPHYS pngChunkPHYS = (PngChunkPHYS)other;
|
||||
this.PixelsxUnitX = pngChunkPHYS.PixelsxUnitX;
|
||||
this.PixelsxUnitY = pngChunkPHYS.PixelsxUnitY;
|
||||
this.Units = pngChunkPHYS.Units;
|
||||
}
|
||||
|
||||
// Token: 0x06000196 RID: 406 RVA: 0x00006B94 File Offset: 0x00004D94
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
if (chunk.Length != 9)
|
||||
{
|
||||
throw new PngjException("bad chunk length " + chunk);
|
||||
}
|
||||
this.PixelsxUnitX = (long)PngHelperInternal.ReadInt4fromBytes(chunk.Data, 0);
|
||||
if (this.PixelsxUnitX < 0L)
|
||||
{
|
||||
this.PixelsxUnitX += 4294967296L;
|
||||
}
|
||||
this.PixelsxUnitY = (long)PngHelperInternal.ReadInt4fromBytes(chunk.Data, 4);
|
||||
if (this.PixelsxUnitY < 0L)
|
||||
{
|
||||
this.PixelsxUnitY += 4294967296L;
|
||||
}
|
||||
this.Units = PngHelperInternal.ReadInt1fromByte(chunk.Data, 8);
|
||||
}
|
||||
|
||||
// Token: 0x06000197 RID: 407 RVA: 0x00006C34 File Offset: 0x00004E34
|
||||
public double GetAsDpi()
|
||||
{
|
||||
if (this.Units != 1 || this.PixelsxUnitX != this.PixelsxUnitY)
|
||||
{
|
||||
return -1.0;
|
||||
}
|
||||
return (double)this.PixelsxUnitX * 0.0254;
|
||||
}
|
||||
|
||||
// Token: 0x06000198 RID: 408 RVA: 0x00006C68 File Offset: 0x00004E68
|
||||
public double[] GetAsDpi2()
|
||||
{
|
||||
if (this.Units != 1)
|
||||
{
|
||||
return new double[] { -1.0, -1.0 };
|
||||
}
|
||||
return new double[]
|
||||
{
|
||||
(double)this.PixelsxUnitX * 0.0254,
|
||||
(double)this.PixelsxUnitY * 0.0254
|
||||
};
|
||||
}
|
||||
|
||||
// Token: 0x06000199 RID: 409 RVA: 0x00006CCF File Offset: 0x00004ECF
|
||||
public void SetAsDpi(double dpi)
|
||||
{
|
||||
this.Units = 1;
|
||||
this.PixelsxUnitX = (long)(dpi / 0.0254 + 0.5);
|
||||
this.PixelsxUnitY = this.PixelsxUnitX;
|
||||
}
|
||||
|
||||
// Token: 0x0600019A RID: 410 RVA: 0x00006D00 File Offset: 0x00004F00
|
||||
public void SetAsDpi2(double dpix, double dpiy)
|
||||
{
|
||||
this.Units = 1;
|
||||
this.PixelsxUnitX = (long)(dpix / 0.0254 + 0.5);
|
||||
this.PixelsxUnitY = (long)(dpiy / 0.0254 + 0.5);
|
||||
}
|
||||
|
||||
// Token: 0x040000DD RID: 221
|
||||
public const string ID = "pHYs";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,135 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200002E RID: 46
|
||||
public class PngChunkPLTE : PngChunkSingle
|
||||
{
|
||||
// Token: 0x0600019B RID: 411 RVA: 0x00006D4C File Offset: 0x00004F4C
|
||||
public PngChunkPLTE(ImageInfo info)
|
||||
: base("PLTE", info)
|
||||
{
|
||||
this.nentries = 0;
|
||||
}
|
||||
|
||||
// Token: 0x0600019C RID: 412 RVA: 0x00006D61 File Offset: 0x00004F61
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NA;
|
||||
}
|
||||
|
||||
// Token: 0x0600019D RID: 413 RVA: 0x00006D64 File Offset: 0x00004F64
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
int num = 3 * this.nentries;
|
||||
int[] array = new int[3];
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(num, true);
|
||||
int i = 0;
|
||||
int num2 = 0;
|
||||
while (i < this.nentries)
|
||||
{
|
||||
this.GetEntryRgb(i, array);
|
||||
chunkRaw.Data[num2++] = (byte)array[0];
|
||||
chunkRaw.Data[num2++] = (byte)array[1];
|
||||
chunkRaw.Data[num2++] = (byte)array[2];
|
||||
i++;
|
||||
}
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x0600019E RID: 414 RVA: 0x00006DE0 File Offset: 0x00004FE0
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
this.SetNentries(chunk.Length / 3);
|
||||
int i = 0;
|
||||
int num = 0;
|
||||
while (i < this.nentries)
|
||||
{
|
||||
this.SetEntry(i, (int)(chunk.Data[num++] & byte.MaxValue), (int)(chunk.Data[num++] & byte.MaxValue), (int)(chunk.Data[num++] & byte.MaxValue));
|
||||
i++;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x0600019F RID: 415 RVA: 0x00006E4C File Offset: 0x0000504C
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkPLTE pngChunkPLTE = (PngChunkPLTE)other;
|
||||
this.SetNentries(pngChunkPLTE.GetNentries());
|
||||
Array.Copy(pngChunkPLTE.entries, 0, this.entries, 0, this.nentries);
|
||||
}
|
||||
|
||||
// Token: 0x060001A0 RID: 416 RVA: 0x00006E88 File Offset: 0x00005088
|
||||
public void SetNentries(int nentries)
|
||||
{
|
||||
this.nentries = nentries;
|
||||
if (nentries < 1 || nentries > 256)
|
||||
{
|
||||
throw new PngjException("invalid pallette - nentries=" + nentries);
|
||||
}
|
||||
if (this.entries == null || this.entries.Length != nentries)
|
||||
{
|
||||
this.entries = new int[nentries];
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001A1 RID: 417 RVA: 0x00006EDD File Offset: 0x000050DD
|
||||
public int GetNentries()
|
||||
{
|
||||
return this.nentries;
|
||||
}
|
||||
|
||||
// Token: 0x060001A2 RID: 418 RVA: 0x00006EE5 File Offset: 0x000050E5
|
||||
public void SetEntry(int n, int r, int g, int b)
|
||||
{
|
||||
this.entries[n] = (r << 16) | (g << 8) | b;
|
||||
}
|
||||
|
||||
// Token: 0x060001A3 RID: 419 RVA: 0x00006EFA File Offset: 0x000050FA
|
||||
public int GetEntry(int n)
|
||||
{
|
||||
return this.entries[n];
|
||||
}
|
||||
|
||||
// Token: 0x060001A4 RID: 420 RVA: 0x00006F04 File Offset: 0x00005104
|
||||
public void GetEntryRgb(int index, int[] rgb, int offset)
|
||||
{
|
||||
int num = this.entries[index];
|
||||
rgb[offset] = (num & 16711680) >> 16;
|
||||
rgb[offset + 1] = (num & 65280) >> 8;
|
||||
rgb[offset + 2] = num & 255;
|
||||
}
|
||||
|
||||
// Token: 0x060001A5 RID: 421 RVA: 0x00006F41 File Offset: 0x00005141
|
||||
public void GetEntryRgb(int n, int[] rgb)
|
||||
{
|
||||
this.GetEntryRgb(n, rgb, 0);
|
||||
}
|
||||
|
||||
// Token: 0x060001A6 RID: 422 RVA: 0x00006F4C File Offset: 0x0000514C
|
||||
public int MinBitDepth()
|
||||
{
|
||||
if (this.nentries <= 2)
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
if (this.nentries <= 4)
|
||||
{
|
||||
return 2;
|
||||
}
|
||||
if (this.nentries <= 16)
|
||||
{
|
||||
return 4;
|
||||
}
|
||||
return 8;
|
||||
}
|
||||
|
||||
// Token: 0x040000E1 RID: 225
|
||||
public const string ID = "PLTE";
|
||||
|
||||
// Token: 0x040000E2 RID: 226
|
||||
private int nentries;
|
||||
|
||||
// Token: 0x040000E3 RID: 227
|
||||
private int[] entries;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,123 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000017 RID: 23
|
||||
public class PngChunkSBIT : PngChunkSingle
|
||||
{
|
||||
// Token: 0x17000009 RID: 9
|
||||
// (get) Token: 0x060000A8 RID: 168 RVA: 0x00003EA9 File Offset: 0x000020A9
|
||||
// (set) Token: 0x060000A9 RID: 169 RVA: 0x00003EB1 File Offset: 0x000020B1
|
||||
public int Graysb { get; set; }
|
||||
|
||||
// Token: 0x1700000A RID: 10
|
||||
// (get) Token: 0x060000AA RID: 170 RVA: 0x00003EBA File Offset: 0x000020BA
|
||||
// (set) Token: 0x060000AB RID: 171 RVA: 0x00003EC2 File Offset: 0x000020C2
|
||||
public int Alphasb { get; set; }
|
||||
|
||||
// Token: 0x1700000B RID: 11
|
||||
// (get) Token: 0x060000AC RID: 172 RVA: 0x00003ECB File Offset: 0x000020CB
|
||||
// (set) Token: 0x060000AD RID: 173 RVA: 0x00003ED3 File Offset: 0x000020D3
|
||||
public int Redsb { get; set; }
|
||||
|
||||
// Token: 0x1700000C RID: 12
|
||||
// (get) Token: 0x060000AE RID: 174 RVA: 0x00003EDC File Offset: 0x000020DC
|
||||
// (set) Token: 0x060000AF RID: 175 RVA: 0x00003EE4 File Offset: 0x000020E4
|
||||
public int Greensb { get; set; }
|
||||
|
||||
// Token: 0x1700000D RID: 13
|
||||
// (get) Token: 0x060000B0 RID: 176 RVA: 0x00003EED File Offset: 0x000020ED
|
||||
// (set) Token: 0x060000B1 RID: 177 RVA: 0x00003EF5 File Offset: 0x000020F5
|
||||
public int Bluesb { get; set; }
|
||||
|
||||
// Token: 0x060000B2 RID: 178 RVA: 0x00003EFE File Offset: 0x000020FE
|
||||
public PngChunkSBIT(ImageInfo info)
|
||||
: base("sBIT", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000B3 RID: 179 RVA: 0x00003F0C File Offset: 0x0000210C
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x060000B4 RID: 180 RVA: 0x00003F10 File Offset: 0x00002110
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (c.Length != this.GetLen())
|
||||
{
|
||||
throw new PngjException("bad chunk length " + c);
|
||||
}
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
this.Graysb = PngHelperInternal.ReadInt1fromByte(c.Data, 0);
|
||||
if (this.ImgInfo.Alpha)
|
||||
{
|
||||
this.Alphasb = PngHelperInternal.ReadInt1fromByte(c.Data, 1);
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
this.Redsb = PngHelperInternal.ReadInt1fromByte(c.Data, 0);
|
||||
this.Greensb = PngHelperInternal.ReadInt1fromByte(c.Data, 1);
|
||||
this.Bluesb = PngHelperInternal.ReadInt1fromByte(c.Data, 2);
|
||||
if (this.ImgInfo.Alpha)
|
||||
{
|
||||
this.Alphasb = PngHelperInternal.ReadInt1fromByte(c.Data, 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060000B5 RID: 181 RVA: 0x00003FD0 File Offset: 0x000021D0
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(this.GetLen(), true);
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
chunkRaw.Data[0] = (byte)this.Graysb;
|
||||
if (this.ImgInfo.Alpha)
|
||||
{
|
||||
chunkRaw.Data[1] = (byte)this.Alphasb;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
chunkRaw.Data[0] = (byte)this.Redsb;
|
||||
chunkRaw.Data[1] = (byte)this.Greensb;
|
||||
chunkRaw.Data[2] = (byte)this.Bluesb;
|
||||
if (this.ImgInfo.Alpha)
|
||||
{
|
||||
chunkRaw.Data[3] = (byte)this.Alphasb;
|
||||
}
|
||||
}
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060000B6 RID: 182 RVA: 0x00004074 File Offset: 0x00002274
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkSBIT pngChunkSBIT = (PngChunkSBIT)other;
|
||||
this.Graysb = pngChunkSBIT.Graysb;
|
||||
this.Redsb = pngChunkSBIT.Redsb;
|
||||
this.Greensb = pngChunkSBIT.Greensb;
|
||||
this.Bluesb = pngChunkSBIT.Bluesb;
|
||||
this.Alphasb = pngChunkSBIT.Alphasb;
|
||||
}
|
||||
|
||||
// Token: 0x060000B7 RID: 183 RVA: 0x000040C4 File Offset: 0x000022C4
|
||||
private int GetLen()
|
||||
{
|
||||
int num = (this.ImgInfo.Greyscale ? 1 : 3);
|
||||
if (this.ImgInfo.Alpha)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
return num;
|
||||
}
|
||||
|
||||
// Token: 0x0400005F RID: 95
|
||||
public const string ID = "sBIT";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,141 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000014 RID: 20
|
||||
public class PngChunkSPLT : PngChunkMultiple
|
||||
{
|
||||
// Token: 0x17000006 RID: 6
|
||||
// (get) Token: 0x0600008D RID: 141 RVA: 0x00003757 File Offset: 0x00001957
|
||||
// (set) Token: 0x0600008E RID: 142 RVA: 0x0000375F File Offset: 0x0000195F
|
||||
public string PalName { get; set; }
|
||||
|
||||
// Token: 0x17000007 RID: 7
|
||||
// (get) Token: 0x0600008F RID: 143 RVA: 0x00003768 File Offset: 0x00001968
|
||||
// (set) Token: 0x06000090 RID: 144 RVA: 0x00003770 File Offset: 0x00001970
|
||||
public int SampleDepth { get; set; }
|
||||
|
||||
// Token: 0x17000008 RID: 8
|
||||
// (get) Token: 0x06000091 RID: 145 RVA: 0x00003779 File Offset: 0x00001979
|
||||
// (set) Token: 0x06000092 RID: 146 RVA: 0x00003781 File Offset: 0x00001981
|
||||
public int[] Palette { get; set; }
|
||||
|
||||
// Token: 0x06000093 RID: 147 RVA: 0x0000378A File Offset: 0x0000198A
|
||||
public PngChunkSPLT(ImageInfo info)
|
||||
: base("sPLT", info)
|
||||
{
|
||||
this.PalName = "";
|
||||
}
|
||||
|
||||
// Token: 0x06000094 RID: 148 RVA: 0x000037A3 File Offset: 0x000019A3
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x06000095 RID: 149 RVA: 0x000037A8 File Offset: 0x000019A8
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
MemoryStream memoryStream = new MemoryStream();
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, ChunkHelper.ToBytes(this.PalName));
|
||||
memoryStream.WriteByte(0);
|
||||
memoryStream.WriteByte((byte)this.SampleDepth);
|
||||
int nentries = this.GetNentries();
|
||||
for (int i = 0; i < nentries; i++)
|
||||
{
|
||||
for (int j = 0; j < 4; j++)
|
||||
{
|
||||
if (this.SampleDepth == 8)
|
||||
{
|
||||
PngHelperInternal.WriteByte(memoryStream, (byte)this.Palette[i * 5 + j]);
|
||||
}
|
||||
else
|
||||
{
|
||||
PngHelperInternal.WriteInt2(memoryStream, this.Palette[i * 5 + j]);
|
||||
}
|
||||
}
|
||||
PngHelperInternal.WriteInt2(memoryStream, this.Palette[i * 5 + 4]);
|
||||
}
|
||||
byte[] array = memoryStream.ToArray();
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(array.Length, false);
|
||||
chunkRaw.Data = array;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000096 RID: 150 RVA: 0x00003864 File Offset: 0x00001A64
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
int num = -1;
|
||||
for (int i = 0; i < c.Data.Length; i++)
|
||||
{
|
||||
if (c.Data[i] == 0)
|
||||
{
|
||||
num = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (num <= 0 || num > c.Data.Length - 2)
|
||||
{
|
||||
throw new PngjException("bad sPLT chunk: no separator found");
|
||||
}
|
||||
this.PalName = ChunkHelper.ToString(c.Data, 0, num);
|
||||
this.SampleDepth = PngHelperInternal.ReadInt1fromByte(c.Data, num + 1);
|
||||
num += 2;
|
||||
int num2 = (c.Data.Length - num) / ((this.SampleDepth == 8) ? 6 : 10);
|
||||
this.Palette = new int[num2 * 5];
|
||||
int num3 = 0;
|
||||
for (int j = 0; j < num2; j++)
|
||||
{
|
||||
int num4;
|
||||
int num5;
|
||||
int num6;
|
||||
int num7;
|
||||
if (this.SampleDepth == 8)
|
||||
{
|
||||
num4 = PngHelperInternal.ReadInt1fromByte(c.Data, num++);
|
||||
num5 = PngHelperInternal.ReadInt1fromByte(c.Data, num++);
|
||||
num6 = PngHelperInternal.ReadInt1fromByte(c.Data, num++);
|
||||
num7 = PngHelperInternal.ReadInt1fromByte(c.Data, num++);
|
||||
}
|
||||
else
|
||||
{
|
||||
num4 = PngHelperInternal.ReadInt2fromBytes(c.Data, num);
|
||||
num += 2;
|
||||
num5 = PngHelperInternal.ReadInt2fromBytes(c.Data, num);
|
||||
num += 2;
|
||||
num6 = PngHelperInternal.ReadInt2fromBytes(c.Data, num);
|
||||
num += 2;
|
||||
num7 = PngHelperInternal.ReadInt2fromBytes(c.Data, num);
|
||||
num += 2;
|
||||
}
|
||||
int num8 = PngHelperInternal.ReadInt2fromBytes(c.Data, num);
|
||||
num += 2;
|
||||
this.Palette[num3++] = num4;
|
||||
this.Palette[num3++] = num5;
|
||||
this.Palette[num3++] = num6;
|
||||
this.Palette[num3++] = num7;
|
||||
this.Palette[num3++] = num8;
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x06000097 RID: 151 RVA: 0x00003A18 File Offset: 0x00001C18
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkSPLT pngChunkSPLT = (PngChunkSPLT)other;
|
||||
this.PalName = pngChunkSPLT.PalName;
|
||||
this.SampleDepth = pngChunkSPLT.SampleDepth;
|
||||
this.Palette = new int[pngChunkSPLT.Palette.Length];
|
||||
Array.Copy(pngChunkSPLT.Palette, 0, this.Palette, 0, this.Palette.Length);
|
||||
}
|
||||
|
||||
// Token: 0x06000098 RID: 152 RVA: 0x00003A72 File Offset: 0x00001C72
|
||||
public int GetNentries()
|
||||
{
|
||||
return this.Palette.Length / 5;
|
||||
}
|
||||
|
||||
// Token: 0x04000050 RID: 80
|
||||
public const string ID = "sPLT";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000018 RID: 24
|
||||
public class PngChunkSRGB : PngChunkSingle
|
||||
{
|
||||
// Token: 0x1700000E RID: 14
|
||||
// (get) Token: 0x060000B8 RID: 184 RVA: 0x000040F5 File Offset: 0x000022F5
|
||||
// (set) Token: 0x060000B9 RID: 185 RVA: 0x000040FD File Offset: 0x000022FD
|
||||
public int Intent { get; set; }
|
||||
|
||||
// Token: 0x060000BA RID: 186 RVA: 0x00004106 File Offset: 0x00002306
|
||||
public PngChunkSRGB(ImageInfo info)
|
||||
: base("sRGB", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060000BB RID: 187 RVA: 0x00004114 File Offset: 0x00002314
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_PLTE_AND_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x060000BC RID: 188 RVA: 0x00004118 File Offset: 0x00002318
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(1, true);
|
||||
chunkRaw.Data[0] = (byte)this.Intent;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060000BD RID: 189 RVA: 0x00004140 File Offset: 0x00002340
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (c.Length != 1)
|
||||
{
|
||||
throw new PngjException("bad chunk length " + c);
|
||||
}
|
||||
this.Intent = PngHelperInternal.ReadInt1fromByte(c.Data, 0);
|
||||
}
|
||||
|
||||
// Token: 0x060000BE RID: 190 RVA: 0x00004170 File Offset: 0x00002370
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkSRGB pngChunkSRGB = (PngChunkSRGB)other;
|
||||
this.Intent = pngChunkSRGB.Intent;
|
||||
}
|
||||
|
||||
// Token: 0x04000065 RID: 101
|
||||
public const string ID = "sRGB";
|
||||
|
||||
// Token: 0x04000066 RID: 102
|
||||
public const int RENDER_INTENT_Perceptual = 0;
|
||||
|
||||
// Token: 0x04000067 RID: 103
|
||||
public const int RENDER_INTENT_Relative_colorimetric = 1;
|
||||
|
||||
// Token: 0x04000068 RID: 104
|
||||
public const int RENDER_INTENT_Saturation = 2;
|
||||
|
||||
// Token: 0x04000069 RID: 105
|
||||
public const int RENDER_INTENT_Absolute_colorimetric = 3;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000012 RID: 18
|
||||
public class PngChunkSTER : PngChunkSingle
|
||||
{
|
||||
// Token: 0x17000005 RID: 5
|
||||
// (get) Token: 0x0600007B RID: 123 RVA: 0x00003556 File Offset: 0x00001756
|
||||
// (set) Token: 0x0600007C RID: 124 RVA: 0x0000355E File Offset: 0x0000175E
|
||||
public byte Mode { get; set; }
|
||||
|
||||
// Token: 0x0600007D RID: 125 RVA: 0x00003567 File Offset: 0x00001767
|
||||
public PngChunkSTER(ImageInfo info)
|
||||
: base("sTER", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600007E RID: 126 RVA: 0x00003575 File Offset: 0x00001775
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x0600007F RID: 127 RVA: 0x00003578 File Offset: 0x00001778
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(1, true);
|
||||
chunkRaw.Data[0] = this.Mode;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000080 RID: 128 RVA: 0x0000359D File Offset: 0x0000179D
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
if (chunk.Length != 1)
|
||||
{
|
||||
throw new PngjException("bad chunk length " + chunk);
|
||||
}
|
||||
this.Mode = chunk.Data[0];
|
||||
}
|
||||
|
||||
// Token: 0x06000081 RID: 129 RVA: 0x000035C8 File Offset: 0x000017C8
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkSTER pngChunkSTER = (PngChunkSTER)other;
|
||||
this.Mode = pngChunkSTER.Mode;
|
||||
}
|
||||
|
||||
// Token: 0x0400004A RID: 74
|
||||
public const string ID = "sTER";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200000F RID: 15
|
||||
public abstract class PngChunkSingle : PngChunk
|
||||
{
|
||||
// Token: 0x0600005D RID: 93 RVA: 0x0000306A File Offset: 0x0000126A
|
||||
public PngChunkSingle(string id, ImageInfo imgInfo)
|
||||
: base(id, imgInfo)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x0600005E RID: 94 RVA: 0x00003074 File Offset: 0x00001274
|
||||
public sealed override bool AllowsMultiple()
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
// Token: 0x0600005F RID: 95 RVA: 0x00003078 File Offset: 0x00001278
|
||||
public override int GetHashCode()
|
||||
{
|
||||
int num = 31;
|
||||
int num2 = 1;
|
||||
return num * num2 + ((this.Id == null) ? 0 : this.Id.GetHashCode());
|
||||
}
|
||||
|
||||
// Token: 0x06000060 RID: 96 RVA: 0x000030A6 File Offset: 0x000012A6
|
||||
public override bool Equals(object obj)
|
||||
{
|
||||
return obj is PngChunkSingle && this.Id != null && this.Id.Equals(((PngChunkSingle)obj).Id);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,45 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000010 RID: 16
|
||||
internal class PngChunkSkipped : PngChunk
|
||||
{
|
||||
// Token: 0x06000061 RID: 97 RVA: 0x000030D0 File Offset: 0x000012D0
|
||||
internal PngChunkSkipped(string id, ImageInfo imgInfo, int clen)
|
||||
: base(id, imgInfo)
|
||||
{
|
||||
base.Length = clen;
|
||||
}
|
||||
|
||||
// Token: 0x06000062 RID: 98 RVA: 0x000030E1 File Offset: 0x000012E1
|
||||
public sealed override bool AllowsMultiple()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
// Token: 0x06000063 RID: 99 RVA: 0x000030E4 File Offset: 0x000012E4
|
||||
public sealed override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
throw new PngjException("Non supported for a skipped chunk");
|
||||
}
|
||||
|
||||
// Token: 0x06000064 RID: 100 RVA: 0x000030F0 File Offset: 0x000012F0
|
||||
public sealed override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
throw new PngjException("Non supported for a skipped chunk");
|
||||
}
|
||||
|
||||
// Token: 0x06000065 RID: 101 RVA: 0x000030FC File Offset: 0x000012FC
|
||||
public sealed override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
throw new PngjException("Non supported for a skipped chunk");
|
||||
}
|
||||
|
||||
// Token: 0x06000066 RID: 102 RVA: 0x00003108 File Offset: 0x00001308
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NONE;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,54 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200002F RID: 47
|
||||
public class PngChunkTEXT : PngChunkTextVar
|
||||
{
|
||||
// Token: 0x060001A7 RID: 423 RVA: 0x00006F71 File Offset: 0x00005171
|
||||
public PngChunkTEXT(ImageInfo info)
|
||||
: base("tEXt", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060001A8 RID: 424 RVA: 0x00006F80 File Offset: 0x00005180
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
if (this.key.Length == 0)
|
||||
{
|
||||
throw new PngjException("Text chunk key must be non empty");
|
||||
}
|
||||
byte[] bytes = PngHelperInternal.charsetLatin1.GetBytes(this.key);
|
||||
byte[] bytes2 = PngHelperInternal.charsetLatin1.GetBytes(this.val);
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(bytes.Length + bytes2.Length + 1, true);
|
||||
Array.Copy(bytes, 0, chunkRaw.Data, 0, bytes.Length);
|
||||
chunkRaw.Data[bytes.Length] = 0;
|
||||
Array.Copy(bytes2, 0, chunkRaw.Data, bytes.Length + 1, bytes2.Length);
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060001A9 RID: 425 RVA: 0x0000700C File Offset: 0x0000520C
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
int num = 0;
|
||||
while (num < c.Data.Length && c.Data[num] != 0)
|
||||
{
|
||||
num++;
|
||||
}
|
||||
this.key = PngHelperInternal.charsetLatin1.GetString(c.Data, 0, num);
|
||||
num++;
|
||||
this.val = ((num < c.Data.Length) ? PngHelperInternal.charsetLatin1.GetString(c.Data, num, c.Data.Length - num) : "");
|
||||
}
|
||||
|
||||
// Token: 0x060001AA RID: 426 RVA: 0x00007088 File Offset: 0x00005288
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkTEXT pngChunkTEXT = (PngChunkTEXT)other;
|
||||
this.key = pngChunkTEXT.key;
|
||||
this.val = pngChunkTEXT.val;
|
||||
}
|
||||
|
||||
// Token: 0x040000E4 RID: 228
|
||||
public const string ID = "tEXt";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000030 RID: 48
|
||||
public class PngChunkTIME : PngChunkSingle
|
||||
{
|
||||
// Token: 0x060001AB RID: 427 RVA: 0x000070B4 File Offset: 0x000052B4
|
||||
public PngChunkTIME(ImageInfo info)
|
||||
: base("tIME", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060001AC RID: 428 RVA: 0x000070C2 File Offset: 0x000052C2
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NONE;
|
||||
}
|
||||
|
||||
// Token: 0x060001AD RID: 429 RVA: 0x000070C8 File Offset: 0x000052C8
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(7, true);
|
||||
PngHelperInternal.WriteInt2tobytes(this.year, chunkRaw.Data, 0);
|
||||
chunkRaw.Data[2] = (byte)this.mon;
|
||||
chunkRaw.Data[3] = (byte)this.day;
|
||||
chunkRaw.Data[4] = (byte)this.hour;
|
||||
chunkRaw.Data[5] = (byte)this.min;
|
||||
chunkRaw.Data[6] = (byte)this.sec;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060001AE RID: 430 RVA: 0x0000713C File Offset: 0x0000533C
|
||||
public override void ParseFromRaw(ChunkRaw chunk)
|
||||
{
|
||||
if (chunk.Length != 7)
|
||||
{
|
||||
throw new PngjException("bad chunk " + chunk);
|
||||
}
|
||||
this.year = PngHelperInternal.ReadInt2fromBytes(chunk.Data, 0);
|
||||
this.mon = PngHelperInternal.ReadInt1fromByte(chunk.Data, 2);
|
||||
this.day = PngHelperInternal.ReadInt1fromByte(chunk.Data, 3);
|
||||
this.hour = PngHelperInternal.ReadInt1fromByte(chunk.Data, 4);
|
||||
this.min = PngHelperInternal.ReadInt1fromByte(chunk.Data, 5);
|
||||
this.sec = PngHelperInternal.ReadInt1fromByte(chunk.Data, 6);
|
||||
}
|
||||
|
||||
// Token: 0x060001AF RID: 431 RVA: 0x000071D0 File Offset: 0x000053D0
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkTIME pngChunkTIME = (PngChunkTIME)other;
|
||||
this.year = pngChunkTIME.year;
|
||||
this.mon = pngChunkTIME.mon;
|
||||
this.day = pngChunkTIME.day;
|
||||
this.hour = pngChunkTIME.hour;
|
||||
this.min = pngChunkTIME.min;
|
||||
this.sec = pngChunkTIME.sec;
|
||||
}
|
||||
|
||||
// Token: 0x060001B0 RID: 432 RVA: 0x0000722C File Offset: 0x0000542C
|
||||
public void SetNow(int secsAgo)
|
||||
{
|
||||
DateTime now = DateTime.Now;
|
||||
this.year = now.Year;
|
||||
this.mon = now.Month;
|
||||
this.day = now.Day;
|
||||
this.hour = now.Hour;
|
||||
this.min = now.Minute;
|
||||
this.sec = now.Second;
|
||||
}
|
||||
|
||||
// Token: 0x060001B1 RID: 433 RVA: 0x0000728D File Offset: 0x0000548D
|
||||
internal void SetYMDHMS(int yearx, int monx, int dayx, int hourx, int minx, int secx)
|
||||
{
|
||||
this.year = yearx;
|
||||
this.mon = monx;
|
||||
this.day = dayx;
|
||||
this.hour = hourx;
|
||||
this.min = minx;
|
||||
this.sec = secx;
|
||||
}
|
||||
|
||||
// Token: 0x060001B2 RID: 434 RVA: 0x000072BC File Offset: 0x000054BC
|
||||
public int[] GetYMDHMS()
|
||||
{
|
||||
return new int[] { this.year, this.mon, this.day, this.hour, this.min, this.sec };
|
||||
}
|
||||
|
||||
// Token: 0x060001B3 RID: 435 RVA: 0x00007308 File Offset: 0x00005508
|
||||
public string GetAsString()
|
||||
{
|
||||
return string.Format("%04d/%02d/%02d %02d:%02d:%02d", new object[] { this.year, this.mon, this.day, this.hour, this.min, this.sec });
|
||||
}
|
||||
|
||||
// Token: 0x040000E5 RID: 229
|
||||
public const string ID = "tIME";
|
||||
|
||||
// Token: 0x040000E6 RID: 230
|
||||
private int year;
|
||||
|
||||
// Token: 0x040000E7 RID: 231
|
||||
private int mon;
|
||||
|
||||
// Token: 0x040000E8 RID: 232
|
||||
private int day;
|
||||
|
||||
// Token: 0x040000E9 RID: 233
|
||||
private int hour;
|
||||
|
||||
// Token: 0x040000EA RID: 234
|
||||
private int min;
|
||||
|
||||
// Token: 0x040000EB RID: 235
|
||||
private int sec;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000031 RID: 49
|
||||
public class PngChunkTRNS : PngChunkSingle
|
||||
{
|
||||
// Token: 0x060001B4 RID: 436 RVA: 0x0000737B File Offset: 0x0000557B
|
||||
public PngChunkTRNS(ImageInfo info)
|
||||
: base("tRNS", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060001B5 RID: 437 RVA: 0x00007389 File Offset: 0x00005589
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.AFTER_PLTE_BEFORE_IDAT;
|
||||
}
|
||||
|
||||
// Token: 0x060001B6 RID: 438 RVA: 0x0000738C File Offset: 0x0000558C
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw;
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(2, true);
|
||||
PngHelperInternal.WriteInt2tobytes(this.gray, chunkRaw.Data, 0);
|
||||
}
|
||||
else if (this.ImgInfo.Indexed)
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(this.paletteAlpha.Length, true);
|
||||
for (int i = 0; i < chunkRaw.Length; i++)
|
||||
{
|
||||
chunkRaw.Data[i] = (byte)this.paletteAlpha[i];
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
chunkRaw = base.createEmptyChunk(6, true);
|
||||
PngHelperInternal.WriteInt2tobytes(this.red, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt2tobytes(this.green, chunkRaw.Data, 0);
|
||||
PngHelperInternal.WriteInt2tobytes(this.blue, chunkRaw.Data, 0);
|
||||
}
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060001B7 RID: 439 RVA: 0x0000744C File Offset: 0x0000564C
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
if (this.ImgInfo.Greyscale)
|
||||
{
|
||||
this.gray = PngHelperInternal.ReadInt2fromBytes(c.Data, 0);
|
||||
return;
|
||||
}
|
||||
if (this.ImgInfo.Indexed)
|
||||
{
|
||||
int num = c.Data.Length;
|
||||
this.paletteAlpha = new int[num];
|
||||
for (int i = 0; i < num; i++)
|
||||
{
|
||||
this.paletteAlpha[i] = (int)(c.Data[i] & byte.MaxValue);
|
||||
}
|
||||
return;
|
||||
}
|
||||
this.red = PngHelperInternal.ReadInt2fromBytes(c.Data, 0);
|
||||
this.green = PngHelperInternal.ReadInt2fromBytes(c.Data, 2);
|
||||
this.blue = PngHelperInternal.ReadInt2fromBytes(c.Data, 4);
|
||||
}
|
||||
|
||||
// Token: 0x060001B8 RID: 440 RVA: 0x000074F4 File Offset: 0x000056F4
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkTRNS pngChunkTRNS = (PngChunkTRNS)other;
|
||||
this.gray = pngChunkTRNS.gray;
|
||||
this.red = pngChunkTRNS.red;
|
||||
this.green = pngChunkTRNS.red;
|
||||
this.blue = pngChunkTRNS.red;
|
||||
if (pngChunkTRNS.paletteAlpha != null)
|
||||
{
|
||||
this.paletteAlpha = new int[pngChunkTRNS.paletteAlpha.Length];
|
||||
Array.Copy(pngChunkTRNS.paletteAlpha, 0, this.paletteAlpha, 0, this.paletteAlpha.Length);
|
||||
}
|
||||
}
|
||||
|
||||
// Token: 0x060001B9 RID: 441 RVA: 0x0000756E File Offset: 0x0000576E
|
||||
public void SetRGB(int r, int g, int b)
|
||||
{
|
||||
if (this.ImgInfo.Greyscale || this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only rgb or rgba images support this");
|
||||
}
|
||||
this.red = r;
|
||||
this.green = g;
|
||||
this.blue = b;
|
||||
}
|
||||
|
||||
// Token: 0x060001BA RID: 442 RVA: 0x000075AC File Offset: 0x000057AC
|
||||
public int[] GetRGB()
|
||||
{
|
||||
if (this.ImgInfo.Greyscale || this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only rgb or rgba images support this");
|
||||
}
|
||||
return new int[] { this.red, this.green, this.blue };
|
||||
}
|
||||
|
||||
// Token: 0x060001BB RID: 443 RVA: 0x00007601 File Offset: 0x00005801
|
||||
public void SetGray(int g)
|
||||
{
|
||||
if (!this.ImgInfo.Greyscale)
|
||||
{
|
||||
throw new PngjException("only grayscale images support this");
|
||||
}
|
||||
this.gray = g;
|
||||
}
|
||||
|
||||
// Token: 0x060001BC RID: 444 RVA: 0x00007622 File Offset: 0x00005822
|
||||
public int GetGray()
|
||||
{
|
||||
if (!this.ImgInfo.Greyscale)
|
||||
{
|
||||
throw new PngjException("only grayscale images support this");
|
||||
}
|
||||
return this.gray;
|
||||
}
|
||||
|
||||
// Token: 0x060001BD RID: 445 RVA: 0x00007642 File Offset: 0x00005842
|
||||
public void SetPalletteAlpha(int[] palAlpha)
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed images support this");
|
||||
}
|
||||
this.paletteAlpha = palAlpha;
|
||||
}
|
||||
|
||||
// Token: 0x060001BE RID: 446 RVA: 0x00007664 File Offset: 0x00005864
|
||||
public void setIndexEntryAsTransparent(int palAlphaIndex)
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed images support this");
|
||||
}
|
||||
this.paletteAlpha = new int[] { palAlphaIndex + 1 };
|
||||
for (int i = 0; i < palAlphaIndex; i++)
|
||||
{
|
||||
this.paletteAlpha[i] = 255;
|
||||
}
|
||||
this.paletteAlpha[palAlphaIndex] = 0;
|
||||
}
|
||||
|
||||
// Token: 0x060001BF RID: 447 RVA: 0x000076BF File Offset: 0x000058BF
|
||||
public int[] GetPalletteAlpha()
|
||||
{
|
||||
if (!this.ImgInfo.Indexed)
|
||||
{
|
||||
throw new PngjException("only indexed images support this");
|
||||
}
|
||||
return this.paletteAlpha;
|
||||
}
|
||||
|
||||
// Token: 0x040000EC RID: 236
|
||||
public const string ID = "tRNS";
|
||||
|
||||
// Token: 0x040000ED RID: 237
|
||||
private int gray;
|
||||
|
||||
// Token: 0x040000EE RID: 238
|
||||
private int red;
|
||||
|
||||
// Token: 0x040000EF RID: 239
|
||||
private int green;
|
||||
|
||||
// Token: 0x040000F0 RID: 240
|
||||
private int blue;
|
||||
|
||||
// Token: 0x040000F1 RID: 241
|
||||
private int[] paletteAlpha;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,106 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000029 RID: 41
|
||||
public abstract class PngChunkTextVar : PngChunkMultiple
|
||||
{
|
||||
// Token: 0x06000174 RID: 372 RVA: 0x00006748 File Offset: 0x00004948
|
||||
protected internal PngChunkTextVar(string id, ImageInfo info)
|
||||
: base(id, info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000175 RID: 373 RVA: 0x00006752 File Offset: 0x00004952
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NONE;
|
||||
}
|
||||
|
||||
// Token: 0x06000176 RID: 374 RVA: 0x00006755 File Offset: 0x00004955
|
||||
public string GetKey()
|
||||
{
|
||||
return this.key;
|
||||
}
|
||||
|
||||
// Token: 0x06000177 RID: 375 RVA: 0x0000675D File Offset: 0x0000495D
|
||||
public string GetVal()
|
||||
{
|
||||
return this.val;
|
||||
}
|
||||
|
||||
// Token: 0x06000178 RID: 376 RVA: 0x00006765 File Offset: 0x00004965
|
||||
public void SetKeyVal(string key, string val)
|
||||
{
|
||||
this.key = key;
|
||||
this.val = val;
|
||||
}
|
||||
|
||||
// Token: 0x040000C3 RID: 195
|
||||
public const string KEY_Title = "Title";
|
||||
|
||||
// Token: 0x040000C4 RID: 196
|
||||
public const string KEY_Author = "Author";
|
||||
|
||||
// Token: 0x040000C5 RID: 197
|
||||
public const string KEY_Description = "Description";
|
||||
|
||||
// Token: 0x040000C6 RID: 198
|
||||
public const string KEY_Copyright = "Copyright";
|
||||
|
||||
// Token: 0x040000C7 RID: 199
|
||||
public const string KEY_Creation_Time = "Creation Time";
|
||||
|
||||
// Token: 0x040000C8 RID: 200
|
||||
public const string KEY_Software = "Software";
|
||||
|
||||
// Token: 0x040000C9 RID: 201
|
||||
public const string KEY_Disclaimer = "Disclaimer";
|
||||
|
||||
// Token: 0x040000CA RID: 202
|
||||
public const string KEY_Warning = "Warning";
|
||||
|
||||
// Token: 0x040000CB RID: 203
|
||||
public const string KEY_Source = "Source";
|
||||
|
||||
// Token: 0x040000CC RID: 204
|
||||
public const string KEY_Comment = "Comment";
|
||||
|
||||
// Token: 0x040000CD RID: 205
|
||||
protected internal string key;
|
||||
|
||||
// Token: 0x040000CE RID: 206
|
||||
protected internal string val;
|
||||
|
||||
// Token: 0x0200002A RID: 42
|
||||
public class PngTxtInfo
|
||||
{
|
||||
// Token: 0x040000CF RID: 207
|
||||
public string title;
|
||||
|
||||
// Token: 0x040000D0 RID: 208
|
||||
public string author;
|
||||
|
||||
// Token: 0x040000D1 RID: 209
|
||||
public string description;
|
||||
|
||||
// Token: 0x040000D2 RID: 210
|
||||
public string creation_time;
|
||||
|
||||
// Token: 0x040000D3 RID: 211
|
||||
public string software;
|
||||
|
||||
// Token: 0x040000D4 RID: 212
|
||||
public string disclaimer;
|
||||
|
||||
// Token: 0x040000D5 RID: 213
|
||||
public string warning;
|
||||
|
||||
// Token: 0x040000D6 RID: 214
|
||||
public string source;
|
||||
|
||||
// Token: 0x040000D7 RID: 215
|
||||
public string comment;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
using System;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x0200002C RID: 44
|
||||
public class PngChunkUNKNOWN : PngChunkMultiple
|
||||
{
|
||||
// Token: 0x06000184 RID: 388 RVA: 0x00006A23 File Offset: 0x00004C23
|
||||
public PngChunkUNKNOWN(string id, ImageInfo info)
|
||||
: base(id, info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x06000185 RID: 389 RVA: 0x00006A2D File Offset: 0x00004C2D
|
||||
private PngChunkUNKNOWN(PngChunkUNKNOWN c, ImageInfo info)
|
||||
: base(c.Id, info)
|
||||
{
|
||||
Array.Copy(c.data, 0, this.data, 0, c.data.Length);
|
||||
}
|
||||
|
||||
// Token: 0x06000186 RID: 390 RVA: 0x00006A57 File Offset: 0x00004C57
|
||||
public override PngChunk.ChunkOrderingConstraint GetOrderingConstraint()
|
||||
{
|
||||
return PngChunk.ChunkOrderingConstraint.NONE;
|
||||
}
|
||||
|
||||
// Token: 0x06000187 RID: 391 RVA: 0x00006A5C File Offset: 0x00004C5C
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(this.data.Length, false);
|
||||
chunkRaw.Data = this.data;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x06000188 RID: 392 RVA: 0x00006A86 File Offset: 0x00004C86
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
this.data = c.Data;
|
||||
}
|
||||
|
||||
// Token: 0x06000189 RID: 393 RVA: 0x00006A94 File Offset: 0x00004C94
|
||||
public byte[] GetData()
|
||||
{
|
||||
return this.data;
|
||||
}
|
||||
|
||||
// Token: 0x0600018A RID: 394 RVA: 0x00006A9C File Offset: 0x00004C9C
|
||||
public void SetData(byte[] data_0)
|
||||
{
|
||||
this.data = data_0;
|
||||
}
|
||||
|
||||
// Token: 0x0600018B RID: 395 RVA: 0x00006AA8 File Offset: 0x00004CA8
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkUNKNOWN pngChunkUNKNOWN = (PngChunkUNKNOWN)other;
|
||||
this.data = pngChunkUNKNOWN.data;
|
||||
}
|
||||
|
||||
// Token: 0x040000DC RID: 220
|
||||
private byte[] data;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,71 @@
|
||||
using System;
|
||||
using System.IO;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000032 RID: 50
|
||||
public class PngChunkZTXT : PngChunkTextVar
|
||||
{
|
||||
// Token: 0x060001C0 RID: 448 RVA: 0x000076DF File Offset: 0x000058DF
|
||||
public PngChunkZTXT(ImageInfo info)
|
||||
: base("zTXt", info)
|
||||
{
|
||||
}
|
||||
|
||||
// Token: 0x060001C1 RID: 449 RVA: 0x000076F0 File Offset: 0x000058F0
|
||||
public override ChunkRaw CreateRawChunk()
|
||||
{
|
||||
if (this.key.Length == 0)
|
||||
{
|
||||
throw new PngjException("Text chunk key must be non empty");
|
||||
}
|
||||
MemoryStream memoryStream = new MemoryStream();
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, ChunkHelper.ToBytes(this.key));
|
||||
memoryStream.WriteByte(0);
|
||||
memoryStream.WriteByte(0);
|
||||
byte[] array = ChunkHelper.compressBytes(ChunkHelper.ToBytes(this.val), true);
|
||||
ChunkHelper.WriteBytesToStream(memoryStream, array);
|
||||
byte[] array2 = memoryStream.ToArray();
|
||||
ChunkRaw chunkRaw = base.createEmptyChunk(array2.Length, false);
|
||||
chunkRaw.Data = array2;
|
||||
return chunkRaw;
|
||||
}
|
||||
|
||||
// Token: 0x060001C2 RID: 450 RVA: 0x00007770 File Offset: 0x00005970
|
||||
public override void ParseFromRaw(ChunkRaw c)
|
||||
{
|
||||
int num = -1;
|
||||
for (int i = 0; i < c.Data.Length; i++)
|
||||
{
|
||||
if (c.Data[i] == 0)
|
||||
{
|
||||
num = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (num < 0 || num > c.Data.Length - 2)
|
||||
{
|
||||
throw new PngjException("bad zTXt chunk: no separator found");
|
||||
}
|
||||
this.key = ChunkHelper.ToString(c.Data, 0, num);
|
||||
int num2 = (int)c.Data[num + 1];
|
||||
if (num2 != 0)
|
||||
{
|
||||
throw new PngjException("bad zTXt chunk: unknown compression method");
|
||||
}
|
||||
byte[] array = ChunkHelper.compressBytes(c.Data, num + 2, c.Data.Length - num - 2, false);
|
||||
this.val = ChunkHelper.ToString(array);
|
||||
}
|
||||
|
||||
// Token: 0x060001C3 RID: 451 RVA: 0x00007810 File Offset: 0x00005A10
|
||||
public override void CloneDataFromRead(PngChunk other)
|
||||
{
|
||||
PngChunkZTXT pngChunkZTXT = (PngChunkZTXT)other;
|
||||
this.key = pngChunkZTXT.key;
|
||||
this.val = pngChunkZTXT.val;
|
||||
}
|
||||
|
||||
// Token: 0x040000F2 RID: 242
|
||||
public const string ID = "zTXt";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,218 @@
|
||||
using System;
|
||||
using System.Collections.Generic;
|
||||
|
||||
namespace Hjg.Pngcs.Chunks
|
||||
{
|
||||
// Token: 0x02000011 RID: 17
|
||||
public class PngMetadata
|
||||
{
|
||||
// Token: 0x06000067 RID: 103 RVA: 0x0000310B File Offset: 0x0000130B
|
||||
internal PngMetadata(ChunksList chunks)
|
||||
{
|
||||
this.chunkList = chunks;
|
||||
if (chunks is ChunksListForWrite)
|
||||
{
|
||||
this.ReadOnly = false;
|
||||
return;
|
||||
}
|
||||
this.ReadOnly = true;
|
||||
}
|
||||
|
||||
// Token: 0x06000068 RID: 104 RVA: 0x00003134 File Offset: 0x00001334
|
||||
public void QueueChunk(PngChunk chunk, bool lazyOverwrite)
|
||||
{
|
||||
ChunksListForWrite chunkListW = this.getChunkListW();
|
||||
if (this.ReadOnly)
|
||||
{
|
||||
throw new PngjException("cannot set chunk : readonly metadata");
|
||||
}
|
||||
if (lazyOverwrite)
|
||||
{
|
||||
ChunkHelper.TrimList(chunkListW.GetQueuedChunks(), new ChunkPredicateEquiv(chunk));
|
||||
}
|
||||
chunkListW.Queue(chunk);
|
||||
}
|
||||
|
||||
// Token: 0x06000069 RID: 105 RVA: 0x00003178 File Offset: 0x00001378
|
||||
public void QueueChunk(PngChunk chunk)
|
||||
{
|
||||
this.QueueChunk(chunk, true);
|
||||
}
|
||||
|
||||
// Token: 0x0600006A RID: 106 RVA: 0x00003182 File Offset: 0x00001382
|
||||
private ChunksListForWrite getChunkListW()
|
||||
{
|
||||
return (ChunksListForWrite)this.chunkList;
|
||||
}
|
||||
|
||||
// Token: 0x0600006B RID: 107 RVA: 0x00003190 File Offset: 0x00001390
|
||||
public double[] GetDpi()
|
||||
{
|
||||
PngChunk byId = this.chunkList.GetById1("pHYs", true);
|
||||
if (byId == null)
|
||||
{
|
||||
return new double[] { -1.0, -1.0 };
|
||||
}
|
||||
return ((PngChunkPHYS)byId).GetAsDpi2();
|
||||
}
|
||||
|
||||
// Token: 0x0600006C RID: 108 RVA: 0x000031E0 File Offset: 0x000013E0
|
||||
public void SetDpi(double dpix, double dpiy)
|
||||
{
|
||||
PngChunkPHYS pngChunkPHYS = new PngChunkPHYS(this.chunkList.imageInfo);
|
||||
pngChunkPHYS.SetAsDpi2(dpix, dpiy);
|
||||
this.QueueChunk(pngChunkPHYS);
|
||||
}
|
||||
|
||||
// Token: 0x0600006D RID: 109 RVA: 0x0000320D File Offset: 0x0000140D
|
||||
public void SetDpi(double dpi)
|
||||
{
|
||||
this.SetDpi(dpi, dpi);
|
||||
}
|
||||
|
||||
// Token: 0x0600006E RID: 110 RVA: 0x00003218 File Offset: 0x00001418
|
||||
public PngChunkTIME SetTimeNow(int nsecs)
|
||||
{
|
||||
PngChunkTIME pngChunkTIME = new PngChunkTIME(this.chunkList.imageInfo);
|
||||
pngChunkTIME.SetNow(nsecs);
|
||||
this.QueueChunk(pngChunkTIME);
|
||||
return pngChunkTIME;
|
||||
}
|
||||
|
||||
// Token: 0x0600006F RID: 111 RVA: 0x00003245 File Offset: 0x00001445
|
||||
public PngChunkTIME SetTimeNow()
|
||||
{
|
||||
return this.SetTimeNow(0);
|
||||
}
|
||||
|
||||
// Token: 0x06000070 RID: 112 RVA: 0x00003250 File Offset: 0x00001450
|
||||
public PngChunkTIME SetTimeYMDHMS(int year, int mon, int day, int hour, int min, int sec)
|
||||
{
|
||||
PngChunkTIME pngChunkTIME = new PngChunkTIME(this.chunkList.imageInfo);
|
||||
pngChunkTIME.SetYMDHMS(year, mon, day, hour, min, sec);
|
||||
this.QueueChunk(pngChunkTIME, true);
|
||||
return pngChunkTIME;
|
||||
}
|
||||
|
||||
// Token: 0x06000071 RID: 113 RVA: 0x00003286 File Offset: 0x00001486
|
||||
public PngChunkTIME GetTime()
|
||||
{
|
||||
return (PngChunkTIME)this.chunkList.GetById1("tIME");
|
||||
}
|
||||
|
||||
// Token: 0x06000072 RID: 114 RVA: 0x000032A0 File Offset: 0x000014A0
|
||||
public string GetTimeAsString()
|
||||
{
|
||||
PngChunkTIME time = this.GetTime();
|
||||
if (time != null)
|
||||
{
|
||||
return time.GetAsString();
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
// Token: 0x06000073 RID: 115 RVA: 0x000032C4 File Offset: 0x000014C4
|
||||
public PngChunkTextVar SetText(string key, string val, bool useLatin1, bool compress)
|
||||
{
|
||||
if (compress && !useLatin1)
|
||||
{
|
||||
throw new PngjException("cannot compress non latin text");
|
||||
}
|
||||
PngChunkTextVar pngChunkTextVar;
|
||||
if (useLatin1)
|
||||
{
|
||||
if (compress)
|
||||
{
|
||||
pngChunkTextVar = new PngChunkZTXT(this.chunkList.imageInfo);
|
||||
}
|
||||
else
|
||||
{
|
||||
pngChunkTextVar = new PngChunkTEXT(this.chunkList.imageInfo);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pngChunkTextVar = new PngChunkITXT(this.chunkList.imageInfo);
|
||||
((PngChunkITXT)pngChunkTextVar).SetLangtag(key);
|
||||
}
|
||||
pngChunkTextVar.SetKeyVal(key, val);
|
||||
this.QueueChunk(pngChunkTextVar, true);
|
||||
return pngChunkTextVar;
|
||||
}
|
||||
|
||||
// Token: 0x06000074 RID: 116 RVA: 0x0000333E File Offset: 0x0000153E
|
||||
public PngChunkTextVar SetText(string key, string val)
|
||||
{
|
||||
return this.SetText(key, val, false, false);
|
||||
}
|
||||
|
||||
// Token: 0x06000075 RID: 117 RVA: 0x0000334C File Offset: 0x0000154C
|
||||
public List<PngChunkTextVar> GetTxtsForKey(string key)
|
||||
{
|
||||
List<PngChunkTextVar> list = new List<PngChunkTextVar>();
|
||||
foreach (PngChunk pngChunk in this.chunkList.GetById("tEXt", key))
|
||||
{
|
||||
list.Add((PngChunkTextVar)pngChunk);
|
||||
}
|
||||
foreach (PngChunk pngChunk2 in this.chunkList.GetById("zTXt", key))
|
||||
{
|
||||
list.Add((PngChunkTextVar)pngChunk2);
|
||||
}
|
||||
foreach (PngChunk pngChunk3 in this.chunkList.GetById("iTXt", key))
|
||||
{
|
||||
list.Add((PngChunkTextVar)pngChunk3);
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
// Token: 0x06000076 RID: 118 RVA: 0x00003460 File Offset: 0x00001660
|
||||
public string GetTxtForKey(string key)
|
||||
{
|
||||
string text = "";
|
||||
List<PngChunkTextVar> txtsForKey = this.GetTxtsForKey(key);
|
||||
if (txtsForKey.Count == 0)
|
||||
{
|
||||
return text;
|
||||
}
|
||||
foreach (PngChunkTextVar pngChunkTextVar in txtsForKey)
|
||||
{
|
||||
text = text + pngChunkTextVar.GetVal() + "\n";
|
||||
}
|
||||
return text.Trim();
|
||||
}
|
||||
|
||||
// Token: 0x06000077 RID: 119 RVA: 0x000034D8 File Offset: 0x000016D8
|
||||
public PngChunkPLTE GetPLTE()
|
||||
{
|
||||
return (PngChunkPLTE)this.chunkList.GetById1("PLTE");
|
||||
}
|
||||
|
||||
// Token: 0x06000078 RID: 120 RVA: 0x000034F0 File Offset: 0x000016F0
|
||||
public PngChunkPLTE CreatePLTEChunk()
|
||||
{
|
||||
PngChunkPLTE pngChunkPLTE = new PngChunkPLTE(this.chunkList.imageInfo);
|
||||
this.QueueChunk(pngChunkPLTE);
|
||||
return pngChunkPLTE;
|
||||
}
|
||||
|
||||
// Token: 0x06000079 RID: 121 RVA: 0x00003516 File Offset: 0x00001716
|
||||
public PngChunkTRNS GetTRNS()
|
||||
{
|
||||
return (PngChunkTRNS)this.chunkList.GetById1("tRNS");
|
||||
}
|
||||
|
||||
// Token: 0x0600007A RID: 122 RVA: 0x00003530 File Offset: 0x00001730
|
||||
public PngChunkTRNS CreateTRNSChunk()
|
||||
{
|
||||
PngChunkTRNS pngChunkTRNS = new PngChunkTRNS(this.chunkList.imageInfo);
|
||||
this.QueueChunk(pngChunkTRNS);
|
||||
return pngChunkTRNS;
|
||||
}
|
||||
|
||||
// Token: 0x04000048 RID: 72
|
||||
private readonly ChunksList chunkList;
|
||||
|
||||
// Token: 0x04000049 RID: 73
|
||||
private readonly bool ReadOnly;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user