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 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 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);
}
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 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 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;
}
public void ME3PCCObjectHelper(MemoryTributary tempStream, string filePath, bool TablesOnly)
{
tempStream.Seek(0, SeekOrigin.Begin);
DataStream = new MemoryTributary();
tempStream.WriteTo(DataStream);
Names = new List<string>();
Imports = new List<ME3ImportEntry>();
Exports = new List<ME3ExportEntry>();
header = tempStream.ReadBytes(headerSize);
if (magic != ZBlock.magic &&
magic.Swap() != ZBlock.magic)
throw new FormatException(filePath + " is not a pcc file");
if (lowVers != 684 && highVers != 194)
throw new FormatException("unsupported version");
if (bCompressed)
{
// seeks the blocks info position
tempStream.Seek(idxOffsets + 60, SeekOrigin.Begin);
int generator = tempStream.ReadValueS32();
tempStream.Seek((generator * 12) + 20, SeekOrigin.Current);
int blockCount = tempStream.ReadValueS32();
blockList = new List<Block>();
// creating the Block list
for (int i = 0; i < blockCount; i++)
{
Block temp = new Block();
temp.uncOffset = tempStream.ReadValueS32();
temp.uncSize = tempStream.ReadValueS32();
temp.cprOffset = tempStream.ReadValueS32();
temp.cprSize = tempStream.ReadValueS32();
blockList.Add(temp);
}
// correcting the header, in case there's need to be saved
Buffer.BlockCopy(BitConverter.GetBytes((int)0), 0, header, header.Length - 12, sizeof(int));
tempStream.Read(header, header.Length - 8, 8);
headerEnd = (int)tempStream.Position;
// copying the extraNamesList
int extraNamesLenght = blockList[0].cprOffset - headerEnd;
if (extraNamesLenght > 0)
{
extraNamesList = new byte[extraNamesLenght];
tempStream.Read(extraNamesList, 0, extraNamesLenght);
//FileStream fileStream = File.Create(Path.GetDirectoryName(pccFileName) + "\\temp.bin");
//fileStream.Write(extraNamesList, 0, extraNamesLenght);
//MessageBox.Show("posizione: " + pccStream.Position.ToString("X8"));
}
int dataStart = 0;
using (MemoryStream he = new MemoryStream(header))
{
he.Seek(0, SeekOrigin.Begin);
he.ReadValueS32();
he.ReadValueS32();
dataStart = he.ReadValueS32();
}
if (TablesOnly)
{
int TableStart = 0;
for (int m = 0; m < blockList.Count; m++)
{
if (blockList[m].uncOffset + blockList[m].uncSize > dataStart)
{
TableStart = m;
break;
}
}
listsStream = new MemoryTributary();
tempStream.Seek(blockList[TableStart].cprOffset, SeekOrigin.Begin);
listsStream.Seek(blockList[TableStart].uncOffset, SeekOrigin.Begin);
listsStream.WriteBytes(ZBlock.Decompress(tempStream, blockList[TableStart].cprSize));
DataStream = new MemoryTributary();
tempStream.WriteTo(DataStream);
bCompressed = true;
}
else
{
//Decompress ALL blocks
listsStream = new MemoryTributary();
for (int i = 0; i < blockCount; i++)
{
tempStream.Seek(blockList[i].cprOffset, SeekOrigin.Begin);
listsStream.Seek(blockList[i].uncOffset, SeekOrigin.Begin);
listsStream.WriteBytes(ZBlock.Decompress(tempStream, blockList[i].cprSize));
}
}
bCompressed = false;
}
else
{
listsStream = new MemoryTributary();
listsStream.WriteBytes(tempStream.ToArray());
}
tempStream.Dispose();
//Fill name list
listsStream.Seek(NameOffset, SeekOrigin.Begin);
for (int i = 0; i < NameCount; i++)
{
int strLength = listsStream.ReadValueS32();
Names.Add(listsStream.ReadString(strLength * -2, true, Encoding.Unicode));
}
// fill import list
listsStream.Seek(ImportOffset, SeekOrigin.Begin);
byte[] buffer = new byte[ME3ImportEntry.byteSize];
for (int i = 0; i < ImportCount; i++)
{
Imports.Add(new ME3ImportEntry(this, listsStream));
}
//fill export list
listsStream.Seek(ExportOffset, SeekOrigin.Begin);
for (int i = 0; i < ExportCount; i++)
{
uint expInfoOffset = (uint)listsStream.Position;
listsStream.Seek(44, SeekOrigin.Current);
int count = listsStream.ReadValueS32();
listsStream.Seek(-48, SeekOrigin.Current);
int expInfoSize = 68 + (count * 4);
buffer = new byte[expInfoSize];
listsStream.Read(buffer, 0, buffer.Length);
Exports.Add(new ME3ExportEntry(this, buffer, expInfoOffset));
}
}
