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 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; }