/// <summary> /// Performs a final task for the worker. Outputting a report, for example. /// </summary> protected virtual void DoFinalTask(IVgmtWorkerStruct pTaskStruct) { }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pTaskStruct, DoWorkEventArgs e) { IsoExtractorStruct taskStruct = (IsoExtractorStruct)pTaskStruct; Dictionary <string, FileStream> streamCache = new Dictionary <string, FileStream>(); try { foreach (IDirectoryStructure d in taskStruct.Directories) { if (!CancellationPending) { // open the stream and cache it if (!streamCache.ContainsKey(d.SourceFilePath)) { streamCache[d.SourceFilePath] = File.Open(d.SourceFilePath, FileMode.Open, FileAccess.Read, FileShare.Read); } d.Extract(ref streamCache, taskStruct.DestinationFolder, taskStruct.ExtractAsRaw); } else { e.Cancel = false; break; } } foreach (IFileStructure f in taskStruct.Files) { if (!CancellationPending) { // open the stream and cache it if (!streamCache.ContainsKey(f.SourceFilePath)) { streamCache[f.SourceFilePath] = File.OpenRead(f.SourceFilePath); } f.Extract(ref streamCache, taskStruct.DestinationFolder, taskStruct.ExtractAsRaw); } else { e.Cancel = false; break; } } } catch (Exception ex) { throw new Exception(String.Format("Error extracting file: {0}", ex.Message)); } finally { // close any open streams foreach (string key in streamCache.Keys) { if (streamCache[key].CanRead) { streamCache[key].Close(); streamCache[key].Dispose(); } } } }
protected virtual void DoTaskForDirectory(string pPath, IVgmtWorkerStruct pTaskStruct, DoWorkEventArgs e) { foreach (string d in Directory.GetDirectories(pPath)) { if (!CancellationPending) { this.DoTaskForDirectory(d, pTaskStruct, e); } else { e.Cancel = true; break; } } foreach (string f in Directory.GetFiles(pPath)) { if (!CancellationPending) { // perform task try { this.DoTaskForFile(f, pTaskStruct, e); } catch (Exception ex) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format(CultureInfo.CurrentCulture, "Error processing <{0}>. Error received: ", f) + ex.Message + Environment.NewLine; ReportProgress(progress, this.progressStruct); } finally { this.DoFinally(); fileCount += 1; // Report Progress if ((fileCount == maxFiles) || (((fileCount * 100) / maxFiles) > this.progressCounter)) { this.progressCounter += this.progressCounterIncrementer; // output info if (this.outputBuffer.Length > 0) { this.progressStruct.Clear(); progressStruct.GenericMessage = this.outputBuffer.ToString(); ReportProgress(this.Progress, progressStruct); // clear out old info this.outputBuffer.Length = 0; } // output progress this.progress = (fileCount * 100) / maxFiles; this.progressStruct.Clear(); this.progressStruct.FileName = f; ReportProgress(this.progress, progressStruct); } } } else { e.Cancel = true; break; } } }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pZlibExtractorStruct, DoWorkEventArgs e) { ZlibExtractorStruct zlibExtractorStruct = (ZlibExtractorStruct)pZlibExtractorStruct; this.progressStruct.Clear(); if (zlibExtractorStruct.DoDecompress) { progressStruct.GenericMessage = String.Format("Decompressing <{0}>{1}", pPath, Environment.NewLine); } else { progressStruct.GenericMessage = String.Format("Compressing <{0}>{1}", pPath, Environment.NewLine); } ReportProgress(this.Progress, progressStruct); try { string outputFileName; if (zlibExtractorStruct.DoDecompress) { outputFileName = Path.ChangeExtension(pPath, CompressionUtil.ZlibDecompressOutputExtension); } else { outputFileName = Path.ChangeExtension(pPath, CompressionUtil.ZlibCompressOutputExtension); } using (FileStream fs = File.OpenRead(pPath)) { if (zlibExtractorStruct.StartingOffset > fs.Length) { throw new ArgumentOutOfRangeException("Starting Offset", "Offset cannot be greater than the file size."); } if (zlibExtractorStruct.DoDecompress) { CompressionUtil.DecompressZlibStreamToFile(fs, outputFileName, zlibExtractorStruct.StartingOffset); } else { CompressionUtil.CompressStreamToZlibFile(fs, outputFileName, zlibExtractorStruct.StartingOffset); } } this.progressStruct.Clear(); if (zlibExtractorStruct.DoDecompress) { progressStruct.GenericMessage = String.Format(" {0} decompressed.{1}", Path.GetFileName(outputFileName), Environment.NewLine); } else { progressStruct.GenericMessage = String.Format(" {0} compressed.{1}", Path.GetFileName(outputFileName), Environment.NewLine); } ReportProgress(this.Progress, progressStruct); } catch (Exception ex) { throw ex; } }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pTaskStruct, DoWorkEventArgs e) { }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pPsf2TimerStruct, DoWorkEventArgs e) { string outputSqFileName = null; string[] libPaths; string[] sqFiles; string[] iniFiles; Psf2.Psf2IniSqIrxStruct psf2IniStruct; string filePath; string fileDir; string fileName; string outputDir; string libOutputDir; Ps2SequenceData.Ps2SqTimingStruct psf2Time; int minutes; double seconds; int sequenceNumber = 0; StringBuilder batchFile = new StringBuilder(); string batchFilePath; string formatString = XsfUtil.GetXsfFormatString(pPath); if (!String.IsNullOrEmpty(formatString) && (formatString.Equals(Xsf.FormatNamePsf2))) { filePath = Path.GetFullPath(pPath); fileDir = Path.GetDirectoryName(filePath); fileName = Path.GetFileNameWithoutExtension(filePath); outputDir = XsfUtil.UnpackPsf2(filePath); // parse ini iniFiles = Directory.GetFiles(outputDir, "PSF2.INI", SearchOption.AllDirectories); if (iniFiles.Length > 0) { using (FileStream iniFs = File.Open(iniFiles[0], FileMode.Open, FileAccess.Read)) { // parse ini file to get SQ info psf2IniStruct = Psf2.ParseClsIniFile(iniFs); } using (FileStream fs = File.OpenRead(pPath)) { Psf2 psf2File = new Psf2(); psf2File.Initialize(fs, pPath); // check for libs libPaths = psf2File.GetLibPathArray(); } // copy the SQ file out (should only be one) sqFiles = Directory.GetFiles(outputDir, psf2IniStruct.SqFileName, SearchOption.AllDirectories); if (sqFiles.Length > 0) { if (!String.IsNullOrEmpty(psf2IniStruct.SequenceNumber)) { sequenceNumber = int.Parse(psf2IniStruct.SequenceNumber); outputSqFileName = String.Format("{0}_n={1}.SQ", outputDir, psf2IniStruct.SequenceNumber); } else { outputSqFileName = String.Format("{0}.SQ", outputDir); } File.Copy(sqFiles[0], outputSqFileName, true); } else // miniPSF2 { // unpack each lib, looking for the needed file foreach (string libPath in libPaths) { fileDir = Path.GetDirectoryName(libPath); fileName = Path.GetFileNameWithoutExtension(libPath); libOutputDir = Path.Combine(fileDir, fileName); if (!extractedLibHash.ContainsKey(libPath)) { libOutputDir = XsfUtil.UnpackPsf2(libPath); extractedLibHash.Add(libPath, libOutputDir.ToUpper()); } // look for the file in this lib sqFiles = Directory.GetFiles(libOutputDir, psf2IniStruct.SqFileName, SearchOption.AllDirectories); if (sqFiles.Length > 0) { if (!String.IsNullOrEmpty(psf2IniStruct.SequenceNumber)) { sequenceNumber = int.Parse(psf2IniStruct.SequenceNumber); outputSqFileName = String.Format("{0}_n={1}.SQ", outputDir, psf2IniStruct.SequenceNumber); } else { outputSqFileName = String.Format("{0}.SQ", outputDir); } File.Copy(sqFiles[0], outputSqFileName, true); break; } // delete the unpkpsf2 output folder if (Directory.Exists(libOutputDir)) { Directory.Delete(libOutputDir, true); } } // foreach (string libPath in libPaths) } // get time and add to script if (!String.IsNullOrEmpty(outputSqFileName)) { psf2Time = XsfUtil.GetTimeForPsf2File(outputSqFileName, sequenceNumber); File.Delete(outputSqFileName); // delete SQ file minutes = (int)(psf2Time.TimeInSeconds / 60d); seconds = (psf2Time.TimeInSeconds - (minutes * 60)); // seconds = Math.Ceiling(seconds); // shouldn't be needed without Math.Ceiling call, but whatever if (seconds >= 60) { minutes++; seconds -= 60d; } batchFile.AppendFormat("psfpoint.exe -length=\"{0}:{1}\" -fade=\"{2}\" \"{3}\"", minutes.ToString(), seconds.ToString().PadLeft(2, '0'), psf2Time.FadeInSeconds.ToString(), Path.GetFileName(pPath)); batchFile.Append(Environment.NewLine); batchFilePath = Path.Combine(Path.GetDirectoryName(pPath), BATCH_FILE_NAME); if (!File.Exists(batchFilePath)) { using (FileStream cfs = File.Create(batchFilePath)) { }; } using (StreamWriter sw = new StreamWriter(File.Open(batchFilePath, FileMode.Append, FileAccess.Write))) { sw.Write(batchFile.ToString()); } // report warnings if (!String.IsNullOrEmpty(psf2Time.Warnings)) { this.progressStruct.Clear(); progressStruct.GenericMessage = String.Format("{0}{1} WARNINGS{2} {3}", pPath, Environment.NewLine, Environment.NewLine, psf2Time.Warnings); ReportProgress(this.Progress, progressStruct); } } } // if (iniFiles.Length > 0) // delete the unpkpsf2 output folder if ((Directory.Exists(outputDir)) && (!extractedLibHash.ContainsValue(outputDir.ToUpper()))) { Directory.Delete(outputDir, true); } } // if (psf2File.getFormat().Equals(Xsf.FORMAT_NAME_PSF2) && (!psf2File.IsFileLibrary())) }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pPsf2DataFinderStruct, DoWorkEventArgs e) { Psf2DataFinderStruct psf2Struct = (Psf2DataFinderStruct)pPsf2DataFinderStruct; long offset; uint sqLength; string sqName; int sqNumber = 0; Psf2.ProbableItemStruct sqEntry; ArrayList sqFiles = new ArrayList(); bool sqNamingMessageDisplayed = false; uint hdLength; string hdName; int hdNumber = 0; HdStruct hdObject; ArrayList hdArrayList = new ArrayList(); ArrayList emptyRowList = new ArrayList(); Psf2.ProbableItemStruct potentialBd; Psf2.ProbableItemStruct[] potentialBdList; byte[] bdRow = new byte[0x10]; // display file name this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format("[{0}]{1}", pPath, Environment.NewLine); this.ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); using (FileStream fs = File.OpenRead(pPath)) { string destinationFolder = Path.Combine(Path.GetDirectoryName(pPath), Path.GetFileNameWithoutExtension(pPath)); // get HD Files #region HD EXTRACT this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format(" Extracting HD{0}", Environment.NewLine); this.ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); offset = 0; while ((offset = ParseFile.GetNextOffset(fs, offset, Psf2.HD_SIGNATURE)) > -1) { try { hdLength = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0xC, 4), 0); hdName = String.Format("{0}_{1}.HD", Path.GetFileNameWithoutExtension(pPath), hdNumber++.ToString("X4")); ParseFile.ExtractChunkToFile(fs, offset - 0x10, (int)hdLength, Path.Combine(destinationFolder, hdName), true, true); // get info hdObject = new HdStruct(); hdObject.FileName = hdName; hdObject.startingOffset = offset - 0x10; hdObject.length = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0xC, 4), 0); hdObject.expectedBdLength = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0x10, 4), 0); hdObject.vagSectionOffset = hdObject.startingOffset + BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0x20, 4), 0); hdObject.maxVagInfoNumber = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, hdObject.vagSectionOffset + 0xC, 4), 0); hdObject.vagInfoOffsetAddr = new long[hdObject.maxVagInfoNumber + 1]; hdObject.vagOffset = new long[hdObject.maxVagInfoNumber + 1]; hdObject.vagLengths = new long[hdObject.maxVagInfoNumber]; hdObject.IsSmallSamplePresent = false; for (int i = 0; i <= hdObject.maxVagInfoNumber; i++) { hdObject.vagInfoOffsetAddr[i] = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, hdObject.vagSectionOffset + 0x10 + (i * 4), 4), 0); hdObject.vagOffset[i] = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, hdObject.vagSectionOffset + hdObject.vagInfoOffsetAddr[i], 4), 0); if (i > 0) { hdObject.vagLengths[i - 1] = hdObject.vagOffset[i] - hdObject.vagOffset[i - 1]; if (hdObject.vagLengths[i - 1] < Psf2.MIN_ADPCM_ROW_SIZE) { hdObject.IsSmallSamplePresent = true; } } } // add to array hdArrayList.Add(hdObject); } catch (Exception hdEx) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format(" Error extracting HD at offset 0x{0}: {1}{2}", offset.ToString("X8"), hdEx.Message, Environment.NewLine); ReportProgress(progress, this.progressStruct); } // increment offset offset += 1; } #endregion // get SQ Files #region SQ EXTRACT this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format(" Extracting SQ{0}", Environment.NewLine); this.ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); sqEntry = new Psf2.ProbableItemStruct(); offset = 0; // build file list while ((offset = ParseFile.GetNextOffset(fs, offset, Ps2SequenceData.SIGNATURE_BYTES)) > -1) { sqLength = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0xC, 4), 0); if ((!psf2Struct.UseSeqMinimumSize) || ((psf2Struct.UseSeqMinimumSize) && (sqLength >= psf2Struct.MinimumSize))) { sqEntry.offset = offset - 0x10; sqEntry.length = sqLength; sqFiles.Add(sqEntry); } offset += 1; } foreach (Psf2.ProbableItemStruct sq in sqFiles) { if (psf2Struct.ReorderSqFiles) { if (hdArrayList.Count < sqFiles.Count) { if (!sqNamingMessageDisplayed) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format( "Warning, cannot reorder SQ files, there are less HD files than SQ files.{0}", Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); sqNamingMessageDisplayed = true; } sqName = String.Format("{0}_{1}.SQ", Path.GetFileNameWithoutExtension(pPath), sqNumber++.ToString("X4")); } else { hdObject = (HdStruct)hdArrayList[hdArrayList.Count - sqFiles.Count + sqNumber++]; sqName = Path.ChangeExtension(hdObject.FileName, ".SQ"); } } else { sqName = String.Format("{0}_{1}.SQ", Path.GetFileNameWithoutExtension(pPath), sqNumber++.ToString("X4")); } ParseFile.ExtractChunkToFile(fs, sq.offset, (int)sq.length, Path.Combine(destinationFolder, sqName), true, true); } #endregion // get BD files #region BD EXTRACT this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format(" Extracting BD...WARNING, THIS CAN TAKE A LONG TIME...{0}", Environment.NewLine); this.ReportProgress(Constants.ProgressMessageOnly, this.progressStruct); offset = 0; // build list of potential adpcm start indexes potentialBd = new Psf2.ProbableItemStruct(); while ((offset = ParseFile.GetNextOffset(fs, offset, Psf2.VB_START_BYTES, false)) > -1) { //if (offset == 0x1DD3800) //{ // int fff = 1; //} if ((psf2Struct.UseZeroOffsetForBd) && (offset % 0x10 == 0) || (!psf2Struct.UseZeroOffsetForBd)) { try { bdRow = ParseFile.ParseSimpleOffset(fs, offset, bdRow.Length); if (Psf2.IsPotentialAdpcm(fs, offset + 0x10, Psf2.MIN_ADPCM_ROW_COUNT, false)) { potentialBd.offset = offset; emptyRowList.Add(potentialBd); } } catch (Exception bdEx) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format(" ERROR finding BD for <{0}> at Offset 0x{1}: {2}{3}", pPath, offset.ToString("X8"), bdEx.Message, Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); } } offset += 1; } potentialBdList = (Psf2.ProbableItemStruct[])emptyRowList.ToArray(typeof(Psf2.ProbableItemStruct)); // set probable lengths for (int i = 0; i < potentialBdList.Length; i++) { if (i > 0) { potentialBdList[i - 1].length = (uint)(potentialBdList[i].offset - potentialBdList[i - 1].offset); } } // compare HD sample sizes to potential adpcm sizes/indexes hdObject.startingOffset = 0; hdObject.length = 0; hdObject.bdStartingOffset = 0; hdObject.bdLength = 0; string bdName; string newFileName; string[] dupeFileNames; for (int i = 0; i < hdArrayList.Count; i++) { hdObject = (HdStruct)hdArrayList[i]; if (hdObject.vagLengths.Length < 1) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format(" ERROR building BD for <{0}>: {1} refers to a single VAG, cannot determine proper BD. Skipping...{2}", pPath, hdObject.FileName, Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); } else { for (int j = 0; j < potentialBdList.Length; j++) { // we have a potential match or are at the last item. if ((hdObject.vagLengths[0] <= potentialBdList[j].length) || (potentialBdList[j].length == 0)) { try { hdObject = PopulateBdOffsetLength(fs, potentialBdList, j, hdObject); if (hdObject.bdLength > 0) { // check for other BD files that matched and rename accordingly dupeFileNames = Directory.GetFiles(destinationFolder, Path.GetFileNameWithoutExtension(hdObject.FileName) + "*.BD"); if (dupeFileNames.Length >= 1) { bdName = String.Format("{0}_{1}.BD", Path.GetFileNameWithoutExtension(hdObject.FileName), (dupeFileNames.Length).ToString("X4")); if (dupeFileNames.Length == 1) { // rename existing newFileName = String.Format("{0}_{1}.BD", Path.GetFileNameWithoutExtension(hdObject.FileName), (dupeFileNames.Length - 1).ToString("X4")); File.Move(dupeFileNames[0], Path.Combine(Path.GetDirectoryName(dupeFileNames[0]), newFileName)); } } else { bdName = Path.ChangeExtension(hdObject.FileName, ".BD"); } ParseFile.ExtractChunkToFile(fs, hdObject.bdStartingOffset, (int)hdObject.bdLength, Path.Combine(destinationFolder, bdName), true, true); } } catch (Exception ex) { this.progressStruct.Clear(); this.progressStruct.ErrorMessage = String.Format(" ERROR building BD for <{0}>: {1}{2}", pPath, ex.Message, Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); } } } } } #endregion } }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pTaskStruct, DoWorkEventArgs e) { ExtractOggStruct extractOggStruct = (ExtractOggStruct)pTaskStruct; long offset = 0; byte pageType; long pageSize; uint bitstreamSerialNumber; byte segmentCount; uint sizeOfAllSegments; byte i; string outputPath; string outputFileName; byte[] rawPageBytes; bool pageWrittenToFile = false; Dictionary <uint, FileStream> outputStreams = new Dictionary <uint, FileStream>(); using (FileStream fs = File.Open(pPath, FileMode.Open, FileAccess.Read)) { try { outputPath = Path.Combine(Path.GetDirectoryName(pPath), String.Format("VGMT_EXTRACTED_OGGs", Path.GetFileNameWithoutExtension(pPath))); while ((offset = ParseFile.GetNextOffset(fs, offset, XiphOrgOggContainer.MAGIC_BYTES)) > -1) { if (!this.CancellationPending) { pageWrittenToFile = false; //------------------ // get page details //------------------ pageType = ParseFile.ParseSimpleOffset(fs, offset + 5, 1)[0]; bitstreamSerialNumber = BitConverter.ToUInt32(ParseFile.ParseSimpleOffset(fs, offset + 0xE, 4), 0); segmentCount = ParseFile.ParseSimpleOffset(fs, offset + 0x1A, 1)[0]; sizeOfAllSegments = 0; for (i = 0; i < segmentCount; i++) { sizeOfAllSegments += ParseFile.ParseSimpleOffset(fs, offset + 0x1B + i, 1)[0]; } pageSize = 0x1B + segmentCount + sizeOfAllSegments; //----------------------------- // write page //----------------------------- rawPageBytes = ParseFile.ParseSimpleOffset(fs, offset, (int)pageSize); // open stream if ((pageType & XiphOrgOggContainer.PAGE_TYPE_BEGIN_STREAM) == XiphOrgOggContainer.PAGE_TYPE_BEGIN_STREAM) { if (outputStreams.ContainsKey(bitstreamSerialNumber)) { if (extractOggStruct.StopParsingOnFormatError) { throw new FormatException( String.Format("Beginning of Stream page found multiple times without End of Stream page, for serial number: {1}.{2}", pPath, bitstreamSerialNumber.ToString("X8"), Environment.NewLine)); } else { //this.progressStruct.Clear(); //progressStruct.GenericMessage = String.Format("Warning, for file <{0}>, Beginning of Stream page found multiple times without End of Stream page, for serial number: {1}.{2}", // pPath, // bitstreamSerialNumber.ToString("X8"), // Environment.NewLine); //ReportProgress(Constants.ProgressMessageOnly, progressStruct); } } else { // create the output stream outputFileName = Path.Combine(outputPath, String.Format("{0}_0x{1}_{2}.ogg", Path.GetFileNameWithoutExtension(pPath), offset.ToString("X8"), bitstreamSerialNumber.ToString("X8"))); outputFileName = FileUtil.GetNonDuplicateFileName(outputFileName); if (!Directory.Exists(outputPath)) { Directory.CreateDirectory(outputPath); } outputStreams[bitstreamSerialNumber] = File.Open(outputFileName, FileMode.CreateNew, FileAccess.Write); outputStreams[bitstreamSerialNumber].Write(rawPageBytes, 0, rawPageBytes.Length); pageWrittenToFile = true; } } // write page otherwise if (outputStreams.ContainsKey(bitstreamSerialNumber)) { if (!pageWrittenToFile) { outputStreams[bitstreamSerialNumber].Write(rawPageBytes, 0, rawPageBytes.Length); pageWrittenToFile = true; } } else { if (extractOggStruct.StopParsingOnFormatError) { throw new FormatException( String.Format("Stream data page found without Beginning of Stream page, for serial number: {1}.{2}", pPath, bitstreamSerialNumber.ToString("X8"), Environment.NewLine)); } else { //this.progressStruct.Clear(); //progressStruct.GenericMessage = String.Format("Warning, for file <{0}>, Stream data page found without Beginning of Stream page, for serial number: {1}.{2}", // pPath, // bitstreamSerialNumber.ToString("X8"), // Environment.NewLine); //ReportProgress(Constants.ProgressMessageOnly, progressStruct); } } // close stream if needed if ((pageType & XiphOrgOggContainer.PAGE_TYPE_END_STREAM) == XiphOrgOggContainer.PAGE_TYPE_END_STREAM) { if (outputStreams.ContainsKey(bitstreamSerialNumber)) { if (!pageWrittenToFile) { outputStreams[bitstreamSerialNumber].Write(rawPageBytes, 0, rawPageBytes.Length); pageWrittenToFile = true; } outputStreams[bitstreamSerialNumber].Close(); outputStreams[bitstreamSerialNumber].Dispose(); // remove stream from dictionary outputStreams.Remove(bitstreamSerialNumber); } else { if (extractOggStruct.StopParsingOnFormatError) { throw new FormatException( String.Format("End of Stream page found without a Beginning of Stream page, for serial number: {1}{2}.", pPath, bitstreamSerialNumber.ToString("X8"), Environment.NewLine)); } else { //this.progressStruct.Clear(); //progressStruct.GenericMessage = String.Format("Warning, for file <{0}>, End of Stream page found without a Beginning of Stream page, for serial number: {1}.{2}", // pPath, // bitstreamSerialNumber.ToString("X8"), // Environment.NewLine); //ReportProgress(Constants.ProgressMessageOnly, progressStruct); } } } //} if (pageType > 0) offset += pageSize; } else { e.Cancel = true; return; } } // while } catch (Exception ex) { throw ex; } finally { // close any unfinished streams foreach (uint k in outputStreams.Keys) { outputStreams[k].Close(); outputStreams[k].Dispose(); } } } }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pSdatFinderStruct, DoWorkEventArgs e) { string[] outputPaths = SdatUtil.ExtractSdatsFromFile(pPath, null); }
protected override void DoTaskForFile(string path, IVgmtWorkerStruct pMpegDemuxStruct, DoWorkEventArgs e) { MpegDemuxStruct demuxStruct = (MpegDemuxStruct)pMpegDemuxStruct; MpegStream.DemuxOptionsStruct demuxOptions = new MpegStream.DemuxOptionsStruct(); demuxOptions.ExtractAudio = demuxStruct.ExtractAudio; demuxOptions.ExtractVideo = demuxStruct.ExtractVideo; demuxOptions.AddHeader = demuxStruct.AddHeader; demuxOptions.SplitAudioStreams = demuxStruct.SplitAudioTracks; demuxOptions.AddPlaybackHacks = demuxStruct.AddPlaybackHacks; switch (demuxStruct.SourceFormat) { case "ASF (MS Advanced Systems Format)": case "WMV (MS Advanced Systems Format)": MicrosoftAsfContainer asfStream = new MicrosoftAsfContainer(path); asfStream.DemultiplexStreams(demuxOptions); break; case "BIK (Bink Video Container)": BinkStream binkStream = new BinkStream(path); binkStream.DemultiplexStreams(demuxOptions); break; case "DSI (Racjin/Racdym PS2 Video)": RacjinDsiStream dsiStream = new RacjinDsiStream(path); dsiStream.DemultiplexStreams(demuxOptions); break; case "DVD Video (VOB)": DvdVideoStream dvdStream = new DvdVideoStream(path); dvdStream.DemultiplexStreams(demuxOptions); break; case "Electronic Arts VP6 (VP6)": ElectronicArtsVp6Stream vp6Stream = new ElectronicArtsVp6Stream(path); vp6Stream.DemultiplexStreams(demuxOptions); break; case "Electronic Arts MPC (MPC)": ElectronicArtsMpcStream mpcStream = new ElectronicArtsMpcStream(path); mpcStream.DemultiplexStreams(demuxOptions); break; case "H4M (Hudson GameCube Video)": HudsonHvqm4VideoStream hvqmStream = new HudsonHvqm4VideoStream(path); hvqmStream.DemultiplexStreams(demuxOptions); break; case "MO (Mobiclip)": MobiclipStream.MovieType movieType = MobiclipStream.GetMobiclipStreamType(path); switch (movieType) { //case MobiclipStream.MovieType.NintendoDs: // MobiclipNdsStream mobiclipNdsStream = new MobiclipNdsStream(path); // mobiclipNdsStream.DemultiplexStreams(demuxOptions); // break; case MobiclipStream.MovieType.Wii: MobiclipWiiStream mobiclipWiiStream = new MobiclipWiiStream(path); mobiclipWiiStream.DemultiplexStreams(demuxOptions); break; default: throw new FormatException(String.Format("Unsupported Mobiclip type, for file: {0}", Path.GetFileName(path))); } break; case "MPEG": int mpegType = MpegStream.GetMpegStreamType(path); switch (mpegType) { case 1: Mpeg1Stream mpeg1Stream = new Mpeg1Stream(path); mpeg1Stream.DemultiplexStreams(demuxOptions); break; case 2: Mpeg2Stream mpeg2Stream = new Mpeg2Stream(path); mpeg2Stream.DemultiplexStreams(demuxOptions); break; default: throw new FormatException(String.Format("Unsupported MPEG type, for file: {0}", Path.GetFileName(path))); } break; case "MPS (PSP UMD Movie)": SonyPspMpsStream mpsStream = new SonyPspMpsStream(path); mpsStream.DemultiplexStreams(demuxOptions); break; case "PAM (PlayStation Advanced Movie)": SonyPamStream pamStream = new SonyPamStream(path); pamStream.DemultiplexStreams(demuxOptions); break; case "PMF (PSP Movie Format)": SonyPmfStream pmfStream = new SonyPmfStream(path); pmfStream.DemultiplexStreams(demuxOptions); break; case "PSS (PlayStation Stream)": SonyPssStream sps = new SonyPssStream(path); sps.DemultiplexStreams(demuxOptions); break; case "SFD (CRI Sofdec Video)": SofdecStream ss = new SofdecStream(path); ss.DemultiplexStreams(demuxOptions); break; case "THP": NintendoThpMovieStream thp = new NintendoThpMovieStream(path); thp.DemultiplexStreams(demuxOptions); break; case "USM (CRI Movie 2)": CriUsmStream cus = new CriUsmStream(path); cus.DemultiplexStreams(demuxOptions); break; case "XMV (Xbox Media Video)": XmvStream xmv = new XmvStream(path); xmv.DemultiplexStreams(demuxOptions); break; default: throw new FormatException("Source format not defined."); } this.outputBuffer.Append(Path.GetFileName(path) + Environment.NewLine); }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pSdatExtractorStruct, DoWorkEventArgs e) { string outputDir = SdatUtil.ExtractSdat(pPath); }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pMk2sfStruct, DoWorkEventArgs e) { this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format("Processing: [{0}]{1}", pPath, Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); NdsTo2sfStruct workingStruct = (NdsTo2sfStruct)pMk2sfStruct; string ndsTo2sfOutputPath = Path.Combine(Path.GetDirectoryName(pPath), String.Format("{0}{1}", Path.GetFileNameWithoutExtension(pPath), XsfUtil.NDSTO2SF_FOLDER_SUFFIX)); // Build Nds object Nds ndsFile = new Nds(); using (FileStream ndsStream = File.OpenRead(pPath)) { ndsFile.Initialize(ndsStream, pPath); } //------------------------ // extract 2SFs and STRMs //------------------------ bool filesWereRipped = XsfUtil.NdsTo2sf(pPath, TESTPACK_FULL_PATH, workingStruct.UseSmapNames); // output info this.progressStruct.Clear(); if (!filesWereRipped) { this.progressStruct.GenericMessage = String.Format(" No extractable SSEQ/STRM/SWAR data found.{0}", Environment.NewLine); } else { this.progressStruct.GenericMessage = String.Format(" SSEQ/STRM/SWAR Data extracted.{0}", Environment.NewLine); } this.ReportProgress(this.progress, this.progressStruct); //--------------- // extract SWAVs //--------------- this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format(" Searching for SWAVs{0}", Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); string swavMessages = String.Empty; FindOffsetStruct findOffsetStruct = new FindOffsetStruct(); findOffsetStruct.CutFile = true; findOffsetStruct.SearchString = "53574156FFFE"; findOffsetStruct.TreatSearchStringAsHex = true; findOffsetStruct.SearchStringOffset = "0"; findOffsetStruct.OutputFileExtension = ".swav"; findOffsetStruct.IsCutSizeAnOffset = true; findOffsetStruct.CutSize = "8"; findOffsetStruct.CutSizeOffsetSize = "4"; findOffsetStruct.IsLittleEndian = true; findOffsetStruct.OutputFolder = Path.Combine(ndsTo2sfOutputPath, "SWAV"); ParseFile.FindOffsetAndCutFile(pPath, findOffsetStruct, out swavMessages, false, false); //-------------- // extract ADXs //-------------- this.progressStruct.Clear(); this.progressStruct.GenericMessage = String.Format(" Searching for ADXs{0}", Environment.NewLine); this.ReportProgress(this.progress, this.progressStruct); string adxMessages = String.Empty; CriUtil.ExtractAdxStreams(pPath, ndsFile.GameSerial, Path.Combine(ndsTo2sfOutputPath, "ADX"), out adxMessages); }
protected override void DoTaskForFile(string pPath, IVgmtWorkerStruct pExamineChecksumGeneratorStruct, DoWorkEventArgs e) { ExamineChecksumGeneratorStruct examineChecksumGeneratorStruct = (ExamineChecksumGeneratorStruct)pExamineChecksumGeneratorStruct; string crc32; string md5; string sha1; string vgmtCrc32 = "Not implemented for this format."; string vgmtMd5 = "Not implemented for this format."; string vgmtSha1 = "Not implemented for this format."; string checksumKey; Type formatType = null; IFormat vgmData = null; using (FileStream fs = File.OpenRead(pPath)) { crc32 = ChecksumUtil.GetCrc32OfFullFile(fs); md5 = ChecksumUtil.GetMd5OfFullFile(fs); sha1 = ChecksumUtil.GetSha1OfFullFile(fs); if (examineChecksumGeneratorStruct.CheckForDuplicates) { checksumKey = String.Format("{0}/{1}/{2}", crc32, md5, sha1); this.addChecksumToHash(checksumKey, pPath, true); } if (examineChecksumGeneratorStruct.DoVgmtChecksums) { formatType = FormatUtil.getObjectType(fs); if (formatType != null) { vgmData = (IFormat)Activator.CreateInstance(formatType); vgmData.Initialize(fs, pPath); } } } if (vgmData != null) { Crc32 crc32Generator = new Crc32(); MD5CryptoServiceProvider md5Hash = new MD5CryptoServiceProvider(); FileStream md5FileStream = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.Write); CryptoStream md5CryptoStream = new CryptoStream(md5FileStream, md5Hash, CryptoStreamMode.Write); SHA1CryptoServiceProvider sha1Hash = new SHA1CryptoServiceProvider(); FileStream sha1FileStream = new FileStream(Path.GetTempFileName(), FileMode.Create, FileAccess.Write); CryptoStream sha1CryptoStream = new CryptoStream(sha1FileStream, sha1Hash, CryptoStreamMode.Write); vgmData.GetDatFileChecksums(ref crc32Generator, ref md5CryptoStream, ref sha1CryptoStream); md5CryptoStream.FlushFinalBlock(); sha1CryptoStream.FlushFinalBlock(); vgmtCrc32 = crc32Generator.Value.ToString("X8"); vgmtMd5 = ParseFile.ByteArrayToString(md5Hash.Hash); vgmtSha1 = ParseFile.ByteArrayToString(sha1Hash.Hash); if (examineChecksumGeneratorStruct.CheckForDuplicates) { checksumKey = String.Format("{0}/{1}/{2}", vgmtCrc32, vgmtMd5, vgmtSha1); this.addChecksumToHash(checksumKey, pPath, false); } md5FileStream.Close(); md5FileStream.Dispose(); sha1FileStream.Close(); sha1FileStream.Dispose(); md5CryptoStream.Close(); md5CryptoStream.Dispose(); sha1CryptoStream.Close(); sha1CryptoStream.Dispose(); } this.outputBuffer.AppendFormat("<{0}>{1}", pPath, Environment.NewLine); this.outputBuffer.AppendFormat("CRC32: {0}{1}", crc32, Environment.NewLine); this.outputBuffer.AppendFormat("MD5: {0}{1}", md5, Environment.NewLine); this.outputBuffer.AppendFormat("SHA1: {0}{1}", sha1, Environment.NewLine); if (examineChecksumGeneratorStruct.DoVgmtChecksums) { this.outputBuffer.AppendFormat("CRC32 (VGMT): {0}{1}", vgmtCrc32, Environment.NewLine); this.outputBuffer.AppendFormat("MD5 (VGMT): {0}{1}", vgmtMd5, Environment.NewLine); this.outputBuffer.AppendFormat("SHA1 (VGMT): {0}{1}", vgmtSha1, Environment.NewLine); } this.outputBuffer.AppendLine(); }
protected override void DoTaskForDirectory(string pPath, IVgmtWorkerStruct pTaskStruct, DoWorkEventArgs e) { XsfRecompressDataStruct xsfRecompressDataStruct = (XsfRecompressDataStruct)pTaskStruct; foreach (string d in Directory.GetDirectories(pPath)) { if (!CancellationPending) { this.DoTaskForDirectory(d, pTaskStruct, e); } else { e.Cancel = true; break; } } foreach (string f in Directory.GetFiles(pPath)) { if (!CancellationPending) { // Report Progress base.progress = (++base.fileCount * 100) / base.maxFiles; base.progressStruct.Clear(); base.progressStruct.FileName = f; ReportProgress(base.progress, base.progressStruct); // perform task try { this.DoTaskForFile(f, pTaskStruct, e); } catch (Exception ex) { base.progressStruct.Clear(); base.progressStruct.ErrorMessage = String.Format(CultureInfo.CurrentCulture, "Error processing <{0}>. Error received: ", f) + ex.Message + Environment.NewLine; ReportProgress(base.progress, base.progressStruct); } finally { this.DoFinally(); } } else { e.Cancel = true; break; } } // recompress folder if requested if (xsfRecompressDataStruct.RecompressFolders && (((IList <string>)xsfRecompressDataStruct.SourcePaths)).Contains(pPath)) { string recompressedFolder = Path.Combine(pPath, XsfUtil.RecompressedSubfolderName); if (Directory.Exists(recompressedFolder)) { string[] sourceFiles = Directory.GetFiles(pPath, "*.*", SearchOption.TopDirectoryOnly); string recompressedFolderFileName; foreach (string f in sourceFiles) { recompressedFolderFileName = Path.Combine(recompressedFolder, Path.GetFileName(f)); if (!File.Exists(recompressedFolderFileName)) { File.Copy(f, recompressedFolderFileName); } } string destinationArchive = Path.Combine(pPath, String.Format("{0}.{1}", Path.GetFileName(pPath), "7z")); if (File.Exists(destinationArchive)) { destinationArchive = Path.Combine(pPath, String.Format("{0}_{1}.{2}", Path.GetFileName(pPath), new Random().Next(0xFF).ToString("X2"), "7z")); } CompressionUtil.CompressFolderWith7zip(recompressedFolder, destinationArchive); } } }