dsdecmp/CSharp/DSDecmp/NewestProgram.cs
barubary 4302517e58 C#: Added xml comments to methods that did not have any (in the main DSDecmp project).
The SupportsDecompression-flag is now also used in the main program, and not just in composite formats.
2011-11-14 17:33:30 +00:00

590 lines
27 KiB
C#

using System;
using System.Collections.Generic;
using System.Text;
using System.Reflection;
using System.IO;
using DSDecmp.Formats;
using DSDecmp.Formats.Nitro;
namespace DSDecmp
{
class NewestProgram
{
#if DEBUG
public static string PluginFolder = "../../../PluginDistro/Debug";
#else
public static string PluginFolder = "./Plugins";
#endif
public static void Main(string[] args)
{
// I/O input:
// file -> read from file, save to file
// folder [-co] -> read all files from folder, save to folder_dec or folder_cmp (when decomp or comp resp.) (Same filenames)
// file newfile -> read from file, save to newfile
// folderin folderout [-co] -> read all files from folderin, save to folderout. (Same filenames)
// file1 file2 ... -> read file1, file2, etc
// file1 file2 ... folderout [-co] -> read file1, file2, etc, save to folderout. (same filenames)
// -> when -co is present, all files that could not be (de)compressed will be copied instead.
// preambles:
// <nothing> -> decompress input to output using first matched format
// -d [-ge] -> decompress input to output using first matched format. If -ge, then guess the extension based on first 4 bytes.
// -d [-ge] -f <format> -> decompress input to output using the indicated format. If -ge, then guess the extension based on first 4 bytes.
// -c <format> [opt1 opt2 ...] -> compress input to output using the specified format and its options.
// built-in formats:
// lz10 -> LZ-0x10, found in >= GBA
// lz11 -> LZ-0x11, found in >= NDS
// lzovl -> LZ-Ovl/Overlay / backwards LZ, found mostly in NDS overlay files.
// huff4 -> 4-bit Huffman, found in >= GBA
// huff8 -> 8-bit Huffman, found in >= GBA
// huff -> any Huffman format.
// gba* -> any format natively supported by the GBA
// nds* -> any format natively supported by the NDS, but not LZ-Ovl
// when compressing, the best format of the selected set is used. when decompression,
// only the formats in the selected set are used.
if (args.Length == 0)
{
PrintUsage();
//Console.ReadLine();
return;
}
if (args[0] == "-c")
{
if (args.Length <= 2) { Console.WriteLine("Too few arguments."); return; }
CompressionFormat format = FirstOrDefault(GetFormat(args[1]));
if (format == null) { return; }
string[] ioArgs = new string[args.Length - 2];
Array.Copy(args, 2, ioArgs, 0, ioArgs.Length);
int optionCount = format.ParseCompressionOptions(ioArgs);
string[] realIoArgs = new string[ioArgs.Length - optionCount];
Array.Copy(ioArgs, optionCount, realIoArgs, 0, realIoArgs.Length);
Compress(realIoArgs, format);
}
else if (args[0] == "-d")
{
if (args.Length <= 1) { PrintUsage(); return; }
int ioIdx = 1;
bool guessExtension = false;
if (args[ioIdx] == "-ge")
{
guessExtension = true;
ioIdx++;
}
IEnumerable<CompressionFormat> formats = GetAllFormats(false); // we do not need the built-in composite formats to decompress.
if (args[ioIdx] == "-f")
{
if (args.Length <= ioIdx + 2) { Console.WriteLine("Too few arguments."); return; }
formats = GetFormat(args[ioIdx + 1]);
ioIdx += 2;
}
if (formats == null) { return; }
if (args.Length <= ioIdx) { Console.WriteLine("Too few arguments."); return; }
string[] ioArgs = new string[args.Length - ioIdx];
Array.Copy(args, ioIdx, ioArgs, 0, ioArgs.Length);
Decompress(ioArgs, formats, guessExtension);
}
else
{
Decompress(args, GetAllFormats(false), false);
}
}
#region Usage printer
private static void PrintUsage()
{
Console.WriteLine("DSDecmp - Decompressor for compression formats used on the NDS - by Barubary");
Console.WriteLine();
Console.WriteLine("Usage:\tDSDecmp FMTARGS IOARGS");
Console.WriteLine();
Console.WriteLine("IOARGS can be:");
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine("file -> read the file, overwrite it.");
Console.WriteLine("folder [-co] -> read all files from folder, save to folder_dec");
Console.WriteLine(" or folder_cmp.");
Console.WriteLine("file newfile -> read the file, save it to newfile.");
Console.WriteLine(" (newfile cannot exist yet)");
Console.WriteLine("folderin folderout [-co] -> read all files from folderin, save to folderout.");
Console.WriteLine("file1 file2 ... -> read file1, file2, etc; overwrite them.");
Console.WriteLine("file1 file2 ... folderout [-co] -> read file1, file2, etc; save to folderout.");
Console.WriteLine();
Console.WriteLine("When -co is present, all files that could not be handled will be copied to the");
Console.WriteLine(" indicated output folder.");
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine();
Console.WriteLine("FMTARGS can be:");
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine("<nothing> -> try to decompress input to output.");
Console.WriteLine("-d [-ge] -> try to decompress input to output.");
Console.WriteLine("-d [-ge] -f <format> -> try to decompress input to output, using fiven format");
Console.WriteLine("-c <format> [opt1 ...] -> compress intput to output using given format ");
Console.WriteLine(" and options.");
Console.WriteLine();
Console.WriteLine("When -ge is present, the extension of the output file will be determined by");
Console.WriteLine(" the first 4 bytes of the decompressed data. (of those are alphanuemric ASCII");
Console.WriteLine(" characters).");
Console.WriteLine("-------------------------------------------------------------------------------");
Console.WriteLine("Supported formats:");
Console.WriteLine("<format> -> description");
foreach (CompressionFormat fmt in GetAllFormats(true))
{
Console.WriteLine(fmt.CompressionFlag.PadRight(7, ' ') + "-> " + fmt.Description);
}
Console.WriteLine("-------------------------------------------------------------------------------");
}
#endregion
#region Method: Decompress(string[] ioArgs, IEnumerable<CompressionFormat> formats)
private static void Decompress(string[] ioArgs, IEnumerable<CompressionFormat> formats, bool guessExtension)
{
string[] inputFiles;
string outputDir;
bool copyErrors;
if (!ParseIOArguments(ioArgs, false, out inputFiles, out outputDir, out copyErrors))
return;
foreach (string input in inputFiles)
{
string outputFile = outputDir ?? IOUtils.GetParent(input);
if (Directory.Exists(outputDir))
outputFile = Path.Combine(outputFile + Path.DirectorySeparatorChar, Path.GetFileName(input));
try
{
// read the file only once.
byte[] inputData;
using (Stream inStream = File.OpenRead(input))
{
inputData = new byte[inStream.Length];
inStream.Read(inputData, 0, inputData.Length);
}
bool decompressed = false;
foreach (CompressionFormat format in formats)
{
if (!format.SupportsDecompression)
continue;
#region try to decompress using the current format
using (MemoryStream inStr = new MemoryStream(inputData),
outStr = new MemoryStream())
{
if (!format.Supports(inStr, input.Length))
continue;
try
{
long decompSize = format.Decompress(inStr, inputData.Length, outStr);
if (decompSize < 0)
continue;
if (guessExtension)
{
string outFileName = Path.GetFileNameWithoutExtension(outputFile);
outStr.Position = 0;
byte[] magic = new byte[4];
outStr.Read(magic, 0, 4);
outStr.Position = 0;
outFileName += "." + GuessExtension(magic, Path.GetExtension(outputFile).Substring(1));
outputFile = outputFile.Replace(Path.GetFileName(outputFile), outFileName);
}
using (FileStream output = File.Create(outputFile))
{
outStr.WriteTo(output);
}
decompressed = true;
Console.WriteLine(format.ShortFormatString + "-decompressed " + input + " to " + outputFile);
break;
}
catch (TooMuchInputException tmie)
{
// a TMIE is fine. let the user know and continue saving the decompressed data.
Console.WriteLine(tmie.Message);
if (guessExtension)
{
string outFileName = Path.GetFileNameWithoutExtension(outputFile);
outStr.Position = 0;
byte[] magic = new byte[4];
outStr.Read(magic, 0, 4);
outStr.Position = 0;
outFileName += "." + GuessExtension(magic, Path.GetExtension(outputFile).Substring(1));
outputFile = outputFile.Replace(Path.GetFileName(outputFile), outFileName);
}
using (FileStream output = File.Create(outputFile))
{
outStr.WriteTo(output);
}
decompressed = true;
Console.WriteLine(format.ShortFormatString + "-decompressed " + input + " to " + outputFile);
break;
}
catch (Exception)
{
continue;
}
}
#endregion
}
if (!decompressed)
{
#region copy or print and continue
if (copyErrors)
{
Copy(input, outputFile);
}
else
Console.WriteLine("No suitable decompressor found for " + input + ".");
#endregion
}
}
catch (FileNotFoundException)
{
Console.WriteLine("The file " + input + " does not exist.");
continue;
}
catch (Exception ex)
{
Console.WriteLine("Could not load file " + input + ";");
Console.WriteLine(ex.Message);
#if DEBUG
Console.WriteLine(ex.StackTrace);
#endif
}
} // end foreach input
}
#endregion Method: Decompress
#region Method: Compress
/// <summary>
/// (Attempts to) Compress the given input to the given output, using the given format.
/// </summary>
/// <param name="ioArgs">The I/O arguments from the program input.</param>
/// <param name="format">The desired format to compress with.</param>
private static void Compress(string[] ioArgs, CompressionFormat format)
{
if (!format.SupportsCompression)
{
Console.WriteLine("Cannot compress using " + format.ShortFormatString + "; compression is not supported.");
return;
}
string[] inputFiles;
string outputDir;
bool copyErrors;
if (!ParseIOArguments(ioArgs, true, out inputFiles, out outputDir, out copyErrors))
return;
foreach (string input in inputFiles)
{
string outputFile = outputDir ?? IOUtils.GetParent(input);
if (Directory.Exists(outputDir))
outputFile = Path.Combine(outputFile + Path.DirectorySeparatorChar, Path.GetFileName(input));
try
{
// read the file only once.
byte[] inputData;
using (Stream inStream = File.OpenRead(input))
{
inputData = new byte[inStream.Length];
inStream.Read(inputData, 0, inputData.Length);
}
bool compressed = false;
#region try to compress
using (MemoryStream inStr = new MemoryStream(inputData),
outStr = new MemoryStream())
{
try
{
long compSize = format.Compress(inStr, inputData.Length, outStr);
if (compSize > 0)
{
using (FileStream output = File.Create(outputFile))
{
outStr.WriteTo(output);
}
compressed = true;
if (format is CompositeFormat)
Console.Write((format as CompositeFormat).LastUsedCompressFormatString);
else
Console.Write(format.ShortFormatString);
Console.WriteLine("-compressed " + input + " to " + outputFile);
}
}
catch (Exception) { }
}
#endregion
if (!compressed)
{
#region copy or print and continue
if (copyErrors)
{
Copy(input, outputFile);
}
else
Console.WriteLine("Could not " + format.ShortFormatString + "-compress " + input + ".");
#endregion
}
}
catch (FileNotFoundException)
{
Console.WriteLine("The file " + input + " does not exist.");
continue;
}
catch (Exception ex)
{
Console.WriteLine("Could not load file " + input + ";");
Console.WriteLine(ex.Message);
#if DEBUG
Console.WriteLine(ex.StackTrace);
#endif
}
} // end foreach input
}
#endregion Method: Compress
#region Method: ParseIOArguments
/// <summary>
/// Parses the IO arguments of the input.
/// </summary>
/// <param name="ioArgs">The arguments to parse.</param>
/// <param name="compress">If the arguments are used for compression. If not, decompression is assumed. (used for default output folder name)</param>
/// <param name="inputFiles">The files to handle as input.</param>
/// <param name="outputDir">The directory to save the handled files in. If this is null,
/// the files should be overwritten. If this does not exist, it is the output file
/// (the input may only contain one file if that si the case).</param>
/// <param name="copyErrors">If files that cannot be handled (properly) should be copied to the output directory.</param>
/// <returns>True iff parsing of the arguments succeeded.</returns>
private static bool ParseIOArguments(string[] ioArgs, bool compress, out string[] inputFiles, out string outputDir, out bool copyErrors)
{
inputFiles = null;
// when null, output dir = input dir. if it does not exist, it is the output file (only possible when only one input file).
outputDir = null;
copyErrors = false;
#region check if the -co flag is present
if (ioArgs.Length > 0 && ioArgs[ioArgs.Length - 1] == "-co")
{
string[] newIoArgs = new string[ioArgs.Length - 1];
Array.Copy(ioArgs, newIoArgs, newIoArgs.Length);
ioArgs = newIoArgs;
copyErrors = true;
}
#endregion
switch (ioArgs.Length)
{
case 0:
Console.WriteLine("No input file given.");
return false;
case 1:
if (Directory.Exists(ioArgs[0]))
{
inputFiles = Directory.GetFiles(ioArgs[0]);
if (compress)
outputDir = Path.GetFullPath(ioArgs[0]) + "_cmp";
else
outputDir = Path.GetFullPath(ioArgs[0]) + "_dec";
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
break;
}
else if (File.Exists(ioArgs[0]))
{
inputFiles = ioArgs;
outputDir = null;
break;
}
else
{
Console.WriteLine("The file " + ioArgs[0] + " does not exist.");
return false;
}
case 2:
if (Directory.Exists(ioArgs[0]))
{
inputFiles = Directory.GetFiles(ioArgs[0]);
outputDir = ioArgs[1];
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
break;
}
else if (File.Exists(ioArgs[0]))
{
if (File.Exists(ioArgs[1]))
{
inputFiles = ioArgs;
outputDir = null;
break;
}
else// if (Directory.Exists(ioArgs[1]))
// both nonexisting file and existing directory is handled the same.
{
inputFiles = new string[] { ioArgs[0] };
outputDir = ioArgs[1];
break;
}
}
else
{
Console.WriteLine("The file " + ioArgs[0] + " does not exist.");
return false;
}
default:
if (File.Exists(ioArgs[ioArgs.Length - 1]))
{
inputFiles = ioArgs;
outputDir = null;
break;
}
else //if (Directory.Exists(ioArgs[ioArgs.Length - 1]))
// both existing and nonexisting directories are fine.
{
outputDir = ioArgs[ioArgs.Length - 1];
inputFiles = new string[ioArgs.Length - 1];
Array.Copy(ioArgs, inputFiles, inputFiles.Length);
// but we must make sure the output directory exists.
if (!Directory.Exists(outputDir))
Directory.CreateDirectory(outputDir);
break;
}
}
return true;
}
#endregion ParseIOArguments
#region Method: GuessExtension(magic, defaultExt)
/// <summary>
/// Guess the extension of a file by looking at the given magic bytes of a file.
/// If they are alphanumeric (without accents), they could indicate the type of file.
/// If no sensible extension could be found from the magic bytes, the given default extension is returned.
/// </summary>
private static string GuessExtension(byte[] magic, string defaultExt)
{
string ext = "";
for (int i = 0; i < magic.Length && i < 4; i++)
{
if ((magic[i] >= 'a' && magic[i] <= 'z') || (magic[i] >= 'A' && magic[i] <= 'Z')
|| char.IsDigit((char)magic[i]))
{
ext += (char)magic[i];
}
else
break;
}
if (ext.Length <= 1)
return defaultExt;
return ext;
}
#endregion
/// <summary>
/// Copies the source file to the destination path.
/// </summary>
private static void Copy(string sourcefile, string destfile)
{
if (Path.GetFullPath(sourcefile) == Path.GetFullPath(destfile))
return;
File.Copy(sourcefile, destfile);
Console.WriteLine("Copied " + sourcefile + " to " + destfile);
}
#region Format sequence getters
/// <summary>
/// Gets the compression format corresponding to the given format string.
/// </summary>
private static IEnumerable<CompressionFormat> GetFormat(string formatstring)
{
if (formatstring == null)
yield break;
foreach (CompressionFormat fmt in GetAllFormats(true))
if (fmt.CompressionFlag == formatstring)
{
yield return fmt;
yield break;
}
Console.WriteLine("No such compression format: " + formatstring);
}
/// <summary>
/// Gets a sequence over all compression formats currently supported; both built-in and plugin-based.
/// </summary>
private static IEnumerable<CompressionFormat> GetAllFormats(bool alsoBuiltInCompositeFormats)
{
foreach (CompressionFormat fmt in GetBuiltInFormats(alsoBuiltInCompositeFormats))
yield return fmt;
foreach (CompressionFormat fmt in GetPluginFormats())
yield return fmt;
}
/// <summary>
/// Gets a sequence over all built-in compression formats.
/// </summary>
/// <param name="alsoCompositeFormats">If the built-in composite formats should also be part of the sequence.</param>
private static IEnumerable<CompressionFormat> GetBuiltInFormats(bool alsoCompositeFormats)
{
yield return new LZOvl();
yield return new LZ10();
yield return new LZ11();
yield return new Huffman4();
yield return new Huffman8();
yield return new RLE();
if (alsoCompositeFormats)
{
}
}
/// <summary>
/// Gets a sequence over all formats that can be used from plugins.
/// </summary>
private static IEnumerable<CompressionFormat> GetPluginFormats()
{
string pluginPath = Directory.GetParent(Assembly.GetExecutingAssembly().Location).FullName;
pluginPath = Path.Combine(pluginPath, PluginFolder);
if (System.IO.Directory.Exists(pluginPath))
{
foreach (CompressionFormat fmt in IOUtils.LoadCompressionPlugins(pluginPath))
yield return fmt;
}
else
{
Console.WriteLine("Plugin folder " + pluginPath + " is not present; only built-in formats are supported.");
}
}
#endregion
/// <summary>
/// Gets the first item from the given sequence, or the default value of the type in the sequence
/// if it is empty.
/// </summary>
private static T FirstOrDefault<T>(IEnumerable<T> sequence)
{
if (sequence != null)
{
IEnumerator<T> enumerator = sequence.GetEnumerator();
if (enumerator.MoveNext())
return enumerator.Current;
}
return default(T);
}
}
}