public void End()
{
this.deflateStream.Flush();
this.deflateStream.Close();
this.deflateWriter.Close();
if (!this.useTempStream)
{
long curPos = this.BaseStream.Position;
this.BaseStream.Seek(this.baseStreamPosition, SeekOrigin.Begin);
uint crc = CheckSum.ComputeHash(this.BaseStream, curPos - this.baseStreamPosition);
this.BaseStream.Seek(this.baseStreamPosition - 4, SeekOrigin.Begin);
this.writer.Write(crc);
this.BaseStream.Seek(curPos, SeekOrigin.Begin);
}
else
{
this.tempStream.Seek(0, SeekOrigin.Begin);
uint crc = CheckSum.ComputeHash(this.tempStream, this.tempStream.Length);
this.writer.Write(crc);
this.tempStream.Seek(0, SeekOrigin.Begin);
StreamUtils.CopyStream(this.tempStream, this.BaseStream, (int)this.tempStream.Length);
this.tempStream.Close();
this.tempStream = null;
}
}
internal void Write(BinaryWriter bw)
{
bw.Write(PexMagic);
bw.Write(MajorVersion);
bw.Write(MinorVersion);
bw.Write(GameId);
bw.Write(CompilationTime.ToUInt64());
bw.Write(SourceFileName);
bw.Write(Username);
bw.Write(MachineName);
var memoryTrib = new MemoryTributary();
var bw2 = new PexWriter(memoryTrib, Encoding.UTF8, this._gameCategory.IsBigEndian());
var writeMeta = new PexWriteMeta(_gameCategory, bw2);
WriteContent(writeMeta);
bw.Write((ushort)writeMeta.Strings.Count);
foreach (var pair in writeMeta.Strings
.OrderBy(x => x.Value))
{
bw.Write(pair.Key);
}
memoryTrib.Position = 0;
memoryTrib.CopyTo(bw.BaseStream);
}
public byte[] GetImageDataAs3Channel()
{
MemoryTributary bitmapStream = new MemoryTributary(Width * Height * 2);
int ptr = 0;
byte[] ImageData = MipMaps[0].data;
using (BinaryWriter bitmapBW = new BinaryWriter(bitmapStream))
{
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
sbyte red = (sbyte)Buffer.GetByte(ImageData, ptr++);
sbyte green = (sbyte)Buffer.GetByte(ImageData, ptr++);
byte blue = 0xFF;
int fCol = blue | (0x7F + green) << 8 | (0x7F + red) << 16 | 0xFF << 24;
bitmapBW.Write(fCol);
}
}
ImageData = bitmapStream.ToArray();
}
return(ImageData);
}
public void Begin()
{
this.writer.Write(Encoding.ASCII.GetBytes("WzPatch\x1A"));
this.writer.Write(2); //version
if (this.BaseStream.CanSeek && this.BaseStream.CanRead)
{
this.writer.Write(0u); //crc 回头计算
this.useTempStream = false;
this.deflateStream = new DeflateStream(this.BaseStream, CompressionMode.Compress, true);
this.baseStreamPosition = this.BaseStream.Position;
//zlib header
this.BaseStream.WriteByte(0x78);
this.BaseStream.WriteByte(0xDA);
}
else
{
this.useTempStream = true;
this.tempStream = new MemoryTributary();
this.deflateStream = new DeflateStream(this.tempStream, CompressionMode.Compress, true);
this.baseStreamPosition = 0;
//zlib header
this.tempStream.WriteByte(0x78);
this.tempStream.WriteByte(0xDA);
}
this.deflateWriter = new BinaryWriter(this.deflateStream, Encoding.ASCII);
}
public static DataSet DecompressDataSet(byte[] bytDs, DataSet ds)
{
using (MemoryTributary inMs = new MemoryTributary(bytDs))
{
inMs.Seek(0, 0);
using (DeflateStream zipStream = new DeflateStream(inMs, CompressionMode.Decompress, true))
{
System.IO.StreamReader sr = new StreamReader(zipStream);
ds.ReadXml(sr);
}
}
//string xml = (string)atLogic.BEManager.DecompressStream(bytDs);
//using (System.IO.StringReader sw = new System.IO.StringReader(xml))
//{
// ds.ReadXml(sw);
//}
ds.AcceptChanges();
ds.RemotingFormat = SerializationFormat.Binary;
AppManager.FixTZDSIssue(ds);
return(ds);
}
public static void WriteSubBlocksParallel(
IWorldspaceSubBlockGetter subBlock,
MasterReferenceReader masters,
int targetIndex,
Stream[] streamDepositArray)
{
var items = subBlock.Items;
var bundle = new WritingBundle(GameConstants.Oblivion)
{
MasterReferences = masters
};
Stream[] streams = new Stream[(items?.Count ?? 0) + 1];
byte[] groupBytes = new byte[GameConstants.Oblivion.GroupConstants.HeaderLength];
BinaryPrimitives.WriteInt32LittleEndian(groupBytes.AsSpan(), RecordTypes.GRUP.TypeInt);
var groupByteStream = new MemoryStream(groupBytes);
using (var stream = new MutagenWriter(groupByteStream, bundle, dispose: false))
{
stream.Position += 8;
WorldspaceSubBlockBinaryWriteTranslation.WriteEmbedded(subBlock, stream);
}
streams[0] = groupByteStream;
if (items != null)
{
Parallel.ForEach(items, (cell, state, counter) =>
{
MemoryTributary trib = new MemoryTributary();
cell.WriteToBinary(new MutagenWriter(trib, bundle, dispose: false));
streams[(int)counter + 1] = trib;
});
}
PluginUtilityTranslation.CompileSetGroupLength(streams, groupBytes);
streamDepositArray[targetIndex] = new CompositeReadStream(streams, resetPositions: true);
}
void ICommunicationService.UploadContent(UploadStreamMessage content)
{
Stream source = content.DataStream;
MemoryTributary ms = new MemoryTributary();
const int bufferLen = 65536;
byte[] buffer = new byte[bufferLen];
int count = 0;
while ((count = source.Read(buffer, 0, bufferLen)) > 0)
{
ms.Write(buffer, 0, count);
}
ms.Seek(0, SeekOrigin.Begin);
try
{
if (owner != null)
owner.RouteData(content.Context, content.ContentType, ms);
}
catch
{
}
//MessageBox.Show(content.ContentType + " " + content.Context + " " + ms.Length);
ms.Close();
}
public static Stream FromUrl(string url)
{
try
{
int patience = 240; // seconds until we run out of patience waiting for generating a memory stream/tributary from a response to complete
var start = DateTime.Now;
var request = (HttpWebRequest)WebRequest.Create(url);
request.UserAgent = "Platform-Installer/2.0.0.0(AppGal Automation v1.0)"; // used by the WebPI, bypasses problems like the license popup on CodePlex
request.Timeout = 90000; // 1.5 minutes
request.AllowAutoRedirect = true;
request.Accept = "*/*";
request.KeepAlive = true;
request.CookieContainer = new CookieContainer();
// Even if we get a response within our allotted timeout (1.5 minutes, see above),
// we still have to actually get all of the bits for the package. That means
// going back and forth from this Web server to the server where the package
// is kept, requesting a buffer's worth of bits at a time. If this takes
// too long, then this Web server will throw an exception, thinking that
// something has gone wrong with the connection, the response, the app pool,
// etc. and there is nothing we can do here to catch that. We'll end up
// going to the generic MS error page when the server thinks an exception
// has occurred on the server. To avoid that nasty result, we are going to
// time ourselves here. If we take more than 4 minutes overall we are going to
// bail out.
AbortIfDelayed(start, patience);
using (var response = (HttpWebResponse)request.GetResponse())
{
AbortIfDelayed(start, patience);
using (var responseStream = response.GetResponseStream())
{
AbortIfDelayed(start, patience);
var m = new MemoryTributary();
var count = 0;
var buffer = new byte[4096];
do
{
AbortIfDelayed(start, patience);
count = responseStream.Read(buffer, 0, buffer.Length);
m.Write(buffer, 0, count);
} while (count != 0);
return(m);
}
}
}
catch (AbortGeneratingStreamException e)
{
throw e;
}
catch
{
return(null);
}
}
public override bool ConvertAndSave(ImageType type, Stream stream, ResILImageBase.MipMapMode MipsMode = MipMapMode.BuildAll, CompressedDataFormat surface = CompressedDataFormat.None, int quality = 80, bool SetJPGQuality = true)
{
// KFreon: If converting to something other than V8U8...
if (surface != SurfaceFormat)
{
byte[] RawImageData = GetImageDataAs3Channel(); // KFreon: Get image data as raw rgb pixels
int stride = (Width * 32 + 7) / 8;
BitmapSource test = BitmapSource.Create(Width, Height, 96, 96, PixelFormats.Bgr32, BitmapPalettes.Halftone125, RawImageData, stride);
MemoryTributary stream2 = new MemoryTributary();
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(test));
encoder.Save(stream2);
using (ResILImage img = new ResILImage(stream2))
return(img.ConvertAndSave(type, stream, MipsMode, surface, quality, SetJPGQuality));
}
else
{
// KFreon: Deal with mips first
int expectedMips = EstimateNumMips(Width, Height);
bool success = true;
switch (MipsMode)
{
case MipMapMode.BuildAll:
if (expectedMips != Mips)
{
success = BuildMipMaps();
}
break;
case MipMapMode.Rebuild:
// KFreon: Remove existing mips before building them again
if (!RemoveMipMaps())
{
success = false;
}
else
{
success = BuildMipMaps();
}
break;
case MipMapMode.ForceRemove:
case MipMapMode.RemoveAllButOne:
success = RemoveMipMaps();
break;
}
if (!success)
{
Debug.WriteLine("Failed to fix mipmaps.");
return(false);
}
// KFreon: Build formatting and write out to file
return(WriteV8U8ToStream(MipMaps, stream, Height, Width, Mips, false));
}
}
private void Read(Stream sourceStream)
{
var stream = new MemoryTributary();
var reader = new BinaryReader(stream);
sourceStream.CopyTo(stream);
stream.Seek(0, SeekOrigin.Begin);
_header = Header.ReadStatic(reader);
UseSingleByteIndices = _header.UseSingleByteIndices;
Name = _header.SceneName;
Textures = ReadArray <HashedName>(reader, _header.TextureOffset, _header.TextureCount);
Materials = ReadArray <Material>(reader, _header.MaterialOffset, _header.MaterialCount);
Meshes = ReadArray <Mesh>(reader, _header.MeshOffset, _header.MeshCount);
Submeshes = ReadArray <Submesh>(reader, _header.SubmeshOffset, _header.SubmeshCount);
BoneIndices = ReadArray <BoneIndex>(reader, _header.BoneIndexOffset, UseSingleByteIndices
? _header.BoneIndexBlockSize
: _header.BoneIndexBlockSize / 2);
BoneTransforms = ReadArray <BoneTransform>(reader, _header.BoneMatOffset, _header.BoneMatCount);
BoneNames = ReadArray <HashedName>(reader, _header.BoneNameOffset, _header.BoneNameCount);
Indices = ReadArray <Index>(reader, _header.IndicesOffset, _header.IndicesCount);
Shaders = ReadArray <HashedName>(reader, _header.ShaderOffset, _header.ShaderCount);
reader.BaseStream.Seek(_header.VertexBufferOffset, SeekOrigin.Begin);
VertexBuffers = new byte[Meshes.Length][];
int i = 0;
foreach (var mesh in Meshes)
{
VertexBuffers[i++] = reader.ReadBytes(mesh.Size, _header.VertexBufferOffset + mesh.Offset);
}
InverseBindPoses = ReadArray <Matrix64>(reader, _header.InverseBindPosesOffset, _header.InverseBindPosesCount);
// This seems to be a list of transforms for attachment (?) bones that have no parent. The first 4 ints are [ID] [Bone No] [Bone No] [?]
_submeshToBones = ReadArray <Unknown1Struct>(reader, _header.Offset01, _header.Count01);
// _unknown1 = BoneTransforms.Where(bt => bt.SupplementaryBoneTableIndex >= 0).Take(6).Select((b, i) =>
// {
// var matrix = new Unknown1Struct();
// matrix.Id = b.SupplementaryBoneTableIndex;
// matrix.BoneNo = b.BoneNo;
// matrix.BoneNo2 = b.BoneNo2;
// matrix.Offset = i * 8;
// return matrix;
// }).ToArray();
// The value range correlates to the number of submeshes
_submeshBonesMeta = ReadArray <Unknown12Struct>(reader, _header.Offset12, _header.Count12 / 8);
// _unknown12[_unknown1[Submeshes[9].Unknown1Offset].Offset / 8].Unknown3 = 10;
_unknown4 = ReadBuffer(reader, _header.Offset04, _header.Count04, 0x10);
_unknown13 = ReadArray <Unknown13Struct>(reader, _header.Offset13, _header.Count13);
_unknown14 = ReadBuffer(reader, _header.Offset14, _header.Count14, 0x40);
_unknown15 = ReadBuffer(reader, _header.Offset15, _header.Count15, 0x40);
}
protected override IOblivionModGetter ConvertMod(OblivionMod mod)
{
var stream = new MemoryTributary();
mod.WriteToBinary(stream);
stream.Position = 0;
return(OblivionMod.CreateFromBinaryOverlay(stream, mod.ModKey));
}
public void ParseRecordLocationsByCount_Alternating_MoreData()
{
MemoryTributary data = new MemoryTributary();
using (MutagenWriter writer = new MutagenWriter(data, GameConstants.Oblivion))
{
using (HeaderExport.Subrecord(writer, RecordTypes.EDID))
{
writer.Write(1);
}
using (HeaderExport.Subrecord(writer, RecordTypes.DATA))
{
writer.Write(-1);
}
using (HeaderExport.Subrecord(writer, RecordTypes.EDID))
{
writer.Write(2);
}
using (HeaderExport.Subrecord(writer, RecordTypes.DATA))
{
writer.Write(-2);
}
using (HeaderExport.Subrecord(writer, RecordTypes.EDID))
{
writer.Write(3);
}
using (HeaderExport.Subrecord(writer, RecordTypes.DATA))
{
writer.Write(-3);
}
using (HeaderExport.Subrecord(writer, RecordTypes.MAST))
{
writer.Write(-3);
}
}
data.Position = 0;
var triggers = new HashSet <RecordType>()
{
RecordTypes.EDID,
RecordTypes.DATA,
};
var stream = new OverlayStream(data.ToArray(), new ParsingBundle(GameConstants.Oblivion, masterReferences: null !));
var pos = BinaryOverlay.ParseRecordLocationsByCount(
stream,
3,
triggers.ToGetter(),
GameConstants.Oblivion.SubConstants,
skipHeader: false);
Assert.Equal(3, pos.Length);
Assert.Equal(0, pos[0]);
Assert.Equal(20, pos[1]);
Assert.Equal(40, pos[2]);
Assert.Equal(60, stream.Position);
Assert.False(stream.Complete);
}
public System.Drawing.Bitmap ToWinFormsBitmap(int width = 0, int height = 0)
{
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
BitmapImage bmp = ToImage(width: width, height: height);
BitmapFrame frame = BitmapFrame.Create(bmp);
encoder.Frames.Add(frame);
using (MemoryTributary ms = new MemoryTributary())
{
encoder.Save(ms);
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(ms);
return(new System.Drawing.Bitmap(bitmap));
}
}
//public static byte[] CompressData(DataTable dt)
//{
// dt.RemotingFormat = SerializationFormat.Binary;
// return CompressStream(dt);
//}
private static byte[] CompressStream(DataSet obj)
{
byte[] b;
BinaryFormatter bf = new BinaryFormatter();
using (MemoryTributary objStream = new MemoryTributary())
{
using (System.IO.Compression.DeflateStream objZS = new System.IO.Compression.DeflateStream(objStream, System.IO.Compression.CompressionMode.Compress))
{
//obj.WriteXml(objZS, XmlWriteMode.DiffGram);
bf.Serialize(objZS, obj);
};
b = objStream.ToArray();
};
return(b);
}
/// <summary>
///
/// </summary>
/// <param name="file"></param>
/// <param name="stream"></param>
/// <param name="WhichGame"></param>
/// <returns></returns>
public static IPCCObject CreatePCCObject(string file, MemoryTributary stream, int WhichGame)
{
IPCCObject pcc;
if (WhichGame == 1)
pcc = new ME1PCCObject(file, stream);
else if (WhichGame == 2)
pcc = new ME2PCCObject(file, stream);
else if (WhichGame == 3)
pcc = new ME3PCCObject(file, stream);
else
{
DebugOutput.PrintLn("WHAT HAVE YOU DONE!! PCCObject creation failed!");
return null;
}
return pcc;
}
public static void WriteGroupParallel <T>(
IGroupGetter <T> group,
MasterReferenceReader masters,
int targetIndex,
GameConstants gameConstants,
Stream[] streamDepositArray)
where T : class, ISkyrimMajorRecordGetter, IBinaryItem
{
if (group.RecordCache.Count == 0)
{
return;
}
var cuts = group.Cut(CutCount).ToArray();
Stream[] subStreams = new Stream[cuts.Length + 1];
byte[] groupBytes = new byte[gameConstants.GroupConstants.HeaderLength];
BinaryPrimitives.WriteInt32LittleEndian(groupBytes.AsSpan(), RecordTypes.GRUP.TypeInt);
var groupByteStream = new MemoryStream(groupBytes);
using (var stream = new MutagenWriter(groupByteStream, gameConstants, dispose: false))
{
stream.Position += 8;
GroupBinaryWriteTranslation.WriteEmbedded <T>(group, stream);
}
subStreams[0] = groupByteStream;
Parallel.ForEach(cuts, (cutItems, state, counter) =>
{
MemoryTributary trib = new MemoryTributary();
var bundle = new WritingBundle(gameConstants)
{
MasterReferences = masters
};
using (var stream = new MutagenWriter(trib, bundle, dispose: false))
{
foreach (var item in cutItems)
{
item.WriteToBinary(stream);
}
}
subStreams[(int)counter + 1] = trib;
});
UtilityTranslation.CompileSetGroupLength(subStreams, groupBytes);
streamDepositArray[targetIndex] = new CompositeReadStream(subStreams, resetPositions: true);
}
public ME2PCCObject(String path)
{
lzo = new SaltLZOHelper();
fullname = path;
BitConverter.IsLittleEndian = true;
DebugOutput.PrintLn("Load file : " + path);
pccFileName = Path.GetFullPath(path);
MemoryTributary tempStream = new MemoryTributary();
if (!File.Exists(pccFileName))
throw new FileNotFoundException("PCC file not found");
using (FileStream fs = new FileStream(pccFileName, FileMode.Open, FileAccess.Read))
{
FileInfo tempInfo = new FileInfo(pccFileName);
tempStream.WriteFromStream(fs, tempInfo.Length);
if (tempStream.Length != tempInfo.Length)
{
throw new FileLoadException("File not fully read in. Try again later");
}
}
LoadHelper(tempStream);
}
public stElemAddr(MemoryTributary source, int beginIndex)
{
byte[] buffer;
BinaryReader binReader = new BinaryReader(source);
binReader.BaseStream.Position = beginIndex;
buffer = binReader.ReadBytes(12);
this.elem_header_addr = BitConverter.ToUInt32(buffer, 0);
this.elem_data_addr = BitConverter.ToUInt32(buffer, 4);
this.fffffff = BitConverter.ToUInt32(buffer, 8);
}
public PCCObject(String path)
{
lzo = new SaltLZOHelper();
fullname = path;
BitConverter.IsLittleEndian = true;
DebugOutput.PrintLn("Load file : " + path);
pccFileName = Path.GetFullPath(path);
MemoryTributary tempStream = new MemoryTributary();
if (!File.Exists(pccFileName))
throw new FileNotFoundException("PCC file not found");
using (FileStream fs = new FileStream(pccFileName, FileMode.Open, FileAccess.Read))
{
FileInfo tempInfo = new FileInfo(pccFileName);
tempStream.WriteFromStream(fs, tempInfo.Length);
if (tempStream.Length != tempInfo.Length)
{
throw new FileLoadException("File not fully read in. Try again later");
}
}
tempStream.Seek(12, SeekOrigin.Begin);
int tempNameSize = tempStream.ReadValueS32();
tempStream.Seek(64 + tempNameSize, SeekOrigin.Begin);
int tempGenerator = tempStream.ReadValueS32();
tempStream.Seek(36 + tempGenerator * 12, SeekOrigin.Current);
int tempPos = (int)tempStream.Position + 4;
tempStream.Seek(0, SeekOrigin.Begin);
header = tempStream.ReadBytes(tempPos);
tempStream.Seek(0, SeekOrigin.Begin);
if (magic != ZBlock.magic && magic.Swap() != ZBlock.magic)
{
DebugOutput.PrintLn("Magic number incorrect: " + magic);
throw new FormatException("This is not a pcc file. The magic number is incorrect.");
}
if (bCompressed)
{
DebugOutput.PrintLn("File is compressed");
listsStream = lzo.DecompressPCC(tempStream, this);
//Correct the header
bCompressed = false;
listsStream.Seek(0, SeekOrigin.Begin);
listsStream.WriteBytes(header);
// Set numblocks to zero
listsStream.WriteValueS32(0);
//Write the magic number
listsStream.WriteBytes(new byte[] { 0xF2, 0x56, 0x1B, 0x4E });
// Write 4 bytes of 0
listsStream.WriteValueS32(0);
}
else
{
DebugOutput.PrintLn("File already decompressed. Reading decompressed data.");
//listsStream = tempStream;
listsStream = new MemoryTributary();
tempStream.WriteTo(listsStream);
}
tempStream.Dispose();
ReadNames(listsStream);
ReadImports(listsStream);
ReadExports(listsStream);
LoadExports();
}
private void ReadNames(MemoryTributary fs)
{
DebugOutput.PrintLn("Reading Names...");
fs.Seek(NameOffset, SeekOrigin.Begin);
Names = new List<string>();
for (int i = 0; i < NameCount; i++)
{
int len = fs.ReadValueS32();
string s = fs.ReadString((uint)(len - 1));
fs.Seek(5, SeekOrigin.Current);
Names.Add(s);
}
}
/// <summary>
/// Сжатие произвольных файлов
/// </summary>
public void Deflate(string in_filename, string out_filename, bool enableNewCode = true)
{
if (!File.Exists(in_filename))
throw new Exception("Input file not found!");
using (FileStream fileReader = File.Open(in_filename, FileMode.Open))
{
MemoryTributary memOutBuffer;
using (MemoryTributary memBuffer = new MemoryTributary())
{
fileReader.CopyTo(memBuffer);
bool success = Deflate(memBuffer, out memOutBuffer);
if (!success)
throw new Exception("Deflate error!");
using (FileStream fileWriter = new FileStream(out_filename, FileMode.Create))
{
memOutBuffer.Position = 0;
memOutBuffer.CopyTo(fileWriter);
}
memOutBuffer.Close();
}
}
}
public void SetHeaderFromMemStream(MemoryTributary source)
{
if (useTempFiles)
{
GenerateTempFileName("header");
using (FileStream file = new FileStream(tmpHeaderFile, FileMode.Create, FileAccess.Write))
{
source.WriteTo(file);
}
} else
{
this.pHeader = source.ToArray();
}
}
public MemoryTributary DecompressPCC(Stream raw, PCCObject pcc)
{
raw.Seek(pcc.header.Length, SeekOrigin.Begin);
int pos = 4;
pcc.NumChunks = raw.ReadValueS32();
List<Chunk> Chunks = new List<Chunk>();
//DebugOutput.PrintLn("Reading chunk headers...");
for (int i = 0; i < pcc.NumChunks; i++)
{
Chunk c = new Chunk();
c.uncompressedOffset = raw.ReadValueS32();
c.uncompressedSize = raw.ReadValueS32();
c.compressedOffset = raw.ReadValueS32();
c.compressedSize = raw.ReadValueS32();
c.Compressed = new byte[c.compressedSize];
c.Uncompressed = new byte[c.uncompressedSize];
//DebugOutput.PrintLn("Chunk " + i + ", compressed size = " + c.compressedSize + ", uncompressed size = " + c.uncompressedSize);
//DebugOutput.PrintLn("Compressed offset = " + c.compressedOffset + ", uncompressed offset = " + c.uncompressedOffset);
Chunks.Add(c);
}
//DebugOutput.PrintLn("\tRead Chunks...");
int count = 0;
for (int i = 0; i < Chunks.Count; i++)
{
Chunk c = Chunks[i];
raw.Seek(c.compressedOffset, SeekOrigin.Begin);
c.Compressed = raw.ReadBytes(c.compressedSize);
ChunkHeader h = new ChunkHeader();
h.magic = BitConverter.ToInt32(c.Compressed, 0);
if (h.magic != -1641380927)
throw new FormatException("Chunk magic number incorrect");
h.blocksize = BitConverter.ToInt32(c.Compressed, 4);
h.compressedsize = BitConverter.ToInt32(c.Compressed, 8);
h.uncompressedsize = BitConverter.ToInt32(c.Compressed, 12);
//DebugOutput.PrintLn("Chunkheader read: Magic = " + h.magic + ", Blocksize = " + h.blocksize + ", Compressed Size = " + h.compressedsize + ", Uncompressed size = " + h.uncompressedsize);
pos = 16;
int blockCount = (h.uncompressedsize % h.blocksize == 0)
?
h.uncompressedsize / h.blocksize
:
h.uncompressedsize / h.blocksize + 1;
List<Block> BlockList = new List<Block>();
//DebugOutput.PrintLn("\t\t" + count + " Read Blockheaders...");
for (int j = 0; j < blockCount; j++)
{
Block b = new Block();
b.compressedsize = BitConverter.ToInt32(c.Compressed, pos);
b.uncompressedsize = BitConverter.ToInt32(c.Compressed, pos + 4);
//DebugOutput.PrintLn("Block " + j + ", compressed size = " + b.compressedsize + ", uncompressed size = " + b.uncompressedsize);
pos += 8;
BlockList.Add(b);
}
int outpos = 0;
//DebugOutput.PrintLn("\t\t" + count + " Read and decompress Blocks...");
foreach (Block b in BlockList)
{
byte[] datain = new byte[b.compressedsize];
byte[] dataout = new byte[b.uncompressedsize];
for (int j = 0; j < b.compressedsize; j++)
datain[j] = c.Compressed[pos + j];
pos += b.compressedsize;
try
{
LZO1X.Decompress(datain, dataout);
}
catch
{
throw new Exception("LZO decompression failed!");
}
for (int j = 0; j < b.uncompressedsize; j++)
c.Uncompressed[outpos + j] = dataout[j];
outpos += b.uncompressedsize;
}
c.header = h;
c.blocks = BlockList;
count++;
Chunks[i] = c;
}
MemoryTributary result = new MemoryTributary();
foreach (Chunk c in Chunks)
{
result.Seek(c.uncompressedOffset, SeekOrigin.Begin);
result.WriteBytes(c.Uncompressed);
}
return result;
}
private bool Inflate(MemoryTributary compressedMemoryStream, out MemoryTributary outBufStream)
{
bool result = true;
outBufStream = new MemoryTributary();
try
{
compressedMemoryStream.Position = 0;
System.IO.Compression.DeflateStream decompressStream = new System.IO.Compression.DeflateStream(compressedMemoryStream, System.IO.Compression.CompressionMode.Decompress);
decompressStream.CopyTo(outBufStream);
}
catch (Exception ex)
{
outBufStream = compressedMemoryStream;
result = false;
}
return result;
}
public V8U8Image(byte[] imgData) : this()
{
using (MemoryTributary stream = new MemoryTributary(imgData))
LoadImage(stream);
}
private void SaveFile(string filename, bool enableNewCode = true)
{
using (FileStream strWriter = new FileStream(filename, System.IO.FileMode.Create))
{
UInt32 stElemSize = stElemAddr.Size();
UInt32 ElemsNum = (UInt32)Elems.Count;
UInt32 cur_block_addr = stFileHeader.Size() + stBlockHeader.Size();
if (stElemAddr.Size() * ElemsNum < V8_DEFAULT_PAGE_SIZE)
cur_block_addr += V8_DEFAULT_PAGE_SIZE; // 512 - стандартный размер страницы 0x200
else
cur_block_addr += stElemAddr.Size() * ElemsNum;
byte[] pTempElemsAddrs = new byte[Elems.Count * stElemSize];
foreach (CV8Elem elem in Elems)
{
int elIndex = Elems.IndexOf(elem);
stElemAddr curAddr = new stElemAddr();
curAddr.elem_header_addr = cur_block_addr;
cur_block_addr += stBlockHeader.Size() + elem.HeaderSize;
curAddr.elem_data_addr = cur_block_addr;
cur_block_addr += stBlockHeader.Size();
if (elem.DataSize > V8_DEFAULT_PAGE_SIZE)
cur_block_addr += elem.DataSize;
else
cur_block_addr += V8_DEFAULT_PAGE_SIZE;
curAddr.fffffff = 0x7fffffff;
byte[] tmpAddrBytes = curAddr.ToBytes();
Array.Copy(tmpAddrBytes, 0, pTempElemsAddrs, elIndex * stElemSize, stElemSize);
}
UInt32 cur_pos = 0;
// записываем заголовок
strWriter.Write(FileHeader.ToBytes(), 0, (int)stFileHeader.Size());
cur_pos += stFileHeader.Size();
// записываем адреса элементов
byte[] buffer;
if (pTempElemsAddrs.Length < V8_DEFAULT_PAGE_SIZE)
{
buffer = new byte[V8_DEFAULT_PAGE_SIZE + stBlockHeader.Size()];
}
else
{
buffer = new byte[pTempElemsAddrs.Length + stBlockHeader.Size()];
}
UInt32 bufCurPos = 0;
SaveBlockDataToBuffer(ref buffer, ref bufCurPos, pTempElemsAddrs);
strWriter.Write(buffer, 0, buffer.Length);
cur_pos += bufCurPos;
// записываем элементы (заголовок и данные)
foreach (CV8Elem elem in Elems)
{
using (MemoryTributary memBuffer = new MemoryTributary())
{
BinaryWriter binMemBuffer = new BinaryWriter(memBuffer);
memBuffer.Position = 0;
SaveBlockDataToBuffer(ref binMemBuffer, elem.GetHeaderLikeMemStream(), elem.HeaderSize);
// Переносим данные из memBuffer в файл
binMemBuffer.BaseStream.Position = 0;
for (int i = 0; i < binMemBuffer.BaseStream.Length; i++)
{
strWriter.WriteByte(Convert.ToByte(binMemBuffer.BaseStream.ReadByte()));
}
}
using (MemoryTributary memBuffer = new MemoryTributary())
{
BinaryWriter binMemBuffer = new BinaryWriter(memBuffer);
memBuffer.Position = 0;
bufCurPos = 0;
SaveBlockDataToBuffer(ref binMemBuffer, elem.GetDataLikeMemStream());
cur_pos += bufCurPos;
// Переносим данные из memBuffer в файл
binMemBuffer.BaseStream.Position = 0;
for (int i = 0; i < binMemBuffer.BaseStream.Length; i++)
{
strWriter.WriteByte(Convert.ToByte(binMemBuffer.BaseStream.ReadByte()));
}
}
}
}
}
private void Pack(bool enableNewCode = true)
{
MemoryTributary DeflateBufferStream = new MemoryTributary();
MemoryTributary DataBufferStream = new MemoryTributary();
foreach (CV8Elem elem in Elems)
{
UInt32 elemNum = (UInt32)Elems.IndexOf(elem);
if (!elem.IsV8File)
{
DataBufferStream = new MemoryTributary();
bool success = Deflate(elem.GetDataLikeMemStream(), out DataBufferStream);
if (!success)
throw new Exception("Ошибка сжатия данных. Некорректный формат данных!");
elem.SetDataFromMemStream(DataBufferStream);
elem.DataSize = (UInt32)DataBufferStream.Length;
}
else
{
DataBufferStream = new MemoryTributary();
MemoryTributary outBufSteram = new MemoryTributary();
elem.UnpackedData.GetData(out DataBufferStream);
bool success = Deflate(DataBufferStream, out outBufSteram);
if (!success)
throw new Exception("Ошибка сжатия данных. Некорректный формат данных!");
elem.UnpackedData = new V8File(this);
elem.IsV8File = false;
elem.SetDataFromMemStream(outBufSteram);
elem.DataSize = (UInt32)outBufSteram.Length;
}
}
DeflateBufferStream.Close();
DataBufferStream.Close();
}
private void LoadFileFromFolder(string dirname, bool enableNewCode = true)
{
long sourceDIrectorySize = DirSize(new DirectoryInfo(dirname));
if (sourceDIrectorySize > V8File.MAX_FILE_SIZE)
this.OperationMode = Mode.FileSystem;
byte[] headerBytes = new byte[] {0xFF, 0xFF, 0xFF, 0x7F,
0x0, 0x2, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0,
0x0, 0x0, 0x0, 0x0};
FileHeader = new stFileHeader(headerBytes, 0);
this.Elems.Clear();
this.ElemsAddrs.Clear();
string[] srcFiles = Directory.GetFiles(dirname, "*");
foreach (string srcFile in srcFiles)
{
FileInfo srcFileInfo = new FileInfo(srcFile);
if (srcFileInfo.Name[0] == '.')
continue;
using (BinaryReader reader = new BinaryReader(File.Open(srcFile, FileMode.Open)))
{
CV8Elem elem = new CV8Elem(this);
elem.IsV8File = false;
elem.HeaderSize = V8File.CV8Elem.stElemHeaderBegin.Size() + (UInt32)srcFileInfo.Name.Length * 2 + 4;
elem.SetElemName(srcFileInfo.Name, srcFileInfo.Name.Length);
elem.DataSize = (UInt32)reader.BaseStream.Length;
MemoryTributary buferData = new MemoryTributary();
reader.BaseStream.CopyTo(buferData);
elem.SetDataFromMemStream(buferData);
this.Elems.Add(elem);
}
}
string[] srcDirectories = Directory.GetDirectories(dirname, "*");
foreach (string srcDir in srcDirectories)
{
DirectoryInfo dirInfo = new DirectoryInfo(srcDir);
if (dirInfo.Name[0] == '.')
continue;
CV8Elem elem = new CV8Elem(this);
elem.IsV8File = true;
elem.HeaderSize = V8File.CV8Elem.stElemHeaderBegin.Size() + (UInt32)dirInfo.Name.Length * 2 + 4;
elem.SetElemName(dirInfo.Name, dirInfo.Name.Length);
elem.UnpackedData = new V8File(this);
elem.UnpackedData.LoadFileFromFolder(srcDir);
this.Elems.Add(elem);
}
}
private static bool IsV8File(MemoryTributary inputFileStream)
{
BinaryReader binReader = new BinaryReader(inputFileStream);
return IsV8File(binReader);
}
/// <summary>
/// Упаковка файла из файловой структуры с минимальной детализацией
/// </summary>
public void PackFromFolder(string dirname, string outFileName, bool enableNewCode = true)
{
string filename;
filename = string.Format("{0}\\FileHeader", dirname);
byte[] fileHeaderBytes = File.ReadAllBytes(filename);
this.FileHeader = new stFileHeader(fileHeaderBytes, 0);
string[] files = Directory.GetFiles(dirname);
var filesWitoutFileHeader = files.Where(el => !el.EndsWith("FileHeader"));
var filesBlockHeaders = filesWitoutFileHeader.Where(el => el.EndsWith(".header"));
UInt32 ElemsNum = 0;
ElemsNum = (UInt32)filesWitoutFileHeader.Count();
Elems.Clear();
ElemsAddrs.Clear();
foreach (string file in filesBlockHeaders)
{
CV8Elem elem = new CV8Elem(this);
filename = file;
using (FileStream fileReader = File.Open(filename, FileMode.Open))
{
MemoryTributary memBuffer = new MemoryTributary();
fileReader.CopyTo(memBuffer);
elem.SetHeaderFromMemStream(memBuffer);
elem.HeaderSize = (UInt32)memBuffer.Length;
}
filename = filename.Replace(".header", ".Data");
using (FileStream fileReader = File.Open(filename, FileMode.Open))
{
MemoryTributary memBuffer = new MemoryTributary();
fileReader.CopyTo(memBuffer);
elem.SetDataFromMemStream(memBuffer);
elem.DataSize = (UInt32)memBuffer.Length;
}
Elems.Add(elem);
}
SaveFile(outFileName, true);
ClearTempData();
}
private void ReadNames(MemoryTributary fs)
{
DebugOutput.PrintLn("Reading Names...");
fs.Seek(NameOffset, SeekOrigin.Begin);
Names = new List<string>();
for (int i = 0; i < NameCount; i++)
{
int len = fs.ReadValueS32();
string s = "";
if (len > 0)
{
s = fs.ReadString((uint)(len - 1));
fs.Seek(9, SeekOrigin.Current);
}
else
{
len *= -1;
for (int j = 0; j < len - 1; j++)
{
s += (char)fs.ReadByte();
fs.ReadByte();
}
fs.Seek(10, SeekOrigin.Current);
}
Names.Add(s);
}
}
public static ResILImageBase Create(byte[] imageData)
{
using (MemoryTributary stream = new MemoryTributary(imageData))
return Create(stream);
}
public MemoryTributary GetHeaderLikeMemStream()
{
MemoryTributary memStream = new MemoryTributary();
if (useTempFiles)
{
using (FileStream tmpFileStream = new FileStream(tmpHeaderFile, FileMode.Open))
{
tmpFileStream.CopyTo(memStream);
}
} else
{
if(this._pHeader.Length > 0)
memStream.Write(this._pHeader, 0, (int)this.HeaderSize);
}
memStream.Position = 0;
return memStream;
}
private void ReadExports(MemoryTributary fs)
{
DebugOutput.PrintLn("Reading Exports...");
fs.Seek(ExportOffset, SeekOrigin.Begin);
Exports = new List<ME2ExportEntry>();
for (int i = 0; i < ExportCount; i++)
{
long start = fs.Position;
ME2ExportEntry exp = new ME2ExportEntry();
exp.pccRef = this;
exp.infoOffset = (int)start;
fs.Seek(40, SeekOrigin.Current);
int count = fs.ReadValueS32();
fs.Seek(4 + count * 12, SeekOrigin.Current);
count = fs.ReadValueS32();
fs.Seek(4 + count * 4, SeekOrigin.Current);
fs.Seek(16, SeekOrigin.Current);
long end = fs.Position;
fs.Seek(start, SeekOrigin.Begin);
exp.info = fs.ReadBytes((int)(end - start));
Exports.Add(exp);
fs.Seek(end, SeekOrigin.Begin);
if (LastExport == null || exp.DataOffset > LastExport.DataOffset)
LastExport = exp;
}
}
/// <summary>
/// Converts image to different types and saves to stream. Returns true if successful.
/// </summary>
/// <param name="type">Desired image type.</param>
/// <param name="stream">Stream to save to. Contains data of image file, NOT raw pixel data.</param>
/// <param name="surface">Surface format. ONLY valid when type is DDS.</param>
/// <param name="quality">JPG quality. ONLY valid when tpye is JPG.</param>
/// <param name="SetJPGQuality">Sets JPG output quality if true.</param>
public override bool ConvertAndSave(ImageType type, Stream stream, MipMapMode MipsMode = MipMapMode.None, CompressedDataFormat surface = CompressedDataFormat.None, int quality = 80, bool SetJPGQuality = true)
{
if (SetJPGQuality && type == ImageType.Jpg)
{
ResIL.Settings.SetJPGQuality(quality);
}
if (surface == CompressedDataFormat.V8U8)
{
byte[] imgdata = ToArray();
if (imgdata == null)
{
return(false);
}
byte[] rawdata = null;
using (MemoryTributary test = new MemoryTributary(imgdata))
{
var frame = BitmapFrame.Create(test);
int stride = (Width * 32 + 7) / 8;
rawdata = new byte[stride * 1024];
frame.CopyPixels(rawdata, stride, 0);
}
using (V8U8Image img = new V8U8Image(rawdata, Width, Height, BitsPerPixel))
{
return(img.ConvertAndSave(type, stream, MipsMode, surface, quality, SetJPGQuality));
}
}
else
{
bool mipsOperationSuccess = true;
switch (MipsMode)
{
case MipMapMode.BuildAll:
mipsOperationSuccess = BuildMipMaps();
break;
case MipMapMode.Rebuild:
mipsOperationSuccess = BuildMipMaps(true);
break;
case MipMapMode.RemoveAllButOne:
mipsOperationSuccess = RemoveMipMaps();
break;
case MipMapMode.ForceRemove:
mipsOperationSuccess = RemoveMipMaps(true);
break;
}
if (!mipsOperationSuccess)
{
Console.WriteLine("Failed to build mips for image.");
}
ChangeSurface(surface);
return(IL2.SaveImageAsStream(handle, type, stream));
}
}
public ME2PCCObject(String path, MemoryTributary tempStream)
{
lzo = new SaltLZOHelper();
fullname = path;
BitConverter.IsLittleEndian = true;
DebugOutput.PrintLn("Load file : " + path);
pccFileName = Path.GetFullPath(path);
LoadHelper(tempStream);
}
public static ResILImageBase Create(byte[] imageData)
{
using (MemoryTributary stream = new MemoryTributary(imageData))
return(Create(stream));
}
private V8File(V8File ParentV8File, MemoryTributary pFileDataStream, int InflateSize, bool boolInflate = true, Mode OperationMode = Mode.Optimal)
{
BinaryReader binReader = new BinaryReader(pFileDataStream);
this.IsDataPacked = true;
Elems = new List<CV8Elem>();
ElemsAddrs = new List<stElemAddr>();
_objectId = Guid.NewGuid();
this.OperationMode = OperationMode;
this._parentV8File = ParentV8File;
this.LoadFile(binReader, boolInflate);
}
private void LoadHelper(MemoryTributary tempStream)
{
tempStream.Seek(12, SeekOrigin.Begin);
int tempNameSize = tempStream.ReadValueS32();
tempStream.Seek(64 + tempNameSize, SeekOrigin.Begin);
int tempGenerator = tempStream.ReadValueS32();
tempStream.Seek(36 + tempGenerator * 12, SeekOrigin.Current);
int tempPos = (int)tempStream.Position;
NumChunks = tempStream.ReadValueS32();
tempStream.Seek(0, SeekOrigin.Begin);
header = tempStream.ReadBytes(tempPos);
tempStream.Seek(0, SeekOrigin.Begin);
if (magic != ZBlock.magic && magic.Swap() != ZBlock.magic)
{
DebugOutput.PrintLn("Magic number incorrect: " + magic);
throw new FormatException("This is not a pcc file. The magic number is incorrect.");
}
if (bCompressed)
{
DebugOutput.PrintLn("File is compressed");
{
listsStream = lzo.DecompressPCC(tempStream, this);
//Correct the header
bCompressed = false;
listsStream.Seek(0, SeekOrigin.Begin);
listsStream.WriteBytes(header);
//Set numblocks to zero
listsStream.WriteValueS32(0);
//Write the magic number
listsStream.WriteValueS32(1026281201);
//Write 8 bytes of 0
listsStream.WriteValueS32(0);
listsStream.WriteValueS32(0);
}
}
else
{
DebugOutput.PrintLn("File already decompressed. Reading decompressed data.");
listsStream = tempStream;
}
ReadNames(listsStream);
ReadImports(listsStream);
ReadExports(listsStream);
LoadExports();
}
public void SetElemName(string ElemName, int ElemNameLen)
{
byte[] pHeaderBuffer = new byte[this.HeaderSize];
UInt32 stElemHeaderBeginSize = V8File.CV8Elem.stElemHeaderBegin.Size();
for (int j = 0; j < ElemNameLen * 2; j += 2, stElemHeaderBeginSize += 2)
{
pHeaderBuffer[stElemHeaderBeginSize] = Convert.ToByte(ElemName[j / 2]);
pHeaderBuffer[stElemHeaderBeginSize + 1] = 0;
}
MemoryTributary bufferHeader = new MemoryTributary(pHeaderBuffer);
this.SetHeaderFromMemStream(bufferHeader);
}
private void ReadImports(MemoryTributary fs)
{
DebugOutput.PrintLn("Reading Imports...");
Imports = new List<ME2ImportEntry>();
fs.Seek(ImportOffset, SeekOrigin.Begin);
for (int i = 0; i < ImportCount; i++)
{
ME2ImportEntry import = new ME2ImportEntry();
import.Package = Names[fs.ReadValueS32()];
fs.Seek(12, SeekOrigin.Current);
import.link = fs.ReadValueS32();
import.Name = Names[fs.ReadValueS32()];
fs.Seek(-24, SeekOrigin.Current);
import.raw = fs.ReadBytes(28);
Imports.Add(import);
}
}
private bool Deflate(MemoryTributary pDataStream, out MemoryTributary outBufStream)
{
bool result = true;
int DataSize = (int)pDataStream.Length;
outBufStream = new MemoryTributary();
pDataStream.Position = 0;
try
{
MemoryTributary srcMemStream = pDataStream;
{
using (MemoryTributary compressedMemStream = new MemoryTributary())
{
using (System.IO.Compression.DeflateStream strmDef = new System.IO.Compression.DeflateStream(compressedMemStream, System.IO.Compression.CompressionMode.Compress))
{
srcMemStream.CopyTo(strmDef);
}
outBufStream = compressedMemStream;
}
}
}
catch (Exception ex)
{
outBufStream = pDataStream;
result = false;
}
return result;
}
public override bool ConvertAndSave(ImageType type, Stream stream, ResILImageBase.MipMapMode MipsMode = MipMapMode.BuildAll, CompressedDataFormat surface = CompressedDataFormat.None, int quality = 80, bool SetJPGQuality = true)
{
// KFreon: If converting to something other than V8U8...
if (surface != SurfaceFormat)
{
byte[] RawImageData = GetImageDataAs3Channel(); // KFreon: Get image data as raw rgb pixels
int stride = (Width * 32 + 7) / 8;
BitmapSource test = BitmapSource.Create(Width, Height, 96, 96, PixelFormats.Bgr32, BitmapPalettes.Halftone125, RawImageData, stride);
MemoryTributary stream2 = new MemoryTributary();
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
encoder.Frames.Add(BitmapFrame.Create(test));
encoder.Save(stream2);
using (ResILImage img = new ResILImage(stream2))
return img.ConvertAndSave(type, stream, MipsMode, surface, quality, SetJPGQuality);
}
else
{
// KFreon: Deal with mips first
int expectedMips = EstimateNumMips(Width, Height);
bool success = true;
switch (MipsMode)
{
case MipMapMode.BuildAll:
if (expectedMips != Mips)
success = BuildMipMaps();
break;
case MipMapMode.Rebuild:
// KFreon: Remove existing mips before building them again
if (!RemoveMipMaps())
success = false;
else
success = BuildMipMaps();
break;
case MipMapMode.ForceRemove:
case MipMapMode.RemoveAllButOne:
success = RemoveMipMaps();
break;
}
if (!success)
{
Debug.WriteLine("Failed to fix mipmaps.");
return false;
}
// KFreon: Build formatting and write out to file
return WriteV8U8ToStream(MipMaps, stream, Height, Width, Mips, false);
}
}
public byte[] GetImageDataAs3Channel()
{
MemoryTributary bitmapStream = new MemoryTributary(Width * Height * 2);
int ptr = 0;
byte[] ImageData = MipMaps[0].data;
using (BinaryWriter bitmapBW = new BinaryWriter(bitmapStream))
{
for (int y = 0; y < Height; y++)
{
for (int x = 0; x < Width; x++)
{
sbyte red = (sbyte)Buffer.GetByte(ImageData, ptr++);
sbyte green = (sbyte)Buffer.GetByte(ImageData, ptr++);
byte blue = 0xFF;
int fCol = blue | (0x7F + green) << 8 | (0x7F + red) << 16 | 0xFF << 24;
bitmapBW.Write(fCol);
}
}
ImageData = bitmapStream.ToArray();
}
return ImageData;
}
public static void WriteWorldspacesParallel(
IGroupGetter <IWorldspaceGetter> group,
MasterReferenceReader masters,
int targetIndex,
Stream[] streamDepositArray)
{
var cache = group.RecordCache;
if (cache == null || cache.Count == 0)
{
return;
}
Stream[] streams = new Stream[cache.Count + 1];
var bundle = new WritingBundle(GameConstants.Oblivion)
{
MasterReferences = masters
};
byte[] groupBytes = new byte[GameConstants.Oblivion.GroupConstants.HeaderLength];
BinaryPrimitives.WriteInt32LittleEndian(groupBytes.AsSpan(), RecordTypes.GRUP.TypeInt);
var groupByteStream = new MemoryStream(groupBytes);
using (var stream = new MutagenWriter(groupByteStream, GameConstants.Oblivion, dispose: false))
{
stream.Position += 8;
GroupBinaryWriteTranslation.WriteEmbedded <IWorldspaceGetter>(group, stream);
}
streams[0] = groupByteStream;
Parallel.ForEach(group, (worldspace, worldspaceState, worldspaceCounter) =>
{
var worldTrib = new MemoryTributary();
using (var writer = new MutagenWriter(worldTrib, bundle, dispose: false))
{
using (HeaderExport.Header(
writer: writer,
record: RecordTypes.WRLD,
type: ObjectType.Record))
{
WorldspaceBinaryWriteTranslation.WriteEmbedded(
item: worldspace,
writer: writer);
WorldspaceBinaryWriteTranslation.WriteRecordTypes(
item: worldspace,
writer: writer,
recordTypeConverter: null);
}
}
var road = worldspace.Road;
var topCell = worldspace.TopCell;
var subCells = worldspace.SubCells;
if (subCells?.Count == 0 &&
road == null &&
topCell == null)
{
streams[worldspaceCounter + 1] = worldTrib;
return;
}
Stream[] subStreams = new Stream[(subCells?.Count ?? 0) + 1];
var worldGroupTrib = new MemoryTributary();
var worldGroupWriter = new MutagenWriter(worldGroupTrib, bundle, dispose: false);
worldGroupWriter.Write(RecordTypes.GRUP.TypeInt);
worldGroupWriter.Write(Zeros.Slice(0, GameConstants.Oblivion.GroupConstants.LengthLength));
FormKeyBinaryTranslation.Instance.Write(
worldGroupWriter,
worldspace.FormKey);
worldGroupWriter.Write((int)GroupTypeEnum.WorldChildren);
worldGroupWriter.Write(worldspace.SubCellsTimestamp);
road?.WriteToBinary(worldGroupWriter);
topCell?.WriteToBinary(worldGroupWriter);
subStreams[0] = worldGroupTrib;
if (subCells != null)
{
Parallel.ForEach(subCells, (block, blockState, blockCounter) =>
{
WriteBlocksParallel(
block,
masters,
(int)blockCounter + 1,
subStreams);
});
}
worldGroupWriter.Position = 4;
worldGroupWriter.Write((uint)(subStreams.NotNull().Select(s => s.Length).Sum()));
streams[worldspaceCounter + 1] = new CompositeReadStream(worldTrib.AsEnumerable().And(subStreams), resetPositions: true);
});
PluginUtilityTranslation.CompileSetGroupLength(streams, groupBytes);
streamDepositArray[targetIndex] = new CompositeReadStream(streams, resetPositions: true);
}
public V8U8Image(byte[] imgData)
: this()
{
using (MemoryTributary stream = new MemoryTributary(imgData))
LoadImage(stream);
}
public System.Drawing.Bitmap ToWinFormsBitmap(int width = 0, int height = 0)
{
JpegBitmapEncoder encoder = new JpegBitmapEncoder();
BitmapImage bmp = ToImage(width: width, height: height);
BitmapFrame frame = BitmapFrame.Create(bmp);
encoder.Frames.Add(frame);
using (MemoryTributary ms = new MemoryTributary())
{
encoder.Save(ms);
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(ms);
return new System.Drawing.Bitmap(bitmap);
}
}
public CV8Elem(MemoryTributary pHeader, UInt32 HeaderSize, MemoryTributary pData, UInt32 DataSize, V8File UnpackedData, bool IsV8File, bool NeedUnpack, bool useTempFiles = false)
{
this.UnpackedData = UnpackedData;
this.IsV8File = IsV8File;
this.NeedUnpack = NeedUnpack;
this._objectId = Guid.NewGuid();
if (this.UnpackedData != null)
{
if (this.UnpackedData.OperationMode == Mode.FileSystem)
this.useTempFiles = true;
else if (this.UnpackedData.OperationMode == Mode.MemoryUsage)
this.useTempFiles = false;
else if (this.UnpackedData.OperationMode == Mode.Optimal)
{
if (this.DataSize > V8File.MAX_BLOCK_SIZE_IN_MEMORY_BYTES)
this.useTempFiles = true;
else
this.useTempFiles = false;
}
else
this.useTempFiles = false;
} else
this.useTempFiles = false;
if (!this.useTempFiles)
this.pHeader = pHeader.ToArray();
else
{
this.SetHeaderFromMemStream(pHeader);
}
this.HeaderSize = HeaderSize;
if(!this.useTempFiles)
this.pData = pData.ToArray();
else
{
this.SetDataFromMemStream(pData);
}
this.DataSize = DataSize;
}
