// Token: 0x060011A3 RID: 4515 RVA: 0x0000378C File Offset: 0x0000198C
public void FolderScanStateChange(Enum7 wmpfss)
{
if (this.delegate59_0 != null)
{
this.delegate59_0(wmpfss);
return;
}
}
public void method_7(Enum7 enum7_1)
{
this.enum7_0 = enum7_1;
}
public void method_7(Enum7 enum7_1)
{
this.enum7_0 = enum7_1;
}
public static string smethod_0(IntPtr intptr_0, Enum7 enum7_0)
{
return(Marshal.PtrToStringAnsi(OpenAL.alcGetString(intptr_0, enum7_0)));
}
private static extern IntPtr alcGetString([In] IntPtr device, Enum7 param);
private static extern IntPtr alcGetString([In] IntPtr device, Enum7 param);
public static string smethod_0(IntPtr intptr_0, Enum7 enum7_0)
{
return Marshal.PtrToStringAnsi(OpenAL.alcGetString(intptr_0, enum7_0));
}
// Token: 0x06000F23 RID: 3875
// RVA: 0x00052AD8 File Offset: 0x00050CD8
public void method_1(string string_0, string string_1, string string_2, Enum7 enum7_0)
{
long num;
long num2;
long num3;
using (FileStream fileStream = File.OpenRead(string_2))
{
byte[] array = new byte[32];
if (fileStream.Read(array, 0, 32) < 32)
{
throw new Exception("invalid patch file (too small)");
}
if (!Class52.smethod_1(array, "BSDIFF40", 0, 8))
{
throw new Exception("invalid patch file (no magic)");
}
num = (long)Class52.smethod_0(array, 8);
num2 = (long)Class52.smethod_0(array, 16);
num3 = (long)Class52.smethod_0(array, 24);
if (num < 0L || num2 < 0L || num3 < 0L)
{
throw new Exception("invalid patch file (sizes are corrupt)");
}
}
long long_ = num3 * 3L;
byte[] array2;
byte[] array3;
byte[] array4;
using (FileStream fileStream2 = File.OpenRead(string_2))
{
fileStream2.Seek(32L, SeekOrigin.Begin);
array2 = new byte[num];
fileStream2.Read(array2, 0, array2.Length);
array3 = new byte[num2];
fileStream2.Read(array3, 0, array3.Length);
array4 = new byte[fileStream2.Length - fileStream2.Position];
fileStream2.Read(array4, 0, array4.Length);
}
Stream stream;
Stream stream2;
Stream stream3;
if (enum7_0 == Enum7.const_1)
{
stream = new Stream10(new MemoryStream(array2));
stream2 = new Stream10(new MemoryStream(array3));
stream3 = new Stream10(new MemoryStream(array4));
}
else
{
stream = new Stream4(new MemoryStream(array2), Enum12.const_1, Enum11.const_0);
stream2 = new Stream4(new MemoryStream(array3), Enum12.const_1, Enum11.const_0);
stream3 = new Stream4(new MemoryStream(array4), Enum12.const_1, Enum11.const_0);
}
int num4 = 1048573;
byte[] array5;
using (FileStream fileStream3 = new FileStream(string_0, FileMode.Open, FileAccess.Read, FileShare.Read))
{
long length = fileStream3.Length;
array5 = new byte[(int)length];
for (int i = 0; i < array5.Length; i += num4)
{
fileStream3.Read(array5, i, Math.Min(num4, array5.Length - i));
this.method_2((long)i, long_);
}
}
byte[] array6 = new byte[num3];
long num5 = (long)array5.Length;
int num6 = 0;
int num7 = 0;
int[] array7 = new int[3];
byte[] array8 = new byte[8];
while ((long)num6 < num3)
{
int num8;
for (int j = 0; j <= 2; j++)
{
num8 = stream.Read(array8, 0, 8);
if (num8 < 8)
{
throw new Exception("invalid patch file (corrupt)");
}
array7[j] = Class52.smethod_0(array8, 0);
}
if ((long)(num6 + array7[0]) > num3)
{
throw new Exception("invalid patch file (corrupt)");
}
num8 = 0;
for (int k = num6; k < num6 + array7[0]; k += 65536)
{
num8 += stream2.Read(array6, k, Math.Min(65536, num6 + array7[0] - k));
this.method_2(num3 + (long)num6 + (long)num8, long_);
}
if (num8 < array7[0])
{
throw new Exception("invalid patch file (corrupt)");
}
for (int l = 0; l < array7[0]; l++)
{
if (num7 + l >= 0 && (long)(num7 + l) < num5)
{
byte[] expr_2EB_cp_0 = array6;
int expr_2EB_cp_1 = num6 + l;
expr_2EB_cp_0[expr_2EB_cp_1] += array5[num7 + l];
}
}
num6 += array7[0];
num7 += array7[0];
if ((long)num6 > num3)
{
throw new Exception("invalid patch file (corrupt)");
}
num8 = stream3.Read(array6, num6, array7[1]);
if (num8 < array7[1])
{
throw new Exception("invalid patch file (corrupt)");
}
num6 += array7[1];
num7 += array7[2];
}
stream.Close();
stream2.Close();
stream3.Close();
using (FileStream fileStream4 = File.Create(string_1))
{
for (int m = 0; m < array6.Length; m += num4)
{
fileStream4.Write(array6, m, Math.Min(num4, array6.Length - m));
this.method_2(num3 * 2L + (long)m, long_);
}
}
if (this.delegate3_0 != null)
{
this.delegate3_0(this, 1L, 1L);
}
}
// Token: 0x06001339 RID: 4921 RVA: 0x00004B62 File Offset: 0x00002D62
public Class28(Enum7 enum7_1)
{
this.enum7_0 = enum7_1;
}
public Attribute10(Enum7 useKindFlags, Enum8 targetFlags)
{
this.Enum7_0 = useKindFlags;
this.Enum8_0 = targetFlags;
}
public Attribute10(Enum7 useKindFlags) : this(useKindFlags, Enum8.Default)
{
}
// Token: 0x06001438 RID: 5176 RVA: 0x00024BA8 File Offset: 0x00022DA8
public void FolderScanStateChange(Enum7 wmpfss)
{
Class28 class28_ = new Class28(wmpfss);
this.class24_0.method_4(this.class24_0, class28_);
}
// Token: 0x06000F19 RID: 3865
// RVA: 0x000521A4 File Offset: 0x000503A4
private Stream method_5(Enum7 enum7_0, Stream stream_0)
{
switch (enum7_0)
{
case Enum7.const_0:
return new Stream4(stream_0, Enum12.const_0, Enum11.const_0, true);
case Enum7.const_1:
return new Stream2(stream_0);
default:
return null;
}
}
// Token: 0x06000F1A RID: 3866
// RVA: 0x000521D4 File Offset: 0x000503D4
public void method_6(string string_0, string string_1, Stream stream_0, Enum7 enum7_0)
{
int num = 0;
int num2;
byte[] array;
int num3;
using (FileStream fileStream = File.OpenRead(string_0))
{
num2 = (int)fileStream.Length;
array = new byte[num2];
num3 = num2 * 9;
for (int i = 0; i < num2; i += 65536)
{
fileStream.Read(array, i, Math.Min(65536, num2 - i));
this.method_7((long)(num + i), (long)num3);
}
num = num2;
}
int[] int_ = new int[num2 + 1];
int[] int_2 = new int[num2 + 1];
this.method_2(int_, int_2, array, num2);
int num4;
byte[] array2;
using (FileStream fileStream2 = File.OpenRead(string_1))
{
num4 = (int)fileStream2.Length;
array2 = new byte[num4];
num3 += num4 * 7 - num2 * 7;
for (int j = 0; j < num4; j += 65536)
{
fileStream2.Read(array2, j, Math.Min(65536, num4 - j));
this.method_7((long)(num + j), (long)num3);
}
num += num4;
}
byte[] array3 = new byte[num4 + 1];
byte[] array4 = new byte[num4 + 1];
int num5 = 0;
int num6 = 0;
using (BinaryWriter binaryWriter = new BinaryWriter(stream_0))
{
binaryWriter.Write(Encoding.ASCII.GetBytes("BSDIFF40"));
binaryWriter.Write(0L);
binaryWriter.Write(0L);
binaryWriter.Write((long)num4);
using (MemoryStream memoryStream = new MemoryStream())
{
using (Stream stream = this.method_5(enum7_0, memoryStream))
{
int num7 = 0;
int k = 0;
int num8 = 0;
int num9 = 0;
int num10 = 0;
int num11 = 0;
while (k < num4)
{
int num12 = 0;
int l;
for (k = (l = k + num8); k < num4; k++)
{
num8 = this.method_3(int_, array, num2, array2, k, num4, 0, num2, ref num7);
while (l < k + num8)
{
if (l + num11 < num2 && array[l + num11] == array2[l])
{
num12++;
}
l++;
}
if ((num8 == num12 && num8 != 0) || num8 > num12 + 8)
{
break;
}
if (k + num11 < num2 && array[k + num11] == array2[k])
{
num12--;
}
}
if (num8 != num12 || k == num4)
{
int num13 = 0;
int num14 = 0;
int num15 = 0;
int num16 = 0;
int num17 = 0;
int num18 = 0;
int num19 = 0;
int num20 = 0;
while (num9 + num20 < k && num10 + num20 < num2)
{
if (array[num10 + num20] == array2[num9 + num20])
{
num13++;
}
num20++;
if (num13 * 2 - num20 > num14 * 2 - num15)
{
num14 = num13;
num15 = num20;
}
}
if (k < num4)
{
num13 = 0;
int num21 = 1;
while (k >= num9 + num21 && num7 >= num21)
{
if (array[num7 - num21] == array2[k - num21])
{
num13++;
}
if (num13 * 2 - num21 > num16 * 2 - num17)
{
num16 = num13;
num17 = num21;
}
num21++;
}
}
if (num9 + num15 > k - num17)
{
int num22 = num9 + num15 - (k - num17);
num13 = 0;
for (int m = 0; m < num22; m++)
{
if (array2[num9 + num15 - num22 + m] == array[num10 + num15 - num22 + m])
{
num13++;
}
if (array2[k - num17 + m] == array[num7 - num17 + m])
{
num13--;
}
if (num13 > num18)
{
num18 = num13;
num19 = m + 1;
}
}
num15 += num19 - num22;
num17 -= num19;
}
for (int n = 0; n < num15; n++)
{
array3[num5 + n] = array2[num9 + n] - array[num10 + n];
}
for (int num23 = 0; num23 < k - num17 - (num9 + num15); num23++)
{
array4[num6 + num23] = array2[num9 + num15 + num23];
}
num5 += num15;
num6 += k - num17 - (num9 + num15);
byte[] array5 = new byte[8];
this.method_4(num15, array5);
stream.Write(array5, 0, 8);
this.method_4(k - num17 - (num9 + num15), array5);
stream.Write(array5, 0, 8);
this.method_4(num7 - num17 - (num10 + num15), array5);
stream.Write(array5, 0, 8);
num9 = k - num17;
num10 = num7 - num17;
num11 = num7 - k;
}
this.method_7((long)(num + k), (long)num3);
}
num += num4;
}
byte[] array6 = memoryStream.ToArray();
num3 += array6.Length - num4;
for (int num24 = 0; num24 < array6.Length; num24 += 65536)
{
binaryWriter.Write(array6, num24, Math.Min(65536, array6.Length - num24));
this.method_7((long)(num + num24), (long)num3);
}
num += array6.Length;
}
binaryWriter.Flush();
long num25 = binaryWriter.BaseStream.Position - 32L;
using (MemoryStream memoryStream2 = new MemoryStream())
{
using (Stream stream2 = this.method_5(enum7_0, memoryStream2))
{
num3 += num5 - num4;
for (int num26 = 0; num26 < num5; num26 += 65536)
{
stream2.Write(array3, num26, Math.Min(65536, num5 - num26));
this.method_7((long)(num + num26), (long)num3);
}
num += num5;
}
byte[] array7 = memoryStream2.ToArray();
num3 += array7.Length - num4;
for (int num27 = 0; num27 < array7.Length; num27 += 65536)
{
binaryWriter.Write(array7, num27, Math.Min(65536, array7.Length - num27));
this.method_7((long)(num += num27), (long)num3);
}
}
binaryWriter.Flush();
long value = binaryWriter.BaseStream.Position - num25 - 32L;
using (MemoryStream memoryStream3 = new MemoryStream())
{
using (Stream stream3 = this.method_5(enum7_0, memoryStream3))
{
num3 += num6 - num4;
for (int num28 = 0; num28 < num6; num28 += 65536)
{
stream3.Write(array4, num28, Math.Min(65536, num6 - num28));
this.method_7((long)(num + num28), (long)num3);
}
num += num6;
}
byte[] array8 = memoryStream3.ToArray();
num3 += array8.Length - num4;
for (int num29 = 0; num29 < array8.Length; num29 += 65536)
{
binaryWriter.Write(array8, num29, Math.Min(65536, array8.Length - num29));
this.method_7((long)(num + num29), (long)num3);
}
}
binaryWriter.Flush();
binaryWriter.Seek(8, SeekOrigin.Begin);
binaryWriter.Write(num25);
binaryWriter.Write(value);
if (this.delegate3_0 != null)
{
this.delegate3_0(this, 1L, 1L);
}
}
}
