public void extractImage(ImageInfo imgInfo, string archiveDir = null, string fileName = null)
{
ImageFile imgFile;
if (fileName == null)
{
fileName = texName + "_" + imgInfo.imgSize + getFileFormat();
}
byte[] imgBuffer;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
case storage.arcCpr:
case storage.arcUnc:
string archivePath = archiveDir + "\\" + arcName + ".tfc";
if (!File.Exists(archivePath))
{
throw new FileNotFoundException("Texture archive not found in " + archivePath);
}
using (FileStream archiveStream = File.OpenRead(archivePath))
{
archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Decompress(archiveStream, imgInfo.cprSize);
}
else
{
imgBuffer = new byte[imgInfo.uncSize];
archiveStream.Read(imgBuffer, 0, imgBuffer.Length);
}
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
if (getFileFormat() == ".dds")
{
imgFile = new DDS(fileName, imgInfo.imgSize, texFormat, imgBuffer);
}
else
{
imgFile = new TGA(fileName, imgInfo.imgSize, texFormat, imgBuffer);
}
byte[] saveImg = imgFile.ToArray();
using (FileStream outputImg = new FileStream(imgFile.fileName, FileMode.Create, FileAccess.Write))
outputImg.Write(saveImg, 0, saveImg.Length);
}
public static void resetColors()
{
OBlock.resetColor();
IBlock.resetColor();
TBlock.resetColor();
JBlock.resetColor();
LBlock.resetColor();
SBlock.resetColor();
ZBlock.resetColor();
}
private void DiscardColors(OptionArgs args)
{
OBlock.resetColor();
IBlock.resetColor();
TBlock.resetColor();
JBlock.resetColor();
LBlock.resetColor();
SBlock.resetColor();
ZBlock.resetColor();
ColorData.saveColors();
}
private void Reset(OptionArgs args)
{
BlockType.textureAsset = "Game/Bricks/Cat-Eye Brick";
OBlock.resetColor();
IBlock.resetColor();
TBlock.resetColor();
JBlock.resetColor();
LBlock.resetColor();
SBlock.resetColor();
ZBlock.resetColor();
ColorData.saveColors();
}
/// <summary>
/// given export data offset, the function recovers it from the file.
/// </summary>
/// <param name="offset">offset position of desired export data</param>
private void getData(int offset, ExportEntry exp = null)
{
byte[] buffer;
if (bCompressed)
{
Block selected = blockList.Find(block => block.uncOffset <= offset && block.uncOffset + block.uncSize > offset);
byte[] uncBlock;
using (FileStream pccStream = File.OpenRead(pccFileName))
{
pccStream.Seek(selected.cprOffset, SeekOrigin.Begin);
uncBlock = ZBlock.Decompress(pccStream, selected.cprSize);
// the selected block has been read
selected.bRead = true;
}
// fill all the exports data extracted from the uncBlock
foreach (ExportEntry expInfo in Exports)
{
if (expInfo.DataOffset >= selected.uncOffset && expInfo.DataOffset + expInfo.DataSize <= selected.uncOffset + selected.uncSize)
{
buffer = new byte[expInfo.DataSize];
Buffer.BlockCopy(uncBlock, expInfo.DataOffset - selected.uncOffset, buffer, 0, expInfo.DataSize);
expInfo.Data = buffer;
}
}
}
else
{
ExportEntry expSelect;
if (exp == null)
{
int expIndex = Exports.FindIndex(export => export.DataOffset <= offset && export.DataOffset + export.DataSize > offset);
expSelect = Exports[expIndex];
}
else
{
expSelect = exp;
}
using (FileStream pccStream = File.OpenRead(pccFileName))
{
buffer = new byte[expSelect.DataSize];
pccStream.Seek(expSelect.DataOffset, SeekOrigin.Begin);
pccStream.Read(buffer, 0, buffer.Length);
expSelect.Data = buffer;
}
}
}
private LongIntComboListPart(int capacity)
{
ZBlock.CleanZBlockFiles("unsorted", "sorted");
b12buffer = new List <B12>(0);
this.enums = new LongIntComboListPartEnumerator[32];
// Pre-set with defaults.
int numzblocks = 139;
int zblockbufsize = 131072; // 128 KB default.
if (null != DistributedObjectsSlave.xslave)
{
System.Xml.XmlNode xzblocks = DistributedObjectsSlave.xslave["zblocks"];
if (null != xzblocks)
{
{
System.Xml.XmlAttribute xnzb = xzblocks.Attributes["count"];
if (null != xnzb)
{
numzblocks = int.Parse(xnzb.Value);
}
}
{
System.Xml.XmlAttribute xzbs = xzblocks.Attributes["addbuffersize"];
if (null != xzbs)
{
zblockbufsize = DistributedObjectsSlave.ParseCapacity(xzbs.Value);
}
}
}
}
if (XLog.logging)
{
XLog.log("Creating " + numzblocks.ToString() + " ZBlock`s");
}
zblocks = new ZBlock[numzblocks];
for (int i = 0; i != numzblocks; i++)
{
zblocks[i] = new ZBlock(this, i, zblockbufsize);
}
}
public byte[] extractRawData(ImageInfo imgInfo, string archiveDir = null)
{
byte[] imgBuffer;
switch (imgInfo.storageType)
{
case storage.pccSto:
imgBuffer = new byte[imgInfo.uncSize];
System.Buffer.BlockCopy(imageData, imgInfo.offset, imgBuffer, 0, imgInfo.uncSize);
break;
case storage.arcCpr:
case storage.arcUnc:
string archivePath = GetTFC(arcName);
if (archivePath != null && File.Exists(archivePath))
{
Console.WriteLine("Loaded texture from tfc '" + archivePath + "'.");
using (FileStream archiveStream = File.OpenRead(archivePath))
{
archiveStream.Seek(imgInfo.offset, SeekOrigin.Begin);
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Decompress(archiveStream, imgInfo.cprSize);
}
else
{
imgBuffer = new byte[imgInfo.uncSize];
archiveStream.Read(imgBuffer, 0, imgBuffer.Length);
}
}
}
else
{
//how do i put default unreal texture
imgBuffer = null; //this will cause exception that will bubble up.
}
break;
default:
throw new FormatException("Unsupported texture storage type");
}
return(imgBuffer); //cannot be uninitialized.
}
BlockType randomize()
{
BlockType randomBlock;
switch (random.Next(1, 8))
{
case 1:
randomBlock = new OBlock();
break;
case 2:
randomBlock = new IBlock();
break;
case 3:
randomBlock = new TBlock();
break;
case 4:
randomBlock = new LBlock();
break;
case 5:
randomBlock = new JBlock();
break;
case 6:
randomBlock = new SBlock();
break;
case 7:
randomBlock = new ZBlock();
break;
default:
randomBlock = new LBlock();
break;
}
randomBlock.load(Game.Content);
return(randomBlock);
}
public static void CleanZBlockFiles(params string[] otherinfos)
{
// Clean any potential old zblock files...
bool found = true;
for (int i = 0; found; i++)
{
found = false;
foreach (string otherinfo in otherinfos)
{
string fn = ZBlock.CreateFileName(i, otherinfo);
if (System.IO.File.Exists(fn))
{
System.IO.File.Delete(fn);
found = true;
}
}
}
}
/// <summary>
/// Generates a random block
/// </summary>
/// <param name="block">A reference to the Block object that will be affected</param>
private void GenerateBlock(ref Block block)
{
switch (random.Next(0, 7))
{
case 0:
block = new IBlock();
break;
case 1:
block = new LBlock();
break;
case 2:
block = new RLBlock();
break;
case 3:
block = new SBlock();
break;
case 4:
block = new SquareBlock();
break;
case 5:
block = new TBlock();
break;
case 6:
block = new ZBlock();
break;
default:
throw new ArgumentException("Bad block type!");
}
}
/// <summary>
/// decompress an entire pcc file.
/// </summary>
/// <param name="input">pcc file passed in stream format</param>
/// <returns>a decompressed array of bytes</returns>
public static byte[] Decompress(Stream input)
{
input.Seek(0, SeekOrigin.Begin);
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x9E2A83C1 &&
magic.Swap() != 0x9E2A83C1)
{
throw new FormatException("not a pcc file");
}
var endian = magic == 0x9E2A83C1 ? Endian.Little : Endian.Big;
var versionLo = input.ReadValueU16(endian);
var versionHi = input.ReadValueU16(endian);
if (versionLo != 684 &&
versionHi != 194)
{
throw new FormatException("unsupported pcc version");
}
long headerSize = 8;
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
var folderNameLength = input.ReadValueS32(endian);
headerSize += 4;
var folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
input.Seek(folderNameByteLength, SeekOrigin.Current);
headerSize += folderNameByteLength;
var packageFlagsOffset = input.Position;
var packageFlags = input.ReadValueU32(endian);
headerSize += 4;
if ((packageFlags & 0x02000000u) == 0)
{
throw new FormatException("pcc file is already decompressed");
}
if ((packageFlags & 8) != 0)
{
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
}
uint nameCount = input.ReadValueU32(endian);
uint nameOffset = input.ReadValueU32(endian);
input.Seek(52, SeekOrigin.Current);
headerSize += 60;
var generationsCount = input.ReadValueU32(endian);
input.Seek(generationsCount * 12, SeekOrigin.Current);
headerSize += generationsCount * 12;
input.Seek(20, SeekOrigin.Current);
headerSize += 24;
var blockCount = input.ReadValueU32(endian);
int headBlockOff = (int)input.Position;
var afterBlockTableOffset = headBlockOff + (blockCount * 16);
var indataOffset = afterBlockTableOffset + 8;
byte[] buff;
input.Seek(0, SeekOrigin.Begin);
using (MemoryStream output = new MemoryStream())
{
output.Seek(0, SeekOrigin.Begin);
output.WriteFromStream(input, headerSize);
output.WriteValueU32(0, endian); // block count
input.Seek(afterBlockTableOffset, SeekOrigin.Begin);
output.WriteFromStream(input, 8);
//check if has extra name list (don't know it's usage...)
if ((packageFlags & 0x10000000) != 0)
{
long curPos = output.Position;
output.WriteFromStream(input, nameOffset - curPos);
}
for (int i = 0; i < blockCount; i++)
{
input.Seek(headBlockOff, SeekOrigin.Begin);
var uncompressedOffset = input.ReadValueU32(endian);
var uncompressedSize = input.ReadValueU32(endian);
var compressedOffset = input.ReadValueU32(endian);
var compressedSize = input.ReadValueU32(endian);
headBlockOff = (int)input.Position;
buff = new byte[compressedSize];
input.Seek(compressedOffset, SeekOrigin.Begin);
input.Read(buff, 0, buff.Length);
byte[] temp = ZBlock.Decompress(buff, 0, buff.Length);
output.Seek(uncompressedOffset, SeekOrigin.Begin);
output.Write(temp, 0, temp.Length);
}
output.Seek(packageFlagsOffset, SeekOrigin.Begin);
output.WriteValueU32(packageFlags & ~0x02000000u, endian);
return(output.ToArray());
}
}
/// <summary>
/// compress an entire pcc into a byte array.
/// </summary>
/// <param name="uncompressedPcc">uncompressed pcc stream.</param>
/// <returns>a compressed array of bytes.</returns>
public static Stream Compress(Stream uncompressedPcc)
{
uncompressedPcc.Position = 0;
var magic = uncompressedPcc.ReadValueU32(Endian.Little);
if (magic != 0x9E2A83C1 &&
magic.Swap() != 0x9E2A83C1)
{
throw new FormatException("not a pcc package");
}
var endian = magic == 0x9E2A83C1 ?
Endian.Little : Endian.Big;
var encoding = endian == Endian.Little ?
Encoding.Unicode : Encoding.BigEndianUnicode;
var versionLo = uncompressedPcc.ReadValueU16(endian);
var versionHi = uncompressedPcc.ReadValueU16(endian);
if (versionLo != 684 &&
versionHi != 194)
{
throw new FormatException("unsupported version");
}
uncompressedPcc.Seek(4, SeekOrigin.Current);
var folderNameLength = uncompressedPcc.ReadValueS32(endian);
var folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
uncompressedPcc.Seek(folderNameByteLength, SeekOrigin.Current);
var packageFlagsOffset = uncompressedPcc.Position;
var packageFlags = uncompressedPcc.ReadValueU32(endian);
if ((packageFlags & 8) != 0)
{
uncompressedPcc.Seek(4, SeekOrigin.Current);
}
var nameCount = uncompressedPcc.ReadValueU32(endian);
var namesOffset = uncompressedPcc.ReadValueU32(endian);
var exportCount = uncompressedPcc.ReadValueU32(endian);
var exportInfosOffset = uncompressedPcc.ReadValueU32(endian);
SortedDictionary <uint, uint> exportDataOffsets = new SortedDictionary <uint, uint>();
Stream data;
if ((packageFlags & 0x02000000) == 0)
{
data = uncompressedPcc;
}
else
{
throw new FormatException("pcc data is compressed");
}
// get info about export data, sizes and offsets
data.Seek(exportInfosOffset, SeekOrigin.Begin);
for (uint i = 0; i < exportCount; i++)
{
var classIndex = data.ReadValueS32(endian);
data.Seek(4, SeekOrigin.Current);
var outerIndex = data.ReadValueS32(endian);
var objectNameIndex = data.ReadValueS32(endian);
data.Seek(16, SeekOrigin.Current);
uint exportDataSize = data.ReadValueU32(endian);
uint exportDataOffset = data.ReadValueU32(endian);
exportDataOffsets.Add(exportDataOffset, exportDataSize);
data.Seek(4, SeekOrigin.Current);
var count = data.ReadValueU32(endian);
data.Seek(count * 4, SeekOrigin.Current);
data.Seek(20, SeekOrigin.Current);
}
const uint maxBlockSize = 0x100000;
Stream outputStream = new MemoryStream();
// copying pcc header
byte[] buffer = new byte[130];
uncompressedPcc.Seek(0, SeekOrigin.Begin);
uncompressedPcc.Read(buffer, 0, 130);
outputStream.Write(buffer, 0, buffer.Length);
//add compressed pcc flag
uncompressedPcc.Seek(12, SeekOrigin.Begin);
folderNameLength = uncompressedPcc.ReadValueS32();
folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
uncompressedPcc.Seek(folderNameByteLength, SeekOrigin.Current);
outputStream.Seek(uncompressedPcc.Position, SeekOrigin.Begin);
packageFlags = uncompressedPcc.ReadValueU32();
packageFlags |= 0x02000000; // add compression flag
outputStream.WriteValueU32(packageFlags);
outputStream.Seek(buffer.Length, SeekOrigin.Begin);
long outOffsetData;
long outOffsetBlockInfo;
long inOffsetData = namesOffset;
List <int> blockSizes = new List <int>();
int countSize = (int)(exportDataOffsets.Min(obj => obj.Key) - namesOffset);
//count the number of blocks and relative sizes
uint lastOffset = exportDataOffsets.Min(obj => obj.Key);
foreach (KeyValuePair <uint, uint> exportInfo in exportDataOffsets)
{
// part that adds empty spaces (leaved when editing export data and moved to the end of pcc) into the count
if (exportInfo.Key != lastOffset)
{
int emptySpace = (int)(exportInfo.Key - lastOffset);
if (countSize + emptySpace > maxBlockSize)
{
blockSizes.Add(countSize);
countSize = 0;
}
else
{
countSize += emptySpace;
}
}
// adds export data into the count
if (countSize + exportInfo.Value > maxBlockSize)
{
blockSizes.Add(countSize);
countSize = (int)exportInfo.Value;
}
else
{
countSize += (int)exportInfo.Value;
}
lastOffset = exportInfo.Key + exportInfo.Value;
}
blockSizes.Add(countSize);
outputStream.WriteValueS32(blockSizes.Count);
outOffsetBlockInfo = outputStream.Position;
outOffsetData = namesOffset + (blockSizes.Count * 16);
uncompressedPcc.Seek(namesOffset, SeekOrigin.Begin);
//divide the block in segments
for (int i = 0; i < blockSizes.Count; i++)
{
int currentUncBlockSize = blockSizes[i];
outputStream.Seek(outOffsetBlockInfo, SeekOrigin.Begin);
outputStream.WriteValueU32((uint)uncompressedPcc.Position);
outputStream.WriteValueS32(currentUncBlockSize);
outputStream.WriteValueU32((uint)outOffsetData);
byte[] inputBlock = new byte[currentUncBlockSize];
uncompressedPcc.Read(inputBlock, 0, currentUncBlockSize);
byte[] compressedBlock = ZBlock.Compress(inputBlock, 0, inputBlock.Length);
outputStream.WriteValueS32(compressedBlock.Length);
outOffsetBlockInfo = outputStream.Position;
outputStream.Seek(outOffsetData, SeekOrigin.Begin);
outputStream.Write(compressedBlock, 0, compressedBlock.Length);
outOffsetData = outputStream.Position;
}
//copying some unknown values + extra names list
int bufferSize = (int)namesOffset - 0x86;
buffer = new byte[bufferSize];
uncompressedPcc.Seek(0x86, SeekOrigin.Begin);
uncompressedPcc.Read(buffer, 0, buffer.Length);
outputStream.Seek(outOffsetBlockInfo, SeekOrigin.Begin);
outputStream.Write(buffer, 0, buffer.Length);
outputStream.Seek(0, SeekOrigin.Begin);
return(outputStream);
}
/// <summary>
/// PCCObject class constructor. It also load namelist, importlist and exportinfo (not exportdata) from pcc file
/// </summary>
/// <param name="pccFilePath">full path + file name of desired pcc file.</param>
public PCCObject(string pccFilePath, bool fullFileInMemory = false)
{
Loaded = true;
pccFileName = Path.GetFullPath(pccFilePath);
Debug.WriteLine("Loading pcc " + pccFileName);
using (FileStream pccStream = File.OpenRead(pccFileName))
{
Names = new List <string>();
Imports = new List <ImportEntry>();
Exports = new List <ExportEntry>();
pccStream.Read(header, 0, header.Length);
if (magic != ZBlock.magic &&
magic.Swap() != ZBlock.magic)
{
throw new FormatException("not a pcc file");
}
// BitConverter isn't working?!?!
if (magic == 0x9E2A83C1)
{
BitConverter.IsLittleEndian = true;
}
else
{
BitConverter.IsLittleEndian = true;
}
if (lowVers != 684 && highVers != 194)
{
throw new FormatException("unsupported version");
}
Stream listsStream;
if (bCompressed)
{
Debug.WriteLine("COMPRESSED...");
// seeks the blocks info position
pccStream.Seek(idxOffsets + 60, SeekOrigin.Begin);
int generator = pccStream.ReadValueS32();
pccStream.Seek((generator * 12) + 20, SeekOrigin.Current);
int blockCount = pccStream.ReadValueS32();
blockList = new List <Block>();
// creating the Block list
for (int i = 0; i < blockCount; i++)
{
Block temp = new Block();
temp.uncOffset = pccStream.ReadValueS32();
temp.uncSize = pccStream.ReadValueS32();
temp.cprOffset = pccStream.ReadValueS32();
temp.cprSize = pccStream.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));
pccStream.Read(header, header.Length - 8, 8);
headerEnd = (int)pccStream.Position;
// copying the extraNamesList
int extraNamesLenght = blockList[0].cprOffset - headerEnd;
if (extraNamesLenght > 0)
{
extraNamesList = new byte[extraNamesLenght];
pccStream.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"));
}
// decompress first block that holds infos about names, imports and exports
pccStream.Seek(blockList[0].cprOffset, SeekOrigin.Begin);
byte[] uncBlock = ZBlock.Decompress(pccStream, blockList[0].cprSize);
// write decompressed block inside temporary stream
listsStream = new MemoryStream();
listsStream.Seek(blockList[0].uncOffset, SeekOrigin.Begin);
listsStream.Write(uncBlock, 0, uncBlock.Length);
}
else
{
listsStream = pccStream;
headerEnd = (int)NameOffset;
// copying the extraNamesList
int extraNamesLenght = headerEnd - headerSize;
if (extraNamesLenght > 0)
{
extraNamesList = new byte[extraNamesLenght];
listsStream.Seek(headerSize, SeekOrigin.Begin);
listsStream.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"));
}
}
/*if(bExtraNamesList)
* {
* int extraNamesListSize = namesOffset - headerEnd;
* extraNamesList = new byte[extraNamesListSize];
* pccStream.Seek(headerEnd, SeekOrigin.Begin);
* pccStream.Read(extraNamesList, 0, extraNamesList.Length);
* }*/
// fill names list
listsStream.Seek(NameOffset, SeekOrigin.Begin);
for (int i = 0; i < NameCount; i++)
{
long currOffset = listsStream.Position;
int strLength = listsStream.ReadValueS32();
string str = listsStream.ReadString(strLength * -2, true, Encoding.Unicode);
//Debug.WriteLine("Read name "+i+" "+str+" length: " + strLength+", offset: "+currOffset);
Names.Add(str);
}
//Debug.WriteLine("Names done. Current offset: "+listsStream.Position);
//Debug.WriteLine("Import Offset: " + ImportOffset);
// fill import list
//Console.Out.WriteLine("IMPORT OFFSET: " + ImportOffset);
listsStream.Seek(ImportOffset, SeekOrigin.Begin);
byte[] buffer = new byte[ImportEntry.byteSize];
for (int i = 0; i < ImportCount; i++)
{
long offset = listsStream.Position;
ImportEntry e = new ImportEntry(this, listsStream);
Imports.Add(e);
//Debug.WriteLine("Read import " + i + " " + e.ObjectName + ", offset: " + offset);
}
;
// fill export list (only the headers, not the data)
listsStream.Seek(ExportOffset, SeekOrigin.Begin);
//Console.Out.WriteLine("Export OFFSET: " + ImportOffset);
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);
ExportEntry e = new ExportEntry(this, buffer, expInfoOffset);
//Debug.WriteLine("Read export " + i + " " + e.ObjectName + ", offset: " + expInfoOffset+ ", size: "+expInfoSize);
Exports.Add(e);
}
}
//Debug.WriteLine(getMetadataString());
}
// KFreon: Decompresses specific blocks if compressed, or returns data specified by offset and length.
public byte[] Decompressor(uint offset, int length)
{
using (MemoryStream retval = new MemoryStream())
{
uint newoffset = 0;
/*if (blockList.Count == 1)
* bCompressed = false;*/
/*if (bCompressed)
* {*/
// KFreon: Find datablocks to decompress
int DataStart = 0;
int DataEnd = 0;
int got = 0;
for (int m = 0; m < blockList.Count; m++)
{
if (got == 0 && blockList[m].uncOffset + blockList[m].uncSize > offset)
{
DataStart = m;
got++;
}
if (got == 1 && blockList[m].uncOffset + blockList[m].uncSize > offset + length)
{
DataEnd = m;
got++;
}
if (got == 2)
{
break;
}
}
if (DataEnd == 0 && DataStart != 0)
{
DataEnd = DataStart;
}
/*// KFreon: Move end along so as able to read
* if (DataStart == DataEnd)
* DataEnd++;*/
// KFreon: Decompress blocks
newoffset = offset - (uint)blockList[DataStart].uncOffset;
for (int i = DataStart; i <= DataEnd; i++)
{
DataStream.Seek(blockList[i].cprOffset, SeekOrigin.Begin);
//retval.Seek(blockList[i].uncOffset, SeekOrigin.Begin);
retval.WriteBytes(ZBlock.Decompress(DataStream, blockList[i].cprSize));
}
/*}
* else
* {
* listsStream.Seek(offset, SeekOrigin.Begin);
* retval.ReadFrom(listsStream, length);
* newoffset = 0;
* }*/
//retval.Seek(offset, SeekOrigin.Begin);
retval.Seek(newoffset, SeekOrigin.Begin);
return(retval.ReadBytes(length));
}
}
public void ME3PCCObjectHelper(MemoryStream tempStream, string filePath, bool TablesOnly)
{
tempStream.Seek(0, SeekOrigin.Begin);
DataStream = new MemoryStream();
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(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 MemoryStream();
tempStream.Seek(blockList[TableStart].cprOffset, SeekOrigin.Begin);
listsStream.Seek(blockList[TableStart].uncOffset, SeekOrigin.Begin);
listsStream.WriteBytes(ZBlock.Decompress(tempStream, blockList[TableStart].cprSize));
DataStream = new MemoryStream();
tempStream.WriteTo(DataStream);
bCompressed = true;
}
else
{
//Decompress ALL blocks
listsStream = new MemoryStream();
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 MemoryStream();
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));
}
}
/// <summary>
/// decompress an entire ME3 pcc file into a new stream
/// </summary>
/// <param name="input">pcc file passed in stream format</param>
/// <returns>a decompressed array of bytes</returns>
public static MemoryStream DecompressME3(Stream input)
{
input.Seek(0, SeekOrigin.Begin);
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x9E2A83C1 &&
magic.Swap() != 0x9E2A83C1)
{
throw new FormatException("not a pcc file");
}
var endian = magic == 0x9E2A83C1 ? Endian.Little : Endian.Big;
var versionLo = input.ReadValueU16(endian);
var versionHi = input.ReadValueU16(endian);
if (versionLo != 684 &&
versionHi != 194)
{
throw new FormatException("unsupported pcc version");
}
long headerSize = 8;
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
var folderNameLength = input.ReadValueS32(endian);
headerSize += 4;
var folderNameByteLength =
folderNameLength >= 0 ? folderNameLength : (-folderNameLength * 2);
input.Seek(folderNameByteLength, SeekOrigin.Current);
headerSize += folderNameByteLength;
var packageFlagsOffset = input.Position;
var packageFlags = input.ReadValueU32(endian);
headerSize += 4;
if ((packageFlags & 0x02000000u) == 0)
{
throw new FormatException("pcc file is already decompressed");
}
if ((packageFlags & 8) != 0)
{
input.Seek(4, SeekOrigin.Current);
headerSize += 4;
}
uint nameCount = input.ReadValueU32(endian);
uint nameOffset = input.ReadValueU32(endian);
input.Seek(52, SeekOrigin.Current);
headerSize += 60;
var generationsCount = input.ReadValueU32(endian);
input.Seek(generationsCount * 12, SeekOrigin.Current);
headerSize += generationsCount * 12;
input.Seek(20, SeekOrigin.Current);
headerSize += 24;
var blockCount = input.ReadValueU32(endian);
int headBlockOff = (int)input.Position;
var afterBlockTableOffset = headBlockOff + (blockCount * 16);
var indataOffset = afterBlockTableOffset + 8;
byte[] buff;
input.Seek(0, SeekOrigin.Begin);
MemoryStream output = new MemoryStream();
output.Seek(0, SeekOrigin.Begin);
output.WriteFromStream(input, headerSize);
output.WriteValueU32(0, endian); // block count
input.Seek(afterBlockTableOffset, SeekOrigin.Begin);
output.WriteFromStream(input, 8);
//check if has extra name list (don't know it's usage...)
if ((packageFlags & 0x10000000) != 0)
{
long curPos = output.Position;
output.WriteFromStream(input, nameOffset - curPos);
}
//decompress blocks in parallel
Task <byte[]>[] tasks = new Task <byte[]> [blockCount];
uint[] uncompressedOffsets = new uint[blockCount];
for (int i = 0; i < blockCount; i++)
{
input.Seek(headBlockOff, SeekOrigin.Begin);
uncompressedOffsets[i] = input.ReadValueU32(endian);
var uncompressedSize = input.ReadValueU32(endian);
var compressedOffset = input.ReadValueU32(endian);
var compressedSize = input.ReadValueU32(endian);
headBlockOff = (int)input.Position;
buff = new byte[compressedSize];
input.Seek(compressedOffset, SeekOrigin.Begin);
input.Read(buff, 0, buff.Length);
tasks[i] = ZBlock.DecompressAsync(buff);
}
Task.WaitAll(tasks);
for (int i = 0; i < blockCount; i++)
{
output.Seek(uncompressedOffsets[i], SeekOrigin.Begin);
output.WriteBytes(tasks[i].Result);
}
//Do not change the IsCompressed bit as it will not accurately reflect the state of the file on disk.
//output.Seek(packageFlagsOffset, SeekOrigin.Begin);
//output.WriteValueU32(packageFlags & ~0x02000000u, endian); //Mark file as decompressed.
return(output);
}
public void replaceImage(string strImgSize, string fileToReplace, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!imgList.Exists(img => img.imgSize == imgSize))
{
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
}
int imageIdx = imgList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = imgList[imageIdx];
if (!File.Exists(fileToReplace))
{
throw new FileNotFoundException("invalid file to replace: " + fileToReplace);
}
// check if replacing image is supported
ImageFile imgFile;
string fileFormat = Path.GetExtension(fileToReplace);
switch (fileFormat)
{
case ".dds": imgFile = new DDS(fileToReplace, null); break;
case ".tga": imgFile = new TGA(fileToReplace, null); break;
default: throw new FileFormatException(fileFormat + " image extension not supported");
}
// check if images have same format type
if (texFormat != imgFile.format)
{
DialogResult selection = MessageBox.Show("Warning, replacing image has format " + imgFile.subtype() + " while original has " + texFormat + ", would you like to replace it anyway?", "Warning, different image format found", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (selection == DialogResult.Yes)
{
imgFile.format = texFormat;
}
else
{
return;
}
//throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
}
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = imgList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
string archivePath = archiveDir + "\\" + arcName + ".tfc";
if (!File.Exists(archivePath))
{
throw new FileNotFoundException("Texture archive not found in " + archivePath);
}
if (getFileFormat() == ".tga")
{
imgBuffer = imgFile.resize(); // shrink image to essential data
}
else
{
imgBuffer = imgFile.imgData;
}
if (imgBuffer.Length != imgInfo.uncSize)
{
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
}
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Compress(imgBuffer);
/*byte[] compressed = ZBlock.Compress(imgBuffer);
* archiveStream.Write(compressed, 0, compressed.Length);*/
imgInfo.cprSize = imgBuffer.Length;
}
//else
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.imgData; // copy image data as-is
if (imgBuffer.Length != imgInfo.uncSize)
{
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
}
using (MemoryStream dataStream = new MemoryStream(imageData))
{
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
dataStream.Write(imgBuffer, 0, imgBuffer.Length);
}
break;
}
imgList[imageIdx] = imgInfo;
}
public void replaceImage(string strImgSize, ImageFile im, string archiveDir)
{
ImageSize imgSize = ImageSize.stringToSize(strImgSize);
if (!imgList.Exists(img => img.imgSize == imgSize))
{
throw new FileNotFoundException("Image with resolution " + imgSize + " isn't found");
}
int imageIdx = privateImageList.FindIndex(img => img.imgSize == imgSize);
ImageInfo imgInfo = privateImageList[imageIdx];
ImageFile imgFile = im;
ImageEngineFormat imgFileFormat = Textures.Methods.ParseFormat(imgFile.format);
// check if images have same format type
if (texFormat != imgFileFormat)
{
bool res = KFreonLib.Misc.Methods.DisplayYesNoDialogBox("Warning, replacing image has format " + imgFile.subtype() + " while original has " + texFormat + ", would you like to replace it anyway?", "Warning, different image format found");
if (res)
{
imgFile.format = Textures.Methods.StringifyFormat(texFormat);
}
else
{
return;
}
//throw new FormatException("Different image format, original is " + texFormat + ", new is " + imgFile.subtype());
}
byte[] imgBuffer;
// if the image is empty then recover the archive compression from the image list
if (imgInfo.storageType == storage.empty)
{
imgInfo.storageType = privateImageList.Find(img => img.storageType != storage.empty && img.storageType != storage.pccSto).storageType;
imgInfo.uncSize = imgFile.resize().Length;
imgInfo.cprSize = imgFile.resize().Length;
}
switch (imgInfo.storageType)
{
case storage.arcCpr:
case storage.arcUnc:
string archivePath = archiveDir + "\\" + arcName + ".tfc";
if (!File.Exists(archivePath))
{
throw new FileNotFoundException("Texture archive not found in " + archivePath);
}
if (getFileFormat() == ".tga")
{
imgBuffer = imgFile.resize(); // shrink image to essential data
}
else
{
imgBuffer = imgFile.imgData;
}
if (imgBuffer.Length != imgInfo.uncSize)
{
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
}
using (FileStream archiveStream = new FileStream(archivePath, FileMode.Append, FileAccess.Write))
{
int newOffset = (int)archiveStream.Position;
if (imgInfo.storageType == storage.arcCpr)
{
imgBuffer = ZBlock.Compress(imgBuffer);
/*byte[] compressed = ZBlock.Compress(imgBuffer);
* archiveStream.Write(compressed, 0, compressed.Length);*/
imgInfo.cprSize = imgBuffer.Length;
}
//else
archiveStream.Write(imgBuffer, 0, imgBuffer.Length);
imgInfo.offset = newOffset;
}
break;
case storage.pccSto:
imgBuffer = imgFile.imgData; // copy image data as-is
if (imgBuffer.Length != imgInfo.uncSize)
{
throw new FormatException("image sizes do not match, original is " + imgInfo.uncSize + ", new is " + imgBuffer.Length);
}
using (MemoryStream dataStream = new MemoryStream(imageData))
{
dataStream.Seek(imgInfo.offset, SeekOrigin.Begin);
dataStream.Write(imgBuffer, 0, imgBuffer.Length);
}
break;
}
imgList[imageIdx] = imgInfo;
}
private LongIntComboListPart(int capacity)
{
ZBlock.CleanZBlockFiles("unsorted", "sorted");
b12buffer = new List<B12>(0);
this.enums = new LongIntComboListPartEnumerator[32];
// Pre-set with defaults.
int numzblocks = 139;
int zblockbufsize = 131072; // 128 KB default.
if (null != DistributedObjectsSlave.xslave)
{
System.Xml.XmlNode xzblocks = DistributedObjectsSlave.xslave["zblocks"];
if (null != xzblocks)
{
{
System.Xml.XmlAttribute xnzb = xzblocks.Attributes["count"];
if (null != xnzb)
{
numzblocks = int.Parse(xnzb.Value);
}
}
{
System.Xml.XmlAttribute xzbs = xzblocks.Attributes["addbuffersize"];
if (null != xzbs)
{
zblockbufsize = DistributedObjectsSlave.ParseCapacity(xzbs.Value);
}
}
}
}
if (XLog.logging)
{
XLog.log("Creating " + numzblocks.ToString() + " ZBlock`s");
}
zblocks = new ZBlock[numzblocks];
for (int i = 0; i != numzblocks; i++)
{
zblocks[i] = new ZBlock(this, i, zblockbufsize);
}
}
public void ImportFromFile(int tfc)
{
OpenFileDialog Dialog = new OpenFileDialog();
if (T2D.PixelFormat == "PF_DXT1\0" ||
T2D.PixelFormat == "PF_DXT5\0")
{
Dialog.Filter = "DDS Files (*.dds)|*.dds";
}
if (T2D.PixelFormat == "PF_G8\0" ||
T2D.PixelFormat == "PF_V8U8\0" ||
T2D.PixelFormat == "PF_A8R8G8B8\0")
{
Dialog.Filter = "TGA Files (*.tga)|*.tga";
}
int format = -1;
if (T2D.PixelFormat == "PF_DXT1\0")
{
format = 0;
}
if (T2D.PixelFormat == "PF_DXT5\0")
{
format = 1;
}
if (T2D.PixelFormat == "PF_V8U8\0")
{
format = 2;
}
if (T2D.PixelFormat == "PF_A8R8G8B8\0")
{
format = 3;
}
if (T2D.PixelFormat == "PF_G8\0")
{
format = 4;
}
if (!TextureTFCs[tfc].InCache)
{
if (Dialog.ShowDialog() == DialogResult.OK)
{
if (format == 0 || format == 1)
{
ImageFile t = new ImageFile();
t.ImportFromFile(Dialog.FileName);
if (t.ImageSizeX == TextureTFCs[tfc].sizeX &&
t.ImageSizeY == TextureTFCs[tfc].sizeY &&
t.ImageFormat == format &&
t.memsize == TextureTFCs[tfc].size)
{
for (int i = 0; i < t.memsize; i++)
{
memory[TextureTFCs[tfc].offset + i] = t.memory[i];
}
MessageBox.Show("Done.");
}
}
if (format > 1 && format < 5)
{
ImageFile t = new ImageFile();
t.ImportFromFile(Dialog.FileName);
if (t.ImageSizeX == TextureTFCs[tfc].sizeX &&
t.ImageSizeY == TextureTFCs[tfc].sizeY)
{
if (t.ImageBits != 32)
{
MessageBox.Show("Please use 32 bit Targa image!");
}
else
{
switch (format)
{
case 2:
for (int i = 0; i < t.memsize / 4; i++)
{
memory[TextureTFCs[tfc].offset + i * 2] = t.memory[i * 4];
memory[TextureTFCs[tfc].offset + i * 2 + 1] = t.memory[i * 4 + 2];
}
break;
case 3:
for (int i = 0; i < t.memsize; i++)
{
memory[TextureTFCs[tfc].offset + i] = t.memory[i];
}
break;
case 4:
for (int i = 0; i < t.memsize / 4; i++)
{
memory[TextureTFCs[tfc].offset + i] = t.memory[i * 4];
}
break;
}
MessageBox.Show("Done.");
}
}
}
}
}
else
if (Dialog.ShowDialog() == DialogResult.OK)
{
ImageFile t = new ImageFile();
t.ImportFromFile(Dialog.FileName);
if ((format == 0 || format == 1) && t.ImageFormat == format)
{
if (t.ImageSizeX == TextureTFCs[tfc].sizeX &&
t.ImageSizeY == TextureTFCs[tfc].sizeY)
{
TFCFile TFCf = new TFCFile(T2D.Tsource);
byte[] buff;
if (TFCf.isTFCCompressed())
{
buff = ZBlock.Compress(t.memory);
}
else
{
buff = t.memory;
}
byte[] buff2 = BitConverter.GetBytes(TFCf.getFileSize());
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 20 + i] = buff2[i];
}
buff2 = BitConverter.GetBytes(buff.Length);
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 16 + i] = buff2[i];
}
TFCf.AppendToTFC(buff);
int size = TFCf.getFileSize();
if (size != -1)
{
TOCeditor tc = new TOCeditor();
if (!tc.UpdateFile(T2D.Tsource + ".tfc", (uint)size))
{
MessageBox.Show("Didn't found Entry");
}
tc.Close();
}
}
else
{
System.Windows.Forms.DialogResult m = MessageBox.Show("The size doesn't match, import anyway?", "ME3 Explorer", MessageBoxButtons.YesNo);
if (m == DialogResult.Yes)
{
TFCFile TFCf = new TFCFile(T2D.Tsource);
byte[] buff;
if (TFCf.isTFCCompressed())
{
buff = ZBlock.Compress(t.memory);
}
else
{
buff = t.memory;
}
byte[] buff2 = BitConverter.GetBytes(TFCf.getFileSize());
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 20 + i] = buff2[i];
}
buff2 = BitConverter.GetBytes(buff.Length);
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 16 + i] = buff2[i];
}
if (tfc == 0)
{
buff2 = BitConverter.GetBytes(t.ImageSizeX);
for (int i = 0; i < 4; i++)
{
memory[T2D.offSizeX + i] = buff2[i];
}
buff2 = BitConverter.GetBytes(t.ImageSizeY);
for (int i = 0; i < 4; i++)
{
memory[T2D.offSizeY + i] = buff2[i];
}
}
else
{
buff2 = BitConverter.GetBytes(t.ImageSizeX * 2);
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + i] = buff2[i];
}
buff2 = BitConverter.GetBytes(t.ImageSizeY * 2);
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 4 + i] = buff2[i];
}
TFCf.AppendToTFC(buff);
}
TFCf.AppendToTFC(buff);
int size = TFCf.getFileSize();
if (size != -1)
{
TOCeditor tc = new TOCeditor();
if (!tc.UpdateFile(T2D.Tsource + ".tfc", (uint)size))
{
MessageBox.Show("Didn't found Entry");
}
tc.Close();
}
}
}
}
if (format > 1 && format < 5)
{
if (t.ImageSizeX == TextureTFCs[tfc].sizeX &&
t.ImageSizeY == TextureTFCs[tfc].sizeY)
{
if (t.ImageBits != 32)
{
MessageBox.Show("Please use 32 bit Targa image!");
}
else
{
byte[] buf = new byte[0];
switch (format)
{
case 2:
buf = new byte[t.memsize / 2];
for (int i = 0; i < t.memsize / 4; i++)
{
buf[i * 2] = t.memory[i * 4];
buf[i * 2 + 1] = t.memory[i * 4 + 2];
}
break;
case 3:
buf = t.memory;
break;
case 4:
buf = new byte[t.memsize / 4];
for (int i = 0; i < t.memsize / 4; i++)
{
buf[i] = t.memory[i * 4];
}
break;
}
TFCFile TFCf = new TFCFile(T2D.Tsource);
byte[] buff;
if (TFCf.isTFCCompressed())
{
buff = ZBlock.Compress(t.memory);
}
else
{
buff = t.memory;
}
byte[] buff2 = BitConverter.GetBytes(TFCf.getFileSize());
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 20 + i] = buff2[i];
}
buff2 = BitConverter.GetBytes(buff.Length);
for (int i = 0; i < 4; i++)
{
memory[TextureTFCs[tfc].HeaderOffset + 12 + i] = buff2[i];
}
TFCf.AppendToTFC(buff);
int size = TFCf.getFileSize();
if (size != -1)
{
TOCeditor tc = new TOCeditor();
if (!tc.UpdateFile(T2D.Tsource + ".tfc", (uint)size))
{
MessageBox.Show("Didn't found Entry");
}
tc.Close();
}
MessageBox.Show("Done.");
}
}
}
}
}
int _kcmp(ZBlock.KeyBlockEntry x, ZBlock.KeyBlockEntry y)
{
for (int i = 0; i != this.keylen; i++)
{
int diff = (int)x.key[i] - (int)y.key[i];
//Console.WriteLine("Comparing {0} with {1} = {2}", (int)kbuf1[k1 + i], (int)kbuf2[k2 + i], diff);
if (0 != diff)
{
return diff;
}
}
return 0;
}
private FixedArrayComboListPart(int keylength, int valuelength)
{
int count_capacity = 1024;
int estimated_row_capacity = 32;
ZBlock.CleanZBlockFiles("value", "key_unsorted", "key_sorted");
this.keylen = keylength;
this.valuelen = valuelength;
if (keylength > 4)
{
_smallbuf = new byte[keylength];
}
else
{
_smallbuf = new byte[4];
}
net = new List<byte[]>(8);
entries = new List<Entry>(1);
kentries = new List<ZBlock.KeyBlockEntry>(1);
ebytes = new byte[count_capacity * estimated_row_capacity];
//evaluesbuf = // Moved down.
net.Add(ebytes);
this.streamwritebuf = new byte[1048576];
// Pre-set with defaults.
int numzblocks = 139;
int zblockkeybufsize = FILE_BUFFER_SIZE;
int zblockvaluebufsize = FILE_BUFFER_SIZE;
if (null != DistributedObjectsSlave.xslave)
{
System.Xml.XmlNode xzblocks = DistributedObjectsSlave.xslave["zblocks"];
if (null != xzblocks)
{
{
System.Xml.XmlAttribute xnzb = xzblocks.Attributes["count"];
if (null != xnzb)
{
numzblocks = int.Parse(xnzb.Value);
/*{
string computer_name = System.Environment.GetEnvironmentVariable("COMPUTERNAME");
if (computer_name == "MAPDCMILLER")
{
numzblocks = 3;
}
}*/
}
}
{
System.Xml.XmlAttribute xzbs = xzblocks.Attributes["addbuffersize"];
if (null != xzbs)
{
int x = DistributedObjectsSlave.ParseCapacity(xzbs.Value);
zblockkeybufsize = x;
zblockvaluebufsize = x;
}
}
{
System.Xml.XmlAttribute xzbs = xzblocks.Attributes["addkeybuffersize"];
if (null != xzbs)
{
zblockkeybufsize = DistributedObjectsSlave.ParseCapacity(xzbs.Value);
}
}
{
System.Xml.XmlAttribute xzbs = xzblocks.Attributes["addvaluebuffersize"];
if (null != xzbs)
{
zblockvaluebufsize = DistributedObjectsSlave.ParseCapacity(xzbs.Value);
}
}
}
}
evaluesbuf = new byte[(count_capacity * estimated_row_capacity) / numzblocks * 2];
if (XLog.logging)
{
XLog.log("Creating " + numzblocks.ToString() + " ZBlock`s");
}
zblocks = new ZBlock[numzblocks];
for (int i = 0; i != numzblocks; i++)
{
zblocks[i] = new ZBlock(this, i, zblockkeybufsize, zblockvaluebufsize);
}
}
