/// <summary>
///
/// </summary>
/// <param name="banks"></param>
/// <param name="patches"></param>
private void ReadProgramBanks(int banks, int patches)
{
for (int index = 0; index < banks; index++)
{
int bankIndex = Util.GetInt(CurrentPcgMemory.Content, _index, 2);
_index += 2;
IProgramBank bank = (IProgramBank)CurrentPcgMemory.ProgramBanks[bankIndex];
//programBank.PcgId = bankId;
bank.ByteOffset = _index;
bank.ByteLength = SampledProgramSize;
bank.BankSynthesisType = bank.DefaultSampledSynthesisType;
bank.IsWritable = true;
bank.IsLoaded = true;
// Read patches.
for (int patchIndex = 0; patchIndex < patches; patchIndex++)
{
// Place in PcgMemory.
IProgram program = (IProgram)bank[patchIndex];
program.ByteOffset = _index;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
_index += bank.ByteLength;
}
}
}
private void FillDictionaryWithSetListSlots()
{
for (int setListIndex = 0; setListIndex < 128; setListIndex++)
{
if ((setListIndex < SetListsRangeFrom) ||
(setListIndex > SetListsRangeTo))
{
continue;
}
ISetList setList = ((ISetList)PcgMemory.SetLists[setListIndex]);
foreach (IPatch setListSlot in setList.Patches.Where(
setListSlot => setList.IsLoaded && !setListSlot.IsEmptyOrInit))
{
switch (((ISetListSlot)setListSlot).SelectedPatchType)
{
case SetListSlot.PatchType.Program:
{
IProgramBank usedProgramBank = ((ISetListSlot)setListSlot).UsedPatch.Parent as IProgramBank;
Tuple <IProgramBank, IProgram> key = new Tuple <IProgramBank, IProgram>(usedProgramBank,
((ISetListSlot)setListSlot).UsedPatch as IProgram);
if (_dict.ContainsKey(key) && !_dict[key].Contains(setListSlot))
{
_dict[key].AddLast(setListSlot);
}
}
break;
}
}
}
}
/// <summary>
///
/// </summary>
private void ReadProgramData(int bankStart, int numberOfBanks)
{
for (int bankIndex = bankStart; bankIndex < numberOfBanks; bankIndex++)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[bankIndex]);
bank.ByteOffset = Index;
bank.BankSynthesisType = ProgramBank.SynthesisType.MossZ1;
bank.ByteLength = 576;
bank.IsWritable = true;
bank.IsLoaded = true;
for (int index = 0; index < bank.Patches.Count; index++)
{
// Place in PcgMemory.
IProgram program = (IProgram)bank[index];
program.ByteOffset = Index;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += bank.ByteLength;
}
}
}
/// <summary>
///
/// </summary>
private void ReadAllData()
{
Index = SysExStartOffset;
IProgramBank programBank = (IProgramBank)CurrentPcgMemory.ProgramBanks[0];
const int numberOfProgramsInBank = 16;
for (int bankIndex = 0; bankIndex < CurrentPcgMemory.ProgramBanks.BankCollection.Count; bankIndex++)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[bankIndex]);
bank.ByteOffset = Index;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
bank.ByteLength = 254;
bank.IsWritable = true;
bank.IsLoaded = true;
for (int index = 0; index < numberOfProgramsInBank; index++)
{
// Place in PcgMemory.
Program program = (Program)bank[index];
program.ByteOffset = Index;
program.ByteLength = programBank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += bank.ByteLength;
}
if (Index + bank.ByteLength >= CurrentPcgMemory.Content.Length)
{
break;
}
}
}
/// <summary>
/// myoldpatches.LIB (MS2000?)
/// 0000 ( 4) MROF
/// 0004 ( 4) Size in IBM Format
/// 0008 ( 4) BLSS
/// 000C ( 4) RDHL
/// 001E ( 4) Size in IBM Format (3A)
/// .. ( 3A)
/// 004E ( 4) QESW
/// 0052 ( 4) Size in IBM Format (8C)
/// b.. 8C
/// 00E2 ( 4) TNEL (Global info)
/// 00E6 ( 4) Size in IBM Format (EB)
/// .. EB
/// 01D5 ( 4) TNEL
/// 01D9 ( 4) Size in IBM Format (114, later also 116, 113, ...)
/// ..
/// 02F1 ( 4) TNEL...
/// offset (program name) starts from 14 (decimal) after size of TNEL
/// Bank Name+ID contained in patch (at end), can be ignored
///
/// ???: Square Comp
/// A01: AC/DC 1987
/// A02: SynthARPEG
/// ...
/// A16: Surrounded
/// B01: Lazy Pitch
/// ...
/// H16: INIT Program
/// </summary>
private void ReadLibData()
{
byte[] content = CurrentPcgMemory.Content;
Index = 4; // Skip MROF
int mrofSize = ReadLength(); // Ignore MROF chunk size.
if (Util.GetChars(content, Index, 4) != "BLSS")
{
throw new NotSupportedException("Unsupported BLSSRDHL chunk");
}
Index += 4;
int bankIndex = 0;
IProgramBank bank = (IProgramBank)CurrentPcgMemory.ProgramBanks[bankIndex];
bank.ByteOffset = Index;
bank.ByteLength = 0xFE;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
int programIndex = 0;
const int numberOfProgramsInBank = 16;
int skip = 1;
bool createBank = false;
while (Index < mrofSize)
{
// Only handle TNEL chunks, containing one program each.
string chunkName = Util.GetChars(content, Index, 4);
Index += 4;
int chunkLength = ReadLength();
// Chunk length of 0xEB is global, some unknown is 0x28, others seem to be 0x112 - 0x118.
if ((chunkName == "TNEL") && (chunkLength >= 0x100))
{
if (createBank)
{
bank = CreateProgramBank(bankIndex);
programIndex = 0;
createBank = false;
}
if (skip > 0)
{
skip--;
}
else
{
programIndex = PlaceInPcgMemory(bank, programIndex);
if (programIndex >= numberOfProgramsInBank)
{
bankIndex++;
createBank = true;
}
}
}
Index += chunkLength;
}
}
/// <summary>
///
/// </summary>
private void ReadMkP0Data()
{
byte[] content = CurrentPcgMemory.Content;
if ((Util.GetInt(content, 0x4, 4) != 0) ||
(Util.GetInt(content, 0x8, 4) != 0x8414) || // Length
(Util.GetChars(content, 0x10, 4) != "mkP0"))
{
throw new NotSupportedException("Unsupported mkP0 chunk");
}
Index = 0x120;
IProgramBank programBank = (IProgramBank)CurrentPcgMemory.ProgramBanks[0];
const int numberOfProgramsInBank = 16;
int patchSize = Util.GetInt(content, Index, 8);
for (int bankIndex = 0; bankIndex < CurrentPcgMemory.ProgramBanks.BankCollection.Count; bankIndex++)
{
if (ReadMkp0Bank(content, patchSize, bankIndex, numberOfProgramsInBank, programBank))
{
break;
}
}
}
/// <summary>
/// Only used when command line arguments are used.
/// </summary>
private void FilterBanks()
{
if (FilterProgramBankNames != null)
{
for (int index = SelectedProgramBanks.Count - 1; index >= 0; index--)
{
IProgramBank bank = SelectedProgramBanks[index];
if (!FilterProgramBankNames.Contains(bank.Id))
{
SelectedProgramBanks.Remove(bank);
}
}
}
if (FilterCombiBankNames != null)
{
for (int index = SelectedCombiBanks.Count - 1; index >= 0; index--)
{
ICombiBank bank = SelectedCombiBanks[index];
if (!FilterCombiBankNames.Contains(bank.Id))
{
SelectedCombiBanks.Remove(bank);
}
}
}
}
/// <summary>
///
/// </summary>
private void CreateDictionary()
{
if (_dict == null)
{
throw new ArgumentNullException();
}
foreach (IProgramBank programBank in SelectedProgramBanks)
{
IProgramBank bank = programBank;
foreach (IPatch patch in (from program in programBank.Patches
where !((IBank)(program.Parent)).IsLoaded ||
(((IBank)(program.Parent)).IsLoaded && (!IgnoreInitPrograms || !program.IsEmptyOrInit))
select program).Where(program => !IgnoreFirstProgram ||
(PcgMemory.ProgramBanks.BankCollection.IndexOf(bank) != 0) ||
(bank.Patches.IndexOf(program) != 0)).Where(
program => (!PcgMemory.AreFavoritesSupported ||
((((ProgramBank)(program.Parent)).Type == BankType.EType.Gm) &&
(ListFilterOnFavorites != FilterOnFavorites.Yes)) ||
((IProgram)program).GetParam(ParameterNames.ProgramParameterName.Favorite) == null) ||
(ListFilterOnFavorites == FilterOnFavorites.All) ||
(((ListFilterOnFavorites == FilterOnFavorites.No) &&
!((IProgram)program).GetParam(ParameterNames.ProgramParameterName.Favorite).Value) ||
((ListFilterOnFavorites == FilterOnFavorites.Yes) &&
((IProgram)program).GetParam(ParameterNames.ProgramParameterName.Favorite).Value))))
{
IProgram program = (IProgram)patch;
_dict.Add(new Tuple <IProgramBank, IProgram>(programBank, program), new LinkedList <IPatch>());
}
}
}
/// <summary>
///
/// </summary>
/// <param name="programBankIndex"></param>
/// <returns></returns>
private int ReadProgramData(int programBankIndex)
{
IProgramBank programBank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[programBankIndex]);
programBank.ByteOffset = Index;
programBank.BankSynthesisType = ProgramBank.SynthesisType.Ai;
programBank.ByteLength = 172;
programBank.ByteLength = programBank.ByteLength;
programBank.IsWritable = true;
programBank.IsLoaded = true;
foreach (Common.Synth.Meta.IPatch program in programBank.Patches)
{
program.ByteOffset = Index;
program.ByteLength = programBank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += programBank.ByteLength;
}
programBankIndex += 1;
return(programBankIndex);
}
/// <summary>
///
/// </summary>
public void Fill()
{
if (CombiBanks != null)
{
CombiBanks.Fill();
}
ProgramBanks.Fill();
IProgramBank firstProgramBank = (IProgramBank)ProgramBanks[0];
AssignedClearProgram = (IProgram)(firstProgramBank[0]);
if (SetLists != null)
{
SetLists.Fill();
}
if (WaveSequenceBanks != null)
{
WaveSequenceBanks.Fill();
}
if (DrumKitBanks != null)
{
DrumKitBanks.Fill();
}
if (DrumPatternBanks != null)
{
DrumPatternBanks.Fill();
}
PcgChecksumType = ChecksumType.None;
Chunks = new Chunks();
}
/// <summary>
///
/// </summary>
/// <param name="banks"></param>
/// <param name="patches"></param>
private void ReadMProgramBanks(int banks, int patches)
{
Debug.Assert(banks <= 1);
for (int index = 0; index < banks; index++)
{
int bankIndex = Util.GetInt(CurrentPcgMemory.Content, _index, 2);
Debug.Assert(bankIndex == 4);
_index += 2;
IProgramBank bank = (IProgramBank)CurrentPcgMemory.ProgramBanks[5]; // Store in M bank.
//programBank.PcgId = bankId;
bank.ByteOffset = _index;
bank.ByteLength = ModeledProgramSize;
bank.BankSynthesisType = ProgramBank.SynthesisType.MossZ1;
bank.IsWritable = true;
bank.IsLoaded = true;
// Read patches.
for (int patchIndex = 0; patchIndex < patches; patchIndex++)
{
// Place in PcgMemory.
Program program = (Program)bank[patchIndex];
program.ByteOffset = _index;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
_index += bank.ByteLength;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="programBank"></param>
/// <param name="index"></param>
public Zero3RwProgram(IProgramBank programBank, int index)
: base(programBank, index)
{
switch (programBank.Type)
{
case BankType.EType.Virtual:
throw new NotSupportedException("03R/W has no virtual banks");
// default: Do nothing.
}
}
/// <summary>
///
/// </summary>
/// <param name="bankIndex"></param>
/// <returns></returns>
private IProgramBank CreateProgramBank(int bankIndex)
{
IProgramBank bank = (IProgramBank)CurrentPcgMemory.ProgramBanks[bankIndex];
bank.ByteOffset = Index;
bank.ByteLength = 0xFE;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
bank.IsWritable = true;
bank.IsLoaded = true;
return(bank);
}
/// <summary>
///
/// </summary>
/// <param name="bank"></param>
private void ReadProgram(IProgramBank bank)
{
foreach (IPatch program in bank.Patches)
{
program.ByteOffset = Index;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += bank.ByteLength;
}
}
/// <summary>
///
/// </summary>
/// <param name="timbre"></param>
/// <param name="clipBoardCombi"></param>
private void CopyTimbreOfCombiToClipboard(ITimbre timbre, IClipBoardCombi clipBoardCombi)
{
IClipBoardProgram clipBoardProgramToAdd = null;
IProgramBank usedProgramBank = timbre.UsedProgramBank;
IProgram usedProgram = (usedProgramBank == null) ? null : timbre.UsedProgram;
if (ShouldTimbreBeCopied(timbre, usedProgramBank, usedProgram))
{
clipBoardProgramToAdd = FindProgram(usedProgram) as IClipBoardProgram ??
CopyProgramToClipBoard(usedProgram, false);
}
clipBoardCombi.References.CopiedPatches.Add(clipBoardProgramToAdd);
}
/// <summary>
///
/// </summary>
/// <param name="part"></param>
/// <param name="toPatches"></param>
/// <returns></returns>
public List <IPatch> Parse(string part, List <IPatch> toPatches = null)
{
part = part.Trim();
int startIndex;
int endIndex;
if (!ParseIndices(ref part, out endIndex, out startIndex))
{
return(null);
}
IProgramBank bank = ParseBank(part);
if (bank == null)
{
return(null);
}
// Reduce the offset from a bank (e.g. bank GM starts with 1).
if (startIndex != -1)
{
if (startIndex < bank.IndexOffset)
{
startIndex -= bank.IndexOffset;
}
}
if (endIndex != -1)
{
endIndex -= bank.IndexOffset;
}
// Now the bank is known, take the whole bank if both indices are -1.
if ((startIndex == -1) && (endIndex == -1))
{
startIndex = 0;
endIndex = bank.Patches.Count - 1;
}
List <IPatch> list = new List <IPatch>();
for (int index = startIndex; index <= endIndex; index++)
{
list.Add(bank[index]);
}
return(list);
}
/// <summary>
/// Improve: use parent method, set patch size in base class.
/// </summary>
/// <param name="offset"></param>
protected virtual void ReadSingleProgram(int offset)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[0]);
bank.ByteOffset = 0;
bank.BankSynthesisType = ProgramBank.SynthesisType.Ai2;
bank.ByteLength = 172;
bank.IsWritable = true;
bank.IsLoaded = true;
Common.Synth.Meta.IPatch program = bank[0];
program.ByteOffset = offset;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
protected override void ReadSingleProgram(int offset)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[0]);
bank.ByteOffset = 0;
bank.BankSynthesisType = ProgramBank.SynthesisType.Ai2;
bank.ByteLength = 172; // 172 bytes despite of 164 according to manual
bank.IsWritable = true;
bank.IsLoaded = true;
Common.Synth.Meta.IPatch program = bank[0];
program.ByteOffset = offset;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
private void ReadSingleProgram(int offset)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[0]);
bank.ByteOffset = 0;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
bank.ByteLength = 160;
bank.IsWritable = true;
bank.IsLoaded = true;
Program program = (Program)bank[0];
program.ByteOffset = offset;
program.ByteLength = bank.ByteLength;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
/// <param name="bankStart"></param>
/// <param name="programNo"></param>
private void ReadSingleProgram(int offset, int bankStart = 0, int programNo = 0)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[bankStart]);
bank.ByteOffset = 0;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
bank.ByteLength = 75;
bank.IsWritable = true;
bank.IsLoaded = true;
IProgram program = (IProgram)bank[programNo];
program.ByteOffset = offset;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
}
/// <summary>
///
/// </summary>
/// <param name="offset"></param>
private void ReadSingleProgram(int offset)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[_bank]);
bank.ByteOffset = 0;
bank.BankSynthesisType = ProgramBank.SynthesisType.Edsx;
bank.ByteLength = 0x85c;
bank.IsWritable = true;
bank.IsLoaded = true;
IProgram program = (IProgram)bank[_patchIndex];
program.ByteOffset = offset;
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
IncreaseProgram();
}
/// <summary>
///
/// </summary>
/// <param name="bank1"></param>
/// <param name="numberOfModeledBanks"></param>
/// <param name="numberOfSampledProgramBanks"></param>
/// <returns></returns>
private static int IsNeededProgramBankPresent(IBank bank1, int numberOfModeledBanks, ref int numberOfSampledProgramBanks)
{
IProgramBank bank = (IProgramBank)bank1;
if (bank.IsModeled)
{
if (bank.ByteOffset != 0)
{
numberOfModeledBanks++;
}
}
else
{
// Check for IsWritable is not needed because a Trinity does not have GM banks.
if (bank.ByteOffset != 0)
{
numberOfSampledProgramBanks++;
}
}
return(numberOfModeledBanks);
}
/// <summary>
///
/// </summary>
/// <param name="programPatchSize"></param>
/// <param name="bankIndex"></param>
private void ReadProgram(int programPatchSize, int bankIndex)
{
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[bankIndex]);
if ((bank.Type != BankType.EType.Virtual) && (bank.Type != BankType.EType.Gm))
{
bank.ByteOffset = Index;
bank.ByteLength = programPatchSize;
bank.IsWritable = true;
bank.IsLoaded = true;
foreach (IPatch program in bank.Patches)
{
program.ByteOffset = Index;
Debug.Assert(program.ByteOffset > 0);
program.ByteLength = bank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += bank.ByteLength;
}
}
}
/// <summary>
///
/// </summary>
/// <param name="content"></param>
/// <param name="patchSize"></param>
/// <param name="bankIndex"></param>
/// <param name="numberOfProgramsInBank"></param>
/// <param name="programBank"></param>
/// <returns></returns>
private bool ReadMkp0Bank(byte[] content, int patchSize, int bankIndex, int numberOfProgramsInBank,
ILocatable programBank)
{
if (Util.GetInt(content, Index, 8) != patchSize)
{
throw new ApplicationException("Illegal length");
}
IProgramBank bank = (IProgramBank)(CurrentPcgMemory.ProgramBanks[bankIndex]);
bank.ByteOffset = Index;
bank.BankSynthesisType = ProgramBank.SynthesisType.AnalogModeling;
bank.ByteLength = patchSize;
bank.IsWritable = true;
bank.IsLoaded = true;
for (int index = 0; index < numberOfProgramsInBank; index++)
{
Index += 8; // Skip patch size
// Place in PcgMemory.
Program program = (Program)bank[index];
program.ByteOffset = Index;
program.ByteLength = programBank.ByteLength;
program.IsLoaded = true;
// Skip to next.
Index += bank.ByteLength;
}
if (Index + bank.ByteLength >= CurrentPcgMemory.Content.Length)
{
return(true);
}
return(false);
}
/// <summary>
///
/// </summary>
/// <param name="programBank"></param>
/// <param name="index"></param>
public OasysProgram(IProgramBank programBank, int index)
: base(programBank, index)
{
}
public M3Program(IProgramBank programBank, int index)
: base(programBank, index)
{
}
/// <summary>
///
/// </summary>
/// <param name="programBank"></param>
/// <param name="index"></param>
/// <param name="name"></param>
public TritonTrClassicStudioRackGmProgram(IProgramBank programBank, int index, string name)
: base(programBank, index)
{
_name = name;
Id = $"{programBank.Id}{UserIndex:000}";
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="maxTimbresPerCombi"></param>
/// <param name="columnText"></param>
/// <param name="programBank"></param>
/// <param name="program"></param>
private void PrintLine(TextWriter writer, int maxTimbresPerCombi, string columnText, IProgramBank programBank,
IPatch program)
{
var key = new Tuple <IProgramBank, IProgram>(programBank, (Program)program);
if (!_dict.ContainsKey(key) || (_dict[key].Count <= 0))
{
return;
}
switch (ListOutputFormat)
{
case OutputFormat.AsciiTable:
PrintAsciiTableLine(writer, maxTimbresPerCombi, columnText, program, key);
break;
case OutputFormat.Text:
PrintTextLine(writer, program, key);
break;
case OutputFormat.Csv:
PrintCsvLine(writer, program, key);
break;
case OutputFormat.Xml:
PrintXmlLine(writer, program, key);
break;
default:
throw new NotSupportedException("Unsupported output");
}
}
public KrossProgram(IProgramBank programBank, int index)
: base(programBank, index)
{
}
/// <summary>
///
/// </summary>
/// <param name="programBank"></param>
/// <param name="index"></param>
public TritonExtremeProgram(IProgramBank programBank, int index)
: base(programBank, index)
{
}
