random-mirrors
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/external_dependencies/openmpt-trunk/mptrack/CleanupSong.cpp

978 lines
27 KiB
C++
Raw Permalink Blame History

/*
* CleanupSong.cpp
* ---------------
* Purpose: Dialog for cleaning up modules (rearranging, removing unused items).
* Notes : (currently none)
* Authors: Olivier Lapicque
* OpenMPT Devs
* The OpenMPT source code is released under the BSD license. Read LICENSE for more details.
*/
#include "stdafx.h"
#include "Moddoc.h"
#include "Mainfrm.h"
#include "CleanupSong.h"
#include "../common/mptStringBuffer.h"
#include "../soundlib/mod_specifications.h"
#include "../soundlib/modsmp_ctrl.h"
#include "../tracklib/SampleEdit.h"
OPENMPT_NAMESPACE_BEGIN
// Default checkbox state
bool CModCleanupDlg::m_CheckBoxes[kMaxCleanupOptions] =
{
true, false, true, true, // patterns
false, false, // orders
true, false, false, true, // samples
true, false, // instruments
true, false, // plugins
false, true, // misc
};
// Checkbox -> Control ID LUT
WORD const CModCleanupDlg::m_CleanupIDtoDlgID[kMaxCleanupOptions] =
{
// patterns
IDC_CHK_CLEANUP_PATTERNS, IDC_CHK_REMOVE_PATTERNS,
IDC_CHK_REARRANGE_PATTERNS, IDC_CHK_REMOVE_DUPLICATES,
// orders
IDC_CHK_MERGE_SEQUENCES, IDC_CHK_REMOVE_ORDERS,
// samples
IDC_CHK_CLEANUP_SAMPLES, IDC_CHK_REMOVE_SAMPLES,
IDC_CHK_REARRANGE_SAMPLES, IDC_CHK_OPTIMIZE_SAMPLES,
// instruments
IDC_CHK_CLEANUP_INSTRUMENTS, IDC_CHK_REMOVE_INSTRUMENTS,
// plugins
IDC_CHK_CLEANUP_PLUGINS, IDC_CHK_REMOVE_PLUGINS,
// misc
IDC_CHK_RESET_VARIABLES, IDC_CHK_UNUSED_CHANNELS,
};
// Options that are mutually exclusive to each other
CModCleanupDlg::CleanupOptions const CModCleanupDlg::m_MutuallyExclusive[CModCleanupDlg::kMaxCleanupOptions] =
{
// patterns
kRemovePatterns, kCleanupPatterns,
kRemovePatterns, kRemovePatterns,
// orders
kRemoveOrders, kMergeSequences,
// samples
kRemoveSamples, kCleanupSamples,
kRemoveSamples, kRemoveSamples,
// instruments
kRemoveAllInstruments, kCleanupInstruments,
// plugins
kRemoveAllPlugins, kCleanupPlugins,
// misc
kNone, kNone,
};
///////////////////////////////////////////////////////////////////////
// CModCleanupDlg
BEGIN_MESSAGE_MAP(CModCleanupDlg, CDialog)
//{{AFX_MSG_MAP(CModTypeDlg)
ON_COMMAND(IDC_BTN_CLEANUP_SONG, &CModCleanupDlg::OnPresetCleanupSong)
ON_COMMAND(IDC_BTN_COMPO_CLEANUP, &CModCleanupDlg::OnPresetCompoCleanup)
ON_COMMAND(IDC_CHK_CLEANUP_PATTERNS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_PATTERNS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REARRANGE_PATTERNS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_DUPLICATES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_MERGE_SEQUENCES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_ORDERS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_CLEANUP_SAMPLES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_SAMPLES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REARRANGE_SAMPLES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_OPTIMIZE_SAMPLES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_CLEANUP_INSTRUMENTS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_INSTRUMENTS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_CLEANUP_PLUGINS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_REMOVE_PLUGINS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_RESET_VARIABLES, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_COMMAND(IDC_CHK_UNUSED_CHANNELS, &CModCleanupDlg::OnVerifyMutualExclusive)
ON_NOTIFY_EX(TTN_NEEDTEXT, 0, &CModCleanupDlg::OnToolTipNotify)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BOOL CModCleanupDlg::OnInitDialog()
{
CDialog::OnInitDialog();
for(int i = 0; i < kMaxCleanupOptions; i++)
{
CheckDlgButton(m_CleanupIDtoDlgID[i], (m_CheckBoxes[i]) ? BST_CHECKED : BST_UNCHECKED);
}
CSoundFile &sndFile = modDoc.GetSoundFile();
GetDlgItem(m_CleanupIDtoDlgID[kMergeSequences])->EnableWindow((sndFile.Order.GetNumSequences() > 1) ? TRUE : FALSE);
GetDlgItem(m_CleanupIDtoDlgID[kRemoveSamples])->EnableWindow((sndFile.GetNumSamples() > 0) ? TRUE : FALSE);
GetDlgItem(m_CleanupIDtoDlgID[kRearrangeSamples])->EnableWindow((sndFile.GetNumSamples() > 1) ? TRUE : FALSE);
GetDlgItem(m_CleanupIDtoDlgID[kCleanupInstruments])->EnableWindow((sndFile.GetNumInstruments() > 0) ? TRUE : FALSE);
GetDlgItem(m_CleanupIDtoDlgID[kRemoveAllInstruments])->EnableWindow((sndFile.GetNumInstruments() > 0) ? TRUE : FALSE);
EnableToolTips(TRUE);
return TRUE;
}
void CModCleanupDlg::OnOK()
{
ScopedLogCapturer logcapturer(modDoc, _T("cleanup"), this);
for(int i = 0; i < kMaxCleanupOptions; i++)
{
m_CheckBoxes[i] = IsDlgButtonChecked(m_CleanupIDtoDlgID[i]) != BST_UNCHECKED;
}
bool modified = false;
// Orders
if(m_CheckBoxes[kMergeSequences]) modified |= MergeSequences();
if(m_CheckBoxes[kRemoveOrders]) modified |= RemoveAllOrders();
// Patterns
if(m_CheckBoxes[kRemovePatterns]) modified |= RemoveAllPatterns();
if(m_CheckBoxes[kCleanupPatterns]) modified |= RemoveUnusedPatterns();
if(m_CheckBoxes[kRemoveDuplicatePatterns]) modified |= RemoveDuplicatePatterns();
if(m_CheckBoxes[kRearrangePatterns]) modified |= RearrangePatterns();
// Instruments
if(modDoc.GetNumInstruments() > 0)
{
if(m_CheckBoxes[kRemoveAllInstruments]) modified |= RemoveAllInstruments();
if(m_CheckBoxes[kCleanupInstruments]) modified |= RemoveUnusedInstruments();
}
// Samples
if(m_CheckBoxes[kRemoveSamples]) modified |= RemoveAllSamples();
if(m_CheckBoxes[kCleanupSamples]) modified |= RemoveUnusedSamples();
if(m_CheckBoxes[kOptimizeSamples]) modified |= OptimizeSamples();
if(modDoc.GetNumSamples() > 1)
{
if(m_CheckBoxes[kRearrangeSamples]) modified |= RearrangeSamples();
}
// Plugins
if(m_CheckBoxes[kRemoveAllPlugins]) modified |= RemoveAllPlugins();
if(m_CheckBoxes[kCleanupPlugins]) modified |= RemoveUnusedPlugins();
// Create samplepack
if(m_CheckBoxes[kResetVariables]) modified |= ResetVariables();
// Remove unused channels
if(m_CheckBoxes[kCleanupChannels]) modified |= RemoveUnusedChannels();
if(modified) modDoc.SetModified();
modDoc.UpdateAllViews(nullptr, UpdateHint().ModType());
logcapturer.ShowLog(true);
CDialog::OnOK();
}
void CModCleanupDlg::OnVerifyMutualExclusive()
{
HWND hFocus = GetFocus()->m_hWnd;
for(int i = 0; i < kMaxCleanupOptions; i++)
{
// if this item is focussed, we have just (un)checked it.
if(hFocus == GetDlgItem(m_CleanupIDtoDlgID[i])->m_hWnd)
{
// if we just unchecked it, there's nothing to verify.
if(IsDlgButtonChecked(m_CleanupIDtoDlgID[i]) == BST_UNCHECKED)
return;
// now we can disable all elements that are mutually exclusive.
if(m_MutuallyExclusive[i] != kNone)
CheckDlgButton(m_CleanupIDtoDlgID[m_MutuallyExclusive[i]], BST_UNCHECKED);
// find other elements which are mutually exclusive with the selected element.
for(int j = 0; j < kMaxCleanupOptions; j++)
{
if(m_MutuallyExclusive[j] == i)
CheckDlgButton(m_CleanupIDtoDlgID[j], BST_UNCHECKED);
}
return;
}
}
}
void CModCleanupDlg::OnPresetCleanupSong()
{
// patterns
CheckDlgButton(IDC_CHK_CLEANUP_PATTERNS, BST_CHECKED);
CheckDlgButton(IDC_CHK_REMOVE_PATTERNS, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REARRANGE_PATTERNS, BST_CHECKED);
CheckDlgButton(IDC_CHK_REMOVE_DUPLICATES, BST_CHECKED);
// orders
CheckDlgButton(IDC_CHK_MERGE_SEQUENCES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_ORDERS, BST_UNCHECKED);
// samples
CheckDlgButton(IDC_CHK_CLEANUP_SAMPLES, BST_CHECKED);
CheckDlgButton(IDC_CHK_REMOVE_SAMPLES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REARRANGE_SAMPLES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_OPTIMIZE_SAMPLES, BST_CHECKED);
// instruments
CheckDlgButton(IDC_CHK_CLEANUP_INSTRUMENTS, BST_CHECKED);
CheckDlgButton(IDC_CHK_REMOVE_INSTRUMENTS, BST_UNCHECKED);
// plugins
CheckDlgButton(IDC_CHK_CLEANUP_PLUGINS, BST_CHECKED);
CheckDlgButton(IDC_CHK_REMOVE_PLUGINS, BST_UNCHECKED);
// misc
CheckDlgButton(IDC_CHK_SAMPLEPACK, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_UNUSED_CHANNELS, BST_CHECKED);
}
void CModCleanupDlg::OnPresetCompoCleanup()
{
// patterns
CheckDlgButton(IDC_CHK_CLEANUP_PATTERNS, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_PATTERNS, BST_CHECKED);
CheckDlgButton(IDC_CHK_REARRANGE_PATTERNS, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_DUPLICATES, BST_UNCHECKED);
// orders
CheckDlgButton(IDC_CHK_MERGE_SEQUENCES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_ORDERS, BST_CHECKED);
// samples
CheckDlgButton(IDC_CHK_CLEANUP_SAMPLES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_SAMPLES, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REARRANGE_SAMPLES, BST_CHECKED);
CheckDlgButton(IDC_CHK_OPTIMIZE_SAMPLES, BST_UNCHECKED);
// instruments
CheckDlgButton(IDC_CHK_CLEANUP_INSTRUMENTS, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_INSTRUMENTS, BST_CHECKED);
// plugins
CheckDlgButton(IDC_CHK_CLEANUP_PLUGINS, BST_UNCHECKED);
CheckDlgButton(IDC_CHK_REMOVE_PLUGINS, BST_CHECKED);
// misc
CheckDlgButton(IDC_CHK_SAMPLEPACK, BST_CHECKED);
CheckDlgButton(IDC_CHK_UNUSED_CHANNELS, BST_CHECKED);
}
BOOL CModCleanupDlg::OnToolTipNotify(UINT, NMHDR *pNMHDR, LRESULT *)
{
TOOLTIPTEXT* pTTT = (TOOLTIPTEXT*)pNMHDR;
UINT_PTR nID = pNMHDR->idFrom;
if (pTTT->uFlags & TTF_IDISHWND)
{
// idFrom is actually the HWND of the tool
nID = ::GetDlgCtrlID((HWND)nID);
}
LPCTSTR lpszText = nullptr;
switch(nID)
{
// patterns
case IDC_CHK_CLEANUP_PATTERNS:
lpszText = _T("Remove all unused patterns and rearrange them.");
break;
case IDC_CHK_REMOVE_PATTERNS:
lpszText = _T("Remove all patterns.");
break;
case IDC_CHK_REARRANGE_PATTERNS:
lpszText = _T("Number the patterns given by their order in the sequence.");
break;
case IDC_CHK_REMOVE_DUPLICATES:
lpszText = _T("Merge patterns with identical content.");
break;
// orders
case IDC_CHK_REMOVE_ORDERS:
lpszText = _T("Reset the order list.");
break;
case IDC_CHK_MERGE_SEQUENCES:
lpszText = _T("Merge multiple sequences into one.");
break;
// samples
case IDC_CHK_CLEANUP_SAMPLES:
lpszText = _T("Remove all unused samples.");
break;
case IDC_CHK_REMOVE_SAMPLES:
lpszText = _T("Remove all samples.");
break;
case IDC_CHK_REARRANGE_SAMPLES:
lpszText = _T("Reorder sample list by removing empty samples.");
break;
case IDC_CHK_OPTIMIZE_SAMPLES:
lpszText = _T("Remove unused data after the sample loop end.");
break;
// instruments
case IDC_CHK_CLEANUP_INSTRUMENTS:
lpszText = _T("Remove all unused instruments.");
break;
case IDC_CHK_REMOVE_INSTRUMENTS:
lpszText = _T("Remove all instruments and convert them to samples.");
break;
// plugins
case IDC_CHK_CLEANUP_PLUGINS:
lpszText = _T("Remove all unused plugins.");
break;
case IDC_CHK_REMOVE_PLUGINS:
lpszText = _T("Remove all plugins.");
break;
// misc
case IDC_CHK_SAMPLEPACK:
lpszText = _T("Convert the module to .IT and reset song / sample / instrument variables");
break;
case IDC_CHK_UNUSED_CHANNELS:
lpszText = _T("Removes all empty pattern channels.");
break;
default:
lpszText = _T("");
break;
}
pTTT->lpszText = const_cast<LPTSTR>(lpszText);
return TRUE;
}
///////////////////////////////////////////////////////////////////////
// Actual cleanup implementations
bool CModCleanupDlg::RemoveDuplicatePatterns()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
const PATTERNINDEX numPatterns = sndFile.Patterns.Size();
std::vector<PATTERNINDEX> patternMapping(numPatterns, PATTERNINDEX_INVALID);
BeginWaitCursor();
CriticalSection cs;
PATTERNINDEX foundDupes = 0;
for(PATTERNINDEX pat1 = 0; pat1 < numPatterns; pat1++)
{
if(!sndFile.Patterns.IsValidPat(pat1))
continue;
const CPattern &pattern1 = sndFile.Patterns[pat1];
for(PATTERNINDEX pat2 = pat1 + 1; pat2 < numPatterns; pat2++)
{
if(!sndFile.Patterns.IsValidPat(pat2) || patternMapping[pat2] != PATTERNINDEX_INVALID)
continue;
const CPattern &pattern2 = sndFile.Patterns[pat2];
if(pattern1 == pattern2)
{
modDoc.GetPatternUndo().PrepareUndo(pat2, 0, 0, pattern2.GetNumChannels(), pattern2.GetNumRows(), "Remove Duplicate Patterns", foundDupes != 0, false);
sndFile.Patterns.Remove(pat2);
patternMapping[pat2] = pat1;
foundDupes++;
}
}
}
if(foundDupes != 0)
{
modDoc.AddToLog(MPT_AFORMAT("{} duplicate pattern{} merged.")(foundDupes, foundDupes == 1 ? "" : "s"));
// Fix order list
for(auto &order : sndFile.Order)
{
for(auto &pat : order)
{
if(pat < numPatterns && patternMapping[pat] != PATTERNINDEX_INVALID)
{
pat = patternMapping[pat];
}
}
}
}
EndWaitCursor();
return foundDupes != 0;
}
// Remove unused patterns
bool CModCleanupDlg::RemoveUnusedPatterns()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
const PATTERNINDEX numPatterns = sndFile.Patterns.Size();
std::vector<bool> patternUsed(numPatterns, false);
BeginWaitCursor();
// First, find all used patterns in all sequences.
for(auto &order : sndFile.Order)
{
for(auto pat : order)
{
if(pat < numPatterns)
{
patternUsed[pat] = true;
}
}
}
// Remove all other patterns.
CriticalSection cs;
PATTERNINDEX numRemovedPatterns = 0;
for(PATTERNINDEX pat = 0; pat < numPatterns; pat++)
{
if(!patternUsed[pat] && sndFile.Patterns.IsValidPat(pat))
{
numRemovedPatterns++;
modDoc.GetPatternUndo().PrepareUndo(pat, 0, 0, sndFile.GetNumChannels(), sndFile.Patterns[pat].GetNumRows(), "Remove Unused Patterns", numRemovedPatterns != 0, false);
sndFile.Patterns.Remove(pat);
}
}
EndWaitCursor();
if(numRemovedPatterns)
{
modDoc.AddToLog(MPT_AFORMAT("{} pattern{} removed.")(numRemovedPatterns, numRemovedPatterns == 1 ? "" : "s"));
return true;
}
return false;
}
// Rearrange patterns (first pattern in order list = 0, etc...)
bool CModCleanupDlg::RearrangePatterns()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
const PATTERNINDEX numPatterns = sndFile.Patterns.Size();
std::vector<PATTERNINDEX> newIndex(numPatterns, PATTERNINDEX_INVALID);
bool modified = false;
BeginWaitCursor();
CriticalSection cs;
// First, find all used patterns in all sequences.
PATTERNINDEX patOrder = 0;
for(auto &order : sndFile.Order)
{
for(auto &pat : order)
{
if(pat < numPatterns)
{
if(newIndex[pat] == PATTERNINDEX_INVALID)
{
newIndex[pat] = patOrder++;
}
pat = newIndex[pat];
}
}
}
// All unused patterns are moved to the end of the pattern list.
for(PATTERNINDEX pat = 0; pat < numPatterns; pat++)
{
PATTERNINDEX &index = newIndex[pat];
if(index == PATTERNINDEX_INVALID && sndFile.Patterns.IsValidPat(pat))
{
index = patOrder++;
}
}
// Also need new indices for any non-existent patterns
for(auto &index : newIndex)
{
if(index == PATTERNINDEX_INVALID)
{
index = patOrder++;
}
}
modDoc.GetPatternUndo().RearrangePatterns(newIndex);
// Now rearrange the actual patterns
for(PATTERNINDEX i = 0; i < static_cast<PATTERNINDEX>(newIndex.size()); i++)
{
PATTERNINDEX j = newIndex[i];
if(i == j)
continue;
while(i < j)
j = newIndex[j];
std::swap(sndFile.Patterns[i], sndFile.Patterns[j]);
modified = true;
}
EndWaitCursor();
return modified;
}
// Remove unused samples
bool CModCleanupDlg::RemoveUnusedSamples()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
std::vector<bool> samplesUsed(sndFile.GetNumSamples() + 1, true);
BeginWaitCursor();
// Check if any samples are not referenced in the patterns (sample mode) or by an instrument (instrument mode).
// This doesn't check yet if a sample is referenced by an instrument, but actually unused in the patterns.
for(SAMPLEINDEX smp = 1; smp <= sndFile.GetNumSamples(); smp++) if (sndFile.GetSample(smp).HasSampleData())
{
if(!modDoc.IsSampleUsed(smp))
{
samplesUsed[smp] = false;
}
}
SAMPLEINDEX nRemoved = sndFile.RemoveSelectedSamples(samplesUsed);
const SAMPLEINDEX unusedInsSamples = sndFile.DetectUnusedSamples(samplesUsed);
EndWaitCursor();
if(unusedInsSamples)
{
mpt::ustring s = MPT_UFORMAT("OpenMPT detected {} sample{} referenced by an instrument,\nbut not used in the song. Do you want to remove them?")
( unusedInsSamples
, (unusedInsSamples == 1) ? U_("") : U_("s")
);
if(Reporting::Confirm(s, "Sample Cleanup", false, false, this) == cnfYes)
{
nRemoved += sndFile.RemoveSelectedSamples(samplesUsed);
}
}
if(nRemoved > 0)
{
modDoc.AddToLog(LogNotification, MPT_UFORMAT("{} unused sample{} removed")(nRemoved, (nRemoved == 1) ? U_("") : U_("s")));
}
return (nRemoved > 0);
}
// Check if the stereo channels of a sample contain identical data
template<typename T>
static bool ComapreStereoChannels(SmpLength length, const T *sampleData)
{
for(SmpLength i = 0; i < length; i++, sampleData += 2)
{
if(sampleData[0] != sampleData[1])
{
return false;
}
}
return true;
}
// Remove unused sample data
bool CModCleanupDlg::OptimizeSamples()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
SAMPLEINDEX numLoopOpt = 0, numStereoOpt = 0;
std::vector<bool> stereoOptSamples(sndFile.GetNumSamples(), false);
for(SAMPLEINDEX smp = 1; smp <= sndFile.GetNumSamples(); smp++)
{
const ModSample &sample = sndFile.GetSample(smp);
// Determine how much of the sample will be played
SmpLength loopLength = sample.nLength;
if(sample.uFlags[CHN_LOOP])
{
loopLength = sample.nLoopEnd;
if(sample.uFlags[CHN_SUSTAINLOOP])
{
loopLength = std::max(sample.nLoopEnd, sample.nSustainEnd);
}
}
// Check if the sample contains identical stereo channels
if(sample.GetNumChannels() == 2)
{
bool identicalChannels = false;
if(sample.GetElementarySampleSize() == 1)
{
identicalChannels = ComapreStereoChannels(loopLength, sample.sample8());
} else if(sample.GetElementarySampleSize() == 2)
{
identicalChannels = ComapreStereoChannels(loopLength, sample.sample16());
}
if(identicalChannels)
{
numStereoOpt++;
stereoOptSamples[smp - 1] = true;
}
}
if(sample.HasSampleData() && sample.nLength > loopLength + 2) numLoopOpt++;
}
if(!numLoopOpt && !numStereoOpt) return false;
std::string s;
if(numLoopOpt)
s = MPT_AFORMAT("{} sample{} unused data after the loop end point.\n")(numLoopOpt, (numLoopOpt == 1) ? " has" : "s have");
if(numStereoOpt)
s += MPT_AFORMAT("{} stereo sample{} actually mono.\n")(numStereoOpt, (numStereoOpt == 1) ? " is" : "s are");
if(numLoopOpt + numStereoOpt == 1)
s += "Do you want to optimize it and remove this unused data?";
else
s += "Do you want to optimize them and remove this unused data?";
if(Reporting::Confirm(s.c_str(), "Sample Optimization", false, false, this) != cnfYes)
{
return false;
}
for(SAMPLEINDEX smp = 1; smp <= sndFile.m_nSamples; smp++)
{
ModSample &sample = sndFile.GetSample(smp);
// Determine how much of the sample will be played
SmpLength loopLength = sample.nLength;
if(sample.uFlags[CHN_LOOP])
{
loopLength = sample.nLoopEnd;
// Sustain loop is played before normal loop, and it can actually be located after the normal loop.
if(sample.uFlags[CHN_SUSTAINLOOP])
{
loopLength = std::max(sample.nLoopEnd, sample.nSustainEnd);
}
}
if(sample.nLength > loopLength && loopLength >= 2)
{
modDoc.GetSampleUndo().PrepareUndo(smp, sundo_delete, "Trim Unused Data", loopLength, sample.nLength);
SampleEdit::ResizeSample(sample, loopLength, sndFile);
}
// Convert stereo samples with identical channels to mono
if(stereoOptSamples[smp - 1])
{
modDoc.GetSampleUndo().PrepareUndo(smp, sundo_replace, "Mono Conversion");
ctrlSmp::ConvertToMono(sample, sndFile, ctrlSmp::onlyLeft);
}
}
if(numLoopOpt)
{
s = MPT_AFORMAT("{} sample loop{} optimized")(numLoopOpt, (numLoopOpt == 1) ? "" : "s");
modDoc.AddToLog(s);
}
if(numStereoOpt)
{
s = MPT_AFORMAT("{} sample{} converted to mono")(numStereoOpt, (numStereoOpt == 1) ? "" : "s");
modDoc.AddToLog(s);
}
return true;
}
// Rearrange sample list
bool CModCleanupDlg::RearrangeSamples()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if(sndFile.GetNumSamples() < 2)
return false;
std::vector<SAMPLEINDEX> sampleMap;
sampleMap.reserve(sndFile.GetNumSamples());
// First, find out which sample slots are unused and create the new sample map only with used samples
for(SAMPLEINDEX i = 1; i <= sndFile.GetNumSamples(); i++)
{
if(sndFile.GetSample(i).HasSampleData())
{
sampleMap.push_back(i);
}
}
// Nothing found to remove...
if(sndFile.GetNumSamples() == sampleMap.size())
{
return false;
}
return (modDoc.ReArrangeSamples(sampleMap) != SAMPLEINDEX_INVALID);
}
// Remove unused instruments
bool CModCleanupDlg::RemoveUnusedInstruments()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if(!sndFile.GetNumInstruments())
return false;
deleteInstrumentSamples removeSamples = doNoDeleteAssociatedSamples;
if(Reporting::Confirm("Remove samples associated with unused instruments?", "Removing unused instruments", false, false, this) == cnfYes)
{
removeSamples = deleteAssociatedSamples;
}
BeginWaitCursor();
std::vector<bool> instrUsed(sndFile.GetNumInstruments());
bool prevUsed = true, reorder = false;
INSTRUMENTINDEX numUsed = 0, lastUsed = 1;
for(INSTRUMENTINDEX i = 0; i < sndFile.GetNumInstruments(); i++)
{
instrUsed[i] = (modDoc.IsInstrumentUsed(i + 1));
if(instrUsed[i])
{
numUsed++;
lastUsed = i;
if(!prevUsed)
{
reorder = true;
}
}
prevUsed = instrUsed[i];
}
EndWaitCursor();
if(reorder && numUsed >= 1)
{
reorder = (Reporting::Confirm("Do you want to reorganize the remaining instruments?", "Removing unused instruments", false, false, this) == cnfYes);
} else
{
reorder = false;
}
const INSTRUMENTINDEX numRemoved = sndFile.GetNumInstruments() - numUsed;
if(numRemoved != 0)
{
BeginWaitCursor();
std::vector<INSTRUMENTINDEX> instrMap;
instrMap.reserve(sndFile.GetNumInstruments());
for(INSTRUMENTINDEX i = 0; i < sndFile.GetNumInstruments(); i++)
{
if(instrUsed[i])
{
instrMap.push_back(i + 1);
} else if(!reorder && i < lastUsed)
{
instrMap.push_back(INSTRUMENTINDEX_INVALID);
}
}
modDoc.ReArrangeInstruments(instrMap, removeSamples);
EndWaitCursor();
modDoc.AddToLog(LogNotification, MPT_UFORMAT("{} unused instrument{} removed")(numRemoved, (numRemoved == 1) ? U_("") : U_("s")));
return true;
}
return false;
}
// Remove ununsed plugins
bool CModCleanupDlg::RemoveUnusedPlugins()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
std::vector<bool> usedmap(MAX_MIXPLUGINS, false);
for(PLUGINDEX nPlug = 0; nPlug < MAX_MIXPLUGINS; nPlug++)
{
// Is the plugin assigned to a channel?
for(CHANNELINDEX nChn = 0; nChn < sndFile.GetNumChannels(); nChn++)
{
if (sndFile.ChnSettings[nChn].nMixPlugin == nPlug + 1)
{
usedmap[nPlug] = true;
break;
}
}
// Is the plugin used by an instrument?
for(INSTRUMENTINDEX nIns = 1; nIns <= sndFile.GetNumInstruments(); nIns++)
{
if (sndFile.Instruments[nIns] && (sndFile.Instruments[nIns]->nMixPlug == nPlug + 1))
{
usedmap[nPlug] = true;
break;
}
}
// Is the plugin assigned to master?
if(sndFile.m_MixPlugins[nPlug].IsMasterEffect())
usedmap[nPlug] = true;
// All outputs of used plugins count as used
if(usedmap[nPlug])
{
if(!sndFile.m_MixPlugins[nPlug].IsOutputToMaster())
{
PLUGINDEX output = sndFile.m_MixPlugins[nPlug].GetOutputPlugin();
if(output != PLUGINDEX_INVALID)
{
usedmap[output] = true;
}
}
}
}
PLUGINDEX numRemoved = modDoc.RemovePlugs(usedmap);
if(numRemoved != 0)
{
modDoc.AddToLog(LogInformation, MPT_UFORMAT("{} unused plugin{} removed")(numRemoved, (numRemoved == 1) ? U_("") : U_("s")));
return true;
}
return false;
}
// Reset variables (convert to IT, reset global/smp/ins vars, etc.)
bool CModCleanupDlg::ResetVariables()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if(Reporting::Confirm(_T("OpenMPT will convert the module to IT format and reset all song, sample and instrument attributes to default values. Continue?"), _T("Resetting variables"), false, false, this) == cnfNo)
return false;
// Stop play.
CMainFrame::GetMainFrame()->StopMod(&modDoc);
BeginWaitCursor();
CriticalSection cs;
// Convert to IT...
modDoc.ChangeModType(MOD_TYPE_IT);
sndFile.SetDefaultPlaybackBehaviour(sndFile.GetType());
sndFile.SetMixLevels(MixLevels::Compatible);
sndFile.m_songArtist.clear();
sndFile.m_nTempoMode = TempoMode::Classic;
sndFile.m_SongFlags = SONG_LINEARSLIDES;
sndFile.m_MidiCfg.Reset();
// Global vars
sndFile.m_nDefaultTempo.Set(125);
sndFile.m_nDefaultSpeed = 6;
sndFile.m_nDefaultGlobalVolume = MAX_GLOBAL_VOLUME;
sndFile.m_nSamplePreAmp = 48;
sndFile.m_nVSTiVolume = 48;
sndFile.Order().SetRestartPos(0);
if(sndFile.Order().empty())
{
modDoc.InsertPattern(64, 0);
}
// Reset instruments (if there are any)
for(INSTRUMENTINDEX i = 1; i <= sndFile.GetNumInstruments(); i++) if(sndFile.Instruments[i])
{
sndFile.Instruments[i]->nFadeOut = 256;
sndFile.Instruments[i]->nGlobalVol = 64;
sndFile.Instruments[i]->nPan = 128;
sndFile.Instruments[i]->dwFlags.reset(INS_SETPANNING);
sndFile.Instruments[i]->nMixPlug = 0;
sndFile.Instruments[i]->nVolSwing = 0;
sndFile.Instruments[i]->nPanSwing = 0;
sndFile.Instruments[i]->nCutSwing = 0;
sndFile.Instruments[i]->nResSwing = 0;
}
for(CHANNELINDEX chn = 0; chn < sndFile.GetNumChannels(); chn++)
{
sndFile.InitChannel(chn);
}
// reset samples
SampleEdit::ResetSamples(sndFile, SampleEdit::SmpResetCompo);
cs.Leave();
EndWaitCursor();
return true;
}
bool CModCleanupDlg::RemoveUnusedChannels()
{
// Avoid M.K. modules to become xCHN modules if some channels are unused.
if(modDoc.GetModType() == MOD_TYPE_MOD && modDoc.GetNumChannels() == 4)
return false;
std::vector<bool> usedChannels;
modDoc.CheckUsedChannels(usedChannels, modDoc.GetNumChannels() - modDoc.GetSoundFile().GetModSpecifications().channelsMin);
return modDoc.RemoveChannels(usedChannels);
}
// Remove all patterns
bool CModCleanupDlg::RemoveAllPatterns()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if(sndFile.Patterns.Size() == 0) return false;
modDoc.GetPatternUndo().ClearUndo();
sndFile.Patterns.ResizeArray(0);
sndFile.SetCurrentOrder(0);
return true;
}
// Remove all orders
bool CModCleanupDlg::RemoveAllOrders()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
sndFile.Order.Initialize();
sndFile.SetCurrentOrder(0);
return true;
}
// Remove all samples
bool CModCleanupDlg::RemoveAllSamples()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if (sndFile.GetNumSamples() == 0) return false;
std::vector<bool> keepSamples(sndFile.GetNumSamples() + 1, false);
sndFile.RemoveSelectedSamples(keepSamples);
SampleEdit::ResetSamples(sndFile, SampleEdit::SmpResetInit, 1, MAX_SAMPLES - 1);
return true;
}
// Remove all instruments
bool CModCleanupDlg::RemoveAllInstruments()
{
CSoundFile &sndFile = modDoc.GetSoundFile();
if(sndFile.GetNumInstruments() == 0) return false;
modDoc.ConvertInstrumentsToSamples();
for(INSTRUMENTINDEX i = 1; i <= sndFile.GetNumInstruments(); i++)
{
sndFile.DestroyInstrument(i, doNoDeleteAssociatedSamples);
}
sndFile.m_nInstruments = 0;
return true;
}
// Remove all plugins
bool CModCleanupDlg::RemoveAllPlugins()
{
std::vector<bool> keepMask(MAX_MIXPLUGINS, false);
modDoc.RemovePlugs(keepMask);
return true;
}
bool CModCleanupDlg::MergeSequences()
{
return modDoc.GetSoundFile().Order.MergeSequences();
}
OPENMPT_NAMESPACE_END
Reference in New Issue View Git Blame Copy Permalink