private void btnFind_Click(object sender, EventArgs e)
{
EnableDisable(false);
DTAFound = 0;
DTARead = 0;
var sw = new StreamWriter(PS3IP, false);
sw.WriteLine("PS3_ADDRESS=" + ipAddress.Text);
sw.WriteLine("PS3_PORT=" + numPort.Value);
sw.WriteLine("PS3_TIMEOUT=" + numTimeOut.Value);
sw.WriteLine("PS3_TRIES=" + numTries.Value);
sw.WriteLine("PS3_WAIT=" + numWait.Value);
sw.Dispose();
Tools.DeleteFile(bigDTA);
Tools.DeleteFile(DTAList);
if (chkListing.Checked)
{
sw = new StreamWriter(DTAList, false);
sw.WriteLine("\"Short Name\",\"DTA Path\",\"Song ID\",\"Artist\",\"Song Name\"");
sw.Dispose();
}
Log("Connecting to " + ipAddress.Text);
FoldersToSearch = radioNTSC.Checked ? NTSCFolders : PALFolders;
startTime = DateTime.Now;
CancelProcess = false;
backgroundWorker1.RunWorkerAsync();
}
private void LoadConfig()
{
if (!File.Exists(config))
{
return;
}
var sr = new StreamReader(config);
try
{
sr.ReadLine(); //skip initial line
var folder = Tools.GetConfigString(sr.ReadLine());
if (!string.IsNullOrWhiteSpace(folder) && Directory.Exists(folder))
{
Log("Loading last used folder...");
txtFolder.Text = folder;
}
artistSongTool.Checked = sr.ReadLine().Contains("True");
songTool.Checked = sr.ReadLine().Contains("True");
songByArtistTool.Checked = sr.ReadLine().Contains("True");
albumArtTool.Checked = sr.ReadLine().Contains("True");
rB3IconTool.Checked = sr.ReadLine().Contains("True");
sr.Dispose();
}
catch (Exception)
{
sr.Dispose();
Tools.DeleteFile(config);
}
}
private void lstFiles_SelectedIndexChanged(object sender, EventArgs e)
{
var file = folder + lstFiles.SelectedItem;
if (!File.Exists(file))
{
MessageBox.Show("Couldn't find that file!", "Error", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
return;
}
var fileSize = new FileInfo(file);
var info = "";
if (extension == ".png_xbox")
{
var png = Application.StartupPath + "\\bin\\temp.png";
Tools.DeleteFile(png);
if (!Tools.ConvertRBImage(file, png))
{
return;
}
var img = Tools.NemoLoadImage(png);
picImage.Image = img;
info = "Dimensions: " + img.Height + "x" + img.Width;
}
if (extension == ".mogg")
{
var bytes = File.ReadAllBytes(file);
info = "Encrypted? " + (bytes[0] == 0x0A ? "No" : "Yes (0x" + bytes[0].ToString("X2") + ")");
}
var size = "Size: ";
if (fileSize.Length >= 1048576)
{
size = size + (Math.Round((double)fileSize.Length / 1048576, 2)) + " MB";
}
else
{
size = size + (Math.Round((double)fileSize.Length / 1024, 2)) + " KB";
}
lblInformation.Text = size + (string.IsNullOrEmpty(info) ? "" : " | " + info);
if (starting)
{
return;
}
timer1.Enabled = false;
lblTimer.Visible = false;
}
public BatchExtractor(Color ButtonBackColor, Color ButtonTextColor)
{
InitializeComponent();
Tools = new NemoTools();
Parser = new DTAParser();
inputFiles = new List <string>();
mMenuBackground = menuStrip1.BackColor;
menuStrip1.Renderer = new DarkRenderer();
var formButtons = new List <Button> {
btnRefresh, btnFolder, btnBegin, btnSelect, btnDeselect, btnConverter
};
foreach (var button in formButtons)
{
button.BackColor = ButtonBackColor;
button.ForeColor = ButtonTextColor;
button.FlatAppearance.MouseOverBackColor = button.BackColor == Color.Transparent ? Color.FromArgb(127, Color.AliceBlue.R, Color.AliceBlue.G, Color.AliceBlue.B) : Tools.LightenColor(button.BackColor);
}
//load last used directory if saved and still exists
Log("Welcome to Batch Extractor");
Log("Drag and drop the CON /LIVE file(s) here");
Log("Or click 'Change Input Folder' to select the files");
config = Application.StartupPath + "\\bin\\config\\extractor.config";
if (!File.Exists(config))
{
return;
}
var sr = new StreamReader(config);
var line = sr.ReadLine();
sr.Dispose();
if (string.IsNullOrWhiteSpace(line))
{
Tools.DeleteFile(config);
}
else if (line != "" && Directory.Exists(line))
{
Log("");
Log("Loaded last directory used: " + line);
txtFolder.Text = line;
}
else
{
Tools.DeleteFile(config);
}
if (string.IsNullOrWhiteSpace(txtFolder.Text))
{
Log("Ready to begin");
}
}
/// <summary>
/// Extracts images from Milo file and saves textures in "(miloDir)/ext_(milofilename)"
/// as "texture(int)" starting from zero.
/// </summary>
/// <param name="inMilo">Milo file location</param>
/// <param name="saveDDS">Save DDS?</param>
/// <param name="saveTEX">Save TEX?</param>
/// <param name="format">Format to output the images to</param>
/// <param name="outTexCount">Number of textures in Milo file</param>
public static void ExtractTextures(string inMilo, bool saveDDS, bool saveTEX, string format, out int outTexCount)
{
var texCount = 0;
var Tools = new NemoTools();
var ext = Path.GetExtension(inMilo);
if (string.IsNullOrWhiteSpace(ext))
{
outTexCount = 0;
return;
}
TexturesFolder = inMilo.Replace(ext, "_textures\\");
BlocksFolder = TexturesFolder + "blocks\\";
FilesFolder = TexturesFolder + "files\\";
try
{
// Reads first four bytes to check its compression type.
var br = new BinaryReader(File.OpenRead(inMilo));
var firstFour = br.ReadBytes(4);
br.Close();
string compressionType;
if (firstFour.IsMilo(out compressionType))
{
var count = 0;
ProcessMilo(inMilo, compressionType, true, saveTEX, ref texCount, false, ref count, false, ref count);
}
}
catch (Exception)
{}
outTexCount = texCount;
//clean up afterwards
if (outTexCount < 1)
{
Tools.DeleteFolder(TexturesFolder, true);
}
else
{
Tools.DeleteFolder(BlocksFolder, true);
Tools.DeleteFolder(FilesFolder, true);
var ddsfiles = Directory.GetFiles(TexturesFolder, "*.dds");
foreach (var dds in ddsfiles)
{
if (!string.IsNullOrWhiteSpace(format))
{
Tools.ConvertRBImage(dds, dds, format);
}
if (!saveDDS)
{
Tools.DeleteFile(dds);
}
}
}
outTexCount = texCount;
}
private void SaveIndex()
{
if (!Songs.Any())
{
return;
}
Tools.DeleteFile(Index);
var sw = new StreamWriter(Index, false);
sw.WriteLine("NewFormat=True");
sw.WriteLine("IndexedCount=" + Songs.Count);
foreach (var song in Songs)
{
sw.WriteLine("SongName=" + song.Name);
sw.WriteLine("SongID=" + song.SongID);
sw.WriteLine("FileLocation=" + song.Location);
}
sw.Dispose();
}
private bool ExtractFile(string extension, bool sublevel, string internalname, string rename, bool keep = false)
{
if (xPackage == null || !xPackage.ParseSuccess)
{
return(false);
}
var outputfolder = txtFolder.Text + "\\" + (organizeFilesByType.Checked ? (extension == "mid" ? "midi" : extension) + "_files\\" : "");
var ext = "." + extension;
var dir = "songs/" + internalname + (sublevel ? "/gen/" : "/") + internalname;
var file = dir + (keep ? "_keep" : "") + ext;
var xfile = xPackage.GetFile(file);
if (xfile == null)
{
Log("Could not find " + extension.ToUpper() + " file inside " + Path.GetFileName(file));
return(false);
}
try
{
var newfile = outputfolder + rename + (keep && !removekeepFromPNGXBOXFiles.Checked ? "_keep" : "") + ext;
extension = extension.ToLowerInvariant() == "mid" ? "MIDI" : extension.ToUpper();
Log("Extracting " + extension + " file " + Path.GetFileName(newfile));
if (!Directory.Exists(outputfolder))
{
Directory.CreateDirectory(outputfolder);
}
Tools.DeleteFile(newfile);
if (xfile.ExtractToFile(newfile))
{
if (Path.GetExtension(newfile) == ".mogg")
{
Tools.WriteOutData(Tools.ObfM(File.ReadAllBytes(newfile)), newfile);
}
Log("File " + rename + ext + " extracted successfully");
}
else
{
Log("Extracting file " + rename + ext + " failed");
}
}
catch (Exception ex)
{
Log("There was an error extracting file " + rename + ext);
Log("The error says: " + ex.Message);
return(false);
}
return(true);
}
private void btnExport_Click(object sender, EventArgs e)
{
var desktop = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
var sfd = new SaveFileDialog
{
Title = "Select location to export to",
FileName = Tools.CleanString(ActiveSetlist, true).Replace("'", "").Replace(" ", "") + "_details.txt",
OverwritePrompt = true,
AddExtension = true,
InitialDirectory = desktop,
Filter = "Text Files (*.txt)|*txt"
};
if (sfd.ShowDialog() != DialogResult.OK || string.IsNullOrWhiteSpace(sfd.FileName))
{
return;
}
Tools.DeleteFile(sfd.FileName);
var sw = new StreamWriter(sfd.FileName, false, System.Text.Encoding.UTF8);
try
{
for (var i = 0; i < lstStats.Items.Count; i++)
{
sw.WriteLine(FormatText(lstStats.Items[i].SubItems[0].Text, lstStats.Items[i].SubItems[1].Text));
}
}
catch (Exception ex)
{
MessageBox.Show("There was an error exporting the Setlist Details\nThe error says: " + ex.Message, Text,
MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
sw.Dispose();
return;
}
sw.Dispose();
if (MessageBox.Show("Setlist Details exported successfully\nDo you want to open the file now?", Text,
MessageBoxButtons.YesNo, MessageBoxIcon.Question) != DialogResult.Yes)
{
return;
}
Process.Start(sfd.FileName);
}
private bool TakeScreenshot(string path)
{
using (var bitmap = new Bitmap(PanelSize.Width, PanelSize.Height))
{
//this method doesn't scale when using display/font scaling - needs fixing
var location = new Point(0, 0);
Invoke(new MethodInvoker(delegate { location = PointToScreen(panelBackground.Location); }));
var g = Graphics.FromImage(bitmap);
g.CopyFromScreen(location, new Point(0, 0), PanelSize, CopyPixelOperation.SourceCopy);
var myEncoder = Encoder.Quality;
var myEncoderParameters = new EncoderParameters(1);
var myEncoderParameter = new EncoderParameter(myEncoder, 100L);
myEncoderParameters.Param[0] = myEncoderParameter;
var myImageCodecInfo = Tools.GetEncoderInfo("image/jpeg");
Tools.DeleteFile(path);
bitmap.Save(path, myImageCodecInfo, myEncoderParameters);
}
return(File.Exists(path));
}
private void GetImage(String file, PictureBox box)
{
if (picWorking.Visible)
{
return;
}
try
{
string contentImage = null;
//if not passed a string path for the image
//show dialog box to find one
if (string.IsNullOrWhiteSpace(file))
{
var openFileDialog1 = new OpenFileDialog
{
Filter = "Image Files|*.bmp;*.jpg;*.jpeg;*.png",
Title = "Select an image",
InitialDirectory = Application.StartupPath + "\\res\\thumbs"
};
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
contentImage = openFileDialog1.FileName;
Tools.CurrentFolder = Path.GetDirectoryName(openFileDialog1.FileName);
}
}
else
{
//if file is not blank, then use that for the image
if ((file.Contains(".jpg") || file.Contains(".bmp") ||
file.Contains(".png") || file.Contains(".jpeg")) && !file.Contains(".png_xbox") && !file.Contains(".png_wii"))
{
contentImage = file;
}
else
{
return;
}
}
if (string.IsNullOrWhiteSpace(contentImage))
{
return;
}
var thumbnail = Tools.NemoLoadImage(contentImage);
if (thumbnail.Width == 64 && thumbnail.Height == 64)
{
box.Image = thumbnail;
return;
}
var newimage = Path.GetTempPath() + Path.GetFileNameWithoutExtension(contentImage) + ".png";
Tools.ResizeImage(contentImage, 64, "png", newimage);
if (File.Exists(newimage))
{
box.Image = Tools.NemoLoadImage(newimage);
}
Tools.DeleteFile(newimage);
}
catch (Exception iSuck)
{
MessageBox.Show("Error: " + iSuck.Message);
}
}
private void ExtractFromSaveFile(string file)
{
ClearAll();
isWorking(true);
var savefile = file;
var isXbox = Path.GetFileName(file).ToLowerInvariant().Contains("xbox") || Path.GetFileName(file) == "band3";
isWii = Path.GetFileName(file).ToLowerInvariant().Contains("wii");
isPS3 = Path.GetFileName(file).ToLowerInvariant().Contains("ps3");
Tools.CurrentFolder = Path.GetDirectoryName(file);
UserSaveFile = file;
if (VariousFunctions.ReadFileType(file) == XboxFileType.STFS)
{
isXbox = true;
isPS3 = false;
isWii = false;
Log("Received save CON file, extracting save.dat file");
var package = new STFSPackage(file);
if (!package.ParseSuccess)
{
isWorking(false);
package.CloseIO();
Log("Couldn't read that CON file, aborting");
Log("Ready");
return;
}
var xent = package.GetFile("save.dat");
if (xent == null)
{
isWorking(false);
package.CloseIO();
Log("Couldn't find save.dat in that CON file, aborting");
Log("Ready");
return;
}
var tempdat = EditorFolder + "\\temp.dat";
Tools.DeleteFile(tempdat);
if (!xent.ExtractToFile(tempdat))
{
isWorking(false);
package.CloseIO();
Log("Couldn't extract save.dat from that CON file, aborting");
Log("Ready");
return;
}
savefile = tempdat;
package.CloseIO();
}
Log("Received save file, extracting images...");
ImageFolder = EditorFolder + Path.GetFileNameWithoutExtension(file) + "_extracted\\";
Tools.DeleteFolder(ImageFolder, true);
var success = false;
if (isXbox)
{
success = Tools.ExtractSaveImages(savefile, EditorFolder + Path.GetFileNameWithoutExtension(file));
}
else if (isWii)
{
success = Tools.ExtractWiiSaveImages(savefile, EditorFolder + Path.GetFileNameWithoutExtension(file));
}
else if (isPS3)
{
success = Tools.ExtractSaveImages(savefile, EditorFolder + Path.GetFileNameWithoutExtension(file), true);
}
else
{
switch (MessageBox.Show("Click Yes if this is a *decrypted* PS3 save file\nClick No if this is a Wii save file\nXbox 360 users must use the 'band3' save file\nPress Cancel to go back",
Text, MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question))
{
case DialogResult.Yes:
isPS3 = true;
isWii = false;
success = Tools.ExtractSaveImages(savefile, EditorFolder + Path.GetFileNameWithoutExtension(file), true);
break;
case DialogResult.No:
isWii = true;
isPS3 = false;
success = Tools.ExtractWiiSaveImages(savefile, EditorFolder + Path.GetFileNameWithoutExtension(file));
break;
case DialogResult.Cancel:
Log("Extracting cancelled by user");
isWorking(false);
Log("Ready");
return;
}
}
if (!success)
{
Log("Extracting from save game file failed");
isWorking(false);
Log("Ready");
return;
}
Log("Extracted images from save file successfully");
if (savefile != file) //i.e. extracted from con
{
Tools.DeleteFile(savefile);
}
lblFileName.Text = Path.GetFileName(file);
lblConsole.Text = isPS3 ? "Playstation 3" : (isWii ? "Wii" : "Xbox 360");
ChangeImagePadding();
LoadExtractedImages();
exportAllImagesToolStripMenuItem.Enabled = true;
closeFileToolStripMenuItem.Enabled = true;
txtBand.Enabled = true;
txtBand.Text = !string.IsNullOrWhiteSpace(Tools.SaveFileBandName) ? Tools.SaveFileBandName : "Unknown";
txtBand.ReadOnly = isWii;
isWorking(false);
Log("Ready");
}
public AdvancedArtConverter(string Folder, Color ButtonBackColor, Color ButtonTextColor)
{
InitializeComponent();
Tools = new NemoTools {
TextureSize = 512
};
var formButtons = new List <Button> {
btnRefresh, btnFolder, btnToPS3, btnFromPS3, btnToWii, btnFromWii, btnToXbox, btnFromXbox
};
foreach (var button in formButtons)
{
button.BackColor = ButtonBackColor;
button.ForeColor = ButtonTextColor;
button.FlatAppearance.MouseOverBackColor = button.BackColor == Color.Transparent ? Color.FromArgb(127, Color.AliceBlue.R, Color.AliceBlue.G, Color.AliceBlue.B) : Tools.LightenColor(button.BackColor);
}
Log("Welcome to Advanced Art Converter");
Log("Drag and drop the file(s) to be converted here");
Log("Or click 'Change Input Folder' to select the files");
Log("Ready to begin");
//folder sent via command line is more important
var pngDir = Folder != "" ? Folder : "";
//load last used directory if saved and still exists
config = Application.StartupPath + "\\bin\\config\\art.config";
if (string.IsNullOrWhiteSpace(pngDir))
{
if (File.Exists(config))
{
var sr = new StreamReader(config);
var line = sr.ReadLine();
sr.Dispose();
if (string.IsNullOrWhiteSpace(line))
{
Tools.DeleteFile(config);
}
else if (line != "" && Directory.Exists(line))
{
Log("Loaded last directory used");
pngDir = line;
}
else
{
Tools.DeleteFile(config);
}
}
}
txtFolder.Text = pngDir;
imgCounter = 0;
wimgt = Application.StartupPath + "\\bin\\wimgt.exe";
if (File.Exists(wimgt))
{
return;
}
MessageBox.Show("Can't find wimgt.exe ... I won't be able to convert Wii files without it",
"Missing Executable", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
tabWii.Enabled = false;
}
private void backgroundWorker1_DoWork(object sender, DoWorkEventArgs e)
{
foreach (var file in FilesToConvert)
{
if (backgroundWorker1.CancellationPending)
{
return;
}
var replaced = 0;
try
{
var xFile = new STFSPackage(file);
if (!xFile.ParseSuccess)
{
ProblemFiles.Add(file);
continue;
}
var xent = xFile.GetFile("/songs/songs.dta");
if (xent == null)
{
xFile.CloseIO();
ProblemFiles.Add(file);
continue;
}
var dta1 = Application.StartupPath + "\\bin\\dta1.txt";
Tools.DeleteFile(dta1);
if (!xent.Extract(dta1))
{
xFile.CloseIO();
ProblemFiles.Add(file);
continue;
}
var dta2 = Application.StartupPath + "\\bin\\dta2.txt";
Tools.DeleteFile(dta2);
var sr = new StreamReader(dta1, Encoding.Default);
var sw = new StreamWriter(dta2, false, Encoding.Default);
while (sr.Peek() >= 0)
{
var line = sr.ReadLine();
if (string.IsNullOrEmpty(line.Trim()))
{
continue;
}
if (line.Contains(";ORIG_ID="))
{
if (DoReverseBatch)
{
var id = line.Replace(";", "").Replace("ORIG_ID=", "").Trim();
sw.WriteLine(" ('song_id' " + id + ")");
sr.ReadLine();//skip the old song_id line
line = sr.ReadLine();
TotalSongs++;
replaced++;
}
else
{
sw.WriteLine(line);
line = sr.ReadLine();
sw.WriteLine(line);
line = sr.ReadLine();
}
}
else if (line.Contains("song_id") && !DoReverseBatch)
{
if (!Parser.IsNumericID(line))
{
line = ";ORIG_ID=" + Parser.GetSongID(line);
sw.WriteLine(line);
line = " ('song_id' " + mMainForm.GetNumericID() + ")";
TotalSongs++;
replaced++;
}
else
{
SkippedFiles.Add(file);
}
}
if (!string.IsNullOrEmpty(line.Trim()))
{
sw.WriteLine(line);
}
}
sr.Dispose();
sw.Dispose();
if (replaced == 0) //don't modify this CON file if nothing is edited in this DTA file
{
if (!SkippedFiles.Contains(file))
{
SkippedFiles.Add(file);
}
xFile.CloseIO();
continue;
}
if (backgroundWorker1.CancellationPending)
{
xFile.CloseIO();
return;
}
if (!xent.Replace(dta2))
{
xFile.CloseIO();
ProblemFiles.Add(file);
continue;
}
Tools.DeleteFile(dta1);
Tools.DeleteFile(dta2);
xFile.Header.MakeAnonymous();
xFile.Header.ThisType = PackageType.SavedGame;
var signature = new RSAParams(Application.StartupPath + "\\bin\\KV.bin");
xFile.RebuildPackage(signature);
xFile.FlushPackage(signature);
xFile.CloseIO();
Tools.UnlockCON(file);
Tools.SignCON(file);
xFile.CloseIO();
}
catch (Exception)
{
ProblemFiles.Add(file);
}
}
}
private void backgroundWorker1_DoWork(object sender, System.ComponentModel.DoWorkEventArgs e)
{
Tools.CurrentFolder = Path.GetDirectoryName(con);
Log("Reading CON file " + Path.GetFileName(con));
var dta = Path.GetTempPath() + "temp_dta.txt";
var backup = con + "_backup";
Tools.DeleteFile(backup);
if (!Parser.ExtractDTA(con))//grab byte[] content of DTA
{
Log("Error extracting DTA file");
ErrorOut();
return;
}
if (!Parser.WriteDTAToFile(dta)) //write it out to file
{
Log("Error extracting DTA file");
ErrorOut();
return;
}
var song = new STFSPackage(con);
if (backUpCONFile.Checked)
{
Log("Found songs.dta file, making a backup of your file before starting");
Log("THIS STEP MAY TAKE A WHILE. DON'T CLOSE ME DOWN!");
song.CloseIO();
File.Copy(con, backup);
song = new STFSPackage(con);
}
var xDTA = song.GetFile("/songs/songs.dta");
Log("Opening DTA file...");
var process = Process.Start(dta);
Log("DTA file is being edited by the user ... waiting...");
do
{
//wait while user has DTA file opened
} while (!process.HasExited);
process.Dispose();
Log("DTA file closed by user, continuing...");
Log("Replacing old DTA file with modified DTA file");
Log("THIS STEP MAY TAKE A WHILE. DON'T CLOSE ME DOWN!");
if (!xDTA.Replace(dta))
{
Log("Error replacing DTA file with modified one");
Tools.DeleteFile(backup);
ErrorOut();
return;
}
Log("Replaced DTA file successfully");
song.Header.MakeAnonymous();
song.Header.ThisType = PackageType.SavedGame;
var success = false;
try
{
Log("Saving changes to pack ... sit tight");
Log("THIS STEP MAY TAKE A WHILE. DON'T CLOSE ME DOWN!");
signature = new RSAParams(Application.StartupPath + "\\bin\\KV.bin");
song.RebuildPackage(signature);
song.FlushPackage(signature);
song.CloseIO();
success = true;
}
catch (Exception ex)
{
Log("There was an error: " + ex.Message);
song.CloseIO();
}
if (success)
{
Log("Trying to unlock CON file");
if (Tools.UnlockCON(con))
{
Log("Unlocked CON file successfully");
}
else
{
Log("Error unlocking CON file");
success = false;
}
}
if (success)
{
if (Tools.SignCON(con))
{
Log("CON file signed successfully");
}
else
{
Log("Error signing CON file");
success = false;
}
}
Tools.DeleteFile(dta);
Log(success ? "Process completed successfully!" : "Something went wrong along the way, sorry!");
if (success)
{
return;
}
if (!backUpCONFile.Checked)
{
return;
}
Log("Restoring backup file");
Tools.DeleteFile(con);
Log(Tools.MoveFile(backup, con) ? "Backup file restored successfully, nothing was lost" : "Sorry, there was an error restoring the backup file");
}
private bool addFiles()
{
if (backgroundWorker1.CancellationPending)
{
return(false);
}
var name = "song";
if (chkFTV.Checked)
{
name = "ftv";
}
var filesAdded = 0;
if (songsFolder.Substring(songsFolder.Length - 1, 1) != "\\")
{
songsFolder = songsFolder + "\\";
}
if (Directory.Exists(songsFolder))
{
var songsInput = Directory.GetFiles(songsFolder);
var enoughFolders = Directory.GetDirectories(songsFolder);
if (enoughFolders.Any()) //only add if there's at least one folder in there
{
packfiles.AddFolder("songs");
foreach (var sFile in songsInput.Where(sFile => sFile.Substring(sFile.Length - 4, 4) != ".dta"))
{
packfiles.AddFile(sFile, "songs/" + Path.GetFileName(sFile));
}
//create song folders and add contents to each
var subFolders = Directory.GetDirectories(songsFolder);
var sFolderLength = songsFolder;
//if songs.dta doesn't exist, create one. if exists, leave it, will be appended
if (!(File.Exists(songsFolder + "songs.dta")))
{
var tempDta = new StreamWriter(songsFolder + "songs.dta", false, Encoding.Default);
tempDta.Dispose();
}
foreach (var songName in from folder in subFolders select folder.Substring(sFolderLength.Length, folder.Length - sFolderLength.Length) into songName select songName.Replace("\\", "") into songName where Directory.Exists(songsFolder + songName) let ending = songName.Substring(songName.Length - 3, 3) where ending != "(1)" && ending != "(2)" && ending != "(3)" && ending != "(4)" && ending != "(5)" select songName)
{
if (backgroundWorker1.CancellationPending)
{
return(false);
}
filesAdded++;
Log("Adding files for song " + filesAdded);
//add all items at the songfolder level (mostly .mid and .mogg files)
packfiles.AddFolder("songs/" + songName);
//if songs.dta is there, add to main songs.dta and then delete
if (File.Exists(songsFolder + songName + "\\songs.dta"))
{
var dtaIn = new StreamReader(songsFolder + songName + "\\songs.dta", Encoding.Default);
var dtaOut = new StreamWriter(songsFolder + "songs.dta", true, Encoding.Default);
while (dtaIn.Peek() >= 0)
{
var line = dtaIn.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
line = Tools.FixBadChars(line);
if (chkID.Checked)
{
//replace short id with custom generated id
if (line == "(")
{
dtaOut.WriteLine(line);
dtaIn.ReadLine();
var month = "0" + nextFriday.Month;
month = month.Substring(month.Length - 2, 2);
var day = "0" + nextFriday.Day;
day = day.Substring(day.Length - 2, 2);
line = " '" + month + day +
nextFriday.Year.ToString(CultureInfo.InvariantCulture)
.Substring(2, 2) + name + filesAdded + "'";
}
else if (!string.IsNullOrWhiteSpace(line) && (line.Substring(0, 1) == "(" && !line.Contains(")")))
{
line = "(" + nextFriday.Month + nextFriday.Day +
nextFriday.Year.ToString(CultureInfo.InvariantCulture)
.Substring(2, 2) + name + filesAdded;
}
}
if (chkRename.Checked)
{
var replace = defaultTool.Checked ? "RECORDING" : "PREVIEW";
//replace artist names to group all together
if (line.ToLowerInvariant().Contains("(artist"))
{
line = " (artist \"VIDEO " + replace + "\")";
}
if (line.ToLowerInvariant().Contains("'artist'"))
{
dtaOut.WriteLine(line);
dtaIn.ReadLine();
line = " \"VIDEO " + replace + "\"";
}
}
if (chkID.Checked)
{
//replace song id with custom generated id
if (line.Contains("song_id"))
{
line = " ('song_id' " + nextFriday.Month + nextFriday.Day +
nextFriday.Year.ToString(CultureInfo.InvariantCulture)
.Substring(2, 2) + name + filesAdded + ")";
}
}
//add mute level setting so all instruments are heard even when missed
if ((line.Contains("'drum_freestyle'") || line.Contains("(drum_freestyle")) && chkVolume.Checked)
{
if (line.Contains("'drum_freestyle'"))
{
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
}
else if (line.Contains("(drum_freestyle"))
{
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
line = dtaIn.ReadLine();
dtaOut.WriteLine(line);
}
dtaOut.WriteLine(" (mute_volume 0.0)");
dtaOut.WriteLine(" (mute_volume_vocals 0.0)");
line = dtaIn.ReadLine();
}
if (line != null && !line.Trim().StartsWith(";;", StringComparison.Ordinal))
{
dtaOut.WriteLine(line);
}
}
dtaIn.Dispose();
dtaOut.WriteLine(""); //separate entries
dtaOut.Dispose();
//delete original dta files
Tools.DeleteFile(songsFolder + songName + "\\songs.dta");
}
//add mid, mogg and other files found at the songname folder level
var songContents = Directory.GetFiles(songsFolder + songName);
if (songContents.Count() != 0)
{
foreach (var contents in songContents)
{
if (backgroundWorker1.CancellationPending)
{
return(false);
}
packfiles.AddFile(contents, "songs/" + songName + "/" + Path.GetFileName(contents));
}
}
//all all items at the gen level (mostly png_xbox and milo_xbox files)
packfiles.AddFolder("songs/" + songName + "/gen");
var subContents = Directory.GetFiles(songsFolder + songName + "\\gen");
if (!subContents.Any())
{
continue;
}
foreach (var contents in subContents)
{
if (backgroundWorker1.CancellationPending)
{
return(false);
}
packfiles.AddFile(contents, "songs/" + songName + "/gen/" + Path.GetFileName(contents));
}
}
//C16 modification. if multiple songs.dta files are found, combine them
var c16Dta = Directory.GetFiles(songsFolder, "*.dta");
if (c16Dta.Count() > 1)
{
//prompt user that multiple dtas were found, and to choose whether to combine them (C16) or not
var dialogResult =
MessageBox.Show("Found multiple songs.dta files in the 'songs' folder\nDo you want me to merge (YES) or discard (NO) the duplicates?\nUnless you're C16 or you know what you're doing, I suggest you discard the duplicates (NO)",
"C16 Modification Activate!", MessageBoxButtons.YesNo, MessageBoxIcon.Information);
switch (dialogResult)
{
case DialogResult.No:
foreach (var c16 in c16Dta.Where(c16 => c16.Substring(c16.Length - 9, 9) != "songs.dta"))
{
Tools.DeleteFile(c16);
}
break;
case DialogResult.Yes:
{
//create temporary dta file
File.Create(songsFolder + "temp_songs.dta").Dispose();
//process the duplicate dtas
foreach (var c16 in c16Dta)
{
//read first dta file
var dtaIn = new StreamReader(c16, Encoding.Default);
var dtaPack = dtaIn.ReadToEnd();
dtaIn.Dispose();
//write to temp dta
var dtaOut = new StreamWriter(songsFolder + "temp_songs.dta", true, Encoding.Default);
dtaOut.Write(dtaPack);
dtaOut.Dispose();
//delete that dta file
Tools.DeleteFile(c16);
}
//now rename that to songs.dta and just allow existing code to add it to the package
Tools.MoveFile(songsFolder + "temp_songs.dta", songsFolder + "songs.dta");
}
break;
}
}
if (File.Exists(songsFolder + "songs.dta"))
{
packfiles.AddFile(songsFolder + "songs.dta", "songs/songs.dta");
}
}
}
Log("Successfully added files for " + filesAdded + (filesAdded > 1 ? " songs" : " song"));
if (filesAdded < inputFiles.Count())
{
Log("It looks like there were some duplicate songs");
Log("I skipped: " + (inputFiles.Count() - filesAdded) + (inputFiles.Count() - filesAdded > 1? " songs" : " song"));
}
Tools.DeleteFolder(tempFolder + "temp\\", true);
return(true);
}
public bool ExtractDecryptMogg(string CON_file, bool bypass, NemoTools tools, DTAParser parser)
{
Initialize();
Tools = tools;
Parser = parser;
Tools.ReleaseStreamHandle();
var temp_dta = Path.GetTempPath() + "temp.dta";
var temp_mogg = Path.GetTempPath() + "temp.mogg";
Tools.DeleteFile(temp_dta);
Tools.DeleteFile(temp_mogg);
if (!Parser.ExtractDTA(CON_file, temp_dta))
{
ErrorLog.Add("Couldn't extract songs.dta file from that CON file");
Tools.DeleteFile(temp_dta);
return(false);
}
if (!Parser.ReadDTA(temp_dta) || !Parser.Songs.Any())
{
ErrorLog.Add("Couldn't read that songs.dta file");
Tools.DeleteFile(temp_dta);
return(false);
}
Tools.DeleteFile(temp_dta);
if (Parser.Songs.Count > 1)
{
ErrorLog.Add("This feature does not support packs, only single songs\nUse the dePACK feature in C3 CON Tools' Quick Pack Editor to split this pack into single songs and try again");
return(false);
}
var internal_name = Parser.Songs[0].InternalName;
var xCON = new STFSPackage(CON_file);
if (!xCON.ParseSuccess)
{
ErrorLog.Add("Couldn't parse that CON file");
xCON.CloseIO();
return(false);
}
var xMogg = xCON.GetFile("songs/" + internal_name + "/" + internal_name + ".mogg");
if (xMogg == null)
{
ErrorLog.Add("Couldn't find the mogg file inside that CON file");
xCON.CloseIO();
return(false);
}
if (!xMogg.Extract(temp_mogg))
{
ErrorLog.Add("Couldn't extract the mogg file from that CON file");
xCON.CloseIO();
return(false);
}
xCON.CloseIO();
LoadLibraries();
if (Tools.DecM(temp_mogg, bypass, false, DecryptMode.ToMemory))
{
Tools.DeleteFile(temp_mogg);
return(true);
}
Tools.DeleteFile(temp_mogg);
ErrorLog.Add("Mogg file is encrypted and I could not decrypt it, can't split it");
UnloadLibraries();
Tools.ReleaseStreamHandle();
return(false);
}
private bool ProcessFiles()
{
var counter = 0;
var success = 0;
foreach (var file in inputFiles.Where(File.Exists).TakeWhile(file => !backgroundWorker1.CancellationPending))
{
try
{
if (VariousFunctions.ReadFileType(file) != XboxFileType.STFS)
{
continue;
}
Song.NewSong();
Song.ReplaceGenreWithSub = useSubgenreInsteadOfGenreToolStripMenuItem.Checked;
try
{
if (!Directory.Exists(PSFolder))
{
Directory.CreateDirectory(PSFolder);
}
counter++;
Parser.ExtractDTA(file);
Parser.ReadDTA(Parser.DTA);
if (Parser.Songs.Count > 1)
{
Log("File " + Path.GetFileName(file) + " is a pack, try dePACKing first, skipping...");
continue;
}
if (!Parser.Songs.Any())
{
Log("There was an error processing the songs.dta file");
continue;
}
if (loadDTA())
{
Log("Loaded and processed songs.dta file for song #" + counter + " successfully");
Log("Song #" + counter + " is " + Song.Artist + " - " + Song.Name);
}
else
{
return(false);
}
var songfolder = PSFolder + Tools.CleanString(Song.Artist, false) + " - " + Tools.CleanString(Song.Name, false) + "\\";
if (!Directory.Exists(songfolder))
{
Directory.CreateDirectory(songfolder);
}
var internal_name = Parser.Songs[0].InternalName;
var xPackage = new STFSPackage(file);
if (!xPackage.ParseSuccess)
{
Log("Failed to parse '" + Path.GetFileName(file) + "'");
Log("Skipping this file");
continue;
}
var xArt = xPackage.GetFile("songs/" + internal_name + "/gen/" + internal_name + "_keep.png_xbox");
if (xArt != null)
{
var newart = songfolder + "album.png_xbox";
if (xArt.ExtractToFile(newart))
{
Log("Extracted album art file " + internal_name + "_keep.png_xbox successfully");
fromXbox(newart);
}
else
{
Log("There was a problem extracting the album art file");
}
}
else
{
Log("WARNING: Did not find album art file in that CON file");
}
var xMIDI = xPackage.GetFile("songs/" + internal_name + "/" + internal_name + ".mid");
if (xMIDI != null)
{
var newmidi = songfolder + "notes.mid";
if (xMIDI.ExtractToFile(newmidi))
{
Log("Extracted MIDI file " + internal_name + ".mid successfully");
ProcessMidi(newmidi);
}
else
{
Log("There was a problem extracting the MIDI file");
Log("Skipping this song...");
xPackage.CloseIO();
continue;
}
}
else
{
Log("ERROR: Did not find a MIDI file in that CON file!");
Log("Skipping this song...");
xPackage.CloseIO();
continue;
}
var xMOGG = xPackage.GetFile("songs/" + internal_name + "/" + internal_name + ".mogg");
if (xMOGG != null)
{
var newmogg = songfolder + internal_name + ".mogg";
if (radioSeparate.Checked)
{
xPackage.CloseIO();
SeparateAudio(file, newmogg, songfolder);
}
else if (radioDownmix.Checked)
{
xPackage.CloseIO();
DownMixAudio(file, songfolder);
}
else
{
var msg = "Extracting audio file " + (radioAudacity.Checked ? "to send to Audacity" : "and leaving it as is");
Log(msg);
var mData = xMOGG.Extract();
if (mData != null && mData.Length > 0)
{
Log("Successfully extracted audio file '" + Path.GetFileName(newmogg) + "'");
if (radioAudacity.Checked)
{
Log("Sending audio file to Audacity now");
Tools.DecM(mData, false, false, DecryptMode.ToFile, newmogg);
Log(Tools.SendtoAudacity(newmogg));
}
else
{
Tools.WriteOutData(Tools.ObfM(mData), newmogg);
}
}
else
{
Log("There was a problem extracting the audio file");
Log("Skipping this song...");
xPackage.CloseIO();
continue;
}
}
}
else
{
Log("ERROR: Did not find an audio file in that CON file!");
Log("Skipping this song...");
xPackage.CloseIO();
continue;
}
xPackage.CloseIO();
if (!Directory.Exists(songfolder))
{
Directory.CreateDirectory(songfolder);
}
Song.WriteINIFile(songfolder, !chkNoC3.Checked);
var banner = Application.StartupPath + "\\res\\phaseshift\\banner.png";
if (File.Exists(banner) && !chkNoC3.Checked)
{
Tools.DeleteFile(songfolder + "banner.png");
File.Copy(banner, songfolder + "banner.png");
}
var icon = Application.StartupPath + "\\res\\phaseshift\\c3.png";
if (File.Exists(icon) && !chkNoC3.Checked)
{
Tools.DeleteFile(songfolder + "ccc.png");
File.Copy(icon, songfolder + "ccc.png");
}
success++;
if (!chkRAR.Checked || backgroundWorker1.CancellationPending)
{
continue;
}
var archive = Path.GetFileName(file);
archive = archive.Replace(" ", "").Replace("-", "_").Replace("\\", "").Replace("'", "").Replace(",", "").Replace("_rb3con", "");
archive = Tools.CleanString(archive, false);
archive = PSFolder + archive + "_ps.rar";
var arg = "a -m5 -ep1 -r \"" + archive + "\" \"" + songfolder.Substring(0, songfolder.Length - 1) + "\"";
Log("Creating RAR archive");
Log(Tools.CreateRAR(rar, archive, arg)? "Created RAR archive successfully" : "RAR archive creation failed");
}
catch (Exception ex)
{
Log("There was an error: " + ex.Message);
Log("Attempting to continue with the next file");
}
}
catch (Exception ex)
{
Log("There was a problem accessing that file");
Log("The error says: " + ex.Message);
}
}
Log("Successfully processed " + success + " of " + counter + " files");
return(true);
}
private bool DoSplitMogg(string folder, string StemsToSplit, MoggSplitFormat format, string quality)
{
var ext = "ogg";
if (format == MoggSplitFormat.WAV)
{
ext = "wav";
}
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var drums = folder + "drums." + ext;
var drums1 = folder + "drums_1." + ext;
var drums2 = folder + "drums_2." + ext;
var drums3 = folder + "drums_3." + ext;
var bass = folder + "bass." + ext;
var rhythm = folder + "rhythm." + ext;
var guitar = folder + "guitar." + ext;
var keys = folder + "keys." + ext;
var vocals = folder + "vocals." + ext;
var backing = folder + "backing." + ext;
var song = folder + "song." + ext;
var crowd = folder + "crowd." + ext;
var tracks = new List <string> {
drums, drums1, drums2, drums3, bass, guitar, keys, vocals, backing, crowd
};
foreach (var track in tracks)
{
Tools.DeleteFile(track);
}
try
{
if (!InitBass())
{
return(false);
}
SourceStream = Bass.BASS_StreamCreateFile(Tools.GetOggStreamIntPtr(), 0, Tools.PlayingSongOggData.Length, BASSFlag.BASS_STREAM_DECODE);
var info = Bass.BASS_ChannelGetInfo(SourceStream);
var ArrangedChannels = ArrangeStreamChannels(info.chans, true);
var isSlave = false;
if (Parser.Songs[0].ChannelsDrums > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("drums")))
{
switch (Parser.Songs[0].ChannelsDrums)
{
case 2:
PrepareChannelsToSplit(0, ArrangedChannels, 2, GetStemVolume(0), drums, format, quality, false);
break;
case 3:
PrepareChannelsToSplit(0, ArrangedChannels, 1, GetStemVolume(0), drums1, format, quality, false);
PrepareChannelsToSplit(1, ArrangedChannels, 2, GetStemVolume(1), drums2, format, quality);
break;
case 4:
PrepareChannelsToSplit(0, ArrangedChannels, 1, GetStemVolume(0), drums1, format, quality, false);
PrepareChannelsToSplit(1, ArrangedChannels, 1, GetStemVolume(1), drums2, format, quality);
PrepareChannelsToSplit(2, ArrangedChannels, 2, GetStemVolume(2), drums3, format, quality);
break;
case 5:
PrepareChannelsToSplit(0, ArrangedChannels, 1, GetStemVolume(0), drums1, format, quality, false);
PrepareChannelsToSplit(1, ArrangedChannels, 2, GetStemVolume(1), drums2, format, quality);
PrepareChannelsToSplit(3, ArrangedChannels, 2, GetStemVolume(3), drums3, format, quality);
break;
case 6:
PrepareChannelsToSplit(0, ArrangedChannels, 2, GetStemVolume(0), drums1, format, quality, false);
PrepareChannelsToSplit(2, ArrangedChannels, 2, GetStemVolume(2), drums2, format, quality);
PrepareChannelsToSplit(4, ArrangedChannels, 2, GetStemVolume(4), drums3, format, quality);
break;
}
isSlave = true;
}
var channel = Parser.Songs[0].ChannelsDrums;
if (Parser.Songs[0].ChannelsBass > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("bass") || StemsToSplit.Contains("rhythm")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsBass, GetStemVolume(channel), StemsToSplit.Contains("rhythm") ? rhythm : bass, format, quality, isSlave);
isSlave = true;
}
channel += Parser.Songs[0].ChannelsBass;
if (Parser.Songs[0].ChannelsGuitar > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("guitar")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsGuitar, GetStemVolume(channel), guitar, format, quality, isSlave);
isSlave = true;
}
channel += Parser.Songs[0].ChannelsGuitar;
if (Parser.Songs[0].ChannelsVocals > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("vocals")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsVocals, GetStemVolume(channel), vocals, format, quality, isSlave);
isSlave = true;
}
channel += Parser.Songs[0].ChannelsVocals;
if (Parser.Songs[0].ChannelsKeys > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("keys")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsKeys, GetStemVolume(channel), keys, format, quality, isSlave);
isSlave = true;
}
channel += Parser.Songs[0].ChannelsKeys;
if (Parser.Songs[0].ChannelsBacking() > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("backing") || StemsToSplit.Contains("song")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsBacking(), GetStemVolume(channel), StemsToSplit.Contains("song") ? song : backing, format, quality, isSlave);
isSlave = true;
}
channel += Parser.Songs[0].ChannelsBacking();
if (Parser.Songs[0].ChannelsCrowd > 0 && (StemsToSplit.Contains("allstems") || StemsToSplit.Contains("crowd")))
{
PrepareChannelsToSplit(channel, ArrangedChannels, Parser.Songs[0].ChannelsCrowd, GetStemVolume(channel), crowd, format, quality, isSlave);
}
while (true)
{
var buffer = new byte[20000];
var c = Bass.BASS_ChannelGetData(Splits[0], buffer, buffer.Length);
if (c < 0)
{
break;
}
for (var i = 1; i < Splits.Count; i++)
{
while (Bass.BASS_ChannelGetData(Splits[i], buffer, buffer.Length) > 0)
{
}
}
}
foreach (var split in Splits)
{
Bass.BASS_StreamFree(split);
}
UnloadLibraries();
Tools.ReleaseStreamHandle();
}
catch (Exception ex)
{
ErrorLog.Add("Error splitting mogg file:");
ErrorLog.Add(ex.Message);
foreach (var split in Splits)
{
Bass.BASS_StreamFree(split);
}
UnloadLibraries();
Tools.ReleaseStreamHandle();
return(false);
}
return(true);
}
private void btnBundle_Click(object sender, EventArgs e)
{
if (!File.Exists(orig_midi))
{
Log("MIDI file " + Path.GetFileName(orig_midi) + " is missing! Did you just delete it?");
MIDIFixFailed(orig_midi, false);
return;
}
if (!File.Exists(orig_dta))
{
Log("DTA file " + Path.GetFileName(orig_dta) + " is missing! Did you just delete it?");
MIDIFixFailed(orig_dta, false);
return;
}
newMIDI = Path.GetDirectoryName(orig_midi) + "\\" + Path.GetFileNameWithoutExtension(orig_midi) + " (bundled).mid";
newDTA = Path.GetDirectoryName(orig_dta) + "\\" + Path.GetFileNameWithoutExtension(orig_dta) + " (bundled).dta";
var skip_tracks = ignoreNoninstrumentTracks.Checked ? new List <string> {
"EVENTS", "VENUE", "BEAT"
} : new List <string>();
var midi = Tools.NemoLoadMIDI(orig_midi);
if (midi == null)
{
MIDIFixFailed(orig_midi);
return;
}
var harm1 = false;
var harm2 = false;
var harm3 = false;
foreach (var UpgMidi in UpgradeMidis)
{
if (!File.Exists(UpgMidi))
{
Log("Upgrade MIDI file " + Path.GetFileName(UpgMidi) + " is missing! Did you just delete it?");
continue;
}
var upgrade = Tools.NemoLoadMIDI(UpgMidi);
if (upgrade == null)
{
MIDIFixFailed(UpgMidi);
return;
}
Tools.DeleteFile(newMIDI);
Tools.DeleteFile(newDTA);
var origtracks = new List <string>();
//check which tracks are in original midi
for (var i = 0; i < midi.Events.Tracks; i++)
{
var trackname = Tools.GetMidiTrackName(midi.Events[i][0].ToString());
if (!origtracks.Contains(trackname) && !skip_tracks.Contains(trackname))
{
origtracks.Add(trackname);
}
}
var upgtracks = new List <string>();
//check what tracks are in the upgrade midi
//skip track 0 = tempo track
for (var i = 1; i < upgrade.Events.Tracks; i++)
{
var trackname = Tools.GetMidiTrackName(upgrade.Events[i][0].ToString());
if (trackname.Contains("HARM1") || trackname.Contains("VOCALS"))
{
harm1 = true;
}
else if (trackname.Contains("HARM2"))
{
harm2 = true;
}
else if (trackname.Contains("HARM3"))
{
harm3 = true;
}
if (!upgtracks.Contains(trackname) && !skip_tracks.Contains(trackname))
{
upgtracks.Add(trackname);
}
}
if (overwriteExistingTrack.Checked) //only remove if checked to overwrite
{
var to_remove = new List <int>();
for (var i = 0; i < midi.Events.Tracks; i++)
{
var trackname = Tools.GetMidiTrackName(midi.Events[i][0].ToString());
if (upgtracks.Contains(trackname))
{
to_remove.Add(i); //remove only if found in the upgrade midi and overwrite is checked
}
}
to_remove.Sort();
for (var i = to_remove.Count - 1; i >= 0; i--)
{
var trackname = Tools.GetMidiTrackName(midi.Events[to_remove[i]][0].ToString());
try
{
midi.Events.RemoveTrack(to_remove[i]);
}
catch (Exception ex)
{
Log("There was an error deleting track " + trackname);
Log("Error: " + ex.Message);
}
}
}
var rbhp_xkeys = false;
var rbhp_ekeys = false;
//combine upgrade with original
for (var i = 0; i < upgrade.Events.Tracks; i++)
{
var trackname = Tools.GetMidiTrackName(upgrade.Events[i][0].ToString());
if (!upgtracks.Contains(trackname) || (origtracks.Contains(trackname) && onlyAddNewTracks.Checked))
{
continue;
}
try
{
if (trackname.Contains("KEYS_X"))
{
if (!rbhp_xkeys)
{
midi.Events.AddTrack(upgrade.Events[i]);
}
rbhp_xkeys = true; //sometimes rbhp uses two pro keys x tracks for whatever reason, only add one
continue;
}
if (trackname.Contains("KEYS_E"))
{
if (!rbhp_ekeys)
{
midi.Events.AddTrack(upgrade.Events[i]);
}
rbhp_ekeys = true; //sometimes rbhp uses two pro keys e tracks for whatever reason, only add one
continue;
}
midi.Events.AddTrack(upgrade.Events[i]);
}
catch (Exception ex)
{
Log("There was an error processing the upgrade MIDI file");
Log("Error: " + ex.Message);
}
}
}
try
{
MidiFile.Export(newMIDI, midi.Events);
}
catch (Exception ex)
{
Log("There was an error exporting the combined MIDI file");
Log("Error: " + ex.Message);
}
if (File.Exists(newMIDI))
{
Log("Combined MIDI files successfully");
}
else
{
Log("There was an error creating the combined MIDI file");
return;
}
if (string.IsNullOrWhiteSpace(orig_con))
{
Log("Process completed successfully");
Log("Bundled MIDI file can be found in:");
Log(newMIDI);
return;
}
if (!string.IsNullOrWhiteSpace(newsongdta) && File.Exists(newsongdta))
{
Log("Replacing original songs.dta with RBHP songs.dta file");
orig_dta = newsongdta; //if we got RBHP dta, completely replace original one
}
if (!string.IsNullOrWhiteSpace(newupgdta) && File.Exists(newupgdta))
{
Log("Merging upgrades.dta information into songs.dta file");
var sr = new StreamReader(orig_dta, Encoding.Default);
var sw = new StreamWriter(newDTA, false, Encoding.Default);
var doneTuning = false;
//first pass, replace values if already present
while (sr.Peek() > 0)
{
var line = sr.ReadLine();
if (!string.IsNullOrWhiteSpace(line))
{
if (line.Contains("rank"))
{
sw.WriteLine(line);
while (line != null && !line.Contains("format"))
{
line = sr.ReadLine();
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
if (line.Contains("bass") && !line.Contains("real_bass"))
{
sw.WriteLine(line);
sw.WriteLine(probassdiff);
line = "";
}
else if (line.Contains("guitar") && !line.Contains("real_guitar"))
{
sw.WriteLine(line);
sw.WriteLine(proguitardiff);
line = "";
}
else if (line.Contains("real_guitar") || line.Contains("real_bass"))
{
line = "";
}
if (!string.IsNullOrWhiteSpace(line))
{
sw.WriteLine(line);
}
}
}
if (string.IsNullOrWhiteSpace(line))
{
continue;
}
if (line.Contains("real_guitar") || line.Contains("real_bass"))
{
line = "";
}
else if (line.Contains(";The following values"))
{
sw.WriteLine(proguitartuning);
sw.WriteLine(probasstuning);
doneTuning = true;
}
else if (line == ")" && !doneTuning)
{
if (sr.Peek() <= 0)
{
sw.WriteLine(proguitartuning);
sw.WriteLine(probasstuning);
}
}
}
if (!string.IsNullOrWhiteSpace(line))
{
sw.WriteLine(line);
}
}
sr.Dispose();
sw.Dispose();
if (File.Exists(newDTA))
{
Log("Merged DTA information successfully");
}
else
{
Log("There was an error merging DTA information");
return;
}
}
else
{
Tools.DeleteFile(newDTA);
File.Copy(orig_dta, newDTA);
}
var vocals = harm3 ? 3 : (harm2 ? 2 : (harm1) ? 1 : 0);
if (showSongIDPrompt.Checked)
{
var popup = new PasswordUnlocker(songID == NA || useUpgradeID.Checked ? upgradeID : songID);
popup.IDChanger();
popup.ShowDialog();
var newID = popup.EnteredText;
popup.Dispose();
if (!string.IsNullOrWhiteSpace(newID))
{
songID = newID;
}
}
else if (useUpgradeID.Checked)
{
songID = upgradeID;
}
Tools.ReplaceSongID(newDTA, songID, vocals.ToString(CultureInfo.InvariantCulture));
Log("Creating the bundled file");
EnableDisable(false);
btnBundle.Visible = false;
backgroundWorker1.RunWorkerAsync();
}
private void replaceFileToolStripMenuItem_Click(object sender, EventArgs e)
{
if (fileList.SelectedIndices.Count == 0)
{
return;
}
var xent = (FileEntry)fileList.SelectedItems[0].Tag;
var extension = Path.GetExtension(fileList.SelectedItems[0].Text);
if (extension != null)
{
var filterFiles = extension.Substring(1).ToUpper() + " File|*." +
extension.Substring(1);
var file = VariousFunctions.GetUserFileLocale("Open a File", filterFiles, true);
if (file == null)
{
return;
}
Log("Replacing file " + xent.Name);
var obf_file = Path.GetTempPath() + "m";
if (Path.GetExtension(file) == ".mogg")
{
Tools.DeleteFile(obf_file);
File.Copy(file, obf_file);
Tools.WriteOutData(Tools.DeObfM(File.ReadAllBytes(obf_file)), obf_file);
}
else
{
obf_file = file;
}
if (!xent.Replace(obf_file))
{
Log("Error replacing file " + xent.Name);
return;
}
Tools.CurrentFolder = Path.GetDirectoryName(file);
}
Log("Replaced file " + xent.Name + " successfully");
ShowChanges(true);
}
