The-Homebrew-Cloud/customizemii-wiidb
2
0
Fork 0
mirror of https://github.com/Brawl345/customizemii.git synced 2024-12-04 13:44:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

CustomizeMii 2.0

Browse Source
This commit is contained in:
Leathl 2009-12-21 23:58:53 +00:00
parent 0f807895ab
commit 0f41cc8326
20 changed files with 3817 additions and 1089 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

714
CustomizeMii/BNS.cs Normal file
View File

@ -0,0 +1,714 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//These classes are based on bns.py of the Wii.py Framework with improvements by me (Leathl)
//Thanks to Xuzz, SquidMan, megazig, Matt_P, Omega and The Lemon Man, the authors of Wii.py!
using System;
using System.Collections.Generic;
using System.IO;
using WaveFile;
namespace BNS
{
internal class BNS_Data
{
//Private Varialbes
private byte[] magic = new byte[] { (byte)'D', (byte)'A', (byte)'T', (byte)'A' };
private UInt32 size = 0x0004d000;
private byte[] data;
//Public Variables
public UInt32 Size { get { return size; } set { size = value; } }
public byte[] Data { get { return data; } set { data = value; } }
public BNS_Data() { }
public void Write(Stream outStream)
{
byte[] temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(magic, 0, magic.Length);
outStream.Write(temp, 0, temp.Length);
outStream.Write(data, 0, data.Length);
}
}
internal class BNS_Info
{
//Private Variables
private byte[] magic = new byte[] { (byte)'I', (byte)'N', (byte)'F', (byte)'O' };
private UInt32 size = 0x000000a0;
private byte codec = 0x00;
private byte hasLoop = 0x00;
private byte channelCount = 0x02;
private byte zero = 0x00;
private UInt16 sampleRate = 0xac44;
private UInt16 pad0 = 0x0000;
private UInt32 loopStart = 0x00000000;
private UInt32 loopEnd = 0x00000000; //Or total sample count
private UInt32 offsetToChannelStart = 0x00000018;
private UInt32 pad1 = 0x00000000;
private UInt32 channel1StartOffset = 0x00000020;
private UInt32 channel2StartOffset = 0x0000002C;
private UInt32 channel1Start = 0x00000000;
private UInt32 coefficients1Offset = 0x0000038;
private UInt32 pad2 = 0x00000000;
private UInt32 channel2Start = 0x00000000;
private UInt32 coefficients2Offset = 0x00000068;
private UInt32 pad3 = 0x00000000;
private int[] coefficients1 = new int[16];
private UInt16 channel1Gain = 0x0000;
private UInt16 channel1PredictiveScale = 0x0000;
private UInt16 channel1PreviousValue = 0x0000;
private UInt16 channel1NextPreviousValue = 0x0000;
private UInt16 channel1LoopPredictiveScale = 0x0000;
private UInt16 channel1LoopPreviousValue = 0x0000;
private UInt16 channel1LoopNextPreviousValue = 0x0000;
private UInt16 channel1LoopPadding = 0x0000;
private int[] coefficients2 = new int[16];
private UInt16 channel2Gain = 0x0000;
private UInt16 channel2PredictiveScale = 0x0000;
private UInt16 channel2PreviousValue = 0x0000;
private UInt16 channel2NextPreviousValue = 0x0000;
private UInt16 channel2LoopPredictiveScale = 0x0000;
private UInt16 channel2LoopPreviousValue = 0x0000;
private UInt16 channel2LoopNextPreviousValue = 0x0000;
private UInt16 channel2LoopPadding = 0x0000;
//Public Variables
public byte HasLoop { get { return hasLoop; } set { hasLoop = value; } }
public UInt32 Coefficients1Offset { get { return coefficients1Offset; } set { coefficients1Offset = value; } }
public UInt32 Channel1StartOffset { get { return channel1StartOffset; } set { channel1StartOffset = value; } }
public UInt32 Channel2StartOffset { get { return channel2StartOffset; } set { channel2StartOffset = value; } }
public UInt32 Size { get { return size; } set { size = value; } }
public UInt16 SampleRate { get { return sampleRate; } set { sampleRate = value; } }
public byte ChannelCount { get { return channelCount; } set { channelCount = value; } }
public UInt32 Channel1Start { get { return channel1Start; } set { channel1Start = value; } }
public UInt32 Channel2Start { get { return channel2Start; } set { channel2Start = value; } }
public UInt32 LoopStart { get { return loopStart; } set { loopStart = value; } }
public UInt32 LoopEnd { get { return loopEnd; } set { loopEnd = value; } }
public int[] Coefficients1 { get { return coefficients1; } set { coefficients1 = value; } }
public int[] Coefficients2 { get { return coefficients2; } set { coefficients2 = value; } }
public BNS_Info() { }
public void Write(Stream outStream)
{
outStream.Write(magic, 0, magic.Length);
byte[] temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
outStream.WriteByte(codec);
outStream.WriteByte(hasLoop);
outStream.WriteByte(channelCount);
outStream.WriteByte(zero);
temp = BitConverter.GetBytes(sampleRate); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad0); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(loopStart); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(loopEnd); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(offsetToChannelStart); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad1); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1StartOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2StartOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1Start); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(coefficients1Offset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
if (this.channelCount == 2)
{
temp = BitConverter.GetBytes(pad2); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2Start); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(coefficients2Offset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(pad3); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
foreach (int thisInt in coefficients1)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel1Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
foreach (int thisInt in coefficients2)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel2Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel2LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
else if (this.channelCount == 1)
{
foreach (int thisInt in coefficients1)
{
temp = BitConverter.GetBytes(thisInt); Array.Reverse(temp);
outStream.Write(temp, 2, temp.Length - 2);
}
temp = BitConverter.GetBytes(channel1Gain); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1PreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1NextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPredictiveScale); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopNextPreviousValue); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(channel1LoopPadding); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
}
}
internal class BNS_Header
{
//Private Variables
private byte[] magic = new byte[] { (byte)'B', (byte)'N', (byte)'S', (byte)' ' };
private UInt32 flags = 0xfeff0100;
private UInt32 fileSize = 0x0004d0c0;
private UInt16 size = 0x0020;
private UInt16 chunkCount = 0x0002;
private UInt32 infoOffset = 0x00000020;
private UInt32 infoLength = 0x000000a0;
private UInt32 dataOffset = 0x000000c0;
private UInt32 dataLength = 0x0004d000;
//Public Varialbes
public UInt32 DataOffset { get { return dataOffset; } set { dataOffset = value; } }
public UInt32 InfoLength { get { return infoLength; } set { infoLength = value; } }
public UInt16 Size { get { return size; } set { size = value; } }
public UInt32 DataLength { get { return dataLength; } set { dataLength = value; } }
public UInt32 FileSize { get { return fileSize; } set { fileSize = value; } }
public BNS_Header() { }
public void Write(Stream outStream)
{
outStream.Write(magic, 0, magic.Length);
byte[] temp = BitConverter.GetBytes(flags); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(fileSize); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(size); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(chunkCount); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(infoOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(infoLength); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(dataOffset); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
temp = BitConverter.GetBytes(dataLength); Array.Reverse(temp);
outStream.Write(temp, 0, temp.Length);
}
}
public class BNS_File
{
//Private Variables
private BNS_Header bnsHeader = new BNS_Header();
private BNS_Info bnsInfo = new BNS_Info();
private BNS_Data bnsData = new BNS_Data();
private int[,] lSamples = new int[2, 2];
private int[,] rlSamples = new int[2, 2];
private int[] tlSamples = new int[2];
private int[] hbcDefTbl = new int[] { 674, 1040, 3598, -1738, 2270, -583, 3967, -1969, 1516, 381, 3453, -1468, 2606, -617, 3795, -1759 };
private int[] defTbl = new int[] { 1820, -856, 3238, -1514, 2333, -550, 3336, -1376, 2444, -949, 3666, -1764, 2654, -701, 3420, -1398 };
private int[] pHist1 = new int[2];
private int[] pHist2 = new int[2];
private int tempSampleCount;
private string waveFile;
private bool loopFromWave = false;
private bool converted = false;
private bool toMono = false;
//Public Variables
/// <summary>
/// 0x00 (0) = No Loop, 0x01 (1) = Loop
/// </summary>
public byte HasLoop { get { return this.bnsInfo.HasLoop; } set { this.bnsInfo.HasLoop = value; } }
/// <summary>
/// The start sample of the Loop
/// </summary>
public UInt32 LoopStart { get { return this.bnsInfo.LoopStart; } set { this.bnsInfo.LoopStart = value; } }
/// <summary>
/// The total number of samples in this file
/// </summary>
public UInt32 TotalSampleCount { get { return this.bnsInfo.LoopEnd; } set { this.bnsInfo.LoopEnd = value; } }
/// <summary>
/// If true and the input Wave file is stereo, the BNS will be converted to Mono.
/// Be sure to set this before you call Convert()!
/// </summary>
public bool StereoToMono { get { return toMono; } set { toMono = value; } }
//Public Functions
public BNS_File(string waveFile)
{
this.waveFile = waveFile;
}
public BNS_File(string waveFile, bool loopFromWave)
{
this.waveFile = waveFile;
this.loopFromWave = loopFromWave;
}
/// <summary>
/// Returns the progress of the conversion
/// </summary>
public event EventHandler<System.ComponentModel.ProgressChangedEventArgs> ProgressChanged;
/// <summary>
/// Converts the Wave file to BNS
/// </summary>
public void Convert()
{
Convert(waveFile, loopFromWave);
}
/// <summary>
/// Returns the BNS file as a Byte Array. If not already converted, it will be done first.
/// </summary>
/// <returns></returns>
public byte[] ToByteArray()
{
return ToMemoryStream().ToArray();
}
/// <summary>
/// Returns the BNS file as a Memory Stream. If not already converted, it will be done first.
/// </summary>
/// <returns></returns>
public MemoryStream ToMemoryStream()
{
if (!converted)
Convert(waveFile, loopFromWave);
MemoryStream ms = new MemoryStream();
this.bnsHeader.Write(ms);
this.bnsInfo.Write(ms);
this.bnsData.Write(ms);
return ms;
}
/// <summary>
/// Saves the BNS file to the given path. If not already converted, it will be done first.
/// </summary>
/// <param name="destionationFile"></param>
public void Save(string destionationFile)
{
if (File.Exists(destionationFile)) File.Delete(destionationFile);
using (FileStream fs = new FileStream(destionationFile, FileMode.Create))
{
byte[] bnsFile = ToMemoryStream().ToArray();
fs.Write(bnsFile, 0, bnsFile.Length);
}
}
/// <summary>
/// Sets the Loop to the given Start Sample. Be sure that you call Convert() first!
/// </summary>
/// <param name="loopStartSample"></param>
public void SetLoop(int loopStartSample)
{
this.bnsInfo.HasLoop = 0x01;
this.bnsInfo.LoopStart = (uint)loopStartSample;
}
//Private Functions
private void Convert(string waveFile, bool loopFromWave)
{
Wave wave = new Wave(waveFile);
int waveLoopCount = wave.LoopCount;
int waveLoopStart = wave.LoopStart;
this.bnsInfo.ChannelCount = (byte)wave.ChannelCount;
this.bnsInfo.SampleRate = (ushort)wave.SampleRate;
if (this.bnsInfo.ChannelCount > 2 || this.bnsInfo.ChannelCount < 1)
throw new Exception("Unsupported Count of Channels!");
if (wave.BitDepth != 16)
throw new Exception("Only 16bit Wave files are supported!");
if (wave.DataFormat != 1)
throw new Exception("The format of this Wave file is not supported!");
this.bnsData.Data = Encode(wave.GetAllFrames());
wave.Close();
if (this.bnsInfo.ChannelCount == 1)
{
this.bnsHeader.InfoLength = 0x60;
this.bnsHeader.DataOffset = 0x80;
this.bnsInfo.Size = 0x60;
this.bnsInfo.Channel1StartOffset = 0x0000001C;
this.bnsInfo.Channel2StartOffset = 0x00000000;
this.bnsInfo.Channel1Start = 0x00000028;
this.bnsInfo.Coefficients1Offset = 0x00000000;
}
this.bnsData.Size = (uint)bnsData.Data.Length + 8;
this.bnsHeader.DataLength = this.bnsData.Size;
this.bnsHeader.FileSize = this.bnsHeader.Size + this.bnsInfo.Size + this.bnsData.Size;
if (loopFromWave)
if (waveLoopCount == 1)
if (waveLoopStart != -1)
{ this.bnsInfo.LoopStart = (uint)waveLoopStart; this.bnsInfo.HasLoop = 0x01; }
this.bnsInfo.LoopEnd = (uint)tempSampleCount;
for (int i = 0; i < 16; i++)
{
this.bnsInfo.Coefficients1[i] = this.defTbl[i];
if (this.bnsInfo.ChannelCount == 2)
this.bnsInfo.Coefficients2[i] = this.defTbl[i];
}
this.converted = true;
}
private byte[] Encode(byte[] inputFrames)
{
int offset = 0;
int[] sampleBuffer = new int[14];
this.tempSampleCount = inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2);
int modLength = (inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2)) % 14;
Array.Resize(ref inputFrames, inputFrames.Length + ((14 - modLength) * (bnsInfo.ChannelCount == 2 ? 4 : 2)));
int sampleCount = inputFrames.Length / (bnsInfo.ChannelCount == 2 ? 4 : 2);
int blocks = (sampleCount + 13) / 14;
List<int> soundDataLeft = new List<int>();
List<int> soundDataRight = new List<int>();
int co = offset;
if (this.toMono && this.bnsInfo.ChannelCount == 2) this.bnsInfo.ChannelCount = 1;
else if (this.toMono) this.toMono = false;
for (int j = 0; j < sampleCount; j++)
{
soundDataLeft.Add(BitConverter.ToInt16(inputFrames, co));
co += 2;
if (this.bnsInfo.ChannelCount == 2 || toMono)
{
soundDataRight.Add(BitConverter.ToInt16(inputFrames, co));
co += 2;
}
}
byte[] data = new byte[(this.bnsInfo.ChannelCount == 2 ? (blocks * 16) : (blocks * 8))];
int data1Offset = 0;
int data2Offset = blocks * 8;
this.bnsInfo.Channel2Start = (this.bnsInfo.ChannelCount == 2 ? (uint)data2Offset : 0);
int[] leftSoundData = soundDataLeft.ToArray();
int[] rightSoundData = soundDataRight.ToArray();
for (int y = 0; y < blocks; y++)
{
try
{
if (y % (int)(blocks / 100) == 0 || (y + 1) == blocks)
ChangeProgress((y + 1) * 100 / blocks);
}
catch { }
for (int a = 0; a < 14; a++)
sampleBuffer[a] = leftSoundData[y * 14 + a];
byte[] outBuffer = RepackAdpcm(0, this.defTbl, sampleBuffer);
for (int a = 0; a < 8; a++)
data[data1Offset + a] = outBuffer[a];
data1Offset += 8;
if (this.bnsInfo.ChannelCount == 2)
{
for (int a = 0; a < 14; a++)
sampleBuffer[a] = rightSoundData[y * 14 + a];
outBuffer = RepackAdpcm(1, this.defTbl, sampleBuffer);
for (int a = 0; a < 8; a++)
data[data2Offset + a] = outBuffer[a];
data2Offset += 8;
}
}
this.bnsInfo.LoopEnd = (uint)(blocks * 7);
return data;
}
private byte[] RepackAdpcm(int index, int[] table, int[] inputBuffer)
{
byte[] data = new byte[8];
int[] blSamples = new int[2];
int bestIndex = -1;
double bestError = 999999999.0;
double error;
for (int tableIndex = 0; tableIndex < 8; tableIndex++)
{
byte[] testData = CompressAdpcm(index, table, tableIndex, inputBuffer, out error);
if (error < bestError)
{
bestError = error;
for (int i = 0; i < 8; i++)
data[i] = testData[i];
for (int i = 0; i < 2; i++)
blSamples[i] = this.tlSamples[i];
bestIndex = tableIndex;
}
}
for (int i = 0; i < 2; i++)
this.rlSamples[index, i] = blSamples[i];
return data;
}
private byte[] CompressAdpcm(int index, int[] table, int tableIndex, int[] inputBuffer, out double outError)
{
byte[] data = new byte[8];
int error = 0;
int factor1 = table[2 * tableIndex + 0];
int factor2 = table[2 * tableIndex + 1];
int exponent = DetermineStdExponent(index, table, tableIndex, inputBuffer);
while (exponent <= 15)
{
bool breakIt = false;
error = 0;
data[0] = (byte)(exponent | (tableIndex << 4));
for (int i = 0; i < 2; i++)
this.tlSamples[i] = this.rlSamples[index, i];
int j = 0;
for (int i = 0; i < 14; i++)
{
int predictor = (int)((this.tlSamples[1] * factor1 + this.tlSamples[0] * factor2) >> 11);
int residual = (inputBuffer[i] - predictor) >> exponent;
if (residual > 7 || residual < -8)
{
exponent++;
breakIt = true;
break;
}
int nibble = Clamp(residual, -8, 7);
if ((i & 1) != 0)
data[i / 2 + 1] = (byte)(data[i / 2 + 1] | (nibble & 0xf));
else
data[i / 2 + 1] = (byte)(nibble << 4);
predictor += nibble << exponent;
this.tlSamples[0] = this.tlSamples[1];
this.tlSamples[1] = Clamp(predictor, -32768, 32767);
error += (int)(Math.Pow((double)(this.tlSamples[1] - inputBuffer[i]), 2));
}
if (!breakIt) j = 14;
if (j == 14) break;
}
outError = error;
return data;
}
private int DetermineStdExponent(int index, int[] table, int tableIndex, int[] inputBuffer)
{
int[] elSamples = new int[2];
int maxResidual = 0;
int factor1 = table[2 * tableIndex + 0];
int factor2 = table[2 * tableIndex + 1];
for (int i = 0; i < 2; i++)
elSamples[i] = this.rlSamples[index, i];
for (int i = 0; i < 14; i++)
{
int predictor = (elSamples[1] * factor1 + elSamples[0] * factor2) >> 11;
int residual = inputBuffer[i] - predictor;
if (residual > maxResidual)
maxResidual = residual;
elSamples[0] = elSamples[1];
elSamples[1] = inputBuffer[i];
}
return FindExponent(maxResidual);
}
private int FindExponent(double residual)
{
int exponent = 0;
while (residual > 7.5 || residual < -8.5)
{
exponent++;
residual /= 2.0;
}
return exponent;
}
private int Clamp(int input, int min, int max)
{
if (input < min) return min;
if (input > max) return max;
return input;
}
private void ChangeProgress(int progressPercentage)
{
EventHandler<System.ComponentModel.ProgressChangedEventArgs> progressChanged = ProgressChanged;
if (progressChanged != null)
{
progressChanged(new object(), new System.ComponentModel.ProgressChangedEventArgs(progressPercentage, new object()));
}
}
}
}

19
CustomizeMii/CustomizeMii.csproj
View File

@ -27,7 +27,7 @@
<UpdateRequired>false</UpdateRequired>
<MapFileExtensions>true</MapFileExtensions>
<ApplicationRevision>0</ApplicationRevision>
<ApplicationVersion>1.2.0.%2a</ApplicationVersion>
<ApplicationVersion>2.0.0.%2a</ApplicationVersion>
<UseApplicationTrust>false</UseApplicationTrust>
<BootstrapperEnabled>true</BootstrapperEnabled>
</PropertyGroup>
@ -55,12 +55,21 @@
</Reference>
<Reference Include="System" />
<Reference Include="System.Data" />
<Reference Include="System.Deployment" />
<Reference Include="System.Drawing" />
<Reference Include="System.Windows.Forms" />
<Reference Include="System.Xml" />
</ItemGroup>
<ItemGroup>
<Compile Include="BNS.cs" />
<Compile Include="CustomizeMii_BackgroundWorkers.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="CustomizeMii_BnsConvert.cs">
<SubType>Form</SubType>
</Compile>
<Compile Include="CustomizeMii_BnsConvert.Designer.cs">
<DependentUpon>CustomizeMii_BnsConvert.cs</DependentUpon>
</Compile>
<Compile Include="CustomizeMii_ComplexForwarder.cs">
<SubType>Form</SubType>
</Compile>
@ -88,6 +97,9 @@
</Compile>
<Compile Include="Program.cs" />
<Compile Include="Properties\AssemblyInfo.cs" />
<EmbeddedResource Include="CustomizeMii_BnsConvert.resx">
<DependentUpon>CustomizeMii_BnsConvert.cs</DependentUpon>
</EmbeddedResource>
<EmbeddedResource Include="CustomizeMii_ComplexForwarder.resx">
<DependentUpon>CustomizeMii_ComplexForwarder.cs</DependentUpon>
</EmbeddedResource>
@ -121,12 +133,15 @@
<DependentUpon>Settings.settings</DependentUpon>
<DesignTimeSharedInput>True</DesignTimeSharedInput>
</Compile>
<Compile Include="CustomizeMii_Structs.cs" />
<Compile Include="Wave.cs" />
<Compile Include="Wii.cs" />
</ItemGroup>
<ItemGroup>
<Content Include="License.txt" />
<Content Include="Readme.txt" />
<Content Include="Instructions.txt" />
<None Include="Resources\btnCreateWad.png" />
<None Include="Resources\CustomizeMii.ico" />
<None Include="Resources\Instructions.rtf" />
</ItemGroup>

742
CustomizeMii/CustomizeMii_BackgroundWorkers.cs Normal file
View File

@ -0,0 +1,742 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using BNS;
namespace CustomizeMii
{
partial class CustomizeMii_Main
{
private bool internalSound;
void bwBannerReplace_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
pbProgress.Value = 100;
lbStatusText.Text = string.Empty;
SetText(tbReplace, BannerReplace);
}
void bwBannerReplace_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bwBannerReplace_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwBannerReplace = sender as BackgroundWorker;
string thisFile = (string)e.Argument;
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (Directory.Exists(TempBannerPath)) Directory.Delete(TempBannerPath, true);
if (thisFile.EndsWith(".bin"))
{
bwBannerReplace.ReportProgress(0, "Loading banner.bin...");
Wii.U8.UnpackU8(thisFile, TempBannerPath);
}
else if (thisFile.EndsWith(".app"))
{
bwBannerReplace.ReportProgress(0, "Loading 00000000.app...");
Wii.U8.UnpackU8(thisFile, TempTempPath);
bwBannerReplace.ReportProgress(50, "Loading banner.bin...");
Wii.U8.UnpackU8(TempTempPath + "meta\\banner.bin", TempBannerPath);
Directory.Delete(TempTempPath, true);
}
else
{
bwBannerReplace.ReportProgress(0, "Loading WAD...");
Wii.WadUnpack.UnpackWad(thisFile, TempTempPath);
if (Wii.U8.CheckU8(TempTempPath + "00000000.app") == false)
throw new Exception("CustomizeMii only handles Channel WADs!");
bwBannerReplace.ReportProgress(30, "Loading 00000000.app...");
Wii.U8.UnpackU8(TempTempPath + "00000000.app", TempTempPath + "00000000.app_OUT");
bwBannerReplace.ReportProgress(60, "Loading banner.bin...");
Wii.U8.UnpackU8(TempTempPath + "00000000.app_OUT\\meta\\banner.bin", TempBannerPath);
Directory.Delete(TempTempPath, true);
}
EventHandler AddBannerTpls = new EventHandler(this.AddBannerTpls);
EventHandler AddIconTpls = new EventHandler(this.AddIconTpls);
EventHandler AddBrlyts = new EventHandler(this.AddBrlyts);
EventHandler AddBrlans = new EventHandler(this.AddBrlans);
this.Invoke(AddBannerTpls);
this.Invoke(AddIconTpls);
this.Invoke(AddBrlyts);
this.Invoke(AddBrlans);
}
catch (Exception ex)
{
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (Directory.Exists(TempBannerPath)) Directory.Delete(TempBannerPath, true);
BannerReplace = string.Empty;
ErrorBox(ex.Message);
}
}
void bwIconReplace_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
pbProgress.Value = 100;
lbStatusText.Text = string.Empty;
SetText(tbReplace, IconReplace);
}
void bwIconReplace_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bwIconReplace_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwIconReplace = sender as BackgroundWorker;
string thisFile = (string)e.Argument;
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (Directory.Exists(TempIconPath)) Directory.Delete(TempIconPath, true);
if (thisFile.EndsWith(".bin"))
{
bwIconReplace.ReportProgress(0, "Loading icon.bin...");
Wii.U8.UnpackU8(thisFile, TempIconPath);
}
else if (thisFile.EndsWith(".app"))
{
bwIconReplace.ReportProgress(0, "Loading 00000000.app...");
Wii.U8.UnpackU8(thisFile, TempTempPath);
bwIconReplace.ReportProgress(50, "Loading icon.bin...");
Wii.U8.UnpackU8(TempTempPath + "meta\\icon.bin", TempIconPath);
Directory.Delete(TempTempPath, true);
}
else
{
bwIconReplace.ReportProgress(0, "Loading WAD...");
Wii.WadUnpack.UnpackWad(thisFile, TempTempPath);
if (Wii.U8.CheckU8(TempTempPath + "00000000.app") == false)
throw new Exception("CustomizeMii only handles Channel WADs!");
bwIconReplace.ReportProgress(30, "Loading 00000000.app...");
Wii.U8.UnpackU8(TempTempPath + "00000000.app", TempTempPath + "00000000.app_OUT");
bwIconReplace.ReportProgress(60, "Loading icon.bin...");
Wii.U8.UnpackU8(TempTempPath + "00000000.app_OUT\\meta\\icon.bin", TempIconPath);
Directory.Delete(TempTempPath, true);
}
EventHandler AddBannerTpls = new EventHandler(this.AddBannerTpls);
EventHandler AddIconTpls = new EventHandler(this.AddIconTpls);
EventHandler AddBrlyts = new EventHandler(this.AddBrlyts);
EventHandler AddBrlans = new EventHandler(this.AddBrlans);
this.Invoke(AddBannerTpls);
this.Invoke(AddIconTpls);
this.Invoke(AddBrlyts);
this.Invoke(AddBrlans);
}
catch (Exception ex)
{
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (Directory.Exists(TempIconPath)) Directory.Delete(TempIconPath, true);
IconReplace = string.Empty;
ErrorBox(ex.Message);
}
}
void bwSoundReplace_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
pbProgress.Value = 100;
lbStatusText.Text = string.Empty;
SetText(tbReplace, SoundReplace);
}
void bwSoundReplace_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bwSoundReplace_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwSoundReplace = sender as BackgroundWorker;
string thisFile = (string)e.Argument;
if (File.Exists(TempSoundPath)) File.Delete(TempSoundPath);
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (thisFile.EndsWith(".bin"))
{
bwSoundReplace.ReportProgress(0, "Copying sound.bin...");
File.Copy(thisFile, TempSoundPath);
}
else if (thisFile.EndsWith(".app"))
{
bwSoundReplace.ReportProgress(0, "Loading 00000000.app...");
Wii.U8.UnpackU8(thisFile, TempTempPath);
bwSoundReplace.ReportProgress(80, "Copying sound.bin...");
File.Copy(TempTempPath + "meta\\sound.bin", TempSoundPath);
Directory.Delete(TempTempPath, true);
}
else
{
bwSoundReplace.ReportProgress(0, "Loading WAD...");
Wii.WadUnpack.UnpackWad(thisFile, TempTempPath);
if (Wii.U8.CheckU8(TempTempPath + "00000000.app") == false)
throw new Exception("CustomizeMii only handles Channel WADs!");
bwSoundReplace.ReportProgress(50, "Loading 00000000.app...");
Wii.U8.UnpackU8(TempTempPath + "00000000.app", TempTempPath + "00000000.app_OUT");
bwSoundReplace.ReportProgress(90, "Copying sound.bin...");
File.Copy(TempTempPath + "00000000.app_OUT\\meta\\sound.bin", TempSoundPath);
Directory.Delete(TempTempPath, true);
}
SetText(tbSound, SoundReplace);
}
catch (Exception ex)
{
if (Directory.Exists(TempTempPath)) Directory.Delete(TempTempPath, true);
if (File.Exists(TempSoundPath)) File.Delete(TempSoundPath);
SoundReplace = string.Empty;
ErrorBox(ex.Message);
}
}
void bwConvertToBns_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (File.Exists(TempBnsPath))
{
if (internalSound == true)
SetText(tbSound, "BNS: Internal Sound");
else
SetText(tbSound, "BNS: " + Mp3Path);
btnBrowseSound.Text = "Clear";
if (!string.IsNullOrEmpty(SoundReplace))
{
SoundReplace = string.Empty;
if (cmbReplace.SelectedIndex == 2) SetText(tbReplace, SoundReplace);
if (File.Exists(TempSoundPath)) File.Delete(TempSoundPath);
}
}
if (File.Exists(TempWavePath)) File.Delete(TempWavePath);
lbStatusText.Text = string.Empty;
Mp3Path = string.Empty;
pbProgress.Value = 100;
}
void bwConvertToBns_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
if (!string.IsNullOrEmpty((string)e.UserState)) currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bns_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
this.Invoke(ProgressUpdate);
}
void bwConvertToBns_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwConvertToBns = sender as BackgroundWorker;
BnsConversionInfo bnsInfo = (BnsConversionInfo)e.Argument;
string audioFile;
if (bnsInfo.AudioFile == "Internal Sound")
{ audioFile = TempWavePath; internalSound = true; }
else
audioFile = bnsInfo.AudioFile;
Mp3Path = audioFile; //Rather audioPath...
bool mp3 = audioFile.EndsWith(".mp3");
if (mp3 && bnsInfo.Loop == BnsConversionInfo.LoopType.FromWave) bnsInfo.Loop = BnsConversionInfo.LoopType.None;
if (mp3)
{
bwConvertToBns.ReportProgress(0, "Converting MP3...");
ProcessStartInfo lameI = new ProcessStartInfo(System.Windows.Forms.Application.StartupPath + "\\lame.exe",
string.Format("--decode \"{0}\" \"{1}\"", audioFile, "C:\\cmtempmp3wav.wav")); //Gotta go this step, cause the TempWavePath is too long for lame.exe
lameI.CreateNoWindow = true;
lameI.UseShellExecute = false;
lameI.RedirectStandardError = true;
Process lame = Process.Start(lameI);
string thisLine = string.Empty;
while (lame.HasExited == false)
{
thisLine = lame.StandardError.ReadLine();
if (!string.IsNullOrEmpty(thisLine))
{
if (thisLine.StartsWith("Frame#"))
{
string thisFrame = thisLine.Remove(thisLine.IndexOf('/'));
thisFrame = thisFrame.Remove(0, thisFrame.LastIndexOf(' ') + 1);
string Frames = thisLine.Remove(0, thisLine.IndexOf('/') + 1);
Frames = Frames.Remove(Frames.IndexOf(' '));
int thisProgress = (int)((Convert.ToDouble(thisFrame) / Convert.ToDouble(Frames)) * 100);
bwConvertToBns.ReportProgress(thisProgress);
}
}
}
lame.WaitForExit();
lame.Close();
if (File.Exists("C:\\cmtempmp3wav.wav"))
{
FileInfo fi = new FileInfo("C:\\cmtempmp3wav.wav");
fi.MoveTo(TempWavePath);
}
if (!File.Exists(TempWavePath)) throw new Exception("Error converting MP3...");
else audioFile = TempWavePath;
}
bwConvertToBns.ReportProgress(0, "Converting To BNS...");
BNS_File bns = new BNS_File(audioFile, bnsInfo.Loop == BnsConversionInfo.LoopType.FromWave);
bns.ProgressChanged += new EventHandler<ProgressChangedEventArgs>(bns_ProgressChanged);
bns.StereoToMono = bnsInfo.StereoToMono;
bns.Convert();
if (bnsInfo.Loop == BnsConversionInfo.LoopType.Manual && bnsInfo.LoopStartSample > -1 && bnsInfo.LoopStartSample < bns.TotalSampleCount)
bns.SetLoop(bnsInfo.LoopStartSample);
bns.Save(TempBnsPath);
if (File.Exists(TempWavePath))
File.Delete(TempWavePath);
}
catch (Exception ex)
{
ErrorBox("Error during conversion:\n" + ex.Message);
}
}
void bwConvertMp3_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
if (File.Exists(TempWavePath))
{
SetText(tbSound, Mp3Path);
btnBrowseSound.Text = "Clear";
if (!string.IsNullOrEmpty(SoundReplace))
{
SoundReplace = string.Empty;
if (cmbReplace.SelectedIndex == 2) SetText(tbReplace, SoundReplace);
if (File.Exists(TempSoundPath)) File.Delete(TempSoundPath);
}
}
lbStatusText.Text = string.Empty;
Mp3Path = string.Empty;
pbProgress.Value = 100;
}
void bwConvertMp3_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
this.Invoke(ProgressUpdate);
}
void bwConvertMp3_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwConvertMp3 = sender as BackgroundWorker;
Mp3Path = (string)e.Argument;
ProcessStartInfo lameI = new ProcessStartInfo(System.Windows.Forms.Application.StartupPath + "\\lame.exe",
string.Format("--decode \"{0}\" \"{1}\"", e.Argument, "C:\\cmtempmp3wav.wav")); //Gotta go this step, cause the TempWavePath is too long for lame.exe
lameI.CreateNoWindow = true;
lameI.UseShellExecute = false;
lameI.RedirectStandardError = true;
Process lame = Process.Start(lameI);
string thisLine = string.Empty;
while (lame.HasExited == false)
{
thisLine = lame.StandardError.ReadLine();
if (!string.IsNullOrEmpty(thisLine))
{
if (thisLine.StartsWith("Frame#"))
{
string thisFrame = thisLine.Remove(thisLine.IndexOf('/'));
thisFrame = thisFrame.Remove(0, thisFrame.LastIndexOf(' ') + 1);
string Frames = thisLine.Remove(0, thisLine.IndexOf('/') + 1);
Frames = Frames.Remove(Frames.IndexOf(' '));
int thisProgress = (int)((Convert.ToDouble(thisFrame) / Convert.ToDouble(Frames)) * 100);
bwConvertMp3.ReportProgress(thisProgress);
}
}
}
lame.WaitForExit();
lame.Close();
if (File.Exists("C:\\cmtempmp3wav.wav"))
{
FileInfo fi = new FileInfo("C:\\cmtempmp3wav.wav");
fi.MoveTo(TempWavePath);
}
}
catch (Exception ex)
{
if (File.Exists(TempWavePath)) File.Delete(TempWavePath);
Mp3Path = string.Empty;
ErrorBox("Error during conversion:\n" + ex.Message);
}
}
void bwLoadChannel_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
pbProgress.Value = 100;
lbStatusText.Text = string.Empty;
}
void bwLoadChannel_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bwLoadChannel_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwLoadChannel = sender as BackgroundWorker;
EventHandler SetSourceWad = new EventHandler(this.SetSourceWad);
byte[] WadFile = Wii.Tools.LoadFileToByteArray((string)e.Argument);
bool hashesMatch = true;
if (Directory.Exists(TempUnpackPath)) Directory.Delete(TempUnpackPath, true);
bwLoadChannel.ReportProgress(0, "Loading WAD...");
Wii.WadUnpack.UnpackWad(WadFile, TempUnpackPath, out hashesMatch);
if (Wii.U8.CheckU8(TempUnpackPath + "00000000.app") == false)
throw new Exception("CustomizeMii only edits Channel WADs!");
this.Invoke(SetSourceWad);
bwLoadChannel.ReportProgress(25, "Loading 00000000.app...");
Wii.U8.UnpackU8(TempUnpackPath + "00000000.app", TempUnpackPath + "00000000.app_OUT");
bwLoadChannel.ReportProgress(50, "Loading banner.bin...");
Wii.U8.UnpackU8(TempUnpackPath + "00000000.app_OUT\\meta\\banner.bin", TempUnpackPath + "00000000.app_OUT\\meta\\banner.bin_OUT");
bwLoadChannel.ReportProgress(75, "Loading icon.bin...");
Wii.U8.UnpackU8(TempUnpackPath + "00000000.app_OUT\\meta\\icon.bin", TempUnpackPath + "00000000.app_OUT\\meta\\icon.bin_OUT");
bwLoadChannel.ReportProgress(90, "Gathering Information...");
string[] ChannelTitles = Wii.WadInfo.GetChannelTitles(WadFile);
string TitleID = Wii.WadInfo.GetTitleID(WadFile, 1);
SetText(tbAllLanguages, ChannelTitles[1]);
if (ChannelTitles[0] != ChannelTitles[1])
SetText(tbJapanese, ChannelTitles[0]);
if (ChannelTitles[2] != ChannelTitles[1])
SetText(tbGerman, ChannelTitles[2]);
if (ChannelTitles[3] != ChannelTitles[1])
SetText(tbFrench, ChannelTitles[3]);
if (ChannelTitles[4] != ChannelTitles[1])
SetText(tbSpanish, ChannelTitles[4]);
if (ChannelTitles[5] != ChannelTitles[1])
SetText(tbItalian, ChannelTitles[5]);
if (ChannelTitles[6] != ChannelTitles[1])
SetText(tbDutch, ChannelTitles[6]);
SetText(tbTitleID, TitleID);
EventHandler AddBannerTpls = new EventHandler(this.AddBannerTpls);
EventHandler AddIconTpls = new EventHandler(this.AddIconTpls);
EventHandler AddBrlyts = new EventHandler(this.AddBrlyts);
EventHandler AddBrlans = new EventHandler(this.AddBrlans);
this.Invoke(AddBannerTpls);
this.Invoke(AddIconTpls);
this.Invoke(AddBrlyts);
this.Invoke(AddBrlans);
bwLoadChannel.ReportProgress(100);
EventHandler EnableCtrls = new EventHandler(this.EnableControls);
this.Invoke(EnableCtrls);
if (!hashesMatch)
System.Windows.Forms.MessageBox.Show("At least one content's hash doesn't match the hash in the TMD!\n" +
"Some files of the WAD might be corrupted, thus it might brick your Wii!", "Warning",
System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
catch (Exception ex)
{
if (Directory.Exists(TempUnpackPath)) Directory.Delete(TempUnpackPath, true);
SourceWad = string.Empty;
SetText(tbSourceWad, string.Empty);
ErrorBox(ex.Message);
}
}
void bwCreateWad_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
{
EventHandler EnableControls = new EventHandler(this.EnableControls);
EventHandler Initialize = new EventHandler(this.Initialize);
pbProgress.Value = 100;
lbStatusText.Text = string.Empty;
this.Invoke(EnableControls);
this.Invoke(Initialize);
}
void bwCreateWad_ProgressChanged(object sender, ProgressChangedEventArgs e)
{
currentProgress.progressValue = e.ProgressPercentage;
currentProgress.progressState = (string)e.UserState;
this.Invoke(ProgressUpdate);
}
void bwCreateWad_DoWork(object sender, DoWorkEventArgs e)
{
try
{
BackgroundWorker bwCreateWad = sender as BackgroundWorker;
WadCreationInfo wadInfo = (WadCreationInfo)e.Argument;
EventHandler DisableControls = new EventHandler(this.DisableControls);
this.Invoke(DisableControls);
bwCreateWad.ReportProgress(0, "Making TPLs transparent");
MakeBannerTplsTransparent();
MakeIconTplsTransparent();
bwCreateWad.ReportProgress(5, "Packing icon.bin...");
byte[] iconbin;
if (!string.IsNullOrEmpty(IconReplace))
iconbin = Wii.U8.PackU8(TempIconPath);
else
iconbin = Wii.U8.PackU8(TempUnpackPath + "00000000.app_OUT\\meta\\icon.bin_OUT");
if (cbLz77.Checked == true) iconbin = Wii.Lz77.Compress(iconbin);
iconbin = Wii.U8.AddHeaderIMD5(iconbin);
Wii.Tools.SaveFileFromByteArray(iconbin, TempUnpackPath + "00000000.app_OUT\\meta\\icon.bin");
Directory.Delete(TempUnpackPath + "00000000.app_OUT\\meta\\icon.bin_OUT", true);
bwCreateWad.ReportProgress(25, "Packing banner.bin...");
byte[] bannerbin;
if (!string.IsNullOrEmpty(BannerReplace))
bannerbin = Wii.U8.PackU8(TempBannerPath);
else
bannerbin = Wii.U8.PackU8(TempUnpackPath + "00000000.app_OUT\\meta\\banner.bin_OUT");
if (cbLz77.Checked == true) bannerbin = Wii.Lz77.Compress(bannerbin);
bannerbin = Wii.U8.AddHeaderIMD5(bannerbin);
Wii.Tools.SaveFileFromByteArray(bannerbin, TempUnpackPath + "00000000.app_OUT\\meta\\banner.bin");
Directory.Delete(TempUnpackPath + "00000000.app_OUT\\meta\\banner.bin_OUT", true);
if (!string.IsNullOrEmpty(SoundReplace) || !string.IsNullOrEmpty(tbSound.Text))
{
bwCreateWad.ReportProgress(50, "Packing sound.bin...");
if (!string.IsNullOrEmpty(SoundReplace))
{
File.Delete(TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin");
File.Copy(TempSoundPath, TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin");
}
else if (!string.IsNullOrEmpty(tbSound.Text))
{
if (tbSound.Text.EndsWith(".bns"))
{
Wii.Sound.BnsToSoundBin(tbSound.Text, TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin", false);
}
else if (tbSound.Text.StartsWith("BNS:"))
{
Wii.Sound.BnsToSoundBin(TempBnsPath, TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin", false);
}
else
{
string SoundFile = tbSound.Text;
if (tbSound.Text.EndsWith(".mp3")) SoundFile = TempWavePath;
Wii.Sound.WaveToSoundBin(SoundFile, TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin", false);
}
}
}
bwCreateWad.ReportProgress(60, "Packing 00000000.app...");
int[] Sizes = new int[3];
string[] Titles = new string[] { tbJapanese.Text, tbEnglish.Text, tbGerman.Text, tbFrench.Text, tbSpanish.Text, tbItalian.Text, tbDutch.Text };
for (int i = 0; i < Titles.Length; i++)
if (string.IsNullOrEmpty(Titles[i])) Titles[i] = tbAllLanguages.Text;
byte[] nullapp = Wii.U8.PackU8(TempUnpackPath + "00000000.app_OUT", out Sizes[0], out Sizes[1], out Sizes[2]);
nullapp = Wii.U8.AddHeaderIMET(nullapp, Titles, Sizes);
Wii.Tools.SaveFileFromByteArray(nullapp, TempUnpackPath + "00000000.app");
Directory.Delete(TempUnpackPath + "00000000.app_OUT", true);
string[] tikfile = Directory.GetFiles(TempUnpackPath, "*.tik");
string[] tmdfile = Directory.GetFiles(TempUnpackPath, "*.tmd");
byte[] tmd = Wii.Tools.LoadFileToByteArray(tmdfile[0]);
if (!string.IsNullOrEmpty(tbDol.Text))
{
bwCreateWad.ReportProgress(80, "Inserting new DOL...");
string[] AppFiles = Directory.GetFiles(TempUnpackPath, "*.app");
foreach (string thisApp in AppFiles)
if (!thisApp.EndsWith("00000000.app")) File.Delete(thisApp);
if (wadInfo.nandLoader == 0)
{
using (BinaryReader nandloader = new BinaryReader(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("CustomizeMii.Resources.comex.app")))
{
using (FileStream fs = new FileStream(TempUnpackPath + "\\00000001.app", FileMode.Create))
{
byte[] temp = nandloader.ReadBytes((int)nandloader.BaseStream.Length);
fs.Write(temp, 0, temp.Length);
}
}
if (tbDol.Text.StartsWith("Simple Forwarder:"))
{
CreateForwarderSimple(TempUnpackPath + "\\00000002.app");
}
else if (tbDol.Text.StartsWith("Complex Forwarder:"))
{
bwCreateWad.ReportProgress(82, "Compiling Forwarder...");
CreateForwarderComplex(TempUnpackPath + "\\00000002.app");
}
else if (tbDol.Text == "Internal" || tbDol.Text.EndsWith(".wad"))
{
File.Copy(TempDolPath, TempUnpackPath + "\\00000002.app");
}
else
{
File.Copy(tbDol.Text, TempUnpackPath + "\\00000002.app");
}
tmd = Wii.WadEdit.ChangeTmdBootIndex(tmd, 1);
}
else
{
using (BinaryReader nandloader = new BinaryReader(System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("CustomizeMii.Resources.Waninkoko.app")))
{
using (FileStream fs = new FileStream(TempUnpackPath + "\\00000002.app", FileMode.Create))
{
byte[] temp = nandloader.ReadBytes((int)nandloader.BaseStream.Length);
fs.Write(temp, 0, temp.Length);
}
}
if (tbDol.Text.StartsWith("Simple Forwarder:"))
{
CreateForwarderSimple(TempUnpackPath + "\\00000001.app");
}
else if (tbDol.Text.StartsWith("Complex Forwarder:"))
{
bwCreateWad.ReportProgress(82, "Compiling Forwarder...");
CreateForwarderComplex(TempUnpackPath + "\\00000001.app");
}
else if (tbDol.Text == "Internal")
{
File.Copy(TempDolPath, TempUnpackPath + "\\00000001.app");
}
else
{
File.Copy(tbDol.Text, TempUnpackPath + "\\00000001.app");
}
tmd = Wii.WadEdit.ChangeTmdBootIndex(tmd, 2);
}
tmd = Wii.WadEdit.ChangeTmdContentCount(tmd, 3);
bwCreateWad.ReportProgress(85, "Updating TMD...");
File.Delete(tmdfile[0]);
using (FileStream fs = new FileStream(tmdfile[0], FileMode.Create))
{
byte[] tmdconts = new byte[108];
tmdconts[7] = 0x01;
tmdconts[39] = 0x01;
tmdconts[41] = 0x01;
tmdconts[43] = 0x01;
tmdconts[75] = 0x02;
tmdconts[77] = 0x02;
tmdconts[79] = 0x01;
fs.Write(tmd, 0, 484);
fs.Write(tmdconts, 0, tmdconts.Length);
}
}
bwCreateWad.ReportProgress(85, "Updating TMD...");
Wii.WadEdit.UpdateTmdContents(tmdfile[0]);
Wii.WadEdit.ChangeTitleID(tikfile[0], 0, tbTitleID.Text.ToUpper());
Wii.WadEdit.ChangeTitleID(tmdfile[0], 1, tbTitleID.Text.ToUpper());
bwCreateWad.ReportProgress(90, "Trucha Signing...");
Wii.WadEdit.TruchaSign(tmdfile[0], 1);
Wii.WadEdit.TruchaSign(tikfile[0], 0);
bwCreateWad.ReportProgress(95, "Packing WAD...");
if (File.Exists(wadInfo.outFile)) File.Delete(wadInfo.outFile);
Wii.WadPack.PackWad(TempUnpackPath, wadInfo.outFile, false);
bwCreateWad.ReportProgress(100, " ");
CreationTimer.Stop();
FileInfo fi = new FileInfo(wadInfo.outFile);
double fileSize = Math.Round(fi.Length * 0.0009765625 * 0.0009765625, 2);
InfoBox(string.Format("Successfully created custom channel!\nTime elapsed: {0} ms\nFilesize: {1} MB\nApprox. Blocks: {2}", CreationTimer.ElapsedMilliseconds, fileSize, Wii.WadInfo.GetNandBlocks(wadInfo.outFile)));
}
catch (Exception ex)
{
CreationTimer.Stop();
EventHandler EnableControls = new EventHandler(this.EnableControls);
this.Invoke(EnableControls);
ErrorBox(ex.Message);
}
}
}
}

391
CustomizeMii/CustomizeMii_BnsConvert.Designer.cs generated Normal file
View File

@ -0,0 +1,391 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
namespace CustomizeMii
{
partial class CustomizeMii_BnsConvert
{
/// <summary>
/// Erforderliche Designervariable.
/// </summary>
private System.ComponentModel.IContainer components = null;
/// <summary>
/// Verwendete Ressourcen bereinigen.
/// </summary>
/// <param name="disposing">True, wenn verwaltete Ressourcen gelöscht werden sollen; andernfalls False.</param>
protected override void Dispose(bool disposing)
{
if (disposing && (components != null))
{
components.Dispose();
}
base.Dispose(disposing);
}
#region Vom Windows Form-Designer generierter Code
/// <summary>
/// Erforderliche Methode für die Designerunterstützung.
/// Der Inhalt der Methode darf nicht mit dem Code-Editor geändert werden.
/// </summary>
private void InitializeComponent()
{
this.btnCancel = new System.Windows.Forms.Button();
this.btnConvert = new System.Windows.Forms.Button();
this.lbAudioFile = new System.Windows.Forms.Label();
this.tbAudioFile = new System.Windows.Forms.TextBox();
this.btnBrowseAudioFile = new System.Windows.Forms.Button();
this.gbLoop = new System.Windows.Forms.GroupBox();
this.tbLoopStart = new System.Windows.Forms.TextBox();
this.rbEnterManually = new System.Windows.Forms.RadioButton();
this.rbFromAudioFile = new System.Windows.Forms.RadioButton();
this.rbNone = new System.Windows.Forms.RadioButton();
this.gbWaveInfo = new System.Windows.Forms.GroupBox();
this.lbStatusValue = new System.Windows.Forms.Label();
this.lbLoopStartValue = new System.Windows.Forms.Label();
this.lbLoopCountValue = new System.Windows.Forms.Label();
this.lbFormatValue = new System.Windows.Forms.Label();
this.lbChannelCountValue = new System.Windows.Forms.Label();
this.lbSamplerateValue = new System.Windows.Forms.Label();
this.lbBitdepthValue = new System.Windows.Forms.Label();
this.lbStatus = new System.Windows.Forms.Label();
this.lbLoopStart = new System.Windows.Forms.Label();
this.lbLoopCount = new System.Windows.Forms.Label();
this.lbFormat = new System.Windows.Forms.Label();
this.lbChannelCount = new System.Windows.Forms.Label();
this.lbSamplerate = new System.Windows.Forms.Label();
this.lbBitdepth = new System.Windows.Forms.Label();
this.cbSourceSound = new System.Windows.Forms.CheckBox();
this.gbLoop.SuspendLayout();
this.gbWaveInfo.SuspendLayout();
this.SuspendLayout();
//
// btnCancel
//
this.btnCancel.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
this.btnCancel.DialogResult = System.Windows.Forms.DialogResult.Cancel;
this.btnCancel.Location = new System.Drawing.Point(186, 179);
this.btnCancel.Name = "btnCancel";
this.btnCancel.Size = new System.Drawing.Size(160, 23);
this.btnCancel.TabIndex = 10;
this.btnCancel.Text = "Cancel";
this.btnCancel.UseVisualStyleBackColor = true;
this.btnCancel.Click += new System.EventHandler(this.btnCancel_Click);
//
// btnConvert
//
this.btnConvert.Anchor = ((System.Windows.Forms.AnchorStyles)((System.Windows.Forms.AnchorStyles.Bottom | System.Windows.Forms.AnchorStyles.Left)));
this.btnConvert.Location = new System.Drawing.Point(15, 179);
this.btnConvert.Name = "btnConvert";
this.btnConvert.Size = new System.Drawing.Size(160, 23);
this.btnConvert.TabIndex = 9;
this.btnConvert.Text = "Convert";
this.btnConvert.UseVisualStyleBackColor = true;
this.btnConvert.Click += new System.EventHandler(this.btnConvert_Click);
//
// lbAudioFile
//
this.lbAudioFile.AutoSize = true;
this.lbAudioFile.Location = new System.Drawing.Point(12, 24);
this.lbAudioFile.Name = "lbAudioFile";
this.lbAudioFile.Size = new System.Drawing.Size(56, 13);
this.lbAudioFile.TabIndex = 11;
this.lbAudioFile.Text = "Audio File:";
//
// tbAudioFile
//
this.tbAudioFile.Location = new System.Drawing.Point(74, 21);
this.tbAudioFile.Name = "tbAudioFile";
this.tbAudioFile.ReadOnly = true;
this.tbAudioFile.Size = new System.Drawing.Size(191, 20);
this.tbAudioFile.TabIndex = 12;
//
// btnBrowseAudioFile
//
this.btnBrowseAudioFile.Location = new System.Drawing.Point(271, 20);
this.btnBrowseAudioFile.Name = "btnBrowseAudioFile";
this.btnBrowseAudioFile.Size = new System.Drawing.Size(75, 23);
this.btnBrowseAudioFile.TabIndex = 13;
this.btnBrowseAudioFile.Text = "Browse...";
this.btnBrowseAudioFile.UseVisualStyleBackColor = true;
this.btnBrowseAudioFile.Click += new System.EventHandler(this.btnBrowseAudioFile_Click);
//
// gbLoop
//
this.gbLoop.Controls.Add(this.tbLoopStart);
this.gbLoop.Controls.Add(this.rbEnterManually);
this.gbLoop.Controls.Add(this.rbFromAudioFile);
this.gbLoop.Controls.Add(this.rbNone);
this.gbLoop.Location = new System.Drawing.Point(15, 72);
this.gbLoop.Name = "gbLoop";
this.gbLoop.Size = new System.Drawing.Size(331, 94);
this.gbLoop.TabIndex = 14;
this.gbLoop.TabStop = false;
this.gbLoop.Text = "Loop";
//
// tbLoopStart
//
this.tbLoopStart.Enabled = false;
this.tbLoopStart.Location = new System.Drawing.Point(227, 64);
this.tbLoopStart.Name = "tbLoopStart";
this.tbLoopStart.Size = new System.Drawing.Size(60, 20);
this.tbLoopStart.TabIndex = 1;
this.tbLoopStart.Text = "0";
//
// rbEnterManually
//
this.rbEnterManually.AutoSize = true;
this.rbEnterManually.Location = new System.Drawing.Point(6, 65);
this.rbEnterManually.Name = "rbEnterManually";
this.rbEnterManually.Size = new System.Drawing.Size(215, 17);
this.rbEnterManually.TabIndex = 0;
this.rbEnterManually.Text = "Enter Manually Loop Start Sample:";
this.rbEnterManually.UseVisualStyleBackColor = true;
this.rbEnterManually.CheckedChanged += new System.EventHandler(this.rbSelectionChanged);
//
// rbFromAudioFile
//
this.rbFromAudioFile.AutoSize = true;
this.rbFromAudioFile.Location = new System.Drawing.Point(6, 42);
this.rbFromAudioFile.Name = "rbFromAudioFile";
this.rbFromAudioFile.Size = new System.Drawing.Size(281, 17);
this.rbFromAudioFile.TabIndex = 0;
this.rbFromAudioFile.Text = "From Audio File (works only with pre-looped wave files)";
this.rbFromAudioFile.UseVisualStyleBackColor = true;
this.rbFromAudioFile.CheckedChanged += new System.EventHandler(this.rbSelectionChanged);
//
// rbNone
//
this.rbNone.AutoSize = true;
this.rbNone.Checked = true;
this.rbNone.Location = new System.Drawing.Point(6, 19);
this.rbNone.Name = "rbNone";
this.rbNone.Size = new System.Drawing.Size(51, 17);
this.rbNone.TabIndex = 0;
this.rbNone.TabStop = true;
this.rbNone.Text = "None";
this.rbNone.UseVisualStyleBackColor = true;
this.rbNone.CheckedChanged += new System.EventHandler(this.rbSelectionChanged);
//
// gbWaveInfo
//
this.gbWaveInfo.Controls.Add(this.lbStatusValue);
this.gbWaveInfo.Controls.Add(this.lbLoopStartValue);
this.gbWaveInfo.Controls.Add(this.lbLoopCountValue);
this.gbWaveInfo.Controls.Add(this.lbFormatValue);
this.gbWaveInfo.Controls.Add(this.lbChannelCountValue);
this.gbWaveInfo.Controls.Add(this.lbSamplerateValue);
this.gbWaveInfo.Controls.Add(this.lbBitdepthValue);
this.gbWaveInfo.Controls.Add(this.lbStatus);
this.gbWaveInfo.Controls.Add(this.lbLoopStart);
this.gbWaveInfo.Controls.Add(this.lbLoopCount);
this.gbWaveInfo.Controls.Add(this.lbFormat);
this.gbWaveInfo.Controls.Add(this.lbChannelCount);
this.gbWaveInfo.Controls.Add(this.lbSamplerate);
this.gbWaveInfo.Controls.Add(this.lbBitdepth);
this.gbWaveInfo.Location = new System.Drawing.Point(363, 20);
this.gbWaveInfo.Name = "gbWaveInfo";
this.gbWaveInfo.Size = new System.Drawing.Size(135, 182);
this.gbWaveInfo.TabIndex = 15;
this.gbWaveInfo.TabStop = false;
this.gbWaveInfo.Text = "Wave Info";
//
// lbStatusValue
//
this.lbStatusValue.Location = new System.Drawing.Point(75, 151);
this.lbStatusValue.Name = "lbStatusValue";
this.lbStatusValue.Size = new System.Drawing.Size(54, 13);
this.lbStatusValue.TabIndex = 7;
//
// lbLoopStartValue
//
this.lbLoopStartValue.Location = new System.Drawing.Point(75, 130);
this.lbLoopStartValue.Name = "lbLoopStartValue";
this.lbLoopStartValue.Size = new System.Drawing.Size(54, 13);
this.lbLoopStartValue.TabIndex = 7;
//
// lbLoopCountValue
//
this.lbLoopCountValue.Location = new System.Drawing.Point(75, 109);
this.lbLoopCountValue.Name = "lbLoopCountValue";
this.lbLoopCountValue.Size = new System.Drawing.Size(54, 13);
this.lbLoopCountValue.TabIndex = 7;
//
// lbFormatValue
//
this.lbFormatValue.Location = new System.Drawing.Point(75, 88);
this.lbFormatValue.Name = "lbFormatValue";
this.lbFormatValue.Size = new System.Drawing.Size(54, 13);
this.lbFormatValue.TabIndex = 7;
//
// lbChannelCountValue
//
this.lbChannelCountValue.Location = new System.Drawing.Point(75, 67);
this.lbChannelCountValue.Name = "lbChannelCountValue";
this.lbChannelCountValue.Size = new System.Drawing.Size(54, 13);
this.lbChannelCountValue.TabIndex = 7;
//
// lbSamplerateValue
//
this.lbSamplerateValue.Location = new System.Drawing.Point(75, 46);
this.lbSamplerateValue.Name = "lbSamplerateValue";
this.lbSamplerateValue.Size = new System.Drawing.Size(54, 13);
this.lbSamplerateValue.TabIndex = 7;
//
// lbBitdepthValue
//
this.lbBitdepthValue.Location = new System.Drawing.Point(75, 25);
this.lbBitdepthValue.Name = "lbBitdepthValue";
this.lbBitdepthValue.Size = new System.Drawing.Size(54, 13);
this.lbBitdepthValue.TabIndex = 7;
//
// lbStatus
//
this.lbStatus.AutoSize = true;
this.lbStatus.Location = new System.Drawing.Point(6, 151);
this.lbStatus.Name = "lbStatus";
this.lbStatus.Size = new System.Drawing.Size(40, 13);
this.lbStatus.TabIndex = 6;
this.lbStatus.Text = "Status:";
//
// lbLoopStart
//
this.lbLoopStart.AutoSize = true;
this.lbLoopStart.Location = new System.Drawing.Point(6, 130);
this.lbLoopStart.Name = "lbLoopStart";
this.lbLoopStart.Size = new System.Drawing.Size(59, 13);
this.lbLoopStart.TabIndex = 5;
this.lbLoopStart.Text = "Loop Start:";
//
// lbLoopCount
//
this.lbLoopCount.AutoSize = true;
this.lbLoopCount.Location = new System.Drawing.Point(6, 109);
this.lbLoopCount.Name = "lbLoopCount";
this.lbLoopCount.Size = new System.Drawing.Size(39, 13);
this.lbLoopCount.TabIndex = 4;
this.lbLoopCount.Text = "Loops:";
//
// lbFormat
//
this.lbFormat.AutoSize = true;
this.lbFormat.Location = new System.Drawing.Point(6, 88);
this.lbFormat.Name = "lbFormat";
this.lbFormat.Size = new System.Drawing.Size(42, 13);
this.lbFormat.TabIndex = 3;
this.lbFormat.Text = "Format:";
//
// lbChannelCount
//
this.lbChannelCount.AutoSize = true;
this.lbChannelCount.Location = new System.Drawing.Point(6, 67);
this.lbChannelCount.Name = "lbChannelCount";
this.lbChannelCount.Size = new System.Drawing.Size(54, 13);
this.lbChannelCount.TabIndex = 2;
this.lbChannelCount.Text = "Channels:";
//
// lbSamplerate
//
this.lbSamplerate.AutoSize = true;
this.lbSamplerate.Location = new System.Drawing.Point(6, 46);
this.lbSamplerate.Name = "lbSamplerate";
this.lbSamplerate.Size = new System.Drawing.Size(63, 13);
this.lbSamplerate.TabIndex = 1;
this.lbSamplerate.Text = "Samplerate:";
//
// lbBitdepth
//
this.lbBitdepth.AutoSize = true;
this.lbBitdepth.Location = new System.Drawing.Point(6, 25);
this.lbBitdepth.Name = "lbBitdepth";
this.lbBitdepth.Size = new System.Drawing.Size(49, 13);
this.lbBitdepth.TabIndex = 0;
this.lbBitdepth.Text = "Bitdepth:";
//
// cbSourceSound
//
this.cbSourceSound.AutoSize = true;
this.cbSourceSound.Enabled = false;
this.cbSourceSound.Location = new System.Drawing.Point(15, 50);
this.cbSourceSound.Name = "cbSourceSound";
this.cbSourceSound.Size = new System.Drawing.Size(170, 17);
this.cbSourceSound.TabIndex = 16;
this.cbSourceSound.Text = "Take sound from source WAD";
this.cbSourceSound.UseVisualStyleBackColor = true;
this.cbSourceSound.CheckedChanged += new System.EventHandler(this.cbSourceSound_CheckedChanged);
//
// CustomizeMii_BnsConvert
//
this.AcceptButton = this.btnConvert;
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.CancelButton = this.btnCancel;
this.ClientSize = new System.Drawing.Size(510, 220);
this.Controls.Add(this.cbSourceSound);
this.Controls.Add(this.gbWaveInfo);
this.Controls.Add(this.gbLoop);
this.Controls.Add(this.btnBrowseAudioFile);
this.Controls.Add(this.tbAudioFile);
this.Controls.Add(this.lbAudioFile);
this.Controls.Add(this.btnCancel);
this.Controls.Add(this.btnConvert);
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
this.Name = "CustomizeMii_BnsConvert";
this.Text = "CustomizeMii_BnsConvert";
this.Load += new System.EventHandler(this.CustomizeMii_BnsConvert_Load);
this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.CustomizeMii_BnsConvert_FormClosing);
this.gbLoop.ResumeLayout(false);
this.gbLoop.PerformLayout();
this.gbWaveInfo.ResumeLayout(false);
this.gbWaveInfo.PerformLayout();
this.ResumeLayout(false);
this.PerformLayout();
}
#endregion
private System.Windows.Forms.Button btnCancel;
private System.Windows.Forms.Button btnConvert;
private System.Windows.Forms.Label lbAudioFile;
private System.Windows.Forms.TextBox tbAudioFile;
private System.Windows.Forms.Button btnBrowseAudioFile;
private System.Windows.Forms.GroupBox gbLoop;
private System.Windows.Forms.RadioButton rbNone;
private System.Windows.Forms.RadioButton rbEnterManually;
private System.Windows.Forms.RadioButton rbFromAudioFile;
private System.Windows.Forms.TextBox tbLoopStart;
private System.Windows.Forms.GroupBox gbWaveInfo;
private System.Windows.Forms.Label lbBitdepth;
private System.Windows.Forms.Label lbSamplerate;
private System.Windows.Forms.Label lbChannelCount;
private System.Windows.Forms.Label lbFormat;
private System.Windows.Forms.Label lbLoopCount;
private System.Windows.Forms.Label lbLoopStart;
private System.Windows.Forms.Label lbStatus;
private System.Windows.Forms.Label lbStatusValue;
private System.Windows.Forms.Label lbLoopStartValue;
private System.Windows.Forms.Label lbLoopCountValue;
private System.Windows.Forms.Label lbFormatValue;
private System.Windows.Forms.Label lbChannelCountValue;
private System.Windows.Forms.Label lbSamplerateValue;
private System.Windows.Forms.Label lbBitdepthValue;
private System.Windows.Forms.CheckBox cbSourceSound;
}
}

356
CustomizeMii/CustomizeMii_BnsConvert.cs Normal file
View File

@ -0,0 +1,356 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.IO;
using System.Windows.Forms;
using System.ComponentModel;
using WaveFile;
namespace CustomizeMii
{
public partial class CustomizeMii_BnsConvert : Form
{
private bool lameExists;
private int loopStartSample;
private BackgroundWorker bwGatherInfo;
private int bitDepth;
private int sampleRate;
private int channelCount;
private int dataFormat;
private int loopCount;
private int loopStart;
private bool error = false;
private bool cancelled = false;
public string AudioFile { get { return tbAudioFile.Text; } }
public bool LoopNone { get { return rbNone.Checked; } }
public bool LoopFromAudio { get { return rbFromAudioFile.Checked; } }
public bool LoopManually { get { return rbEnterManually.Checked; } }
public int LoopStartSample { get { return loopStartSample; } }
public int ChannelCount { get { return channelCount; } }
public CustomizeMii_BnsConvert(bool lameExists)
{
InitializeComponent();
this.lameExists = lameExists;
}
private void CustomizeMii_BnsConvert_Load(object sender, EventArgs e)
{
//this.Size = new System.Drawing.Size(358, 220);
this.Size = new System.Drawing.Size(btnCancel.Location.X + btnCancel.Size.Width + 15, 220);
this.CenterToParent();
bwGatherInfo = new BackgroundWorker();
bwGatherInfo.WorkerSupportsCancellation = true;
bwGatherInfo.DoWork += new DoWorkEventHandler(bwGatherInfo_DoWork);
byte[] soundBin = Wii.Tools.LoadFileToByteArray(CustomizeMii_Main.TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin", 32, 16);
if (soundBin[0] == 'R' && soundBin[1] == 'I' && soundBin[2] == 'F' && soundBin[3] == 'F')
{ cbSourceSound.Enabled = true; }
else if (soundBin[0] == 'L' && soundBin[1] == 'Z' && soundBin[2] == '7' && soundBin[3] == '7')
if (soundBin[9] == 'R' && soundBin[10] == 'I' && soundBin[11] == 'F' && soundBin[12] == 'F')
{ cbSourceSound.Enabled = true; }
}
private void CustomizeMii_BnsConvert_FormClosing(object sender, FormClosingEventArgs e)
{
cancelled = true;
if (bwGatherInfo.IsBusy)
bwGatherInfo.CancelAsync();
}
private void rbSelectionChanged(object sender, EventArgs e)
{
tbLoopStart.Enabled = rbEnterManually.Checked;
}
private void btnConvert_Click(object sender, EventArgs e)
{
if (!File.Exists(tbAudioFile.Text) && tbAudioFile.Text != "Internal Sound")
{
tbAudioFile.Focus();
tbAudioFile.SelectAll();
return;
}
if (!int.TryParse(tbLoopStart.Text, out loopStartSample))
{
tbLoopStart.Focus();
tbLoopStart.SelectAll();
}
this.DialogResult = DialogResult.OK;
this.Close();
}
private void btnCancel_Click(object sender, EventArgs e)
{
this.DialogResult = DialogResult.Cancel;
this.Close();
}
private void cbSourceSound_CheckedChanged(object sender, EventArgs e)
{
if (cbSourceSound.Checked)
{
tbAudioFile.Text = "Internal Sound";
FileStream fs = new FileStream(CustomizeMii_Main.TempUnpackPath + "00000000.app_OUT\\meta\\sound.bin", FileMode.Open);
byte[] audio = new byte[fs.Length - 32];
int offset = 0;
fs.Seek(32, SeekOrigin.Begin);
fs.Read(audio, 0, audio.Length);
fs.Close();
if ((offset = Wii.Lz77.GetLz77Offset(audio)) != -1)
audio = Wii.Lz77.Decompress(audio, offset);
foreach (Label thisLabel in gbWaveInfo.Controls)
if (thisLabel.Name.ToLower().Contains("value"))
{
thisLabel.ForeColor = System.Drawing.Color.Black;
thisLabel.Text = "Gathering";
}
bwGatherInfo.RunWorkerAsync(audio);
//this.Size = new System.Drawing.Size(510, 220);
this.Size = new System.Drawing.Size(gbWaveInfo.Location.X + gbWaveInfo.Size.Width + 15, 220);
}
else
{
if (tbAudioFile.Text == "Internal Sound")
tbAudioFile.Text = string.Empty;
//this.Size = new System.Drawing.Size(358, 220);
this.Size = new System.Drawing.Size(btnCancel.Location.X + btnCancel.Size.Width + 15, 220);
}
}
private void btnBrowseAudioFile_Click(object sender, EventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
if (lameExists)
{ ofd.Filter = "Wave|*.wav|MP3|*.mp3|All|*.wav;*.mp3"; ofd.FilterIndex = 3; }
else
{ ofd.Filter = "Wave|*.wav"; }
if (ofd.ShowDialog() == DialogResult.OK)
{
if (ofd.FileName != tbAudioFile.Text)
{
btnConvert.Enabled = false;
cbSourceSound.Checked = false;
tbAudioFile.Text = ofd.FileName;
if (ofd.FileName.EndsWith(".wav"))
{
rbFromAudioFile.Enabled = true;
foreach (Label thisLabel in gbWaveInfo.Controls)
if (thisLabel.Name.ToLower().Contains("value"))
{
thisLabel.ForeColor = System.Drawing.Color.Black;
thisLabel.Text = "Gathering";
}
bwGatherInfo.RunWorkerAsync(ofd.FileName);
//this.Size = new System.Drawing.Size(510, 220);
this.Size = new System.Drawing.Size(gbWaveInfo.Location.X + gbWaveInfo.Size.Width + 15, 220);
}
else if (ofd.FileName.EndsWith(".mp3"))
{
channelCount = 0;
btnConvert.Enabled = true;
if (rbFromAudioFile.Checked) rbNone.Checked = true;
rbFromAudioFile.Enabled = false;
//this.Size = new System.Drawing.Size(358, 220);
this.Size = new System.Drawing.Size(btnCancel.Location.X + btnCancel.Size.Width + 15, 220);
}
}
}
}
void bwGatherInfo_DoWork(object sender, DoWorkEventArgs e)
{
EventHandler UpdateValues = new EventHandler(this.UpdateValues);
try
{
Wave wave;
if (e.Argument is byte[])
{ wave = new Wave((byte[])e.Argument); }
else
{ wave = new Wave((string)e.Argument); }
try { bitDepth = wave.BitDepth; }
catch { bitDepth = -1; }
try { sampleRate = wave.SampleRate; }
catch { sampleRate = -1; }
try { channelCount = wave.ChannelCount; }
catch { channelCount = -1; }
try { dataFormat = wave.DataFormat; }
catch { dataFormat = -1; }
try { loopCount = wave.LoopCount; }
catch { loopCount = -1; }
try { loopStart = wave.LoopStart; }
catch { loopStart = -1; }
if (!cancelled)
this.Invoke(UpdateValues);
if (e.Argument is byte[])
{
byte[] audio = e.Argument as byte[];
using (FileStream fs = new FileStream(CustomizeMii_Main.TempWavePath, FileMode.Create))
{
fs.Write(audio, 0, audio.Length);
}
}
}
catch
{
error = true;
if (!cancelled)
this.Invoke(UpdateValues);
}
}
void UpdateValues(object sender, EventArgs e)
{
if (error == true)
{
foreach (Label thisLabel in gbWaveInfo.Controls)
if (thisLabel.Name.ToLower().Contains("value"))
{
thisLabel.Text = "Error";
thisLabel.ForeColor = System.Drawing.Color.Red;
}
error = false;
return;
}
bool statusOk = true;
if (bitDepth == -1) lbBitdepthValue.Text = "Error";
else lbBitdepthValue.Text = bitDepth.ToString();
if (sampleRate == -1) lbSamplerateValue.Text = "Error";
else lbSamplerateValue.Text = sampleRate.ToString();
if (dataFormat == -1) lbFormatValue.Text = "Error";
else if (dataFormat == 1) lbFormatValue.Text = "1 (PCM)";
else lbFormatValue.Text = dataFormat.ToString();
if (channelCount == -1) lbChannelCountValue.Text = "Error";
else if (channelCount == 1) lbChannelCountValue.Text = "1 (Mono)";
else if (channelCount == 2) lbChannelCountValue.Text = "2 (Stereo)";
else lbChannelCountValue.Text = channelCount.ToString();
if (loopCount == -1) lbLoopCountValue.Text = "Error";
else lbLoopCountValue.Text = loopCount.ToString();
if (loopCount == -1) lbLoopStartValue.Text = "Error";
else if (loopCount == 1) { lbLoopStartValue.Text = loopStart == -1 ? "Error" : loopStart.ToString(); }
else lbLoopStartValue.Text = "-";
if (lbBitdepthValue.Text == "Error" || bitDepth != 16)
{
lbBitdepthValue.ForeColor = System.Drawing.Color.Red;
statusOk = false;
}
else lbBitdepthValue.ForeColor = System.Drawing.Color.Green;
if (lbSamplerateValue.Text == "Error")
{
lbSamplerateValue.ForeColor = System.Drawing.Color.Red;
statusOk = false;
}
else lbSamplerateValue.ForeColor = System.Drawing.Color.Green;
if (lbFormatValue.Text == "Error" || dataFormat != 1)
{
lbFormatValue.ForeColor = System.Drawing.Color.Red;
statusOk = false;
}
else lbFormatValue.ForeColor = System.Drawing.Color.Green;
if (lbChannelCountValue.Text == "Error" || (channelCount > 2 || channelCount < 1))
{
lbChannelCountValue.ForeColor = System.Drawing.Color.Red;
statusOk = false;
}
else lbChannelCountValue.ForeColor = System.Drawing.Color.Green;
if (lbLoopCountValue.Text == "Error" || loopCount > 1)
lbLoopCountValue.ForeColor = System.Drawing.Color.Orange;
else lbLoopCountValue.ForeColor = System.Drawing.Color.Green;
if (lbLoopStartValue.Text == "Error" || lbLoopStartValue.Text == "-")
lbLoopStartValue.ForeColor = System.Drawing.Color.Orange;
else lbLoopStartValue.ForeColor = System.Drawing.Color.Green;
if (!statusOk)
{
lbStatusValue.Text = "Not OK!";
lbStatusValue.ForeColor = System.Drawing.Color.Red;
btnConvert.Enabled = false;
}
else
{
btnConvert.Enabled = true;
if (lbLoopCountValue.ForeColor == System.Drawing.Color.Orange ||
lbLoopStartValue.ForeColor == System.Drawing.Color.Orange)
{
lbStatusValue.Text = "No Loop!";
lbStatusValue.ForeColor = System.Drawing.Color.Orange;
if (rbFromAudioFile.Checked) rbNone.Checked = true;
rbFromAudioFile.Enabled = false;
}
else
{
rbFromAudioFile.Enabled = true;
lbStatusValue.Text = "OK!";
lbStatusValue.ForeColor = System.Drawing.Color.Green;
}
}
}
}
}

120
CustomizeMii/CustomizeMii_BnsConvert.resx Normal file
View File

@ -0,0 +1,120 @@
<?xml version="1.0" encoding="utf-8"?>
<root>
<!--
Microsoft ResX Schema
Version 2.0
The primary goals of this format is to allow a simple XML format
that is mostly human readable. The generation and parsing of the
various data types are done through the TypeConverter classes
associated with the data types.
Example:
... ado.net/XML headers & schema ...
<resheader name="resmimetype">text/microsoft-resx</resheader>
<resheader name="version">2.0</resheader>
<resheader name="reader">System.Resources.ResXResourceReader, System.Windows.Forms, ...</resheader>
<resheader name="writer">System.Resources.ResXResourceWriter, System.Windows.Forms, ...</resheader>
<data name="Name1"><value>this is my long string</value><comment>this is a comment</comment></data>
<data name="Color1" type="System.Drawing.Color, System.Drawing">Blue</data>
<data name="Bitmap1" mimetype="application/x-microsoft.net.object.binary.base64">
<value>[base64 mime encoded serialized .NET Framework object]</value>
</data>
<data name="Icon1" type="System.Drawing.Icon, System.Drawing" mimetype="application/x-microsoft.net.object.bytearray.base64">
<value>[base64 mime encoded string representing a byte array form of the .NET Framework object]</value>
<comment>This is a comment</comment>
</data>
There are any number of "resheader" rows that contain simple
name/value pairs.
Each data row contains a name, and value. The row also contains a
type or mimetype. Type corresponds to a .NET class that support
text/value conversion through the TypeConverter architecture.
Classes that don't support this are serialized and stored with the
mimetype set.
The mimetype is used for serialized objects, and tells the
ResXResourceReader how to depersist the object. This is currently not
extensible. For a given mimetype the value must be set accordingly:
Note - application/x-microsoft.net.object.binary.base64 is the format
that the ResXResourceWriter will generate, however the reader can
read any of the formats listed below.
mimetype: application/x-microsoft.net.object.binary.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Binary.BinaryFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.soap.base64
value : The object must be serialized with
: System.Runtime.Serialization.Formatters.Soap.SoapFormatter
: and then encoded with base64 encoding.
mimetype: application/x-microsoft.net.object.bytearray.base64
value : The object must be serialized into a byte array
: using a System.ComponentModel.TypeConverter
: and then encoded with base64 encoding.
-->
<xsd:schema id="root" xmlns="" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:msdata="urn:schemas-microsoft-com:xml-msdata">
<xsd:import namespace="http://www.w3.org/XML/1998/namespace" />
<xsd:element name="root" msdata:IsDataSet="true">
<xsd:complexType>
<xsd:choice maxOccurs="unbounded">
<xsd:element name="metadata">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" />
</xsd:sequence>
<xsd:attribute name="name" use="required" type="xsd:string" />
<xsd:attribute name="type" type="xsd:string" />
<xsd:attribute name="mimetype" type="xsd:string" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="assembly">
<xsd:complexType>
<xsd:attribute name="alias" type="xsd:string" />
<xsd:attribute name="name" type="xsd:string" />
</xsd:complexType>
</xsd:element>
<xsd:element name="data">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
<xsd:element name="comment" type="xsd:string" minOccurs="0" msdata:Ordinal="2" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" msdata:Ordinal="1" />
<xsd:attribute name="type" type="xsd:string" msdata:Ordinal="3" />
<xsd:attribute name="mimetype" type="xsd:string" msdata:Ordinal="4" />
<xsd:attribute ref="xml:space" />
</xsd:complexType>
</xsd:element>
<xsd:element name="resheader">
<xsd:complexType>
<xsd:sequence>
<xsd:element name="value" type="xsd:string" minOccurs="0" msdata:Ordinal="1" />
</xsd:sequence>
<xsd:attribute name="name" type="xsd:string" use="required" />
</xsd:complexType>
</xsd:element>
</xsd:choice>
</xsd:complexType>
</xsd:element>
</xsd:schema>
<resheader name="resmimetype">
<value>text/microsoft-resx</value>
</resheader>
<resheader name="version">
<value>2.0</value>
</resheader>
<resheader name="reader">
<value>System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<resheader name="writer">
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
</root>

111
CustomizeMii/CustomizeMii_ComplexForwarder.Designer.cs generated
View File

@ -47,12 +47,6 @@ namespace CustomizeMii
{
this.lbAppFolder = new System.Windows.Forms.Label();
this.tbAppFolder = new System.Windows.Forms.TextBox();
this.panSdUsb = new System.Windows.Forms.Panel();
this.rbUSB = new System.Windows.Forms.RadioButton();
this.rbSD = new System.Windows.Forms.RadioButton();
this.panDolElf = new System.Windows.Forms.Panel();
this.rbELF = new System.Windows.Forms.RadioButton();
this.rbDOL = new System.Windows.Forms.RadioButton();
this.cbImage43 = new System.Windows.Forms.CheckBox();
this.cbImage169 = new System.Windows.Forms.CheckBox();
this.tbImage43 = new System.Windows.Forms.TextBox();
@ -62,14 +56,12 @@ namespace CustomizeMii
this.label1 = new System.Windows.Forms.Label();
this.btnOK = new System.Windows.Forms.Button();
this.btnCancel = new System.Windows.Forms.Button();
this.panSdUsb.SuspendLayout();
this.panDolElf.SuspendLayout();
this.SuspendLayout();
//
// lbAppFolder
//
this.lbAppFolder.AutoSize = true;
this.lbAppFolder.Location = new System.Drawing.Point(12, 13);
this.lbAppFolder.Location = new System.Drawing.Point(12, 17);
this.lbAppFolder.Name = "lbAppFolder";
this.lbAppFolder.Size = new System.Drawing.Size(107, 13);
this.lbAppFolder.TabIndex = 0;
@ -77,77 +69,15 @@ namespace CustomizeMii
//
// tbAppFolder
//
this.tbAppFolder.Location = new System.Drawing.Point(125, 10);
this.tbAppFolder.Location = new System.Drawing.Point(125, 14);
this.tbAppFolder.Name = "tbAppFolder";
this.tbAppFolder.Size = new System.Drawing.Size(221, 20);
this.tbAppFolder.TabIndex = 1;
//
// panSdUsb
//
this.panSdUsb.Controls.Add(this.rbUSB);
this.panSdUsb.Controls.Add(this.rbSD);
this.panSdUsb.Location = new System.Drawing.Point(15, 38);
this.panSdUsb.Name = "panSdUsb";
this.panSdUsb.Size = new System.Drawing.Size(157, 64);
this.panSdUsb.TabIndex = 2;
//
// rbUSB
//
this.rbUSB.AutoSize = true;
this.rbUSB.Location = new System.Drawing.Point(24, 35);
this.rbUSB.Name = "rbUSB";
this.rbUSB.Size = new System.Drawing.Size(87, 17);
this.rbUSB.TabIndex = 0;
this.rbUSB.TabStop = true;
this.rbUSB.Text = "Try USB First";
this.rbUSB.UseVisualStyleBackColor = true;
//
// rbSD
//
this.rbSD.AutoSize = true;
this.rbSD.Location = new System.Drawing.Point(24, 12);
this.rbSD.Name = "rbSD";
this.rbSD.Size = new System.Drawing.Size(80, 17);
this.rbSD.TabIndex = 0;
this.rbSD.TabStop = true;
this.rbSD.Text = "Try SD First";
this.rbSD.UseVisualStyleBackColor = true;
//
// panDolElf
//
this.panDolElf.Controls.Add(this.rbELF);
this.panDolElf.Controls.Add(this.rbDOL);
this.panDolElf.Location = new System.Drawing.Point(189, 38);
this.panDolElf.Name = "panDolElf";
this.panDolElf.Size = new System.Drawing.Size(157, 64);
this.panDolElf.TabIndex = 2;
//
// rbELF
//
this.rbELF.AutoSize = true;
this.rbELF.Location = new System.Drawing.Point(41, 35);
this.rbELF.Name = "rbELF";
this.rbELF.Size = new System.Drawing.Size(84, 17);
this.rbELF.TabIndex = 0;
this.rbELF.TabStop = true;
this.rbELF.Text = "Try ELF First";
this.rbELF.UseVisualStyleBackColor = true;
//
// rbDOL
//
this.rbDOL.AutoSize = true;
this.rbDOL.Location = new System.Drawing.Point(41, 12);
this.rbDOL.Name = "rbDOL";
this.rbDOL.Size = new System.Drawing.Size(87, 17);
this.rbDOL.TabIndex = 0;
this.rbDOL.TabStop = true;
this.rbDOL.Text = "Try DOL First";
this.rbDOL.UseVisualStyleBackColor = true;
//
// cbImage43
//
this.cbImage43.AutoSize = true;
this.cbImage43.Location = new System.Drawing.Point(15, 141);
this.cbImage43.Location = new System.Drawing.Point(15, 111);
this.cbImage43.Name = "cbImage43";
this.cbImage43.Size = new System.Drawing.Size(73, 17);
this.cbImage43.TabIndex = 3;
@ -158,7 +88,7 @@ namespace CustomizeMii
// cbImage169
//
this.cbImage169.AutoSize = true;
this.cbImage169.Location = new System.Drawing.Point(15, 171);
this.cbImage169.Location = new System.Drawing.Point(15, 141);
this.cbImage169.Name = "cbImage169";
this.cbImage169.Size = new System.Drawing.Size(79, 17);
this.cbImage169.TabIndex = 3;
@ -169,7 +99,7 @@ namespace CustomizeMii
// tbImage43
//
this.tbImage43.Enabled = false;
this.tbImage43.Location = new System.Drawing.Point(94, 139);
this.tbImage43.Location = new System.Drawing.Point(94, 109);
this.tbImage43.Name = "tbImage43";
this.tbImage43.Size = new System.Drawing.Size(171, 20);
this.tbImage43.TabIndex = 4;
@ -177,7 +107,7 @@ namespace CustomizeMii
// tbImage169
//
this.tbImage169.Enabled = false;
this.tbImage169.Location = new System.Drawing.Point(94, 168);
this.tbImage169.Location = new System.Drawing.Point(94, 138);
this.tbImage169.Name = "tbImage169";
this.tbImage169.Size = new System.Drawing.Size(171, 20);
this.tbImage169.TabIndex = 5;
@ -185,7 +115,7 @@ namespace CustomizeMii
// btnBrowseImage43
//
this.btnBrowseImage43.Enabled = false;
this.btnBrowseImage43.Location = new System.Drawing.Point(271, 139);
this.btnBrowseImage43.Location = new System.Drawing.Point(271, 109);
this.btnBrowseImage43.Name = "btnBrowseImage43";
this.btnBrowseImage43.Size = new System.Drawing.Size(75, 23);
this.btnBrowseImage43.TabIndex = 6;
@ -196,7 +126,7 @@ namespace CustomizeMii
// btnBrowseImage169
//
this.btnBrowseImage169.Enabled = false;
this.btnBrowseImage169.Location = new System.Drawing.Point(271, 168);
this.btnBrowseImage169.Location = new System.Drawing.Point(271, 138);
this.btnBrowseImage169.Name = "btnBrowseImage169";
this.btnBrowseImage169.Size = new System.Drawing.Size(75, 23);
this.btnBrowseImage169.TabIndex = 6;
@ -206,16 +136,17 @@ namespace CustomizeMii
//
// label1
//
this.label1.Location = new System.Drawing.Point(0, 116);
this.label1.Location = new System.Drawing.Point(0, 55);
this.label1.Name = "label1";
this.label1.Size = new System.Drawing.Size(358, 13);
this.label1.Size = new System.Drawing.Size(358, 40);
this.label1.TabIndex = 7;
this.label1.Text = "The images must be 640 x 480, else they will be resized!";
this.label1.Text = "The images must be 640 x 480, else they will be resized!\r\nThe 16:9 image should b" +
"e made in 832 x 480 and resized\r\nto 640 x 480, it will be streched on the Wii!";
this.label1.TextAlign = System.Drawing.ContentAlignment.TopCenter;
//
// btnOK
//
this.btnOK.Location = new System.Drawing.Point(15, 209);
this.btnOK.Location = new System.Drawing.Point(15, 179);
this.btnOK.Name = "btnOK";
this.btnOK.Size = new System.Drawing.Size(160, 23);
this.btnOK.TabIndex = 8;
@ -225,7 +156,7 @@ namespace CustomizeMii
//
// btnCancel
//
this.btnCancel.Location = new System.Drawing.Point(186, 209);
this.btnCancel.Location = new System.Drawing.Point(186, 179);
this.btnCancel.Name = "btnCancel";
this.btnCancel.Size = new System.Drawing.Size(160, 23);
this.btnCancel.TabIndex = 8;
@ -237,7 +168,7 @@ namespace CustomizeMii
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font;
this.ClientSize = new System.Drawing.Size(358, 245);
this.ClientSize = new System.Drawing.Size(358, 220);
this.Controls.Add(this.btnCancel);
this.Controls.Add(this.btnOK);
this.Controls.Add(this.label1);
@ -247,17 +178,11 @@ namespace CustomizeMii
this.Controls.Add(this.tbImage43);
this.Controls.Add(this.cbImage169);
this.Controls.Add(this.cbImage43);
this.Controls.Add(this.panDolElf);
this.Controls.Add(this.panSdUsb);
this.Controls.Add(this.tbAppFolder);
this.Controls.Add(this.lbAppFolder);
this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.None;
this.Name = "CustomizeMii_ComplexForwarder";
this.Text = "CustomizeMii_ComplexForwarder";
this.panSdUsb.ResumeLayout(false);
this.panSdUsb.PerformLayout();
this.panDolElf.ResumeLayout(false);
this.panDolElf.PerformLayout();
this.ResumeLayout(false);
this.PerformLayout();
@ -266,14 +191,8 @@ namespace CustomizeMii
#endregion
private System.Windows.Forms.Label lbAppFolder;
private System.Windows.Forms.Panel panSdUsb;
private System.Windows.Forms.Panel panDolElf;
private System.Windows.Forms.Label label1;
public System.Windows.Forms.TextBox tbAppFolder;
public System.Windows.Forms.RadioButton rbUSB;
public System.Windows.Forms.RadioButton rbSD;
public System.Windows.Forms.RadioButton rbELF;
public System.Windows.Forms.RadioButton rbDOL;
public System.Windows.Forms.CheckBox cbImage43;
public System.Windows.Forms.CheckBox cbImage169;
public System.Windows.Forms.TextBox tbImage43;

184
CustomizeMii/CustomizeMii_Main.Designer.cs generated
View File

@ -80,6 +80,7 @@ namespace CustomizeMii
this.tbAllLanguages = new System.Windows.Forms.TextBox();
this.lbAllLanguages = new System.Windows.Forms.Label();
this.tabOptions = new System.Windows.Forms.TabPage();
this.btnOptionsExtract = new System.Windows.Forms.Button();
this.btnForwarder = new System.Windows.Forms.Button();
this.cbFailureChecks = new System.Windows.Forms.CheckBox();
this.cbLz77 = new System.Windows.Forms.CheckBox();
@ -150,6 +151,22 @@ namespace CustomizeMii
this.cmForwarder = new System.Windows.Forms.ContextMenuStrip(this.components);
this.cmSimpleForwarder = new System.Windows.Forms.ToolStripMenuItem();
this.cmComplexForwarder = new System.Windows.Forms.ToolStripMenuItem();
this.cmOptionsExtract = new System.Windows.Forms.ContextMenuStrip(this.components);
this.cmExtractWad = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractDol = new System.Windows.Forms.ToolStripMenuItem();
this.tsExtractSound = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractSoundAsBin = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractSoundAsAudio = new System.Windows.Forms.ToolStripMenuItem();
this.tsExtractImages = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractBannerImages = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractIconImages = new System.Windows.Forms.ToolStripMenuItem();
this.cmExtractBothImages = new System.Windows.Forms.ToolStripMenuItem();
this.cmSound = new System.Windows.Forms.ContextMenuStrip(this.components);
this.cmLoadAudioFile = new System.Windows.Forms.ToolStripMenuItem();
this.cmConvertToBns = new System.Windows.Forms.ToolStripMenuItem();
this.cmDol = new System.Windows.Forms.ContextMenuStrip(this.components);
this.cmLoadDol = new System.Windows.Forms.ToolStripMenuItem();
this.cmDolFromSource = new System.Windows.Forms.ToolStripMenuItem();
this.tabControl.SuspendLayout();
this.tabSource.SuspendLayout();
this.tabTitle.SuspendLayout();
@ -162,6 +179,9 @@ namespace CustomizeMii
this.tabCredits.SuspendLayout();
this.ssMain.SuspendLayout();
this.cmForwarder.SuspendLayout();
this.cmOptionsExtract.SuspendLayout();
this.cmSound.SuspendLayout();
this.cmDol.SuspendLayout();
this.SuspendLayout();
//
// btnCreateWad
@ -314,7 +334,7 @@ namespace CustomizeMii
//
// btnBrowseSource
//
this.btnBrowseSource.Location = new System.Drawing.Point(360, 12);
this.btnBrowseSource.Location = new System.Drawing.Point(360, 13);
this.btnBrowseSource.Name = "btnBrowseSource";
this.btnBrowseSource.Size = new System.Drawing.Size(75, 23);
this.btnBrowseSource.TabIndex = 2;
@ -514,6 +534,7 @@ namespace CustomizeMii
//
// tabOptions
//
this.tabOptions.Controls.Add(this.btnOptionsExtract);
this.tabOptions.Controls.Add(this.btnForwarder);
this.tabOptions.Controls.Add(this.cbFailureChecks);
this.tabOptions.Controls.Add(this.cbLz77);
@ -536,6 +557,16 @@ namespace CustomizeMii
this.tabOptions.Text = "Options";
this.tabOptions.UseVisualStyleBackColor = true;
//
// btnOptionsExtract
//
this.btnOptionsExtract.Location = new System.Drawing.Point(360, 47);
this.btnOptionsExtract.Name = "btnOptionsExtract";
this.btnOptionsExtract.Size = new System.Drawing.Size(75, 23);
this.btnOptionsExtract.TabIndex = 14;
this.btnOptionsExtract.Text = "Extract...";
this.btnOptionsExtract.UseVisualStyleBackColor = true;
this.btnOptionsExtract.Click += new System.EventHandler(this.btnOptionsExtract_Click);
//
// btnForwarder
//
this.btnForwarder.Location = new System.Drawing.Point(360, 109);
@ -553,12 +584,15 @@ namespace CustomizeMii
this.cbFailureChecks.Name = "cbFailureChecks";
this.cbFailureChecks.Size = new System.Drawing.Size(172, 17);
this.cbFailureChecks.TabIndex = 12;
this.cbFailureChecks.Tag = "Independent";
this.cbFailureChecks.Text = "/!\\ Turn off security checks /!\\";
this.cbFailureChecks.UseVisualStyleBackColor = true;
//
// cbLz77
//
this.cbLz77.AutoSize = true;
this.cbLz77.Checked = true;
this.cbLz77.CheckState = System.Windows.Forms.CheckState.Checked;
this.cbLz77.Location = new System.Drawing.Point(11, 180);
this.cbLz77.Name = "cbLz77";
this.cbLz77.Size = new System.Drawing.Size(134, 17);
@ -578,7 +612,7 @@ namespace CustomizeMii
//
// btnBrowseSound
//
this.btnBrowseSound.Location = new System.Drawing.Point(360, 144);
this.btnBrowseSound.Location = new System.Drawing.Point(360, 145);
this.btnBrowseSound.Name = "btnBrowseSound";
this.btnBrowseSound.Size = new System.Drawing.Size(75, 23);
this.btnBrowseSound.TabIndex = 9;
@ -609,7 +643,7 @@ namespace CustomizeMii
//
// btnBrowseDol
//
this.btnBrowseDol.Location = new System.Drawing.Point(360, 80);
this.btnBrowseDol.Location = new System.Drawing.Point(360, 81);
this.btnBrowseDol.Name = "btnBrowseDol";
this.btnBrowseDol.Size = new System.Drawing.Size(75, 23);
this.btnBrowseDol.TabIndex = 6;
@ -1257,7 +1291,7 @@ namespace CustomizeMii
this.cmSimpleForwarder,
this.cmComplexForwarder});
this.cmForwarder.Name = "contextMenuStrip1";
this.cmForwarder.Size = new System.Drawing.Size(178, 70);
this.cmForwarder.Size = new System.Drawing.Size(178, 48);
//
// cmSimpleForwarder
//
@ -1273,6 +1307,128 @@ namespace CustomizeMii
this.cmComplexForwarder.Text = "Complex Forwarder";
this.cmComplexForwarder.Click += new System.EventHandler(this.cmForwarderItem_Click);
//
// cmOptionsExtract
//
this.cmOptionsExtract.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.cmExtractWad,
this.cmExtractDol,
this.tsExtractSound,
this.tsExtractImages});
this.cmOptionsExtract.Name = "cmOptionsExtract";
this.cmOptionsExtract.Size = new System.Drawing.Size(153, 92);
//
// cmExtractWad
//
this.cmExtractWad.Name = "cmExtractWad";
this.cmExtractWad.Size = new System.Drawing.Size(152, 22);
this.cmExtractWad.Text = "WAD Contents";
this.cmExtractWad.Click += new System.EventHandler(this.cmExtractWad_Click);
//
// cmExtractDol
//
this.cmExtractDol.Name = "cmExtractDol";
this.cmExtractDol.Size = new System.Drawing.Size(152, 22);
this.cmExtractDol.Text = "DOL";
this.cmExtractDol.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// tsExtractSound
//
this.tsExtractSound.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.cmExtractSoundAsBin,
this.cmExtractSoundAsAudio});
this.tsExtractSound.Name = "tsExtractSound";
this.tsExtractSound.Size = new System.Drawing.Size(152, 22);
this.tsExtractSound.Text = "Sound";
//
// cmExtractSoundAsBin
//
this.cmExtractSoundAsBin.Name = "cmExtractSoundAsBin";
this.cmExtractSoundAsBin.Size = new System.Drawing.Size(143, 22);
this.cmExtractSoundAsBin.Text = "As sound.bin";
this.cmExtractSoundAsBin.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// cmExtractSoundAsAudio
//
this.cmExtractSoundAsAudio.Name = "cmExtractSoundAsAudio";
this.cmExtractSoundAsAudio.Size = new System.Drawing.Size(143, 22);
this.cmExtractSoundAsAudio.Text = "As Audiofile";
this.cmExtractSoundAsAudio.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// tsExtractImages
//
this.tsExtractImages.DropDownItems.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.cmExtractBannerImages,
this.cmExtractIconImages,
this.cmExtractBothImages});
this.tsExtractImages.Name = "tsExtractImages";
this.tsExtractImages.Size = new System.Drawing.Size(152, 22);
this.tsExtractImages.Text = "Images";
//
// cmExtractBannerImages
//
this.cmExtractBannerImages.Name = "cmExtractBannerImages";
this.cmExtractBannerImages.Size = new System.Drawing.Size(111, 22);
this.cmExtractBannerImages.Text = "Banner";
this.cmExtractBannerImages.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// cmExtractIconImages
//
this.cmExtractIconImages.Name = "cmExtractIconImages";
this.cmExtractIconImages.Size = new System.Drawing.Size(111, 22);
this.cmExtractIconImages.Text = "Icon";
this.cmExtractIconImages.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// cmExtractBothImages
//
this.cmExtractBothImages.Name = "cmExtractBothImages";
this.cmExtractBothImages.Size = new System.Drawing.Size(111, 22);
this.cmExtractBothImages.Text = "Both";
this.cmExtractBothImages.Click += new System.EventHandler(this.cmOptionsExtract_MouseClick);
//
// cmSound
//
this.cmSound.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.cmLoadAudioFile,
this.cmConvertToBns});
this.cmSound.Name = "cmSound";
this.cmSound.Size = new System.Drawing.Size(159, 48);
//
// cmLoadAudioFile
//
this.cmLoadAudioFile.Name = "cmLoadAudioFile";
this.cmLoadAudioFile.Size = new System.Drawing.Size(158, 22);
this.cmLoadAudioFile.Text = "Load Audio File";
this.cmLoadAudioFile.Click += new System.EventHandler(this.cmLoadAudioFile_Click);
//
// cmConvertToBns
//
this.cmConvertToBns.Name = "cmConvertToBns";
this.cmConvertToBns.Size = new System.Drawing.Size(158, 22);
this.cmConvertToBns.Text = "Convert To BNS";
this.cmConvertToBns.Click += new System.EventHandler(this.cmConvertToBns_Click);
//
// cmDol
//
this.cmDol.Items.AddRange(new System.Windows.Forms.ToolStripItem[] {
this.cmLoadDol,
this.cmDolFromSource});
this.cmDol.Name = "cmDol";
this.cmDol.Size = new System.Drawing.Size(200, 48);
//
// cmLoadDol
//
this.cmLoadDol.Name = "cmLoadDol";
this.cmLoadDol.Size = new System.Drawing.Size(199, 22);
this.cmLoadDol.Text = "Load DOL File";
this.cmLoadDol.Click += new System.EventHandler(this.cmLoadDol_Click);
//
// cmDolFromSource
//
this.cmDolFromSource.Name = "cmDolFromSource";
this.cmDolFromSource.Size = new System.Drawing.Size(199, 22);
this.cmDolFromSource.Text = "Take From Source WAD";
this.cmDolFromSource.Click += new System.EventHandler(this.cmDolFromSource_Click);
//
// CustomizeMii_Main
//
this.AutoScaleDimensions = new System.Drawing.SizeF(6F, 13F);
@ -1308,6 +1464,9 @@ namespace CustomizeMii
this.ssMain.ResumeLayout(false);
this.ssMain.PerformLayout();
this.cmForwarder.ResumeLayout(false);
this.cmOptionsExtract.ResumeLayout(false);
this.cmSound.ResumeLayout(false);
this.cmDol.ResumeLayout(false);
this.ResumeLayout(false);
this.PerformLayout();
@ -1418,6 +1577,23 @@ namespace CustomizeMii
private System.Windows.Forms.ContextMenuStrip cmForwarder;
private System.Windows.Forms.ToolStripMenuItem cmSimpleForwarder;
private System.Windows.Forms.ToolStripMenuItem cmComplexForwarder;
private System.Windows.Forms.Button btnOptionsExtract;
private System.Windows.Forms.ContextMenuStrip cmOptionsExtract;
private System.Windows.Forms.ToolStripMenuItem cmExtractDol;
private System.Windows.Forms.ToolStripMenuItem tsExtractSound;
private System.Windows.Forms.ToolStripMenuItem tsExtractImages;
private System.Windows.Forms.ToolStripMenuItem cmExtractBannerImages;
private System.Windows.Forms.ToolStripMenuItem cmExtractIconImages;
private System.Windows.Forms.ToolStripMenuItem cmExtractBothImages;
private System.Windows.Forms.ToolStripMenuItem cmExtractSoundAsBin;
private System.Windows.Forms.ToolStripMenuItem cmExtractSoundAsAudio;
private System.Windows.Forms.ContextMenuStrip cmSound;
private System.Windows.Forms.ToolStripMenuItem cmLoadAudioFile;
private System.Windows.Forms.ToolStripMenuItem cmConvertToBns;
private System.Windows.Forms.ToolStripMenuItem cmExtractWad;
private System.Windows.Forms.ContextMenuStrip cmDol;
private System.Windows.Forms.ToolStripMenuItem cmLoadDol;
private System.Windows.Forms.ToolStripMenuItem cmDolFromSource;
}
}

1625
CustomizeMii/CustomizeMii_Main.cs
View File

File diff suppressed because it is too large Load Diff

9
CustomizeMii/CustomizeMii_Main.resx
View File

@ -131,6 +131,15 @@ comex and Waninkoko for both their NAND Loader</value>
<metadata name="cmForwarder.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>105, 7</value>
</metadata>
<metadata name="cmOptionsExtract.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>228, 7</value>
</metadata>
<metadata name="cmSound.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>376, 7</value>
</metadata>
<metadata name="cmDol.TrayLocation" type="System.Drawing.Point, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a">
<value>479, 7</value>
</metadata>
<metadata name="$this.TrayHeight" type="System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089">
<value>42</value>
</metadata>

35
CustomizeMii/CustomizeMii_Structs.cs Normal file
View File

@ -0,0 +1,35 @@
namespace CustomizeMii
{
public struct BnsConversionInfo
{
public enum LoopType
{
None,
FromWave,
Manual
}
public LoopType Loop;
public int LoopStartSample;
public string AudioFile;
public bool StereoToMono;
}
public struct WadCreationInfo
{
public enum NandLoader : int
{
comex = 0,
Waninkoko = 1
}
public string outFile;
public NandLoader nandLoader;
}
public struct Progress
{
public int progressValue;
public string progressState;
}
}

13
CustomizeMii/Instructions.txt
View File

@ -55,8 +55,8 @@ C, E, F, H, J, L, M, N, P, Q, W
INSERTING A NEW DOL
Let's bring some life into the channel. In the "Options" tab, use the browse button for a new DOL.
Either load a forwarder or the DOL of any application. Note that some channles require more than just a DOL
and thus may not work in a channel (e.g. MPlayer CE).
Either load a forwarder, the DOL of any application or a WAD to use it's DOL. Note that some applications
require more than just a DOL and thus may not work in a channel (e.g. MPlayer CE).
Choose a NAND loader or just stick with the one selected (both will do fine).
You can also use the built-in forwarder creation by using the forwarder button right below the browse button
@ -67,10 +67,15 @@ You need the ForwardMii.dll in order to use the forwarder creation.
INSERTING A NEW SOUND
For the sound, you can either use a wave file or the sound replace function to use the sound of an
existing sound.bin/00000000.app/WAD.
For the sound, you can either use a wave or mp3 (needs lame.exe) file or the sound replace function to use
the sound of an existing sound.bin/00000000.app/WAD.
If you want looped sound, open your wave file with wavosaur and add loop points before.
To save space, you can convert your wav or mp3 files to BNS. You can take the loop from a prelooped wave file
or enter the loop start point manually. Wave files must be 16bit PCM.
It is possible to directly convert stereo Wave files to mono BNS files, note that only the left channel of
the Wave will be taken.
EDITING THE BANNER/ICON (If you're an advanced user and want to edit the brlyt/brlan, do that first!)

4
CustomizeMii/Properties/AssemblyInfo.cs
View File

@ -50,6 +50,6 @@ using System.Resources;
// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern
// übernehmen, indem Sie "*" eingeben:
// [assembly: AssemblyVersion("1.0.*")]
[assembly: AssemblyVersion("1.2.0.0")]
[assembly: AssemblyFileVersion("1.2.0.0")]
[assembly: AssemblyVersion("2.0.0.0")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: NeutralResourcesLanguageAttribute("en")]

32
CustomizeMii/Properties/Resources.Designer.cs generated
View File

@ -1,21 +1,4 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// <auto-generated>
// Dieser Code wurde von einem Tool generiert.
// Laufzeitversion:2.0.50727.4927
@ -77,6 +60,13 @@ namespace CustomizeMii.Properties {
}
}
internal static System.Drawing.Bitmap btnCreateWad {
get {
object obj = ResourceManager.GetObject("btnCreateWad", resourceCulture);
return ((System.Drawing.Bitmap)(obj));
}
}
internal static System.Drawing.Icon CustomizeMii {
get {
object obj = ResourceManager.GetObject("CustomizeMii", resourceCulture);
@ -85,14 +75,14 @@ namespace CustomizeMii.Properties {
}
/// <summary>
/// Sucht eine lokalisierte Zeichenfolge, die {\rtf1\ansi\ansicpg1252\deff0\deflang1031{\fonttbl{\f0\fnil\fcharset0 Arial;}}
/// Sucht eine lokalisierte Zeichenfolge, die {\rtf1\ansi\ansicpg1252\deff0\deflang1031{\fonttbl{\f0\fnil\fcharset0 MS Sans Serif;}}
///{\colortbl ;\red255\green0\blue0;\red0\green0\blue255;}
///{\*\generator Msftedit 5.41.21.2509;}\viewkind4\uc1\pard\sa200\sl276\slmult1\b\fs20 These are some basic instructions for CustomizeMii.\b0\par
///{\*\generator Msftedit 5.41.21.2509;}\viewkind4\uc1\pard\sl276\slmult1\b\f0\fs17 These are some basic instructions for CustomizeMii.\b0\par
///\par
///\cf1 At the very beginning, let me say this again: Don&apos;t install any WADs without a proper brick protection!\cf0\par
///\par
///Ok, so you want to create your own custom channels?\par
///First it is important to understand how the [Rest der Zeichenfolge wurde abgeschnitten]&quot;; ähnelt.
///First it is important to understand how [Rest der Zeichenfolge wurde abgeschnitten]&quot;; ähnelt.
/// </summary>
internal static string Instructions {
get {

3
CustomizeMii/Properties/Resources.resx
View File

@ -118,6 +118,9 @@
<value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
</resheader>
<assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
<data name="btnCreateWad" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\btnCreateWad.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>
<data name="CustomizeMii" type="System.Resources.ResXFileRef, System.Windows.Forms">
<value>..\Resources\CustomizeMii.ico;System.Drawing.Icon, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
</data>

19
CustomizeMii/Readme.txt
View File

@ -1,6 +1,4 @@
CustomizeMii is a 100% legal custom channel creator for the Wii.
It's completely written by myself (some parts are based on other 100% legal codes).
Use legal Base WADs to create your own legal custom channels.
CustomizeMii is a custom channel creator for the Wii.
The .NET Framework 2.0 is required to run this application!
For any further information, see: http://customizemii.googlecode.com
@ -11,11 +9,22 @@ Thanks to icefire / Xuzz for the basic idea of this Application!
-----------------------------------------------------------------------------------------
Changelog:
Version 2.0
- Added BNS conversion (Mono and Stereo, with and without loop)
- Fixed MP3 conversion (some files didn't convert)
- Lz77 checkbox is now ticked by default
- Removed Lz77 compression of sound.bin as most sounds will get bigger
- Added ability to insert DOLs from any channel WAD
- Added ability to re-add the interal DOL (To switch the NAND Loader)
- Added ability to extract the contents, DOL, sound and all images
- Added displaying of approx. blocks to the success-message
- Deleted some functions of the complex forwarder as they weren't working properly
- Some bugfixes and improvements
Version 1.2
- Fixed writing/reading of channel titles, so japanese characters will work now
- Added checkbox (Options tab) to turn security checks off
- Added built-in forwarder creator (Needs the ForwardMii.dll which is
separately avaiable)
- Added built-in forwarder creator (Needs the ForwardMii.dll which is separately avaiable)
- You can choose MP3 files as channel sound (Needs lame.exe in application directory)
- Bugfixes

18
CustomizeMii/Resources/Instructions.rtf
View File

@ -57,21 +57,27 @@ C, E, F, H, J, L, M, N, P, Q, W\par
\b INSERTING A NEW DOL\b0\par
\par
Let's bring some life into the channel. In the "Options" tab, use the browse button for a new DOL.\par
Either load a forwarder or the DOL of any application. Note that some channles require more than just a DOL\par
and thus may not work in a channel (e.g. MPlayer CE).\par
Either load a forwarder, the DOL of any application or a WAD to use it's DOL. Note that some applications\par
require more than just a DOL and thus may not work in a channel (e.g. MPlayer CE).\par
Choose a NAND loader or just stick with the one selected (both will do fine).\par
\par
You can also use the built-in forwarder creation by using the forwarder button right below the browse button for DOLs.\par
You need to get the ForwardMii.dll in order to use the forwarder creation.\par
You can also use the built-in forwarder creation by using the forwarder button right below the browse button\par
for DOLs.\par
You need the ForwardMii.dll in order to use the forwarder creation.\par
\par
\par
\par
\b INSERTING A NEW SOUND\b0\par
\par
For the sound, you can either use a wave file or the sound replace function to use the sound of an\par
existing sound.bin/00000000.app/WAD.\par
For the sound, you can either use a wave or mp3 (needs lame.exe) file or the sound replace function to use\par
the sound of an existing sound.bin/00000000.app/WAD.\par
If you want looped sound, open your wave file with wavosaur and add loop points before.\par
\par
To save space, you can convert your wav or mp3 files to BNS. You can take the loop from a prelooped wave file\par
or enter the loop start point manually. Wave files must be 16bit PCM.\par
It is possible to directly convert stereo Wave files to mono BNS files, note that only the left channel of\par
the Wave will be taken.\par
\par
\par
\par
\b EDITING THE BANNER/ICON (If you're an advanced user and want to edit the brlyt/brlan, do that first!)\b0\par

BIN
CustomizeMii/Resources/btnCreateWad.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 5.2 KiB

325
CustomizeMii/Wave.cs Normal file
View File

@ -0,0 +1,325 @@
/* This file is part of CustomizeMii
* Copyright (C) 2009 Leathl
*
* CustomizeMii is free software: you can redistribute it and/or
* modify it under the terms of the GNU General Public License as published
* by the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* CustomizeMii is distributed in the hope that it will be
* useful, but WITHOUT ANY WARRANTY; without even the implied warranty
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
using System;
using System.IO;
namespace WaveFile
{
/// <summary>
/// A class for RIFF Wave files
/// </summary>
public class Wave
{
//Private Variables
private int fmtOffset;
private int dataOffset;
private int smplOffset;
private byte[] waveFile;
//Public Variables
/// <summary>
/// The Samplerate of the Wave file
/// </summary>
public int SampleRate { get { return GetSampleRate(); } }
/// <summary>
/// The Bitdepth of the Wave file
/// </summary>
public int BitDepth { get { return GetBitDepth(); } }
/// <summary>
/// The number of channels of the Wave file
/// </summary>
public int ChannelCount { get { return GetChannelCount(); } }
/// <summary>
/// The format of the Wave file's data. 1 = PCM
/// </summary>
public int DataFormat { get { return GetDataFormat(); } }
/// <summary>
/// The number of Loops in the Wave file
/// </summary>
public int LoopCount { get { return GetLoopCount(); } }
/// <summary>
/// The start sample of the first Loop (if exist)
/// </summary>
public int LoopStart { get { return GetLoopStart(); } }
//Public Functions
public Wave(string waveFile)
{
using (FileStream fs = new FileStream(waveFile, FileMode.Open))
{
byte[] temp = new byte[fs.Length];
fs.Read(temp, 0, temp.Length);
this.waveFile = temp;
}
if (!CheckWave()) throw new Exception("This is not a supported PCM Wave File!");
if (!GetFmtOffset()) throw new Exception("The format section couldn't be found!");
if (!GetDataOffset()) throw new Exception("The data section couldn't be found!");
GetSmplOffset();
}
public Wave(byte[] waveFile)
{
this.waveFile = waveFile;
if (!CheckWave()) throw new Exception("This is not a supported PCM Wave File!");
if (!GetFmtOffset()) throw new Exception("The format section couldn't be found!");
if (!GetDataOffset()) throw new Exception("The data section couldn't be found!");
GetSmplOffset();
}
/// <summary>
/// Returns the Wave file as a Byte Array
/// </summary>
/// <returns></returns>
public byte[] ToByteArray()
{
return waveFile;
}
/// <summary>
/// Returns the Wave file as a Memory Stream
/// </summary>
/// <returns></returns>
public MemoryStream ToMemoryStream()
{
return new MemoryStream(waveFile);
}
/// <summary>
/// Returns only the audio data of the Wave file (No header or anything else)
/// </summary>
/// <returns></returns>
public byte[] GetAllFrames()
{
int dataLength = GetDataLength();
MemoryStream ms = new MemoryStream();
ms.Write(waveFile, dataOffset, dataLength);
return ms.ToArray();
}
/// <summary>
/// Closes the Wave file
/// </summary>
public void Close()
{
waveFile = null;
}
//Private Functions
private int GetLoopStart()
{
if (smplOffset == -1) return 0;
byte[] temp = new byte[4];
temp[0] = waveFile[smplOffset + 52];
temp[1] = waveFile[smplOffset + 53];
temp[2] = waveFile[smplOffset + 54];
temp[3] = waveFile[smplOffset + 55];
return BitConverter.ToInt32(temp, 0);
}
private int GetLoopCount()
{
if (smplOffset == -1) return 0;
byte[] temp = new byte[4];
temp[0] = waveFile[smplOffset + 36];
temp[1] = waveFile[smplOffset + 37];
temp[2] = waveFile[smplOffset + 38];
temp[3] = waveFile[smplOffset + 39];
return BitConverter.ToInt32(temp, 0);
}
private bool GetSmplOffset()
{
try
{
int length = (waveFile.Length > 5004 ? (waveFile.Length - 5000) : 0);
for (int i = waveFile.Length - 4; i > length; i--)
{
if (waveFile[i] == 's' &&
waveFile[i + 1] == 'm' &&
waveFile[i + 2] == 'p' &&
waveFile[i + 3] == 'l')
{
this.smplOffset = i;
return true;
}
}
}
catch { }
for (int i = 0; i < waveFile.Length - 4; i++)
{
if (waveFile[i] == 's' &&
waveFile[i + 1] == 'm' &&
waveFile[i + 2] == 'p' &&
waveFile[i + 3] == 'l')
{
this.smplOffset = i;
return true;
}
}
this.smplOffset = -1;
return false;
}
private bool GetFmtOffset()
{
if (waveFile[12] == 'f' &&
waveFile[13] == 'm' &&
waveFile[14] == 't' &&
waveFile[15] == ' ')
{
this.fmtOffset = 12;
return true;
}
int length = (waveFile.Length > 5004 ? 5000 : waveFile.Length - 4);
for (int i = 0; i < length; i++)
{
if (waveFile[i] == 'f' &&
waveFile[i + 1] == 'm' &&
waveFile[i + 2] == 't' &&
waveFile[i + 3] == ' ')
{
this.fmtOffset = i;
return true;
}
}
this.fmtOffset = -1;
return false;
}
private int GetDataLength()
{
byte[] temp = new byte[4];
temp[0] = waveFile[dataOffset + 4];
temp[1] = waveFile[dataOffset + 5];
temp[2] = waveFile[dataOffset + 6];
temp[3] = waveFile[dataOffset + 7];
return BitConverter.ToInt32(temp, 0);
}
private bool GetDataOffset()
{
if (waveFile[40] == 'd' &&
waveFile[41] == 'a' &&
waveFile[42] == 't' &&
waveFile[43] == 'a')
{
this.dataOffset = 40;
return true;
}
for (int i = 0; i < waveFile.Length - 4; i++)
{
if (waveFile[i] == 'd' &&
waveFile[i + 1] == 'a' &&
waveFile[i + 2] == 't' &&
waveFile[i + 3] == 'a')
{
this.dataOffset = i;
return true;
}
}
this.dataOffset = -1;
return false;
}
private int GetSampleRate()
{
byte[] temp = new byte[4];
temp[0] = waveFile[fmtOffset + 12];
temp[1] = waveFile[fmtOffset + 13];
temp[2] = waveFile[fmtOffset + 14];
temp[3] = waveFile[fmtOffset + 15];
return BitConverter.ToInt32(temp, 0);
}
private int GetBitDepth()
{
byte[] temp = new byte[2];
temp[0] = waveFile[fmtOffset + 22];
temp[1] = waveFile[fmtOffset + 23];
return BitConverter.ToInt16(temp, 0);
}
private int GetChannelCount()
{
byte[] temp = new byte[2];
temp[0] = waveFile[fmtOffset + 10];
temp[1] = waveFile[fmtOffset + 11];
return BitConverter.ToInt16(temp, 0);
}
private int GetDataFormat()
{
byte[] temp = new byte[2];
temp[0] = waveFile[fmtOffset + 8];
temp[1] = waveFile[fmtOffset + 9];
return BitConverter.ToInt16(temp, 0);
}
private bool CheckWave()
{
if (waveFile[0] != 'R' ||
waveFile[1] != 'I' ||
waveFile[2] != 'F' ||
waveFile[3] != 'F' ||
waveFile[8] != 'W' ||
waveFile[9] != 'A' ||
waveFile[10] != 'V' ||
waveFile[11] != 'E') return false;
return true;
}
}
}

186
CustomizeMii/Wii.cs
View File

@ -22,11 +22,11 @@
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Security.Cryptography;
using System.Drawing;
using System.IO;
using System.Net;
using System.Security.Cryptography;
using System.Text;
namespace Wii
{
@ -257,7 +257,8 @@ namespace Wii
{
if (fs.Length < length) length = (int)fs.Length;
byte[] filearray = new byte[length];
fs.Read(filearray, offset, length);
fs.Seek(offset, SeekOrigin.Begin);
fs.Read(filearray, 0, length);
return filearray;
}
}
@ -530,6 +531,18 @@ namespace Wii
return Headersize + Tools.AddPadding(GetCertSize(wadfile));
}
/// <summary>
/// Returns the title ID of the wad file.
/// </summary>
/// <param name="wadfile"></param>
/// <param name="type">0 = Tik, 1 = Tmd</param>
/// <returns></returns>
public static string GetTitleID(string wadtiktmd, int type)
{
byte[] temp = Tools.LoadFileToByteArray(wadtiktmd);
return GetTitleID(temp, type);
}
/// <summary>
/// Returns the title ID of the wad file.
/// </summary>
@ -883,6 +896,23 @@ namespace Wii
return contents;
}
/// <summary>
/// Returns the boot index specified in the tmd
/// </summary>
/// <param name="wadfile"></param>
/// <returns></returns>
public static int GetBootIndex(byte[] wadtmd)
{
int tmdpos = 0;
if (IsThisWad(wadtmd))
tmdpos = GetTmdPos(wadtmd);
int bootIndex = Tools.HexStringToInt(wadtmd[tmdpos + 0x1e0].ToString("x2") + wadtmd[tmdpos + 0x1e1].ToString("x2"));
return bootIndex;
}
/// <summary>
/// Returns the approx. destination size on the Wii
/// </summary>
@ -953,6 +983,21 @@ namespace Wii
return size.Replace(",", ".");
}
/// <summary>
/// Returns the approx. destination block on the Wii
/// </summary>
/// <param name="wadfile"></param>
/// <returns></returns>
public static string GetNandBlocks(string wadtmd)
{
using (FileStream fs = new FileStream(wadtmd, FileMode.Open))
{
byte[] temp = new byte[fs.Length];
fs.Read(temp, 0, temp.Length);
return GetNandBlocks(temp);
}
}
/// <summary>
/// Returns the approx. destination block on the Wii
/// </summary>
@ -2226,26 +2271,6 @@ namespace Wii
public class WadUnpack
{
/// <summary>
/// Unpacks the the wad file
/// </summary>
public static void UnpackWad(string pathtowad, string destinationpath)
{
byte[] wadfile = Tools.LoadFileToByteArray(pathtowad);
UnpackWad(wadfile, destinationpath);
}
/// <summary>
/// Unpacks the wad file to *wadpath*\wadunpack\
/// </summary>
/// <param name="pathtowad"></param>
public static void UnpackWad(string pathtowad)
{
string destinationpath = pathtowad.Remove(pathtowad.LastIndexOf('\\'));
byte[] wadfile = Tools.LoadFileToByteArray(pathtowad);
UnpackWad(wadfile, destinationpath);
}
/// <summary>
/// Unpacks the 00000000.app of a wad
/// </summary>
@ -2287,14 +2312,54 @@ namespace Wii
throw new Exception("00000000.app couldn't be found in the Wad");
}
/// <summary>
/// Unpacks the the wad file
/// </summary>
public static void UnpackWad(string pathtowad, string destinationpath)
{
byte[] wadfile = Tools.LoadFileToByteArray(pathtowad);
UnpackWad(wadfile, destinationpath);
}
/// <summary>
/// Unpacks the the wad file
/// </summary>
public static void UnpackWad(string pathtowad, string destinationpath, out bool hashesmatch)
{
byte[] wadfile = Tools.LoadFileToByteArray(pathtowad);
UnpackWad(wadfile, destinationpath, out hashesmatch);
}
/// <summary>
/// Unpacks the wad file to *wadpath*\wadunpack\
/// </summary>
/// <param name="pathtowad"></param>
public static void UnpackWad(string pathtowad)
{
string destinationpath = pathtowad.Remove(pathtowad.LastIndexOf('\\'));
byte[] wadfile = Tools.LoadFileToByteArray(pathtowad);
UnpackWad(wadfile, destinationpath);
}
/// <summary>
/// Unpacks the wad file
/// </summary>
public static void UnpackWad(byte[] wadfile, string destinationpath)
{
bool temp;
UnpackWad(wadfile, destinationpath, out temp);
}
/// <summary>
/// Unpacks the wad file
/// </summary>
public static void UnpackWad(byte[] wadfile, string destinationpath, out bool hashesmatch)
{
if (destinationpath[destinationpath.Length - 1] != '\\')
{ destinationpath = destinationpath + "\\"; }
hashesmatch = true;
if (!Directory.Exists(destinationpath))
{ Directory.CreateDirectory(destinationpath); }
if (Directory.GetFiles(destinationpath, "*.app").Length > 0)
@ -2370,8 +2435,8 @@ namespace Wii
byte[] thishash = sha1.ComputeHash(thiscontent);
byte[] tmdhash = Tools.HexStringToByteArray(contents[i, 4]);
if (Tools.CompareByteArrays(thishash, tmdhash) == false)
throw new Exception("At least one content's hash doesn't match the hash in the Tmd!");
if (Tools.CompareByteArrays(thishash, tmdhash) == false) hashesmatch = false;
// throw new Exception("At least one content's hash doesn't match the hash in the Tmd!");
}
}
@ -5317,19 +5382,72 @@ namespace Wii
/// </summary>
/// <param name="soundbin"></param>
/// <param name="wavefile"></param>
public static void SoundBinToWave(string soundbin, string wavefile)
public static void SoundBinToAudio(string soundbin, string audiofile)
{
MemoryStream ms = new MemoryStream(Tools.LoadFileToByteArray(soundbin));
byte[] wave = new byte[ms.Length - 32];
FileStream fs = new FileStream(soundbin, FileMode.Open);
byte[] audio = new byte[fs.Length - 32];
int offset = 0;
ms.Seek(32, SeekOrigin.Begin);
ms.Read(wave, 0, wave.Length);
fs.Seek(32, SeekOrigin.Begin);
fs.Read(audio, 0, audio.Length);
fs.Close();
if ((offset = Lz77.GetLz77Offset(wave)) != -1)
wave = Lz77.Decompress(wave, offset);
if ((offset = Lz77.GetLz77Offset(audio)) != -1)
audio = Lz77.Decompress(audio, offset);
Tools.SaveFileFromByteArray(wave, wavefile);
Tools.SaveFileFromByteArray(audio, audiofile);
}
/// <summary>
/// Converts a BNS file to a sound.bin
/// </summary>
/// <param name="bnsFile"></param>
/// <param name="soundBin"></param>
public static void BnsToSoundBin(string bnsFile, string soundBin, bool compress)
{
byte[] bns = Tools.LoadFileToByteArray(bnsFile);
if (bns[0] != 'B' || bns[1] != 'N' || bns[2] != 'S')
throw new Exception("This is not a supported BNS file!");
if (compress) bns = Lz77.Compress(bns);
bns = U8.AddHeaderIMD5(bns);
Tools.SaveFileFromByteArray(bns, soundBin);
}
/// <summary>
/// Returns the length of the BNS audio file in seconds
/// </summary>
/// <param name="bnsFile"></param>
/// <returns></returns>
public static int GetBnsLength(string bnsFile)
{
byte[] temp = Tools.LoadFileToByteArray(bnsFile, 0, 100);
return GetBnsLength(temp);
}
/// <summary>
/// Returns the length of the BNS audio file in seconds
/// </summary>
/// <param name="bnsFile"></param>
/// <returns></returns>
public static int GetBnsLength(byte[] bnsFile)
{
byte[] temp = new byte[4];
temp[0] = bnsFile[45];
temp[1] = bnsFile[44];
int sampleRate = BitConverter.ToInt16(temp, 0);
temp[0] = bnsFile[55];
temp[1] = bnsFile[54];
temp[2] = bnsFile[53];
temp[3] = bnsFile[52];
int sampleCount = BitConverter.ToInt32(temp, 0);
return sampleCount / sampleRate;
}
}