public void Parse(BinaryReader buffer, AKAOType type, long limit = long.MaxValue)
{
_type = type;
if (buffer.BaseStream.Length < 4)
{
return;
}
if (_type == AKAOType.UNKNOWN)
{
// we must try to find the AKAO type
byte[] header = buffer.ReadBytes(4); // AKAO
if (!CheckHeader(header))
{
return;
}
ushort v1 = buffer.ReadUInt16(); // ID or type
ushort v2 = buffer.ReadUInt16(); // File Length or empty
byte v3 = buffer.ReadByte(); // Type or empty
byte v4 = buffer.ReadByte(); // Type var or empty
if (v2 + v3 + v4 == 0)
{
if (v1 == 0)
{
_type = AKAOType.SAMPLE;
}
else
{
if (buffer.BaseStream.Position == 10)
{
// v1 is the sample collection ID in this case
_type = AKAOType.SOUND;
}
else
{
// E075.P have an AKAO PROG without v3 = 0xC8...
_type = AKAOType.PROG;
}
}
}
else if (v3 == 0xC8)
{
_type = AKAOType.EFFECT;
}
else if (v2 > 0 && v2 == buffer.BaseStream.Length)
{
_type = AKAOType.MUSIC;
}
buffer.BaseStream.Position -= 10;
}
switch (_type)
{
case AKAOType.MUSIC:
//https://github.com/vgmtrans/vgmtrans/blob/master/src/main/formats/AkaoSeq.cpp
// header datas
byte[] header = buffer.ReadBytes(4); // AKAO
ushort fileId = buffer.ReadUInt16();
ushort byteLen = buffer.ReadUInt16();
ushort reverb = buffer.ReadUInt16(); // 0x0500 | Just on case 0x0400 (MUSIC000.DAT), maybe it refer to the WAVE0005.DAT sample collection
buffer.ReadBytes(6); // padding
uint unk1 = buffer.ReadUInt32(); // never > 127, maybe a general volume ? or something like that
uint sampleSet = buffer.ReadUInt32(); // ID of the WAVE*.DAT in the SOUND folder
buffer.ReadBytes(8); // padding
int bnumt = buffer.ReadInt32();
uint numTrack = ToolBox.GetNumPositiveBits(bnumt);
short unk3 = buffer.ReadInt16(); // (0, -1, 255 or 16383) from MUSIC050 to MUSIC101 => unk3 != 0
// when != 0 it seems like it's not a "music" but more like a sounds store for maps ambiance or monsters
// when != 0, in most of case there is no instruments set nor a drum (excp 68, 69) and Unknowns AKAO events occur a lot.
// in these cases you really feal that it doesn't really make sence to out a midi file and less a wav...
// when != 0 => sampleSet 17 to 25
// Case 255 (66 to 73, 82, 83, 96, 97)
// Case 16383 (78 to 81, 88 to 91)
// Case -1 all others from 50 to 101
buffer.ReadBytes(10); // padding
uint ptr1 = buffer.ReadUInt32() + 0x30; // instruments pointer
uint ptr2 = buffer.ReadUInt32() + 0x34; // Drums pointer
buffer.ReadBytes(8); // padding
ushort jump = buffer.ReadUInt16();
long basePtr = buffer.BaseStream.Position;
long musInstrPtr = buffer.BaseStream.Position + jump - 2;
if (true)
{
Debug.Log(string.Concat("AKAO from : ", FileName, " FileSize = ", FileSize, " | reverb : ", reverb, " numTrack : ", numTrack, " sampleSet : ", sampleSet,
"\r\ninstruments at : ", ptr1, " Drums at : ", ptr2, " musInstrPtr : ", musInstrPtr, " | unk1 : ", unk1, " unk3 : ", unk3));
}
ushort[] tracksPtr = new ushort[numTrack];
tracksPtr[0] = (ushort)musInstrPtr;
for (uint i = 0; i < numTrack - 1; i++)
{
tracksPtr[i + 1] = (ushort)((basePtr + i * 2) + buffer.ReadUInt16());
}
// music instuctions begin here, MIDI like format, we don't care yet, so let's jump
uint instrCount = 0;
// Instruments
if (ptr1 > 0x30)
{
buffer.BaseStream.Position = ptr1;
// Instruments Header always 0x20 ?
List <ushort> instrPtrs = new List <ushort>();
for (int i = 0; i < 0x10; i++)
{
ushort instrPtr = buffer.ReadUInt16();
if (instrPtr != 0xFFFF)
{
instrPtrs.Add(instrPtr);
}
else
{
// Padding
}
}
instrCount = (uint)instrPtrs.Count;
if (ptr2 > 0x34)
{
instrCount++;
}
if (UseDebug)
{
Debug.Log("Instruments number : " + instrCount);
}
instruments = new List <AKAOInstrument>();
for (int i = 0; i < instrPtrs.Count; i++)
{
AKAOInstrument instrument = new AKAOInstrument((uint)i, AKAOInstrument.InstrumentType.INSTR_MELODIC);
instrument.name = "Instrument #" + (ushort)i;
long instrStart = ptr1 + 0x20 + instrPtrs[i];
long instrEnd;
if (i < instrPtrs.Count - 1)
{
instrEnd = ptr1 + 0x20 + instrPtrs[i + 1];
}
else
{
if (ptr2 > 0x34)
{
instrEnd = ptr2;
}
else
{
instrEnd = byteLen;
}
}
int instrRegLoop = (int)(instrEnd - instrStart) / 0x08;
if (UseDebug)
{
Debug.Log(string.Concat("Instrument #", i, " Regions count : ", instrRegLoop - 1));
}
instrument.regions = new AKAORegion[instrRegLoop - 1]; // -1 because the last 8 bytes are padding
for (int j = 0; j < instrRegLoop - 1; j++)
{
AKAORegion reg = new AKAORegion();
reg.FeedMelodic(buffer.ReadBytes(8));
instrument.regions[j] = reg;
if (UseDebug)
{
Debug.Log(reg.ToString());
}
}
buffer.ReadBytes(8); // 0000 0000 0000 0000 padding
instruments.Add(instrument);
}
}
// Drum
if (ptr2 > 0x34)
{
if (buffer.BaseStream.Position != ptr2)
{
buffer.BaseStream.Position = ptr2;
}
// Special case when there is no melodic instruments
if (instruments == null)
{
instrCount++;
instruments = new List <AKAOInstrument>();
}
AKAOInstrument drum = new AKAOInstrument(instrCount - 1, AKAOInstrument.InstrumentType.INSTR_DRUM);
drum.name = "Drum";
int drumRegLoop = (int)(byteLen - ptr2) / 0x08;
if (UseDebug)
{
Debug.Log(string.Concat("Drum Regions count : ", drumRegLoop - 1));
}
List <AKAORegion> dr = new List <AKAORegion>();
for (int j = 0; j < drumRegLoop - 1; j++)
{
byte[] b = buffer.ReadBytes(8);
if (b[0] == 0xFF && b[1] == 0xFF && b[2] == 0xFF && b[3] == 0xFF && b[4] == 0xFF && b[5] == 0xFF && b[6] == 0xFF && b[7] == 0xFF)
{
break;
}
if (b[0] > 0 && b[1] > 0 && b[6] > 0 && b[7] > 0)
{
AKAORegion dregion = new AKAORegion();
dregion.FeedDrum(b, j);
dr.Add(dregion);
if (UseDebug)
{
Debug.Log(dregion.ToString());
}
}
}
drum.regions = dr.ToArray();
instruments.Add(drum);
}
long end = 0;
if (ptr1 > 0x30)
{
end = ptr1;
}
else if (ptr2 > 0x34)
{
end = ptr2;
}
else
{
end = buffer.BaseStream.Length;
}
composer = new AKAOComposer(buffer, musInstrPtr, end, instrCount, numTrack, tracksPtr, FileName, true);
// AKAO from : WAVE0000 startingArticulationId = 0
// AKAO from : WAVE0005 startingArticulationId = 32
// AKAO from : WAVE0032 startingArticulationId = 32
// All other startingArticulationId = 64
// AKAO from : WAVE0200 startingArticulationId = 128
// So we seek for the appropriate WAVE*.DAT in the SOUND folder
string[] hash = FilePath.Split("/"[0]);
hash[hash.Length - 2] = "SOUND";
AKAO[] sampleCollections = new AKAO[3];
// Program from 32 to 63
hash[hash.Length - 1] = "WAVE0005.DAT"; // wave 005 or wave 032 ? (5 seems good)
AKAO SampleColl32 = new AKAO();
SampleColl32.UseDebug = UseDebug;
SampleColl32.Parse(String.Join("/", hash), AKAO.SOUND);
sampleCollections[0] = SampleColl32;
string zz = "0";
if (sampleSet < 100)
{
zz += "0";
}
if (sampleSet < 10)
{
zz += "0";
}
hash[hash.Length - 1] = "WAVE" + zz + sampleSet + ".DAT";
string samplePath = String.Join("/", hash);
bool test = File.Exists(samplePath);
// Program from 64 to 95 or 127
AKAO SampleColl64 = new AKAO();
SampleColl64.UseDebug = UseDebug;
SampleColl64.Parse(samplePath, AKAO.SOUND);
sampleCollections[1] = SampleColl64;
// Additionnal Collection, somztimes usefull for drum kit or A1 program change
if (SampleColl64.articulations.Length < 64)
{
hash[hash.Length - 1] = "WAVE0091.DAT";
AKAO addiColl = new AKAO();
addiColl.UseDebug = UseDebug;
addiColl.Parse(String.Join("/", hash), AKAO.SOUND);
sampleCollections[2] = addiColl;
}
if (composer.A1Calls.Count > 0)
{
// we need to add new instruments with an unique region
foreach (uint iid in composer.A1Calls)
{
AKAOInstrument A1Instrument = new AKAOInstrument(iid);
A1Instrument.name = "A1 Instrument #" + (ushort)iid;
A1Instrument.a1 = true;
A1Instrument.regions = new AKAORegion[1];
AKAORegion defaultRegion = new AKAORegion();
defaultRegion.articulationId = (byte)iid;
A1Instrument.regions[0] = defaultRegion;
if (instruments == null)
{
instruments = new List <AKAOInstrument>();
}
instruments.Add(A1Instrument);
}
}
SF2 sf2 = null;
if (bWAV || bSF2 || bDLS)
{
sf2 = SoundFundry(this, sampleCollections);
}
if (bMID || bWAV)
{
if (unk3 != 0)
{
bWAV = false; // we don't want 1Gb crap .wav
}
composer.Synthetize(bMID, bWAV, sf2);
}
break;
case AKAOType.SOUND:
// Samples Collection
// header datas
header = buffer.ReadBytes(4); // AKAO
ushort sampleId = buffer.ReadUInt16();
buffer.ReadBytes(10); // padding
unk1 = buffer.ReadByte(); // almost always 0 (but one case 48 in WAVE0032)
unk3 = buffer.ReadByte(); // almost always 81 (two cases 49 (WAVE0000, WAVE0005), one case 16 in WAVE0032, one case 177 in WAVE0200)
buffer.ReadBytes(2); // padding
var sampleSize = buffer.ReadUInt32();
startingArticulationId = buffer.ReadUInt32();
var numArts = buffer.ReadUInt32();
// mostly 32, sometimes 64, one case 48 (WAVE0071), one case 96 (WAVE0200)
/* List of 64 arts
* WAVE0044
* WAVE0045
* WAVE0046
* WAVE0053
* WAVE0054
* WAVE0055
* WAVE0064
* WAVE0065
* WAVE0068
* WAVE0069
* WAVE0091
* WAVE0097
* WAVE0099
*/
buffer.ReadBytes(32); // padding
if (UseDebug)
{
Debug.Log(string.Concat("AKAO from : ", FileName, " len = ", FileSize, " ID : ", sampleId, " unk1 : ", unk1, " unk3 : ", unk3, " sampleSize : ", sampleSize, " stArtId : ", startingArticulationId, " numArts : ", numArts));
}
// Articulations section here
articulations = new AKAOArticulation[numArts];
for (uint i = 0; i < numArts; i++)
{
AKAOArticulation arti = new AKAOArticulation(buffer, startingArticulationId + i);
articulations[i] = arti;
if (UseDebug)
{
//Debug.Log(arti.ToString());
}
}
// Samples section here
ulong samStart = (ulong)buffer.BaseStream.Position;
// First we need to determine the start and the end of the samples, 16 null bytes indicate a new sample, so lets find them.
List <long> samPtr = new List <long>();
List <long> samEPtr = new List <long>();
while (buffer.BaseStream.Position < buffer.BaseStream.Length)
{
if (buffer.ReadUInt64() + buffer.ReadUInt64() == 0)
{
if (samPtr.Count > 0)
{
//samEPtr.Add(buffer.BaseStream.Position - 0x20);
samEPtr.Add(buffer.BaseStream.Position - 0x10);
}
samPtr.Add(buffer.BaseStream.Position - 0x10);
//samPtr.Add(buffer.BaseStream.Position);
}
}
samEPtr.Add(buffer.BaseStream.Length);
// Let's loop again to get samples
int numSam = samPtr.Count;
samples = new AKAOSample[numSam];
for (int i = 0; i < numSam; i++)
{
buffer.BaseStream.Position = samPtr[i];
int size = (int)(samEPtr[i] - samPtr[i]);
byte[] dt = buffer.ReadBytes(size);
AKAOSample sam = new AKAOSample(string.Concat(FileName, " Sample #", (ushort)i), dt, (ulong)samPtr[i]);
sam.index = i;
samples[i] = sam;
if (UseDebug && bWAV)
{
WAV wavSam = sam.ConvertToWAV();
wavSam.SetName(FileName + "_Sample_" + i);
ToolBox.DirExNorCreate(Application.dataPath + "/../Assets/Resources/Sounds/SampleColl/");
wavSam.WriteFile(Application.dataPath + "/../Assets/Resources/Sounds/SampleColl/" + FileName + "_Sample_" + i + ".wav", wavSam.Write());
}
}
// now to verify and associate each articulation with a sample index value
// for every sample of every instrument, we add sample_section offset, because those values
// are relative to the beginning of the sample section
for (uint i = 0; i < articulations.Length; i++)
{
for (uint l = 0; l < samples.Length; l++)
{
//if (articulations[i].sampleOff + samStart + 0x10 == samples[l].offset)
if (articulations[i].sampleOff + samStart == samples[l].offset)
{
articulations[i].sampleNum = l;
articulations[i].sample = samples[l];
samples[l].loopStart = articulations[i].loopPt;
break;
}
}
}
break;
case AKAOType.PROG:
// unknown yet
header = buffer.ReadBytes(4); // AKAO
ushort id = buffer.ReadUInt16();
buffer.ReadUInt16();
ushort tp = buffer.ReadUInt16();
buffer.ReadUInt16();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt16();
byteLen = buffer.ReadUInt16();
//Debug.Log(string.Concat("AKAO PROG : id : ", id, " tp : ", tp, " byteLen : ", byteLen));
//composer = new AKAOComposer(buffer, buffer.BaseStream.Position, limit, 0, 1, new ushort[] { (ushort)buffer.BaseStream.Position }, FileName, true);
//composer.Synthetize(true, false);
break;
case AKAOType.EFFECT:
//https://github.com/vgmtrans/vgmtrans/blob/akao-ps1/src/main/formats/AkaoSeq.cpp
header = buffer.ReadBytes(4); // AKAO
id = buffer.ReadUInt16();
byteLen = buffer.ReadUInt16();
reverb = buffer.ReadUInt16();
bnumt = buffer.ReadInt32();
numTrack = ToolBox.GetNumPositiveBits(bnumt);
buffer.ReadBytes(6);
Debug.Log(string.Concat("AKAO EFFECT : id : ", id, " byteLen : ", byteLen, " reverb : ", reverb, " numTrack : ", numTrack));
composer = new AKAOComposer(buffer, buffer.BaseStream.Position, limit, 0, 1, new ushort[] { (ushort)buffer.BaseStream.Position }, FileName, true);
Debug.Log(string.Concat("composer.A1Calls.Count : ", composer.A1Calls.Count));
composer.Synthetize(true, false);
break;
case AKAOType.SAMPLE:
// similar to AKAOType.SOUND without articulations, we can output a WAV file
// header datas
header = buffer.ReadBytes(4); // AKAO
buffer.ReadUInt16();
buffer.ReadBytes(10); // padding
buffer.ReadUInt16(); //
buffer.ReadBytes(2); // padding
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadUInt32();
buffer.ReadBytes(32); // padding
buffer.ReadBytes(16); // sample padding
AKAOSample sample = new AKAOSample(FileName, buffer.ReadBytes((int)(limit - buffer.BaseStream.Position)), (ulong)buffer.BaseStream.Position);
WAV nw = sample.ConvertToWAV();
nw.SetName(FileName);
if (UseDebug && bWAV)
{
ToolBox.DirExNorCreate(Application.dataPath + "/../Assets/Resources/Sounds/Effects/");
nw.WriteFile(Application.dataPath + "/../Assets/Resources/Sounds/Effects/" + FileName + ".wav", nw.Write());
}
break;
}
}
private SF2 SoundFundry(AKAO sequencer, AKAO[] sampleCollections)
{
DLS dls = new DLS();
dls.SetName(FileName + ".dls");
SF2 sf2 = new SF2();
sf2.InfoChunk.Bank = "Vagrant Story SoundFont for " + FileName;
sf2.InfoChunk.Products = "Vagrant Story";
sf2.InfoChunk.Tools = "https://github.com/korobetski/Vagrant-Story-Unity-Parser";
sf2.InfoChunk.Designer = "Korobetski Sigfrid";
sf2.InfoChunk.Date = DateTime.Now.ToString();
sf2.InfoChunk.Copyright = "Musics & Samples belong to Hitoshi Sakimoto @ Squaresoft";
sf2.InfoChunk.Comment = string.Concat("This SoundFont was generated by reading raw AKAO format from the original game in SOUND folder.\r",
"\nNever forget that musics and samples belongs to SquareEnix, don't use them as your own. Sample collections : ",
sampleCollections[0].FileName, ", ",
sampleCollections[1].FileName);
List <AKAOSample> Samples = new List <AKAOSample>();
// MUSIC024.DAT has no instruments Oo, maybe unfinished work, or development test
// we use composer program change to load articulations from WAVE000.DAT the only file where start id = 0
if (sequencer.instruments == null)
{
foreach (uint id in sequencer.composer.progIDs)
{
AKAOInstrument instrument = new AKAOInstrument(id, AKAOInstrument.InstrumentType.INSTR_MELODIC);
instrument.name = "No instrument " + id;
instrument.regions = new AKAORegion[1];
AKAORegion defaultRegion = new AKAORegion();
defaultRegion.articulationId = (byte)id;
instrument.regions[0] = defaultRegion;
sequencer.instruments = new List <AKAOInstrument>();
sequencer.instruments.Add(instrument);
}
}
if (sequencer.instruments != null)
{
uint i = 0;
foreach (AKAOInstrument instrument in sequencer.instruments)
{
if (composer.progIDs.Contains(instrument.program) || composer.A1Calls.Contains(instrument.program) || instrument.IsDrum())
{
uint midiBank = 0x00000000;
if (instrument.IsDrum())
{
midiBank = DLS.F_INSTRUMENT_DRUMS;
sf2.AddPreset(instrument.name, 0, 128);
}
else
{
sf2.AddPreset(instrument.name, (ushort)instrument.program, 0);
}
sf2.AddPresetBag();
sf2.AddPresetGenerator(SF2Generator.ReverbEffectsSend, new SF2GeneratorAmount {
UAmount = (ushort)1000
});
sf2.AddPresetGenerator(SF2Generator.Instrument, new SF2GeneratorAmount {
UAmount = (ushort)i
});
sf2.AddInstrument(instrument.name);
i++;
if (instrument.regions.Length > 0)
{
Lins DSLInstrument = new Lins(midiBank, instrument.program, instrument.name);
foreach (AKAORegion region in instrument.regions)
{
AKAOArticulation articulation = null;
AKAO coll = sampleCollections[2];
if (region.articulationId >= 0 && region.articulationId < 32)
{
// trick for MUSIC024.DAT
coll = sampleCollections[1];
articulation = coll.articulations[region.articulationId];
}
else if (region.articulationId >= 32 && region.articulationId < 64)
{
coll = sampleCollections[0];
articulation = coll.articulations[region.articulationId - coll.startingArticulationId];
}
else if (region.articulationId >= 64 && region.articulationId < 128)
{
coll = sampleCollections[1];
if (region.articulationId - coll.startingArticulationId < coll.articulations.Length /* && !instrument.a1*/)
{
articulation = coll.articulations[region.articulationId - coll.startingArticulationId];
}
else
{
// we check in additional collection
//Debug.LogWarning(region.articulationId);
coll = sampleCollections[2];
articulation = coll.articulations[region.articulationId - coll.startingArticulationId];
}
}
if (UseDebug)
{
Debug.Log(string.Concat("Instrument ", i, " ", instrument.name, " | Region articulation " + region.articulationId + " found in ", coll.FileName));
}
if (articulation != null)
{
articulation.BuildADSR();
region.articulation = articulation;
AKAOSample sample = coll.samples[articulation.sampleNum];
if (instrument.IsDrum())
{
region.unityKey = (uint)articulation.unityKey + region.lowRange - region.relativeKey; // maybe
}
else
{
region.unityKey = articulation.unityKey;
}
short ft = articulation.fineTune;
if (ft < 0)
{
ft += short.MaxValue;
}
double freq_multiplier = ((ft * 32) + 0x100000) / (double)0x100000;
double cents = (short)(1200 * Math.Log(freq_multiplier, 2));
if (articulation.fineTune < 0)
{
cents -= 1200;
}
region.fineTune = (short)cents;
sample.loopStart = (uint)(articulation.loopPt * 1.75);
sample.unityKey = (byte)region.unityKey;
if (!Samples.Contains(sample))
{
Samples.Add(sample);
}
int sampleIDX = Samples.IndexOf(sample);
// Making DLS
Lrgn reg = new Lrgn(region.lowRange, region.hiRange, 0x00, 0x7F);
CKwsmp smp = new CKwsmp((ushort)region.unityKey, region.fineTune, region.attenuation, 1);
if (articulation.loopPt != 0)
{
smp.AddLoop(new Loop(1, (uint)(articulation.loopPt * 1.75f), (uint)(sample.size * 1.75f - articulation.loopPt * 1.75f)));
}
reg.SetSample(smp);
CKart2 iart = new CKart2();
iart.AddPan(0x40);
iart.AddADSR(articulation.A, articulation.D, articulation.S, articulation.R, articulation.AT, articulation.RT);
reg.AddArticulation(iart);
reg.SetWaveLinkInfo(0, 0, 1, region.sampleNum);
DSLInstrument.AddRegion(reg);
// http://linuxmao.org/SoundFont+specification+SF2
sf2.AddInstrumentBag();
sf2.AddInstrumentGenerator(SF2Generator.KeyRange, new SF2GeneratorAmount {
LowByte = region.lowRange, HighByte = region.hiRange
});
//sf2.AddInstrumentGenerator(SF2Generator.VelRange, new SF2GeneratorAmount { LowByte = region.lowVel, HighByte = region.hiVel }); // not sure
sf2.AddInstrumentGenerator(SF2Generator.VelRange, new SF2GeneratorAmount {
LowByte = 0, HighByte = 127
});
/* C'est l'atténuation, en centibels, pour laquelle une note est atténuée en dessous de la valeur maximum prévue.
* Si = 0, il n'y a aucune atténuation, la note sera jouée au maximum prévu.
* Ex : 60 indique que la note sera jouée à 6 dB en-dessous du maximum prévu pour la note.
* Max value = 1440 */
sf2.AddInstrumentGenerator(SF2Generator.InitialAttenuation, new SF2GeneratorAmount {
UAmount = (ushort)(region.attenuation / 10)
});
//sf2.AddInstrumentGenerator(SF2Generator.ReverbEffectsSend, new SF2GeneratorAmount { Amount = 1000 });
sf2.AddInstrumentGenerator(SF2Generator.Pan, new SF2GeneratorAmount {
Amount = region.pan
});
sf2.AddInstrumentGenerator(SF2Generator.SampleModes, new SF2GeneratorAmount {
UAmount = (articulation.loopPt != 0) ? (ushort)1 : (ushort)0
});
sf2.AddInstrumentGenerator(SF2Generator.OverridingRootKey, new SF2GeneratorAmount {
UAmount = (ushort)region.unityKey
});
sf2.AddInstrumentGenerator(SF2Generator.DelayVolEnv, new SF2GeneratorAmount {
Amount = (short)short.MinValue
});
/* En timecents absolu, c'est la durée, depuis la fin du délai de l'enveloppe de volume jusqu'au point où la valeur de l'enveloppe de volume atteint son apogée.
* Une valeur de 0 indique 1 seconde. Une valeur négative indique un temps inférieur à une seconde, une valeur positive un temps supérieur à une seconde.
* Le nombre le plus négatif (-32768) indique conventionnellement une attaque instantanée.
* Ex : un temps d'attaque de 10 ms serait 1200log2 (.01) = -7973.
* En musique, le logarithme binaire intervient dans la formule permettant de déterminer la valeur en cents d’un intervalle.
* Un cent, ou centième de demi-ton au tempérament égal, vaut 1200 fois le logarithme binaire du rapport de fréquence des sons concernés.
* 546 * 60 ~= short.MaxValue */
sf2.AddInstrumentGenerator(SF2Generator.AttackVolEnv, new SF2GeneratorAmount {
Amount = (short)(1200 * Math.Log(articulation.A, 2))
});
sf2.AddInstrumentGenerator(SF2Generator.HoldVolEnv, new SF2GeneratorAmount {
Amount = (short)0
});
/* C'est le temps, en timecents absolus, pour une variation de 100% de la valeur de l'enveloppe du volume pendant la phase de décroissance.
* Pour l'enveloppe de volume, la décroissance tend linéairement vers le niveau de maintien, ce qui provoque un changement de dB constant pour chaque unité de temps.
* Si le niveau de maintien = -100dB, le temps de décroissance de l'enveloppe de volume = temps de la phase de décroissance.
* Une valeur de 0 indique 1 seconde de temps de décroissance pour un niveau zéro. Une valeur négative indique un temps inférieur à une seconde,
* une valeur positive un temps supérieur à une seconde.
* Ex : un temps de décroissance de 10 msec serait 1200log2 (.01) = -7973.*/
sf2.AddInstrumentGenerator(SF2Generator.DecayVolEnv, new SF2GeneratorAmount {
Amount = (short)(1200 * Math.Log(articulation.D, 2))
});
/* C'est le taux de la diminution, exprimé en centibels, pour laquelle l'enveloppe de volume décroît au cours de la phase de décroissance.
* Pour l'enveloppe de volume, le niveau d'atténuation du sustain est mieux exprimé en centibels. Une valeur de 0 indique que le niveau est maximum.
* Une valeur positive indique une décroissance au niveau correspondant. Les valeurs inférieures à zéro doivent être interprétés comme zéro;
* conventionnellement 1000 indique une atténuation complète.
* Ex : un niveau de soutien qui correspond à une valeur absolue de 12 dB en dessous du pic serait 120.*/
sf2.AddInstrumentGenerator(SF2Generator.SustainVolEnv, new SF2GeneratorAmount {
Amount = (short)(articulation.S)
});
/* C'est la durée, en timecents absolu, pour une variation de 100% de la valeur de l'enveloppe du volume pendant la phase de libération (release).
* Pour l'enveloppe de volume, la phase de libération tend linéairement vers zéro depuis la niveau en cours,
* ce qui provoque un changement en dB constant pour chaque unité de temps.
* Si le niveau actuel est maximum, la durée du release de l'enveloppe de volume sera le temps de libération jusqu'à ce que 100 dB d'atténuation soit atteint.
* Une valeur de 0 indique 1 seconde de temps de décroissance pour finir complètement. Une valeur négative indique un temps inférieur à une seconde,
* une valeur positive un temps de plus d'une seconde.
* Ex : un temps de libération de 10 msec serait 1200log2 (.01) = -7973. */
sf2.AddInstrumentGenerator(SF2Generator.ReleaseVolEnv, new SF2GeneratorAmount {
Amount = (short)(1200 * Math.Log(articulation.R, 2))
});
/* Décalage de la hauteur, en cents, qui sera appliqué à la note.
* Il est additionnel à coarseTune. Une valeur positive indique que le son est reproduit à une hauteur plus élevée, une valeur négative indique une hauteur inférieure.
* Ex : une valeur finetune = -5 provoquera un son joué cinq cents plus bas. */
sf2.AddInstrumentGenerator(SF2Generator.FineTune, new SF2GeneratorAmount {
Amount = (short)(region.fineTune)
});
sf2.AddInstrumentGenerator(SF2Generator.SampleID, new SF2GeneratorAmount {
UAmount = (ushort)sampleIDX
});
}
}
dls.AddInstrument(DSLInstrument);
}
}
}
}
if (Samples.Count > 0)
{
foreach (AKAOSample AKAOsmp in Samples)
{
WAV nw = AKAOsmp.ConvertToWAV();
nw.SetName(AKAOsmp.name);
nw.Riff = false;
dls.AddWave(nw);
short[] pcm = AKAOsmp.WAVDatas.ToArray();
sf2.AddSample(pcm, AKAOsmp.name, (AKAOsmp.loopStart > 0), AKAOsmp.loopStart, 44100, AKAOsmp.unityKey, 0);
}
}
if (bDLS)
{
ToolBox.DirExNorCreate("Assets/Resources/Sounds/DLS/");
dls.WriteFile("Assets/Resources/Sounds/DLS/" + FileName + ".dls");
}
if (bSF2)
{
ToolBox.DirExNorCreate("Assets/Resources/Sounds/SF2/");
sf2.Save("Assets/Resources/Sounds/SF2/" + FileName + ".sf2");
}
return(sf2);
}
