private byte[] appendEndFile(byte[] arraytoAppend, GeneralFileInfo endFileInfo)
{
// For files without endfiles (STREAM)
if (endFileInfo == null)
{
return(arraytoAppend);
}
bool ifFileExist = realFileInfos.Any(s => s.Name == endFileInfo.fileName);
if (!ifFileExist)
{
throw new Exception("Cannot find endFile " + endFileInfo.fileName);
}
FileInfo file = realFileInfos.FirstOrDefault(s => s.Name == endFileInfo.fileName);
byte[] endFileBuffer = new byte[file.OpenRead().Length];
file.OpenRead().Read(endFileBuffer, 0, endFileBuffer.Length);
int originalSize = arraytoAppend.Length;
Array.Resize(ref arraytoAppend, arraytoAppend.Length + endFileBuffer.Length);
Buffer.BlockCopy(endFileBuffer, 0, arraytoAppend, originalSize, endFileBuffer.Length);
return(arraytoAppend);
}
private void parseSTREAMInfo(int fileNumber, bool isRootSTREAM)
{
string[] STREAMInfo = fileInfoDic[fileNumber];
GeneralFileInfo streamFile = new GeneralFileInfo();
if (parsedFileInfo.ContainsKey(fileNumber))
{
streamFile = parsedFileInfo[fileNumber];
}
streamFile.totalFileSize = 0;
streamFile.numberofFiles = 1;
streamFile.FHMChunkSize = 0;
streamFile.additionalInfoFlag = 0;
streamFile.fileName = getSpecificFileInfoProperties("fileName: ", STREAMInfo);
streamFile.fileNo = fileNumber;
streamFile.header = "STREAM";
parsedFileInfo[fileNumber] = streamFile;
// stream
string[] newFileInfos = fileInfoDic[fileNumberinInfoFile];
repackSTREAM.parseSTREAMMetadata(newFileInfos);
}
private TreeViewItem addHierarchy(TreeViewItem treeViewItem, GeneralFileInfo fileInfo)
{
// Convert fileInfo into TreeViewItem
TreeViewItem newItem = getTreeView(fileInfo);
if (fileInfo.header == "fhm")
{
List <GeneralFileInfo> allChildFileInfos = parsedFileInfo.Values.Where(s => s.FHMFileNumber == fileInfo.fileNo).ToList();
if (fileInfo.numberofFiles != allChildFileInfos.Count)
{
throw new Exception("number of child files in FHM dosen't match with the total FHM file number!");
}
foreach (var childFileInfos in allChildFileInfos)
{
TreeViewItem treeView = addHierarchy(newItem, childFileInfos);
//treeView.Header = childFileInfos.fileName;
}
treeViewItem.Items.Add(newItem);
}
else
{
treeViewItem.Items.Add(newItem);
}
return(treeViewItem);
}
private void TreeView_SelectedItemChanged(object sender, RoutedPropertyChangedEventArgs <object> e)
{
TreeViewItem selectedItem = (TreeViewItem)TreeView.SelectedItem;
var ddd = selectedItem.Header;
try
{
GeneralFileInfo tag = (GeneralFileInfo)selectedItem.Tag;
if (tag != null)
{
fileNumberInput.Text = tag.fileNo.ToString();
fileNameInput.Text = tag.fileName;
headerInput.Text = tag.header;
FHMEnumSelect.SelectedIndex = tag.FHMAssetLoadEnum;
if (tag.isLinked)
{
isLinkedFile.IsChecked = true;
linkedtoFile.IsEnabled = true;
//linkedtoFile.Text = tag.linkedFileName;
}
else
{
isLinkedFile.IsChecked = false;
linkedtoFile.IsEnabled = false;
}
}
}
catch
{
NTP3FileInfo tag = (NTP3FileInfo)selectedItem.Tag;
GeneralFileInfo parentTag = (GeneralFileInfo)(GetSelectedTreeViewItemParent(selectedItem) as TreeViewItem).Tag;
if (parentTag != null)
{
fileNumberInput.Text = parentTag.fileNo.ToString();
fileNameInput.Text = parentTag.fileName;
headerInput.Text = parentTag.header;
FHMEnumSelect.SelectedIndex = parentTag.FHMAssetLoadEnum;
if (parentTag.isLinked)
{
isLinkedFile.IsChecked = true;
linkedtoFile.IsEnabled = true;
//linkedtoFile.Text = tag.linkedFileName;
}
else
{
isLinkedFile.IsChecked = false;
linkedtoFile.IsEnabled = false;
}
}
}
}
private void parseFHMFileInfoReferences(GeneralFileInfo fileInfo)
{
int FHMFileNumber = fileInfo.FHMFileNumber;
if (FHMFileNumber != 0)
{
if (!parsedFileInfo.ContainsKey(FHMFileNumber))
{
throw new Exception("Cannot find corresponding FHMFileNumber of: " + FHMFileNumber + " in parsedFileInfo!");
}
string FHMFileName = parsedFileInfo[FHMFileNumber].fileName;
fileInfo.FHMFileName = FHMFileName;
}
if (fileInfo.header == "fhm")
{
List <int> filePointers = new List <int>();
//List<GeneralFileInfo> allChildFileInfos =;
List <int> allChildFileInfoIndexes = parsedFileInfo.Where(s => s.Value.FHMFileNumber == fileInfo.fileNo).Select(x => x.Key).ToList();
if (fileInfo.numberofFiles != allChildFileInfoIndexes.Count)
{
throw new Exception("number of child files in FHM dosen't match with the total FHM file number!");
}
if (fileInfo.numberofFiles != 0)
{
for (int i = 0; i < allChildFileInfoIndexes.Count(); i++)
{
var childFileInfos = parsedFileInfo[allChildFileInfoIndexes[i]];
if (childFileInfos.isLinked)
{
int linkedFileNo = childFileInfos.linkedFileNo - 1;
if (allChildFileInfoIndexes.Count() < linkedFileNo)
{
throw new Exception("linkedFileNo exceed index of allChildFiles in index!");
}
string linkedFileName = parsedFileInfo[allChildFileInfoIndexes[linkedFileNo]].fileName;
parsedFileInfo[allChildFileInfoIndexes[i]].linkedFileName = linkedFileName;
}
parseFHMFileInfoReferences(childFileInfos);
}
}
}
}
private void parseFHMInfo(int fileNumber, bool isRootFHM)
{
// For the .fhm File
int fileNumberinFHM = 1;
string[] FHMinfos = fileInfoDic[fileNumber];
//FHMFileInfo fhmFileInfo = new FHMFileInfo();
//FHMFileInfoDic[fileNumber] = fhmFileInfo;
GeneralFileInfo fhmFile = new GeneralFileInfo();
if (parsedFileInfo.ContainsKey(fileNumber))
{
fhmFile = parsedFileInfo[fileNumber];
}
// parse and get info of FHM from PAC.info
//fhmFileInfo.totalFileSize = convertStringtoInt(getSpecificFileInfoProperties("Total file size: ", FHMinfos));
//fhmFileInfo.numberofFiles = convertStringtoInt(getSpecificFileInfoProperties("Number of files: ", FHMinfos));
//fhmFileInfo.FHMChunkSize = convertStringtoInt(getSpecificFileInfoProperties("FHM chunk size: ", FHMinfos));
//fhmFileInfo.additionalInfoFlag = (additionalInfo)convertStringtoInt(getSpecificFileInfoProperties("Additional info flag: ", FHMinfos));
fhmFile.totalFileSize = convertStringtoInt(getSpecificFileInfoProperties("Total file size: ", FHMinfos));
fhmFile.numberofFiles = convertStringtoInt(getSpecificFileInfoProperties("Number of files: ", FHMinfos));
fhmFile.FHMChunkSize = convertStringtoInt(getSpecificFileInfoProperties("FHM chunk size: ", FHMinfos));
fhmFile.additionalInfoFlag = (additionalInfo)convertStringtoInt(getSpecificFileInfoProperties("Additional info flag: ", FHMinfos));
fhmFile.fileName = getSpecificFileInfoProperties("fileName: ", FHMinfos);
fhmFile.fileNo = fileNumber;
fhmFile.header = "fhm";
parsedFileInfo[fileNumber] = fhmFile;
for (int i = 1; i <= fhmFile.numberofFiles; i++)
{
// For the rest of the files in the FHM tag in PAC.info
fileNumberinInfoFile++;
string[] newFileInfos = fileInfoDic[fileNumberinInfoFile];
parseGeneralFileInfo(newFileInfos, fileNumberinInfoFile, fileNumberinFHM, fhmFile.additionalInfoFlag);
fileNumberinFHM++;
}
// For endfile
if (isRootFHM)
{
fileNumberinInfoFile++;
string[] endFileInfos = fileInfoDic[fileNumberinInfoFile];
parseGeneralFileInfo(endFileInfos, fileNumberinInfoFile, fileNumberinFHM, fhmFile.additionalInfoFlag);
}
}
internal ModelImportStatus DoSurveyImport(string SelectedFile, string SelectedFormatFile, ImportDataMap importMap, RawFileReader rawFileReader, Guid NKDProjectID, bool doOverwrite, bool checkForDuplicates)
{
BaseImportTools bit = new BaseImportTools();
ModelImportStatus mos = new ModelImportStatus();
GeneralFileInfo gfi = new GeneralFileInfo();
gfi.GeneralFileStats(SelectedFile);
int numLines = gfi.numLines;
Stream fileStream = new FileStream(SelectedFile, FileMode.Open, FileAccess.Read, FileShare.ReadWrite);
//Stream fileStream = new FileStream(SelectedFile, FileMode.Open);
bit.PerformSurveyImport(mos, fileStream, null, importMap, this.backgroundWorker, NKDProjectID, ConnectionString, numLines, doOverwrite, checkForDuplicates);
return(mos);
}
private byte[] repackFHMFiles(GeneralFileInfo fileInfo, out int beforeAppendSize)
{
int fileNumber = fileInfo.fileNo;
beforeAppendSize = 0;
if (fileInfo.header == "fhm")
{
MemoryStream FHMStream = new MemoryStream();
List <int> filePointers = new List <int>();
List <int> fileSizes = new List <int>();
List <int> assetLoadEnums = new List <int>();
List <byte[]> filesByteArray = new List <byte[]>();
appendUIntMemoryStream(FHMStream, 0x46484D20, true); // FHM Magic
appendUIntMemoryStream(FHMStream, 0x01010010, true); // Unknown Flag, constant
appendZeroMemoryStream(FHMStream, 4);
appendIntMemoryStream(FHMStream, fileInfo.totalFileSize, true); // Supposed to be the FHM size, but very weird, so we reuse it for identification purposes (system does not read these)
appendIntMemoryStream(FHMStream, fileInfo.numberofFiles, true);
List <GeneralFileInfo> allChildFileInfos = parsedFileInfo.Values.Where(s => s.FHMFileNumber == fileNumber).ToList();
if (fileInfo.numberofFiles != allChildFileInfos.Count)
{
throw new Exception("number of child files in FHM dosen't match with the total FHM file number!");
}
if (fileInfo.numberofFiles != 0)
{
// Calculate the FHM Chunk Size based on the number of files
// each child files has 4 4 byte info, pointer, size, assetLoadEnum and unkEnum.
int FHMChunkSize = addPaddingSizeCalculation((allChildFileInfos.Count * 0x04) * 4 + (int)FHMStream.Length);
// The first pointer is the end of FHM, or the FHMChunkSize.
filePointers.Add(FHMChunkSize);
foreach (var childFileInfos in allChildFileInfos)
{
if (!childFileInfos.isLinked)
{
byte[] tempByteArray = repackFHMFiles(childFileInfos, out beforeAppendSize);
filePointers.Add(tempByteArray.Length + filePointers.Last());
fileSizes.Add(beforeAppendSize);
assetLoadEnums.Add(childFileInfos.FHMAssetLoadEnum);
filesByteArray.Add(tempByteArray);
}
else
{
int linkedFileNo = allChildFileInfos.IndexOf(allChildFileInfos.FirstOrDefault(s => s.fileName == childFileInfos.linkedFileName));
byte[] tempByteArray = new byte[0];
// Assuming the same pointer has already been added, since we sort the pointers when repacking.
if (filePointers.Count() < linkedFileNo)
{
throw new Exception("Cannot find file number: " + linkedFileNo + " in filePointers!");
}
filePointers.Insert(filePointers.Count() - 2, filePointers[linkedFileNo]);
fileSizes.Insert(fileSizes.Count() - 1, fileSizes[linkedFileNo]);
//fileSizes.Add(fileSizes[linkedFileNo - 1]);
assetLoadEnums.Insert(assetLoadEnums.Count() - 1, assetLoadEnums[linkedFileNo]);
filesByteArray.Add(tempByteArray);
}
}
for (int i = 0; i < allChildFileInfos.Count; i++)
{
appendIntMemoryStream(FHMStream, filePointers[i], true);
}
for (int i = 0; i < allChildFileInfos.Count; i++)
{
appendIntMemoryStream(FHMStream, fileSizes[i], true);
}
for (int i = 0; i < allChildFileInfos.Count; i++)
{
appendIntMemoryStream(FHMStream, assetLoadEnums[i], true);
}
for (int i = 0; i < allChildFileInfos.Count; i++)
{
appendZeroMemoryStream(FHMStream, 0x04);
}
addPaddingStream(FHMStream);
for (int i = 0; i < allChildFileInfos.Count; i++)
{
FHMStream.Write(filesByteArray[i], 0, filesByteArray[i].Length);
}
}
beforeAppendSize = (int)FHMStream.Length; // FHM file size is unused, so no matter if they are appended or not.
return(FHMStream.ToArray());
}
else
{
bool ifFileExist = realFileInfos.Any(s => s.Name == fileInfo.fileName);
if (!ifFileExist)
{
throw new Exception("Cannot find file " + fileInfo.fileName);
}
FileInfo file = realFileInfos.FirstOrDefault(s => s.Name == fileInfo.fileName);
switch (fileInfo.header)
{
case "NTP3":
byte[] NTP3Buffer = repackNTP3.repackDDStoNTP3(file, fileNumber);
beforeAppendSize = NTP3Buffer.Length;
NTP3Buffer = addPaddingArrayBuffer(NTP3Buffer);
return(NTP3Buffer);
case "EIDX":
byte[] EIDXBuffer = repackEIDX.repackEIDX();
beforeAppendSize = EIDXBuffer.Length;
EIDXBuffer = addPaddingArrayBuffer(EIDXBuffer);
return(EIDXBuffer);
case "STREAM":
byte[] STREAMBuffer = repackSTREAM.repackSTREAM(file);
beforeAppendSize = STREAMBuffer.Length;
STREAMBuffer = addPaddingArrayBuffer(STREAMBuffer);
return(STREAMBuffer);
default:
FileStream fileOpen = file.OpenRead();
byte[] generalBuffer = new byte[fileOpen.Length];
fileOpen.Read(generalBuffer, 0, generalBuffer.Length);
beforeAppendSize = generalBuffer.Length;
generalBuffer = addPaddingArrayBuffer(generalBuffer);
fileOpen.Close();
return(generalBuffer);
}
}
}
private void parseGeneralFileInfo(string[] newFileInfos, int fileNo, int fileNoinFHM, additionalInfo additionalInfoFlag)
{
//GeneralFileInfo generalFileInfo = new GeneralFileInfo();
string header = getSpecificFileInfoProperties("Header: ", newFileInfos);
GeneralFileInfo fhmFile = new GeneralFileInfo();
if (header != "endfile")
{
// parse and get infos from PAC.info
// we should link up duplicate infos, but this will suffice for now
int FHMOffset = convertStringtoInt(getSpecificFileInfoProperties("FHMOffset: ", newFileInfos, false));
int fileSize = convertStringtoInt(getSpecificFileInfoProperties("Size: ", newFileInfos, false));
int FHMassetEnum = convertStringtoInt(getSpecificFileInfoProperties("FHMAssetLoadEnum: ", newFileInfos));
int FHMunkEnum = convertStringtoInt(getSpecificFileInfoProperties("FHMunkEnum: ", newFileInfos));
int FHMFileNo = convertStringtoInt(getSpecificFileInfoProperties("FHMFileNo: ", newFileInfos));
string fileName = getSpecificFileInfoProperties("fileName: ", newFileInfos);
// parse and get infos from PAC.info
//generalFileInfo.FHMOffset = FHMOffset;
//generalFileInfo.fileSize = fileSize;
//generalFileInfo.header = header;
//generalFileInfo.fileNo = fileNumber;
//generalFileInfo.fileNoinFHM = fileNoinFHM;
fhmFile.FHMOffset = FHMOffset;
fhmFile.fileSize = fileSize;
fhmFile.header = header;
fhmFile.fileNo = fileNo;
//fhmFile.fileNoinFHM = fileNoinFHM;
fhmFile.FHMAssetLoadEnum = FHMassetEnum;
fhmFile.FHMunkEnum = FHMunkEnum;
fhmFile.FHMFileNumber = FHMFileNo;
fhmFile.fileName = fileName;
if (checkLinked(newFileInfos))
{
//generalFileInfo.isLinked = true;
//generalFileInfo.linkFileNumber = convertStringtoInt(getSpecificFileInfoProperties("LinkFHMOffset: ", newFileInfos));
fhmFile.isLinked = true;
fhmFile.linkedFileNo = convertStringtoInt(getSpecificFileInfoProperties("LinkedFileNo_in_FHM: ", newFileInfos));
}
parsedFileInfo[fileNo] = fhmFile;
switch (fhmFile.header)//generalFileInfo.header
{
case "fhm":
parseFHMInfo(fileNo, false);
break;
case "NTP3":
// TODO: should check if the fileNumber has been parsed before instead of checking linked. Hopefully there's no linked non-multi NTP3.
if (!fhmFile.isLinked) //!generalFileInfo.isLinked
{
// Pre Base64 code, TODO: Remove
// StreamReader NTP3Info = repackNTP3.getNTP3InfoStreamReader(newFileInfos);
repackNTP3.parseNTP3Info(newFileInfos, fileNo);
}
break;
case "EIDX":
repackEIDX.parseEIDXMetadata(newFileInfos);
break;
case "STREAM":
repackSTREAM.parseSTREAMMetadata(newFileInfos);
break;
default:
break;
}
if (fhmFile.header != "fhm") // generalFileInfo.header != "fhm"
{
//GeneralFileInfoDic[fileNo] = fhmFile; //generalFileInfo
//parsedFileInfo[fileNumber] = fhmFile;
}
parseAdditionalInfo(additionalInfoFlag, newFileInfos, fileNo, header);
}
else
{
// TODO: Check offset and Size with repacked file
int EndFileOffset = convertStringtoInt(getSpecificFileInfoProperties("End File Offset: ", newFileInfos));
int EndFileSize = convertStringtoInt(getSpecificFileInfoProperties("End File Size: ", newFileInfos));
string fileName = getSpecificFileInfoProperties("fileName: ", newFileInfos);
// parse and get infos from PAC.info
//generalFileInfo.FHMOffset = EndFileOffset;
//generalFileInfo.fileSize = EndFileSize;
//generalFileInfo.header = header;
//generalFileInfo.fileNo = fileNumber;
fhmFile.FHMOffset = EndFileOffset;
fhmFile.fileSize = EndFileSize;
fhmFile.header = header;
fhmFile.fileNo = fileNo;
//fhmFile.fileNoinFHM = fileNoinFHM;
fhmFile.fileName = fileName;
//GeneralFileInfoDic[fileNo] = fhmFile; //generalFileInfo;
parsedFileInfo[fileNo] = fhmFile;
}
}
private TreeViewItem getTreeView(GeneralFileInfo fileInfo)
{
TreeViewItem item = new TreeViewItem();
item.IsExpanded = true;
// create stack panel
StackPanel stack = new StackPanel();
stack.Orientation = Orientation.Horizontal;
// Label
Label lbl = new Label();
lbl.Content = fileInfo.fileNo.ToString("000") + " - " + fileInfo.fileName;
//stack.Children.Add(border);
if (fileInfo.header == "NTP3" && !fileInfo.isLinked)
{
if (!repackInstance.repackNTP3.NTP3FileInfoDic.ContainsKey(fileInfo.fileNo))
{
throw new Exception("Cannot find fileNumber: " + fileInfo.fileNo + " in NTP3FileInfoDic!");
}
lbl.Content = fileInfo.fileNo.ToString("000") + "-NTP3";
var NTP3FileInfo = repackInstance.repackNTP3.NTP3FileInfoDic[fileInfo.fileNo];
foreach (var NTP3File in NTP3FileInfo)
{
TreeViewItem itemDDS = new TreeViewItem();
itemDDS.IsExpanded = true;
// create stack panel
StackPanel stackDDS = new StackPanel();
stackDDS.Orientation = Orientation.Horizontal;
// Label
Label lblDDS = new Label();
lblDDS.Content = NTP3File.fileName;
stackDDS.Children.Add(lblDDS);
itemDDS.Header = stackDDS;
itemDDS.Tag = NTP3File;
item.Items.Add(itemDDS);
}
}
if (fileInfo.header == "STREAM")
{
lbl.Content = fileInfo.fileNo.ToString("000") + "-STREAM";
var STREAMFileInfoList = repackInstance.repackSTREAM.streamFileInfoList;
foreach (var audioFile in STREAMFileInfoList)
{
TreeViewItem itemAudio = new TreeViewItem();
itemAudio.IsExpanded = true;
// create stack panel
StackPanel stackAudio = new StackPanel();
stackAudio.Orientation = Orientation.Horizontal;
// Label
Label lblDDS = new Label();
lblDDS.Content = audioFile.file_Name;
stackAudio.Children.Add(lblDDS);
itemAudio.Header = stackAudio;
//itemAudio.Tag = audioFile;
item.Items.Add(itemAudio);
}
}
/*// create Image
* Border border = new Border();
* border.Width = 8;
* border.Height = 12;
*/
stack.Children.Add(lbl);
//item.HeaderTemplate.ad
item.Header = stack;
item.Tag = fileInfo;
return(item);
}
