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);
}
}
//*****************************************************
// 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);
}
// 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;
}
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;
}
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 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);
}
}
}
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();
}
// param _allTakes only makes sense if jobTake() is used
bool FindWnd::FindMediaItem(int _dir, bool _allTakes, bool (*jobTake)(MediaItem_Take*,const char*), bool (*jobItem)(MediaItem*,const char*))
{
bool update = false, found = false, sel = true;
if (g_searchStr && *g_searchStr)
{
PreventUIRefresh(1);
MediaItem* startItem = NULL;
bool clearCurrentSelection = false;
if (_dir)
{
WDL_PtrList<MediaItem> items;
SNM_GetSelectedItems(NULL, &items);
if (items.GetSize())
{
startItem = FindPrevNextItem(_dir, items.Get(_dir > 0 ? 0 : items.GetSize()-1));
clearCurrentSelection = (startItem != NULL);
}
else
startItem = FindPrevNextItem(_dir, NULL);
}
else
{
startItem = FindPrevNextItem(1, NULL);
clearCurrentSelection = (startItem != NULL);
}
if (clearCurrentSelection)
{
Undo_BeginBlock2(NULL);
Main_OnCommand(40289,0); // unselect all items
update = true;
}
MediaItem* item = NULL;
MediaTrack* startTr = startItem ? GetMediaItem_Track(startItem) : NULL;
int startTrIdx = startTr ? CSurf_TrackToID(startTr, false) : -1;
if (startTr && startItem && startTrIdx>=0)
{
// find startItem idx
int startItemIdx=-1;
while (item != startItem)
item = GetTrackMediaItem(startTr,++startItemIdx);
bool firstItem=true, breakSelection=false;
for (int i=startTrIdx; !breakSelection && i <= CountTracks(NULL) && i>=1; i += (!_dir ? 1 : _dir))
{
MediaTrack* tr = CSurf_TrackFromID(i, false);
int nbItems = GetTrackNumMediaItems(tr);
for (int j = (firstItem ? startItemIdx : (_dir >= 0 ? 0 : (nbItems-1)));
tr && !breakSelection && j < nbItems && j >= 0;
j += (!_dir ? 1 : _dir))
{
item = GetTrackMediaItem(tr,j);
firstItem = false;
// search at item level
if (jobItem)
{
if (jobItem(item, g_searchStr))
{
if (!update) Undo_BeginBlock2(NULL);
update = found = true;
GetSetMediaItemInfo(item, "B_UISEL", &sel);
if (_dir) breakSelection = true;
}
}
// search at take level
else if (jobTake)
{
int nbTakes = GetMediaItemNumTakes(item);
for (int k=0; item && k < nbTakes; k++)
{
MediaItem_Take* tk = GetMediaItemTake(item, k);
if (tk && (_allTakes || (!_allTakes && tk == GetActiveTake(item))))
{
if (jobTake(tk, g_searchStr))
{
if (!update) Undo_BeginBlock2(NULL);
update = found = true;
GetSetMediaItemInfo(item, "B_UISEL", &sel);
if (_dir) {
breakSelection = true;
break;
}
}
}
}
}
}
}
}
UpdateNotFoundMsg(found);
if (found && m_zoomSrollItems) {
if (!_dir) ZoomToSelItems();
else if (item) ScrollToSelItem(item);
}
PreventUIRefresh(-1);
}
if (update)
{
UpdateTimeline();
Undo_EndBlock2(NULL, __LOCALIZE("Find: change media item selection","sws_undo"), UNDO_STATE_ALL);
}
return update;
}
