void RMSNormalizeAll(double dTargetDb, double dWindowSize)
{
WDL_TypedBuf<MediaItem*> items;
SWS_GetSelectedMediaItems(&items);
double dMaxRMS = -DBL_MAX;
ANALYZE_PCM a;
memset(&a, 0, sizeof(a));
a.dWindowSize = dWindowSize;
for (int i = 0; i < items.GetSize(); i++)
{
MediaItem* mi = items.Get()[i];
MediaItem_Take* take = GetMediaItemTake(mi, -1);
if (take && AnalyzeItem(mi, &a) && a.dRMS != 0.0 && a.dRMS > dMaxRMS)
dMaxRMS = a.dRMS;
}
if (dMaxRMS > -DBL_MAX)
{
for (int i = 0; i < items.GetSize(); i++)
{
MediaItem* mi = items.Get()[i];
MediaItem_Take* take = GetMediaItemTake(mi, -1);
if (take)
{
double dVol = *(double*)GetSetMediaItemTakeInfo(take, "D_VOL", NULL);
dVol *= DB2VAL(dTargetDb) / dMaxRMS;
GetSetMediaItemTakeInfo(take, "D_VOL", &dVol);
}
}
UpdateTimeline();
Undo_OnStateChangeEx(__LOCALIZE("Normalize items to RMS","sws_undo"), UNDO_STATE_ITEMS, -1);
}
}
void RegionsFromItems(COMMAND_T* ct)
{
// Ignore the fact that the user may have items selected with the exact same times. Just blindly create regions!
WDL_TypedBuf<MediaItem*> items;
SWS_GetSelectedMediaItems(&items);
bool bUndo = false;
for (int i = 0; i < items.GetSize(); i++)
{
MediaItem_Take* take = GetActiveTake(items.Get()[i]);
if (take)
{
char* cName = (char*)GetSetMediaItemTakeInfo(take, "P_NAME", NULL);
double dStart = *(double*)GetSetMediaItemInfo(items.Get()[i], "D_POSITION", NULL);
double dEnd = *(double*)GetSetMediaItemInfo(items.Get()[i], "D_LENGTH", NULL) + dStart;
AddProjectMarker(NULL, true, dStart, dEnd, cName, -1);
bUndo = true;
}
else if (!CountTakes(items.Get()[i])) /* In case of an empty item there is no take so process item instead */
{
double dStart = *(double*)GetSetMediaItemInfo(items.Get()[i], "D_POSITION", NULL);
double dEnd = *(double*)GetSetMediaItemInfo(items.Get()[i], "D_LENGTH", NULL) + dStart;
AddProjectMarker(NULL, true, dStart, dEnd, NULL, -1);
bUndo = true;
}
}
if (bUndo)
{
UpdateTimeline();
Undo_OnStateChangeEx(SWS_CMD_SHORTNAME(ct), UNDO_STATE_MISCCFG, -1);
}
}
void TakeRandomCols(COMMAND_T* = NULL)
{
COLORREF cr;
// All black check
if (AllBlack())
return;
for (int i = 1; i <= GetNumTracks(); i++)
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
for (int j = 0; j < GetTrackNumMediaItems(tr); j++)
{
MediaItem* mi = GetTrackMediaItem(tr, j);
if (*(bool*)GetSetMediaItemInfo(mi, "B_UISEL", NULL))
{
for (int h = 0; h < CountTakes(mi); h++)
{
while (!(cr = g_custColors[rand() % 16]));
cr |= 0x1000000;
GetSetMediaItemTakeInfo(GetTake(mi, h), "I_CUSTOMCOLOR", &cr);
}
}
}
}
Undo_OnStateChange(__LOCALIZE("Set takes in selected item(s) to random custom color(s)","sws_undo"));
UpdateTimeline();
}
void RecSrcOut(COMMAND_T* = NULL)
{
// Set the rec source to output
// Set to mono or stereo based on first item
for (int i = 1; i <= GetNumTracks(); i++)
{
int iMode = 1; // 5 = mono, 1 = stereo
MediaTrack* tr = CSurf_TrackFromID(i, false);
if (*(int*)GetSetMediaTrackInfo(tr, "I_SELECTED", NULL))
{
if (GetTrackNumMediaItems(tr))
{
MediaItem* mi = GetTrackMediaItem(tr, 0);
if (GetMediaItemNumTakes(mi))
{
MediaItem_Take* mit = GetMediaItemTake(mi, 0);
PCM_source* p = (PCM_source*)GetSetMediaItemTakeInfo(mit, "P_SOURCE", NULL);
if (p && p->GetNumChannels() == 1)
iMode = 5;
}
}
GetSetMediaTrackInfo(tr, "I_RECMODE", &iMode);
}
}
}
void NameTrackLikeItem(COMMAND_T* ct)
{
WDL_TypedBuf<MediaTrack*> tracks;
SWS_GetSelectedTracks(&tracks);
bool bUndo = false;
for (int i = 0; i < tracks.GetSize(); i++)
{
for (int j = 0; j < GetTrackNumMediaItems(tracks.Get()[i]); j++)
{
MediaItem* mi = GetTrackMediaItem(tracks.Get()[i], j);
if (*(bool*)GetSetMediaItemInfo(mi, "B_UISEL", NULL) && GetMediaItemNumTakes(mi))
{
MediaItem_Take* take = GetMediaItemTake(mi, -1);
if (take)
{
const char* pName = (const char*)GetSetMediaItemTakeInfo(take, "P_NAME", NULL);
if (pName && strlen(pName))
{
char* pNameNoExt = new char[strlen(pName)+1];
strcpy(pNameNoExt, pName);
char* pDot = strrchr(pNameNoExt, '.');
if (pDot && IsMediaExtension(pDot+1, false))
*pDot = 0;
GetSetMediaTrackInfo(tracks.Get()[i], "P_NAME", (void*)pNameNoExt);
bUndo = true;
delete [] pNameNoExt;
}
break;
}
}
}
}
if (bUndo)
Undo_OnStateChangeEx(SWS_CMD_SHORTNAME(ct), UNDO_STATE_TRACKCFG, -1);
}
void NameTrackLikeFirstItem(COMMAND_T* ct)
{
// Get the first item's take
MediaItem* item = GetSelectedMediaItem(NULL, 0);
if (!item || !GetMediaItemNumTakes(item))
return;
MediaItem_Take* take = GetMediaItemTake(item, -1);
if (!take)
return;
// Get the first item's name
const char* pName = (const char*)GetSetMediaItemTakeInfo(take, "P_NAME", NULL);
if (!pName || !strlen(pName))
return;
// Strip out extension
char* pNameNoExt = new char[strlen(pName)+1];
strcpy(pNameNoExt, pName);
char* pDot = strrchr(pNameNoExt, '.');
if (pDot && IsMediaExtension(pDot+1, false))
*pDot = 0;
// Set all sel tracks to that name
WDL_TypedBuf<MediaTrack*> tracks;
SWS_GetSelectedTracks(&tracks);
for (int i = 0; i < tracks.GetSize(); i++)
GetSetMediaTrackInfo(tracks.Get()[i], "P_NAME", (void*)pNameNoExt);
Undo_OnStateChangeEx(SWS_CMD_SHORTNAME(ct), UNDO_STATE_TRACKCFG, -1);
delete [] pNameNoExt;
}
// return true for successful analysis
// wraps AnalyzePCM to check item validity and create a wait dialog
bool AnalyzeItem(MediaItem* mi, ANALYZE_PCM* a)
{
a->dProgress = 0.0;
a->pcm = (PCM_source*)mi;
if (!a->pcm || strcmp(a->pcm->GetType(), "MIDI") == 0 || strcmp(a->pcm->GetType(), "MIDIPOOL") == 0)
return false;
a->pcm = a->pcm->Duplicate();
if (!a->pcm || !a->pcm->GetNumChannels())
return false;
double dZero = 0.0;
GetSetMediaItemInfo((MediaItem*)a->pcm, "D_POSITION", &dZero);
const char* cName = NULL;
MediaItem_Take* take = GetMediaItemTake(mi, -1);
if (take)
cName = (const char*)GetSetMediaItemTakeInfo(take, "P_NAME", NULL);
CreateThread(NULL, 0, AnalyzePCMThread, a, 0, NULL);
WDL_String title;
title.AppendFormatted(100, __LOCALIZE_VERFMT("Please wait, analyzing %s...","sws_analysis"), cName ? cName : __LOCALIZE("item","sws_analysis"));
SWS_WaitDlg wait(title.Get(), &a->dProgress);
delete a->pcm;
return true;
}
//*****************************************************
// ActiveTake Class
ActiveTake::ActiveTake(MediaItem* mi)
{
// Make sure an active take exists before calling this!
// GetMediaItemNumTakes(mi) != 0
m_item = *(GUID*)GetSetMediaItemInfo(mi, "GUID", NULL);
m_activeTake = *(GUID*)GetSetMediaItemTakeInfo(GetMediaItemTake(mi, -1), "GUID", NULL);
}
bool TakeFilenameMatch(MediaItem_Take* _tk, const char* _searchStr)
{
bool match = false;
PCM_source* src = _tk ? (PCM_source*)GetSetMediaItemTakeInfo(_tk, "P_SOURCE", NULL) : NULL;
if (src)
{
const char* takeFilename = src->GetFileName();
match = (takeFilename && strstr(takeFilename, _searchStr)); // no stristr: osx + utf-8
}
return match;
}
bool ActiveTake::Restore(MediaItem* mi)
{
int i;
for (i = 0; i < GetMediaItemNumTakes(mi); i++)
if (GuidsEqual(&m_activeTake, (GUID*)GetSetMediaItemTakeInfo(GetMediaItemTake(mi, i), "GUID", NULL)))
{
GetSetMediaItemInfo(mi, "I_CURTAKE", &i);
return true;
}
return false;
}
void UnselNotRender(COMMAND_T* = NULL)
{
for (int i = 1; i <= GetNumTracks(); i++)
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
for (int j = 0; j < GetTrackNumMediaItems(tr); j++)
{
MediaItem* mi = GetTrackMediaItem(tr, j);
if (GetMediaItemNumTakes(mi))
{
PCM_source* src = (PCM_source*)GetSetMediaItemTakeInfo(GetMediaItemTake(mi, -1), "P_SOURCE", NULL);
if (src && src->GetFileName() && !strstr(src->GetFileName(), "render"))
GetSetMediaItemInfo(mi, "B_UISEL", &g_bFalse);
}
}
}
UpdateTimeline();
}
void TakeGradient(COMMAND_T* = NULL)
{
int tCurPos = 0;
for (int i = 1; i <= GetNumTracks(); i++)
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
for (int j = 0; j < GetTrackNumMediaItems(tr); j++)
{
MediaItem* mi = GetTrackMediaItem(tr, j);
if (*(bool*)GetSetMediaItemInfo(mi, "B_UISEL", NULL))
{
for (int h = 0; h < CountTakes(mi); h++)
{
COLORREF cr = CalcGradient(g_crGradStart, g_crGradEnd, (double)tCurPos++ / (CountTakes(mi)-1)) | 0x1000000;
GetSetMediaItemTakeInfo(GetTake(mi, h), "I_CUSTOMCOLOR", &cr);
}
tCurPos = 0;
}
}
}
Undo_OnStateChange(__LOCALIZE("Set takes in selected item(s) to color gradient","sws_undo"));
UpdateTimeline();
}
void TakeOrderedCol(COMMAND_T* = NULL)
{
UpdateCustomColors();
int tCurPos = 0;
for (int i = 1; i <= GetNumTracks(); i++)
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
for (int j = 0; j < GetTrackNumMediaItems(tr); j++)
{
MediaItem* mi = GetTrackMediaItem(tr, j);
if (*(bool*)GetSetMediaItemInfo(mi, "B_UISEL", NULL))
{
for (int h = 0; h < CountTakes(mi); h++)
{
COLORREF cr = g_custColors[tCurPos++ % 16] | 0x1000000;
GetSetMediaItemTakeInfo(GetTake(mi, h), "I_CUSTOMCOLOR", &cr);
}
tCurPos = 0;
}
}
}
Undo_OnStateChange(__LOCALIZE("Set takes in selected item(s) to ordered custom colors","sws_undo"));
UpdateTimeline();
}
void TakeCustomColor(int iCustColor)
{
COLORREF cr;
UpdateCustomColors();
cr = g_custColors[iCustColor] | 0x1000000;
for (int i = 1; i <= GetNumTracks(); i++)
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
for (int j = 0; j < GetTrackNumMediaItems(tr); j++)
{
MediaItem* mi = GetTrackMediaItem(tr, j);
if (*(bool*)GetSetMediaItemInfo(mi, "B_UISEL", NULL))
{
MediaItem_Take* take = GetActiveTake(mi);
if (take)
GetSetMediaItemTakeInfo(take, "I_CUSTOMCOLOR", &cr);
}
}
}
char cUndoText[100];
sprintf(cUndoText, __LOCALIZE_VERFMT("Set take(s) to custom color %d","sws_undo"), iCustColor+1);
Undo_OnStateChange(cUndoText);
UpdateTimeline();
}
void RprTake::setName(const char *name)
{
GetSetMediaItemTakeInfo(mTake, "P_NAME", (void *)name);
}
bool TakeNameMatch(MediaItem_Take* _tk, const char* _searchStr)
{
char* takeName = _tk ? (char*)GetSetMediaItemTakeInfo(_tk, "P_NAME", NULL) : NULL;
return (takeName && stristr(takeName, _searchStr));
}
double RprTake::getPlayRate() const
{
double playRate = *(double *)GetSetMediaItemTakeInfo(mTake, "D_PLAYRATE", NULL);
return playRate;
}
void RprTake::setPlayRate(double playRate)
{
GetSetMediaItemTakeInfo(mTake, "D_PLAYRATE", (void *)&playRate);
}
RprItem RprTake::getParent() const
{
RprItem item((MediaItem *)GetSetMediaItemTakeInfo(mTake, "P_ITEM", NULL));
return item;
}
PCM_source *RprTake::getSource()
{
return (PCM_source *)GetSetMediaItemTakeInfo(mTake, "P_SOURCE", NULL);
}
double RprTake::getStartOffset() const
{
return *(double *)GetSetMediaItemTakeInfo(mTake, "D_STARTOFFS", NULL);
}
void RprTake::setStartOffset(double offset)
{
GetSetMediaItemTakeInfo(mTake, "D_STARTOFFS", &offset);
}
GUID *RprTake::getGUID() const
{
return (GUID *)GetSetMediaItemTakeInfo(mTake, "GUID", NULL);
}
const char *RprTake::getName()
{
return (const char *)GetSetMediaItemTakeInfo(mTake, "P_NAME", NULL);
}
// Import local files from m3u/pls playlists onto a new track
void PlaylistImport(COMMAND_T* ct)
{
char cPath[256];
vector<SPlaylistEntry> filelist;
GetProjectPath(cPath, 256);
string listpath = BrowseForFiles(__LOCALIZE("Import playlist","sws_mbox"), cPath, NULL, false, "Playlist files (*.m3u,*.pls)\0*.m3u;*.pls\0All Files (*.*)\0*.*\0");
string ext = ParseFileExtension(listpath);
// Decide what kind of playlist we have
if(ext == "m3u")
{
ParseM3U(listpath, filelist);
}
else if(ext == "pls")
{
ParsePLS(listpath, filelist);
}
if(filelist.empty())
{
ShowMessageBox(__LOCALIZE("Failed to import playlist. No files found.","sws_mbox"), __LOCALIZE("Import playlist","sws_mbox"), 0);
return;
}
// Validate files
vector<string> badfiles;
for(int i = 0, c = (int)filelist.size(); i < c; i++)
{
SPlaylistEntry e = filelist[i];
if(!file_exists(e.path.c_str()))
{
badfiles.push_back(e.path);
}
}
// If files can't be found, ask user what to do.
bool includeMissing = false;
if(!badfiles.empty())
{
stringstream ss;
ss << __LOCALIZE("Cannot find some files. Create items anyway?\n","sws_mbox");
unsigned int limit = min((int)badfiles.size(), 9); // avoid enormous messagebox
for(unsigned int i = 0; i < limit; i++)
{
ss << "\n " << badfiles[i];
}
if(badfiles.size() > limit)
{
ss << "\n +" << badfiles.size() - limit << __LOCALIZE(" more files","sws_mbox");
}
switch(ShowMessageBox(ss.str().c_str(), __LOCALIZE("Import playlist","sws_mbox"), 3))
{
case 6 : // Yes
includeMissing = true;
break;
case 7 : // No
break;
default :
return;
}
}
Undo_BeginBlock2(NULL);
// Add new track
int idx = GetNumTracks();
int panMode = 5; // Stereo pan
double panLaw = 1.0; // 0dB
InsertTrackAtIndex(idx, false);
MediaTrack *pTrack = GetTrack(NULL, idx);
GetSetMediaTrackInfo(pTrack, "P_NAME", (void*) listpath.c_str());
GetSetMediaTrackInfo(pTrack, "I_PANMODE", (void*) &panMode);
GetSetMediaTrackInfo(pTrack, "D_PANLAW", (void*) &panLaw);
SetOnlyTrackSelected(pTrack);
// Add new items to track
double pos = 0.0;
for(int i = 0, c = (int)filelist.size(); i < c; i++)
{
SPlaylistEntry e = filelist[i];
//TODO: Would be better if missing files were offline rather than just empty items.
PCM_source *pSrc = PCM_Source_CreateFromFile(e.path.c_str());
if(pSrc || includeMissing)
{
MediaItem *pItem = AddMediaItemToTrack(pTrack);
if(pItem)
{
MediaItem_Take *pTake = AddTakeToMediaItem(pItem);
if(pTake)
{
GetSetMediaItemTakeInfo(pTake, "P_SOURCE", pSrc);
GetSetMediaItemTakeInfo(pTake, "P_NAME", (void*) e.title.c_str());
SetMediaItemPosition(pItem, pos, false);
SetMediaItemLength(pItem, e.length, false);
pos += e.length;
}
}
}
}
Undo_EndBlock2(NULL, SWS_CMD_SHORTNAME(ct), UNDO_STATE_ITEMS|UNDO_STATE_TRACKCFG);
TrackList_AdjustWindows(false);
UpdateTimeline();
Main_OnCommand(40047, 0); // Build missing peaks
}
