public static Smap GetSmapFromSdat(string pSdatPath) { Smap smap = new Smap(); string fullPath = Path.GetFullPath(pSdatPath); if (!File.Exists(fullPath)) { throw new FileNotFoundException(String.Format("Cannot find file <{0}>", fullPath)); } else { using (FileStream fs = File.OpenRead(fullPath)) { Type dataType = FormatUtil.getObjectType(fs); if (dataType != null && dataType.Name.Equals("Sdat")) { Sdat sdat = new Sdat(); sdat.Initialize(fs, fullPath); smap = new Smap(sdat); } } } return(smap); }
public static string ExtractSdat(string pSdatPath) { string fullPath = Path.GetFullPath(pSdatPath); string outputPath = null; string waveArcOutputPath; if (!File.Exists(fullPath)) { throw new FileNotFoundException(String.Format("Cannot find file <{0}>", fullPath)); } else { Swar swar = new Swar(); string swavOutputPath; using (FileStream fs = File.OpenRead(fullPath)) { Type dataType = FormatUtil.getObjectType(fs); if (dataType != null && dataType.Name.Equals("Sdat")) { string filePrefix = Path.GetFileNameWithoutExtension(fullPath); outputPath = Path.Combine(Path.GetDirectoryName(fullPath), filePrefix); Sdat sdat = new Sdat(); sdat.Initialize(fs, fullPath); sdat.ExtractBanks(fs, outputPath); sdat.ExtractSseqs(fs, outputPath); sdat.ExtractSeqArc(fs, outputPath); sdat.ExtractStrms(fs, outputPath); waveArcOutputPath = sdat.ExtractWaveArcs(fs, outputPath); // extract SWAVs if (!String.IsNullOrEmpty(waveArcOutputPath)) { foreach (string f in Directory.GetFiles(waveArcOutputPath, "*" + Swar.FILE_EXTENSION)) { using (FileStream swarFs = File.Open(f, FileMode.Open, FileAccess.Read)) { dataType = FormatUtil.getObjectType(swarFs); if (dataType != null && dataType.Name.Equals("Swar")) { swavOutputPath = Path.Combine(waveArcOutputPath, Path.GetFileNameWithoutExtension(f)); swar.Initialize(swarFs, f); ExtractAndWriteSwavFromSwar(swarFs, swar, swavOutputPath); } } } } sdat.BuildSmap(outputPath, filePrefix); } } } return(outputPath); }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pSdatOptimizerStruct, DoWorkEventArgs e) { SdatOptimizerStruct sdatOptimizerStruct = (SdatOptimizerStruct)pSdatOptimizerStruct; string sdatDirectory; string sdatOptimizingFileName; string sdatOptimizingPath; string sdatCompletedFileName; string sdatCompletedPath; Sdat sdat = null; int startSequence = Sdat.NO_SEQUENCE_RESTRICTION; int endSequence = Sdat.NO_SEQUENCE_RESTRICTION; sdatDirectory = Path.GetDirectoryName(pPath); sdatOptimizingFileName = String.Format("{0}_OPTIMIZING.sdat", Path.GetFileNameWithoutExtension(pPath)); sdatOptimizingPath = Path.Combine(sdatDirectory, sdatOptimizingFileName); sdatCompletedFileName = String.Format("{0}_OPTIMIZED.sdat", Path.GetFileNameWithoutExtension(pPath)); sdatCompletedPath = Path.Combine(sdatDirectory, sdatCompletedFileName); File.Copy(pPath, sdatOptimizingPath, true); using (FileStream fs = File.Open(sdatOptimizingPath, FileMode.Open, FileAccess.ReadWrite)) { Type dataType = FormatUtil.getObjectType(fs); if (dataType != null && dataType.Name.Equals("Sdat")) { sdat = new Sdat(); sdat.Initialize(fs, sdatOptimizingPath); } } if (sdat != null) { if (!String.IsNullOrEmpty(sdatOptimizerStruct.startSequence)) { startSequence = (int)VGMToolbox.util.ByteConversion.GetLongValueFromString(sdatOptimizerStruct.startSequence.Trim()); } if (!String.IsNullOrEmpty(sdatOptimizerStruct.endSequence)) { endSequence = (int)VGMToolbox.util.ByteConversion.GetLongValueFromString(sdatOptimizerStruct.endSequence); } sdat.OptimizeForZlib(startSequence, endSequence); } File.Copy(sdatOptimizingPath, sdatCompletedPath, true); File.Delete(sdatOptimizingPath); }
private void initializeSseq(Sdat pSdat) { this.sseqSection = new SmapSeqStruct[pSdat.InfoSection.SdatInfoSseqs.Length]; for (int i = 0; i < this.sseqSection.Length; i++) { this.sseqSection[i] = new SmapSeqStruct(); this.sseqSection[i].number = i; if (pSdat.InfoSection.SdatInfoSseqs[i].fileId != null) { int intFileId = BitConverter.ToInt16(pSdat.InfoSection.SdatInfoSseqs[i].fileId, 0); if ((pSdat.SymbSection != null) && (i < pSdat.SymbSection.SymbSeqFileNames.Length) && (!String.IsNullOrEmpty(pSdat.SymbSection.SymbSeqFileNames[i]))) { this.sseqSection[i].label = pSdat.SymbSection.SymbSeqFileNames[i]; this.sseqSection[i].name = pSdat.SymbSection.SymbSeqFileNames[i] + Sdat.SEQUENCE_FILE_EXTENSION; } else { this.sseqSection[i].label = "SSEQ" + intFileId.ToString("X4"); this.sseqSection[i].name = String.Format("SSEQ{0}{1}", intFileId.ToString("X4"), Sdat.SEQUENCE_FILE_EXTENSION); } this.sseqSection[i].fileID = BitConverter.ToInt16(pSdat.InfoSection.SdatInfoSseqs[i].fileId, 0); this.sseqSection[i].bnk = BitConverter.ToInt16(pSdat.InfoSection.SdatInfoSseqs[i].bnk, 0); this.sseqSection[i].vol = pSdat.InfoSection.SdatInfoSseqs[i].vol[0]; this.sseqSection[i].cpr = pSdat.InfoSection.SdatInfoSseqs[i].cpr[0]; this.sseqSection[i].ppr = pSdat.InfoSection.SdatInfoSseqs[i].ppr[0]; this.sseqSection[i].ply = pSdat.InfoSection.SdatInfoSseqs[i].ply[0]; // this.sseqSection[i].hsize; @TODO figure this out this.sseqSection[i].size = BitConverter.ToInt32(pSdat.FatSection.SdatFatRecs[BitConverter.ToInt16(pSdat.InfoSection.SdatInfoSseqs[i].fileId, 0)].nSize, 0); } else { this.sseqSection[i].fileID = EMPTY_FILE_ID; } } }
public static ArrayList GetDuplicateSseqsList(string pSdatPath) { string fullPath = Path.GetFullPath(pSdatPath); ArrayList ret = null; if (!File.Exists(fullPath)) { throw new FileNotFoundException(String.Format("Cannot find file <{0}>", fullPath)); } else { if (Sdat.IsSdat(fullPath)) { using (FileStream fs = File.OpenRead(fullPath)) { Sdat sdat = new Sdat(); sdat.Initialize(fs, fullPath); ret = sdat.GetDuplicatesList(); } } } return(ret); }
private void LoadComboBox(string pSourcePath) { Smap.SmapSeqStruct s; this.dataGridSseq.Rows.Clear(); if (Sdat.IsSdat(pSourcePath)) { Smap smap = SdatUtil.GetSmapFromSdat(pSourcePath); DataGridViewRow row = new DataGridViewRow(); if ((smap.SseqSection != null) && (smap.SseqSection.Length > 0)) { // get duplicates list ArrayList duplicatesList = SdatUtil.GetDuplicateSseqsList(pSourcePath); // setup volume tracking struct this.sseqVolumeList = new Mk2sfWorker.VolumeChangeStruct[smap.SseqSection.Length]; // foreach (Smap.SmapSeqStruct s in smap.SseqSection) for (int i = 0; i < smap.SseqSection.Length; i++) { s = smap.SseqSection[i]; row = new DataGridViewRow(); row.CreateCells(this.dataGridSseq); row.Cells[1].Value = s.number.ToString("x4"); if (!String.IsNullOrEmpty(s.name)) { row.Cells[0].Value = true; row.Cells[2].Value = s.fileID.ToString(); row.Cells[3].Value = s.size.ToString().PadLeft(6, '0'); row.Cells[4].Value = s.name.ToString(); row.Cells[5].Value = s.bnk.ToString(); row.Cells[6].Value = s.vol.ToString(); row.Cells[7].Value = s.cpr.ToString(); row.Cells[8].Value = s.ppr.ToString(); row.Cells[9].Value = s.ply.ToString(); // add volume tracking this.sseqVolumeList[i].oldValue = s.vol; this.sseqVolumeList[i].newValue = s.vol; // check for duplicate if (duplicatesList.Contains(i)) { row.Cells[0].Value = false; row.DefaultCellStyle.BackColor = Color.Crimson; } } else { row.Cells[0].Value = false; } this.dataGridSseq.Rows.Add(row); } } } }
private void Make2sfFiles(Mk2sfStruct pMk2sfStruct) { string sdatDestinationPath; string TwoSFDestinationPath; string sdatPrefix; string testpackDestinationPath; string unallowedDestinationPath; string strmDestinationPath; Sdat sdat; // Build Paths if (String.IsNullOrEmpty(pMk2sfStruct.GameSerial)) { sdatDestinationPath = Path.Combine(pMk2sfStruct.DestinationFolder, Path.GetFileName(pMk2sfStruct.SourcePath)); } else { sdatDestinationPath = Path.Combine(pMk2sfStruct.DestinationFolder, pMk2sfStruct.GameSerial + Path.GetExtension(pMk2sfStruct.SourcePath)); } TwoSFDestinationPath = Path.Combine(pMk2sfStruct.DestinationFolder, Path.GetFileNameWithoutExtension(sdatDestinationPath)); sdatPrefix = Path.GetFileNameWithoutExtension(sdatDestinationPath); testpackDestinationPath = Path.Combine(pMk2sfStruct.DestinationFolder, Path.GetFileName(TESTPACK_FULL_PATH)); unallowedDestinationPath = Path.Combine(TwoSFDestinationPath, "UnAllowed Sequences"); strmDestinationPath = TwoSFDestinationPath; // Copy SDAT to destination folder try { File.Copy(pMk2sfStruct.SourcePath, sdatDestinationPath, false); } catch (Exception sdatException) { throw new IOException(String.Format("Error: Cannot copy SDAT <{0}> to destination directory: {1}.", sdatDestinationPath, sdatException.Message)); } // Copy STRMs this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Copying STRM files" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); using (FileStream sdatStream = File.OpenRead(sdatDestinationPath)) { sdat = new Sdat(); sdat.Initialize(sdatStream, sdatDestinationPath); sdat.ExtractStrms(sdatStream, strmDestinationPath); } // Update Volume for (int i = 0; i < pMk2sfStruct.VolumeChangeList.Length; i++) { if (pMk2sfStruct.VolumeChangeList[i].newValue != pMk2sfStruct.VolumeChangeList[i].oldValue) { sdat.UpdateSseqVolume(i, pMk2sfStruct.VolumeChangeList[i].newValue); } } // Optimize SDAT this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Optimizing SDAT" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); using (FileStream sdatStream = File.OpenRead(sdatDestinationPath)) { sdat = new Sdat(); sdat.Initialize(sdatStream, sdatDestinationPath); } sdat.OptimizeForZlib(pMk2sfStruct.AllowedSequences); // Copy testpack.nds File.Copy(TESTPACK_FULL_PATH, testpackDestinationPath, true); // Create 2SF output path if (!Directory.Exists(TwoSFDestinationPath)) { Directory.CreateDirectory(TwoSFDestinationPath); } // Build 2SFs this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Build 2SFs" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); XsfUtil.Make2sfSet(testpackDestinationPath, sdatDestinationPath, GetMinAllowedSseq(pMk2sfStruct.AllowedSequences), GetMaxAllowedSseq(pMk2sfStruct.AllowedSequences), TwoSFDestinationPath); // Move unallowed Sequences string unallowedFileName; string unallowedFilePath; foreach (int unallowedSequenceNumber in pMk2sfStruct.UnAllowedSequences) { unallowedFileName = String.Format("{0}-{1}.mini2sf", sdatPrefix, unallowedSequenceNumber.ToString("x4")); unallowedFilePath = Path.Combine(TwoSFDestinationPath, unallowedFileName); if (!Directory.Exists(unallowedDestinationPath)) { Directory.CreateDirectory(unallowedDestinationPath); } if (File.Exists(unallowedFilePath)) { File.Copy(unallowedFilePath, Path.Combine(unallowedDestinationPath, unallowedFileName), true); File.Delete(unallowedFilePath); } } // Add Tags this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Tagging Output" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); XsfBasicTaggingStruct tagStruct = new XsfBasicTaggingStruct(); tagStruct.TagArtist = pMk2sfStruct.TagArtist; tagStruct.TagCopyright = pMk2sfStruct.TagCopyright; tagStruct.TagYear = pMk2sfStruct.TagYear; tagStruct.TagGame = pMk2sfStruct.TagGame; tagStruct.TagComment = "uses Legacy of Ys: Book II driver hacked by Caitsith2"; tagStruct.TagXsfByTagName = "-2sfby"; tagStruct.TagXsfByTagValue = "VGMToolbox"; string taggingBatchPath = XsfUtil.BuildBasicTaggingBatch(TwoSFDestinationPath, tagStruct, "*.mini2sf"); XsfUtil.ExecutePsfPointBatchScript(taggingBatchPath, true); // Time 2SFs this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Timing Output" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); string outputTimerMessages; Time2sfStruct timerStruct = new Time2sfStruct(); timerStruct.DoSingleLoop = false; timerStruct.Mini2sfDirectory = TwoSFDestinationPath; timerStruct.SdatPath = pMk2sfStruct.SourcePath; XsfUtil.Time2sfFolder(timerStruct, out outputTimerMessages); // Delete Files this.progressStruct.Clear(); this.progressStruct.GenericMessage = "Cleaning Up" + Environment.NewLine; ReportProgress(Constants.ProgressMessageOnly, progressStruct); if (File.Exists(sdatDestinationPath)) { File.Delete(sdatDestinationPath); } if (File.Exists(testpackDestinationPath)) { File.Delete(testpackDestinationPath); } }
static void Main(string[] args) { string pathTo2sf; string pathToSdat; string filePrefix; string smapPath = String.Empty; bool processSuccess = false; string emptyFolderFileName; if (args.Length != 3) { usage(); return; } else { pathTo2sf = args[0]; pathToSdat = args[1]; filePrefix = args[2]; } if (!Directory.Exists(pathTo2sf)) { Console.WriteLine(String.Format("Cannot find directory <{0}>", pathTo2sf)); return; } if (!File.Exists(pathToSdat)) { Console.WriteLine(String.Format("Cannot find file <{0}>", pathToSdat)); return; } if (!String.IsNullOrEmpty(smapPath) && !File.Exists(smapPath)) { Console.WriteLine(String.Format("Cannot find file <{0}>", smapPath)); return; } string sseq2MidPath = Path.Combine(Path.Combine(".", "helper"), "sseq2mid.exe"); string psfpointPath = Path.Combine(Path.Combine(".", "helper"), "psfpoint.exe"); // delete old .bat file string psfpointBatchFilePath = Path.Combine(Path.Combine(pathTo2sf, "text"), PSFPOINT_BATCH_TXT); Console.WriteLine(); if (File.Exists(psfpointBatchFilePath)) { Console.WriteLine("Deleting Old Batch File"); File.Delete(psfpointBatchFilePath); } // Extract SDAT Console.WriteLine("Extracting SDAT"); string extractedSdatPath = Path.Combine(Path.GetDirectoryName(pathToSdat), Path.GetFileNameWithoutExtension(pathToSdat)); if (Directory.Exists(extractedSdatPath)) { extractedSdatPath += String.Format("_temp_{0}", new Random().Next().ToString()); } string extractedSseqPath = Path.Combine(extractedSdatPath, "Seq"); FileStream fs = File.Open(pathToSdat, FileMode.Open, FileAccess.Read); Sdat sdat = new Sdat(); sdat.Initialize(fs, pathToSdat); sdat.ExtractSseqs(fs, extractedSdatPath); fs.Close(); fs.Dispose(); // Make SMAP Console.WriteLine("Building Internal SMAP"); Smap smap = new Smap(sdat); // Loop through SMAP and build timing script Console.WriteLine("Building Timing Script"); string emptyFileDir = Path.Combine(pathTo2sf, EMPTY_FILE_DIRECTORY); int totalSequences = smap.SseqSection.Length; int i = 1; // Initialize Bass if (smap.SseqSection.Length > 0) { Console.WriteLine("Going to sleep for 5 seconds to avoid the freeware billboard..."); Bass.BASS_Init(-1, 44100, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero, null); Thread.Sleep(5000); Console.WriteLine("Ok, back to work..."); } foreach (Smap.SmapSeqStruct s in smap.SseqSection) { Console.Write("\r" + String.Format("Processing [{0}/{1}]", i.ToString().PadLeft(4, '0'), totalSequences.ToString().PadLeft(4, '0'))); string rippedFileName = String.Format("{0}-{1}.mini2sf", filePrefix, s.number.ToString("X4")); string rippedFilePath = Path.Combine(pathTo2sf, rippedFileName); // check if file is empty or not if (s.fileID == Smap.EMPTY_FILE_ID) { // move to empty dir if (!Directory.Exists(emptyFileDir)) { Directory.CreateDirectory(emptyFileDir); } if (File.Exists(rippedFilePath)) { emptyFolderFileName = Path.Combine(emptyFileDir, rippedFileName); File.Copy(rippedFilePath, emptyFolderFileName, true); File.Delete(rippedFilePath); } } else { string sseqFilePath = Path.Combine(extractedSseqPath, s.name); // convert sseq file to midi processSuccess = convertSseqFile(sseq2MidPath, pathTo2sf, sseqFilePath); // time file if (processSuccess) { processSuccess = buildFileTimingBatch(pathTo2sf, rippedFilePath, sseqFilePath); } } i++; } // run timing script Console.WriteLine(Environment.NewLine + "Executing Timing Script"); executeBatchScript(psfpointPath, pathTo2sf); // Cleanup Console.WriteLine("Cleaning Up"); doCleanup(extractedSdatPath, pathTo2sf, psfpointPath); }
public Smap(Sdat pSdat) { // SSEQ this.initializeSseq(pSdat); this.setMinMaxSseq(); }
static void Main(string[] args) { if ((args.Length > 3) || (args.Length < 2)) { Console.WriteLine("usage: sdatopt.exe fileName start_sequence end_sequence"); Console.WriteLine(" sdatopt.exe fileName ALL"); Console.WriteLine(" sdatopt.exe fileName PREP"); Console.WriteLine(" sdatopt.exe fileName MAP smap_file"); Console.WriteLine(" sdatopt.exe fileName MAP"); Console.WriteLine(); Console.WriteLine("fileName: .sdat or .2sflib containing SDAT to optimize"); Console.WriteLine("start_sequence: starting sequence number to keep"); Console.WriteLine("end_sequence: endinging sequence number to keep"); Console.WriteLine("ALL: use this if you wish to keep all sequences"); Console.WriteLine("PREP: use this to output an SMAP to use for sequence selection. Delete the entire line of sequences you do not want to include."); Console.WriteLine("MAP smap_file: uses smap_file from PREP to select sequences to keep."); Console.WriteLine("MAP: looks for an smap file based on the sdat name select sequences to keep. Must be in proper format."); } else { Sdat sdat = null; bool is2sfSource = false;; string sdatDirectory; string sdatOptimizingFileName; string sdatOptimizingPath; string sdatCompletedFileName; string sdatCompletedPath; int startSequence = Sdat.NO_SEQUENCE_RESTRICTION; int endSequence = Sdat.NO_SEQUENCE_RESTRICTION; string[] extractedSdats = null; string decompressedDataPath = null; string extractedToFolder = null; ArrayList cleanupList = new ArrayList(); string filename = Path.GetFullPath(args[0]); string smapFileName = null; if (!File.Exists(filename)) { Console.WriteLine("Cannot find SDAT: {0}", filename); return; } if (args[1].Trim().ToUpper().Equals("MAP")) { if (args.Length < 3) { smapFileName = Path.ChangeExtension(filename, Smap.FILE_EXTENSION); } else { smapFileName = Path.GetFullPath(args[2]); } if (!File.Exists(smapFileName)) { Console.WriteLine("Cannot find SMAP: {0}", smapFileName); return; } } sdatDirectory = Path.GetDirectoryName(filename); sdatOptimizingFileName = String.Format("{0}_OPTIMIZING{1}", Path.GetFileNameWithoutExtension(filename), Path.GetExtension(filename)); sdatOptimizingPath = Path.Combine(sdatDirectory, sdatOptimizingFileName); sdatCompletedFileName = String.Format("{0}_OPTIMIZED{1}", Path.GetFileNameWithoutExtension(filename), Path.GetExtension(filename)); sdatCompletedPath = Path.Combine(sdatDirectory, sdatCompletedFileName); try { File.Copy(filename, sdatOptimizingPath, true); using (FileStream fs = File.Open(sdatOptimizingPath, FileMode.Open, FileAccess.Read)) { Type dataType = FormatUtil.getObjectType(fs); if (dataType != null) { if (dataType.Name.Equals("Sdat")) { Console.WriteLine("Input file is an SDAT."); Console.WriteLine("Building Internal SDAT."); sdat = new Sdat(); sdat.Initialize(fs, sdatOptimizingPath); } else if (dataType.Name.Equals("Xsf")) // is an Xsf, confirm it is a 2sf { Xsf libFile = new Xsf(); libFile.Initialize(fs, sdatOptimizingPath); if (libFile.GetFormat().Equals(Xsf.FormatName2sf)) { Console.WriteLine("Input file is a 2SF."); is2sfSource = true; // close stream, we're gonna need this file fs.Close(); fs.Dispose(); // unpack compressed section Console.WriteLine("Decompressing Compressed Data section of 2SF."); Xsf2ExeStruct xsf2ExeStruct = new Xsf2ExeStruct(); xsf2ExeStruct.IncludeExtension = true; xsf2ExeStruct.StripGsfHeader = false; decompressedDataPath = XsfUtil.ExtractCompressedDataSection(sdatOptimizingPath, xsf2ExeStruct); // extract SDAT Console.WriteLine("Extracting SDAT from Decompressed Compressed Data Section."); VGMToolbox.util.FindOffsetStruct findOffsetStruct = new VGMToolbox.util.FindOffsetStruct(); findOffsetStruct.SearchString = Sdat.ASCII_SIGNATURE_STRING; findOffsetStruct.TreatSearchStringAsHex = true; findOffsetStruct.CutFile = true; findOffsetStruct.SearchStringOffset = "0"; findOffsetStruct.CutSize = "8"; findOffsetStruct.CutSizeOffsetSize = "4"; findOffsetStruct.IsCutSizeAnOffset = true; findOffsetStruct.OutputFileExtension = ".sdat"; findOffsetStruct.IsLittleEndian = true; findOffsetStruct.UseTerminatorForCutSize = false; findOffsetStruct.TerminatorString = null; findOffsetStruct.TreatTerminatorStringAsHex = false; findOffsetStruct.IncludeTerminatorLength = false; findOffsetStruct.ExtraCutSizeBytes = null; string output; extractedToFolder = ParseFile.FindOffsetAndCutFile(decompressedDataPath, findOffsetStruct, out output, false, false); // create SDAT object Console.WriteLine("Building Internal SDAT."); extractedSdats = Directory.GetFiles(extractedToFolder, "*.sdat"); if (extractedSdats.Length > 1) { Console.WriteLine("Sorry, this 2SF file contains more than 1 SDAT. sdatopt cannot currently handle this."); return; } else if (extractedSdats.Length == 0) { Console.WriteLine("ERROR: Did not find an SDAT in the Decompressed Data Section."); return; } else { using (FileStream sdatFs = File.Open(extractedSdats[0], FileMode.Open, FileAccess.Read)) { sdat = new Sdat(); sdat.Initialize(sdatFs, extractedSdats[0]); } } } } else { Console.WriteLine("ERROR: Cannot determine format of the input file."); return; } } } if (sdat != null) { if (args[1].Trim().ToUpper().Equals("PREP")) { sdat.BuildSmapPrep(Path.GetDirectoryName(filename), Path.GetFileNameWithoutExtension(filename)); } else if (args[1].Trim().ToUpper().Equals("MAP")) { ArrayList allowedSequences = buildSequenceList(smapFileName); Console.WriteLine("Optimizing SDAT."); sdat.OptimizeForZlib(allowedSequences); } else { if (!args[1].Trim().ToUpper().Equals("ALL")) { if (!String.IsNullOrEmpty(args[1])) { startSequence = (int)VGMToolbox.util.ByteConversion.GetLongValueFromString(args[1]); } if (!String.IsNullOrEmpty(args[2])) { endSequence = (int)VGMToolbox.util.ByteConversion.GetLongValueFromString(args[2]); } } Console.WriteLine("Optimizing SDAT."); sdat.OptimizeForZlib(startSequence, endSequence); } } if (is2sfSource) { if (!args[1].Trim().ToUpper().Equals("PREP")) { // replace SDAT section Console.WriteLine("Inserting SDAT back into Decompressed Compressed Data Section."); long sdatOffset; using (FileStream dcFs = File.Open(decompressedDataPath, FileMode.Open, FileAccess.ReadWrite)) { sdatOffset = ParseFile.GetNextOffset(dcFs, 0, Sdat.ASCII_SIGNATURE); } FileInfo fi = new FileInfo(extractedSdats[0]); FileUtil.ReplaceFileChunk(extractedSdats[0], 0, fi.Length, decompressedDataPath, sdatOffset); // rebuild 2sf Console.WriteLine("Rebuilding 2sf File."); string bin2PsfStdOut = String.Empty; string bin2PsfStdErr = String.Empty; XsfUtil.Bin2Psf(Path.GetExtension(filename).Substring(1), (int)Xsf.Version2sf, decompressedDataPath, ref bin2PsfStdOut, ref bin2PsfStdErr); Console.WriteLine("Cleaning up intermediate files."); File.Copy(Path.ChangeExtension(decompressedDataPath, Path.GetExtension(filename)), sdatOptimizingPath, true); File.Delete(Path.ChangeExtension(decompressedDataPath, Path.GetExtension(filename))); } File.Delete(decompressedDataPath); Directory.Delete(extractedToFolder, true); } if (!args[1].Trim().ToUpper().Equals("PREP")) { Console.WriteLine("Copying to OPTIMIZED file."); File.Copy(sdatOptimizingPath, sdatCompletedPath, true); } Console.WriteLine("Deleting OPTIMIZING file."); File.Delete(sdatOptimizingPath); Console.WriteLine("Optimization Complete."); } catch (Exception ex) { Console.WriteLine(String.Format("ERROR: {0}", ex.Message)); } } }