public void BsDiffCreateFromStreams()
{
const int outputSize = 0x2A000;
foreach (var oldBuffer in GetBuffers(Sizes))
{
foreach (var newBuffer in GetBuffers(Sizes))
{
byte[] bytesOut;
using (var mmf = MemoryMappedFile.CreateNew(null, outputSize, MemoryMappedFileAccess.ReadWrite))
{
using (var mmfStream = mmf.CreateViewStream())
{
BsDiff.Create(oldBuffer, newBuffer, mmfStream);
}
using (var msA = new MemoryStream(oldBuffer))
using (var msOutput = new MemoryStream())
{
BsPatch.Apply(msA, mmf.CreateViewStream, msOutput);
bytesOut = msOutput.ToArray();
}
}
Assert.Equal(newBuffer, bytesOut);
}
}
}
public DeltaqBsDiff()
{
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin1, Samples.target1, outputStream);
sample1Delta = outputStream.ToArray();
}
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin2, Samples.target2, outputStream);
sample2Delta = outputStream.ToArray();
}
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin3, Samples.target3, outputStream);
sample3Delta = outputStream.ToArray();
}
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin4, Samples.target4, outputStream);
sample4Delta = outputStream.ToArray();
}
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin5, Samples.target5, outputStream);
sample5Delta = outputStream.ToArray();
}
}
public byte[] CreateDelta5()
{
using (var outputStream = new MemoryStream())
{
BsDiff.Create(Samples.origin5, Samples.target5, outputStream);
return(outputStream.ToArray());
}
}
private static byte[] BsDiffCreate(byte[] oldBuf, byte[] newBuf)
{
using (var outputStream = new MemoryStream())
{
BsDiff.Create(oldBuf, newBuf, outputStream);
return(outputStream.ToArray());
}
}
public void WritePatchFile(Stream stream)
{
using (var io = IoWriter.FromStream(stream, ByteOrder.LITTLE_ENDIAN))
{
io.WriteCString("TSOp", 4);
io.WriteInt32(0); //version
//generate patches for the files that are the same
var patches = new List <Tuple <string, byte[]> >();
Console.Write("Progress: ");
var progress = 0;
foreach (var file in SameFiles)
{
Console.Write($"\rProgress: {progress++}/{SameFiles.Count}");
var srcDat = File.ReadAllBytes(Path.Combine(SourcePath, file));
var dstDat = File.ReadAllBytes(Path.Combine(DestPath, file));
var same = srcDat.Length == dstDat.Length && srcDat.SequenceEqual(dstDat);
if (!same)
{
using (var outips = new MemoryStream()) {
BsDiff.Create(srcDat, dstDat, outips);
patches.Add(new Tuple <string, byte[]>(file, outips.ToArray()));
}
}
}
Console.WriteLine();
Console.WriteLine($"Done generating patches ({patches.Count}). Inserting additions and deletions...");
io.WriteCString("IPS_", 4);
io.WriteInt32(patches.Count);
foreach (var piff in patches)
{
io.WriteVariableLengthPascalString(piff.Item1);
io.WriteInt32(piff.Item2.Length);
io.WriteBytes(piff.Item2);
}
io.WriteCString("ADD_", 4);
io.WriteInt32(AddFiles.Count);
foreach (var add in AddFiles)
{
io.WriteVariableLengthPascalString(add);
var data = File.ReadAllBytes(Path.Combine(DestPath, add));
io.WriteInt32(data.Length);
io.WriteBytes(data);
}
io.WriteCString("DEL_", 4);
io.WriteInt32(RemovedFiles.Count);
foreach (var del in RemovedFiles)
{
io.WriteVariableLengthPascalString(del);
}
}
}
private static void CreatePatch(string src, string dst, string patch)
{
if (File.Exists(patch))
{
File.Delete(patch);
}
using (var fh = File.Create(patch)) {
BsDiff.Create(File.ReadAllBytes(src), File.ReadAllBytes(dst), fh);
}
}
private void CheckOriginalList(PatchContainer patchResult)
{
foreach (var key in originalList.Keys)
{
if (key.TrimStart('\\') == "AUTOEXEC.BAT" || key.TrimStart('\\') == "CONFIG.SYS")
{
continue;
}
if (key.ToLower().EndsWith(@"\\CONFIG.SYS"))
{
continue;
}
var file = new PatchedFile {
Name = key,
Action = PatchAction.Original,
OriginalMd5Sum = originalList[key]
};
if (!translatedList.ContainsKey(key))
{
if (form.Ask($"Translated HDI doesn't contain file {key}",
$"Delete {key} from source during patching?"))
{
file.Action = PatchAction.Delete;
}
}
else if (originalList[key] != translatedList[key])
{
file.Action = PatchAction.Patch;
using (var ms = new MemoryStream()) {
using (var src = originalFs.OpenFile(key, FileMode.Open)) {
using (var patched = translatedFs.OpenFile(key, FileMode.Open)) {
BsDiff.Create(src, patched, ms);
patchResult.TotalSize += patched.Length;
}
}
file.Patch = ms.ToArray();
}
}
else
{
var info = originalFs.GetFileInfo(key);
patchResult.TotalSize += info.Length;
}
patchResult.Add(file);
}
}
private static void CreateAssetPatch(Settings settings, IBSA original, Fo3File originalRecord, Fo3File resultRecord, RecordAction recordAction)
{
string patchName;
string patchFile;
// @todo: memory stream and name with md5
using (var patchStream = new MemoryStream())
{
// @todo: lock
byte[] originalRecordBytes;
if (original != null)
{
lock (original)
{
originalRecordBytes = originalRecord.GetData(original.Reader);
}
}
else
{
originalRecordBytes = originalRecord.GetData();
}
var referenceBytes = resultRecord.GetData();
BsDiff.Create(originalRecordBytes, referenceBytes, patchStream);
patchStream.Seek(0, SeekOrigin.Begin);
patchName = new Guid(MD5.Create().ComputeHash(patchStream)).ToString();
recordAction.PatchName = patchName;
patchFile = string.Format("{0}\\{1}.patch", settings.GetTempFolder("Patches"), patchName);
try
{
using (var fileStream = new FileStream(patchFile, FileMode.CreateNew))
{
patchStream.Seek(0, SeekOrigin.Begin);
patchStream.CopyTo(fileStream);
}
}
catch (IOException exc)
{
// ignored
}
}
}
private static void ProcessESMs(Recipe recipe, Settings settings)
{
Console.WriteLine("Processing ESMs ...");
foreach (var filepair in settings.Files.Where(fp => fp.Type == ContentType.ESP))
{
Console.Write("{0} => {1} ... ", filepair.OriginalName, filepair.ResultName);
string patchName;
string patchFile;
// @todo: memory stream and name with md5
using (var patchStream = new MemoryStream())
{
var originalBytes = File.ReadAllBytes(string.Format("{0}\\{1}", settings.Fo3DataPath, filepair.OriginalName));
var resultBytes = File.ReadAllBytes(string.Format("{0}\\{1}", settings.CurrentDataPath, filepair.ResultName));
BsDiff.Create(originalBytes, resultBytes, patchStream);
patchStream.Seek(0, SeekOrigin.Begin);
patchName = new Guid(MD5.Create().ComputeHash(patchStream)).ToString();
patchFile = string.Format("{0}\\{1}.patch", settings.GetTempFolder("Patches"), patchName);
if (!File.Exists(patchFile))
{
using (var fileStream = new FileStream(patchFile, FileMode.CreateNew))
{
patchStream.Seek(0, SeekOrigin.Begin);
patchStream.CopyTo(fileStream);
}
}
}
filepair.PatchName = patchName;
recipe.Files.Add(filepair);
Console.WriteLine("Done");
FlushRecipe(settings, recipe);
}
Console.WriteLine("ESMs completed");
}
public void BsPatchFlushesOutput()
{
var oldBuffer = GetRandomFilledBuffer(0x123);
var newBuffer = GetRandomFilledBuffer(0x4567);
//can't use MemoryStream directly as Flush has no effect
var patchMs = new MemoryStream();
var wrappedPatchMs = new BufferedStream(patchMs);
BsDiff.Create(oldBuffer, newBuffer, wrappedPatchMs);
var patchBuffer = patchMs.ToArray();
var reconstructMs = new MemoryStream();
var wrappedReconstructMs = new BufferedStream(reconstructMs);
BsPatch.Apply(oldBuffer, patchBuffer, wrappedReconstructMs);
var reconstructedBuffer = reconstructMs.ToArray();
Assert.Equal(newBuffer, reconstructedBuffer);
}
public void BsDiffCreateBadStreams(byte[] oldData, byte[] newData, Stream outStream)
{
Assert.Throws <ArgumentException>(() => BsDiff.Create(oldData, newData, outStream));
}
private static List <RepoFile> AddFiles(string repoPath, SemVersion version, string path, string previousVersionNumber = null, RepoVersion previousVersion = null)
{
string previousVersionPath = null;
if (previousVersionNumber != null)
{
previousVersionPath = Path.Combine(repoPath, previousVersionNumber);
}
Console.WriteLine("Adding files from " + path + ((previousVersionPath != null) ? " | Comparing them to: " + previousVersionPath : ""));
List <RepoFile> files = new List <RepoFile>();
var fileList = new List <string>();
FileUtil.GetFiles(path, ref fileList);
foreach (var file in fileList)
{
var repoFile = new RepoFile
{
Path = FileUtil.GetRelativePath(path, file).Replace("\\", "/"),
Checksum = Checksum.GetSHA1Sum(file)
};
string exportPath = Path.Combine(repoPath, version.ToString(), repoFile.Path);
if (previousVersion != null)
{
var oldRepoFile = previousVersion.GetFile(repoFile.Path);
if (oldRepoFile?.Checksum == repoFile.Checksum)
{
// Flag the file as unchanged to consolidate repo space
repoFile.UnchangedSince = oldRepoFile.UnchangedSince ?? previousVersionNumber;
}
else
{
Console.WriteLine("\tAdding file " + repoFile.Path);
// Copy the entire file if a previous version doesn't exist.
Directory.CreateDirectory(Path.GetDirectoryName(exportPath));
File.Copy(file, exportPath);
// Generate patches
string prevPath;
if (oldRepoFile?.UnchangedSince != null)
{
Console.WriteLine("\t\tUnchanged since " + oldRepoFile.UnchangedSince);
prevPath = Path.Combine(Path.Combine(repoPath, oldRepoFile.UnchangedSince), repoFile.Path);
}
else
{
prevPath = Path.Combine(previousVersionPath, repoFile.Path);
}
if (File.Exists(prevPath))
{
var origChecksum = Checksum.GetSHA1Sum(prevPath);
// Don't generate a patch for an unchanged file
if (origChecksum != repoFile.Checksum)
{
Console.WriteLine("\t\tGenerating patch...");
repoFile.PatchSourceChecksum = origChecksum;
// Create the BsDiff patch
using (FileStream patchFileStream =
new FileStream(exportPath + ".patch", FileMode.Create))
BsDiff.Create(File.ReadAllBytes(exportPath), File.ReadAllBytes(prevPath),
patchFileStream);
// Get checksum of the patch
repoFile.PatchChecksum = Checksum.GetSHA1Sum(exportPath + ".patch");
}
}
}
}
else
{
Console.WriteLine("\tAdding file " + repoFile.Path);
// Copy the entire file if a previous version doesn't exist.
Directory.CreateDirectory(Path.GetDirectoryName(exportPath));
File.Copy(file, exportPath);
}
files.Add(repoFile);
}
return(files);
}
