412 lines
9.3 KiB
C++
412 lines
9.3 KiB
C++
/**********************************************************************
|
|
|
|
Audacity: A Digital Audio Editor
|
|
|
|
Snap.cpp
|
|
|
|
Dominic Mazzoni
|
|
|
|
**********************************************************************/
|
|
|
|
#include "Audacity.h"
|
|
#include "Snap.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstdlib>
|
|
|
|
#include "Project.h"
|
|
#include "LabelTrack.h"
|
|
#include "TrackPanel.h"
|
|
#include "WaveTrack.h"
|
|
|
|
#include <wx/arrimpl.cpp>
|
|
|
|
inline bool operator < (SnapPoint s1, SnapPoint s2)
|
|
{
|
|
return s1.t < s2.t;
|
|
}
|
|
|
|
TrackClip::TrackClip(Track *t, WaveClip *c)
|
|
{
|
|
track = origTrack = t;
|
|
dstTrack = NULL;
|
|
clip = c;
|
|
}
|
|
|
|
#ifndef __AUDACITY_OLD_STD__
|
|
TrackClip::TrackClip(TrackClip&& tc)
|
|
: track{tc.track}, origTrack{tc.origTrack}, dstTrack{tc.dstTrack},
|
|
clip{tc.clip}, holder{std::move(tc.holder)} {}
|
|
#endif
|
|
|
|
TrackClip::~TrackClip()
|
|
{
|
|
|
|
}
|
|
|
|
SnapManager::SnapManager(TrackList *tracks,
|
|
const ZoomInfo *zoomInfo,
|
|
const TrackClipArray *clipExclusions,
|
|
const TrackArray *trackExclusions,
|
|
bool noTimeSnap,
|
|
int pixelTolerance)
|
|
: mConverter(NumericConverter::TIME)
|
|
{
|
|
mTracks = tracks;
|
|
mZoomInfo = zoomInfo;
|
|
mClipExclusions = clipExclusions;
|
|
mTrackExclusions = trackExclusions;
|
|
mPixelTolerance = pixelTolerance;
|
|
mNoTimeSnap = noTimeSnap;
|
|
|
|
mProject = GetActiveProject();
|
|
wxASSERT(mProject);
|
|
|
|
mSnapTo = 0;
|
|
mRate = 0.0;
|
|
mFormat.Empty();
|
|
|
|
// Two time points closer than this are considered the same
|
|
mEpsilon = 1 / 44100.0;
|
|
|
|
Reinit();
|
|
}
|
|
|
|
SnapManager::~SnapManager()
|
|
{
|
|
}
|
|
|
|
void SnapManager::Reinit()
|
|
{
|
|
int snapTo = mProject->GetSnapTo();
|
|
double rate = mProject->GetRate();
|
|
wxString format = mProject->GetSelectionFormat();
|
|
|
|
// No need to reinit if these are still the same
|
|
if (snapTo == mSnapTo && rate == mRate && format == mFormat)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Save NEW settings
|
|
mSnapTo = snapTo;
|
|
mRate = rate;
|
|
mFormat = format;
|
|
|
|
mSnapPoints.clear();
|
|
|
|
// Grab time-snapping prefs (unless otherwise requested)
|
|
mSnapToTime = false;
|
|
|
|
// Look up the format string
|
|
if (mSnapTo != SNAP_OFF && !mNoTimeSnap)
|
|
{
|
|
mSnapToTime = true;
|
|
mConverter.SetSampleRate(mRate);
|
|
mConverter.SetFormatName(mFormat);
|
|
}
|
|
|
|
// Add a SnapPoint at t=0
|
|
mSnapPoints.push_back(SnapPoint{});
|
|
|
|
TrackListIterator iter(mTracks);
|
|
for (Track *track = iter.First(); track; track = iter.Next())
|
|
{
|
|
if (mTrackExclusions &&
|
|
mTrackExclusions->end() !=
|
|
std::find(mTrackExclusions->begin(), mTrackExclusions->end(), track))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (track->GetKind() == Track::Label)
|
|
{
|
|
LabelTrack *labelTrack = (LabelTrack *)track;
|
|
for (int i = 0, cnt = labelTrack->GetNumLabels(); i < cnt; ++i)
|
|
{
|
|
const LabelStruct *label = labelTrack->GetLabel(i);
|
|
const double t0 = label->getT0();
|
|
const double t1 = label->getT1();
|
|
CondListAdd(t0, labelTrack);
|
|
if (t1 != t0)
|
|
{
|
|
CondListAdd(t1, labelTrack);
|
|
}
|
|
}
|
|
}
|
|
else if (track->GetKind() == Track::Wave)
|
|
{
|
|
auto waveTrack = static_cast<const WaveTrack *>(track);
|
|
for (const auto &clip: waveTrack->GetClips())
|
|
{
|
|
if (mClipExclusions)
|
|
{
|
|
bool skip = false;
|
|
for (size_t j = 0, cnt = mClipExclusions->size(); j < cnt; ++j)
|
|
{
|
|
if ((*mClipExclusions)[j].track == waveTrack &&
|
|
(*mClipExclusions)[j].clip == clip.get())
|
|
{
|
|
skip = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (skip)
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
CondListAdd(clip->GetStartTime(), waveTrack);
|
|
CondListAdd(clip->GetEndTime(), waveTrack);
|
|
}
|
|
}
|
|
#ifdef USE_MIDI
|
|
else if (track->GetKind() == Track::Note)
|
|
{
|
|
CondListAdd(track->GetStartTime(), track);
|
|
CondListAdd(track->GetEndTime(), track);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// Sort all by time
|
|
std::sort(mSnapPoints.begin(), mSnapPoints.end());
|
|
}
|
|
|
|
// Adds to mSnapPoints, filtering by TimeConverter
|
|
void SnapManager::CondListAdd(double t, const Track *track)
|
|
{
|
|
if (mSnapToTime)
|
|
{
|
|
mConverter.SetValue(t);
|
|
}
|
|
|
|
if (!mSnapToTime || mConverter.GetValue() == t)
|
|
{
|
|
mSnapPoints.push_back(SnapPoint{ t, track });
|
|
}
|
|
}
|
|
|
|
// Return the time of the SnapPoint at a given index
|
|
double SnapManager::Get(size_t index)
|
|
{
|
|
return mSnapPoints[index].t;
|
|
}
|
|
|
|
// Returns the difference in time between t and the point at a given index
|
|
wxInt64 SnapManager::PixelDiff(double t, size_t index)
|
|
{
|
|
return std::abs(mZoomInfo->TimeToPosition(t, 0) -
|
|
mZoomInfo->TimeToPosition(Get(index), 0));
|
|
}
|
|
|
|
// Find the index where this SnapPoint should go in
|
|
// sorted order, between i0 (inclusive) and i1 (exclusive).
|
|
size_t SnapManager::Find(double t, size_t i0, size_t i1)
|
|
{
|
|
if (i1 <= i0 + 1)
|
|
{
|
|
return i0;
|
|
}
|
|
|
|
size_t half = (i0 + i1) / 2;
|
|
|
|
if (t < Get(half))
|
|
{
|
|
return Find(t, i0, half);
|
|
}
|
|
|
|
return Find(t, half, i1);
|
|
}
|
|
|
|
// Find the SnapPoint nearest to time t
|
|
size_t SnapManager::Find(double t)
|
|
{
|
|
size_t cnt = mSnapPoints.size();
|
|
size_t index = Find(t, 0, cnt);
|
|
|
|
// At this point, either index is the closest, or the next one
|
|
// to the right is. Keep moving to the right until we get a
|
|
// different value
|
|
size_t next = index + 1;
|
|
while (next + 1 < cnt && Get(next) == Get(index))
|
|
{
|
|
next++;
|
|
}
|
|
|
|
// Now return whichever one is closer to time t
|
|
if (next < cnt && PixelDiff(t, next) < PixelDiff(t, index))
|
|
{
|
|
return next;
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Helper: performs snap-to-points for Snap(). Returns true if a snap happened.
|
|
bool SnapManager::SnapToPoints(Track *currentTrack,
|
|
double t,
|
|
bool rightEdge,
|
|
double *outT)
|
|
{
|
|
*outT = t;
|
|
|
|
size_t cnt = mSnapPoints.size();
|
|
if (cnt == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Find the nearest SnapPoint
|
|
size_t index = Find(t);
|
|
|
|
// If it's too far away, just give up now
|
|
if (PixelDiff(t, index) >= mPixelTolerance)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Otherwise, search left and right for all of the points
|
|
// within the allowed range.
|
|
size_t left = index;
|
|
size_t right = index;
|
|
size_t i;
|
|
|
|
while (left > 0 && PixelDiff(t, left - 1) < mPixelTolerance)
|
|
{
|
|
left--;
|
|
}
|
|
|
|
while (right < cnt - 1 && PixelDiff(t, right + 1) < mPixelTolerance)
|
|
{
|
|
right++;
|
|
}
|
|
|
|
if (left == index && right == index)
|
|
{
|
|
// Awesome, there's only one point that matches!
|
|
*outT = Get(index);
|
|
return true;
|
|
}
|
|
|
|
size_t indexInThisTrack = 0;
|
|
size_t countInThisTrack = 0;
|
|
for (i = left; i <= right; ++i)
|
|
{
|
|
if (mSnapPoints[i].track == currentTrack)
|
|
{
|
|
indexInThisTrack = i;
|
|
countInThisTrack++;
|
|
}
|
|
}
|
|
|
|
if (countInThisTrack == 1)
|
|
{
|
|
// Cool, only one of the points is in the same track, so
|
|
// we'll use that one.
|
|
*outT = Get(indexInThisTrack);
|
|
return true;
|
|
}
|
|
|
|
if (Get(right) - Get(left) < mEpsilon)
|
|
{
|
|
// OK, they're basically the same point
|
|
if (rightEdge)
|
|
{
|
|
*outT = Get(right); // Return rightmost
|
|
}
|
|
else {
|
|
*outT = Get(left); // Return leftmost
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// None of the points matched, bummer.
|
|
return false;
|
|
}
|
|
|
|
bool SnapManager::Snap(Track *currentTrack,
|
|
double t,
|
|
bool rightEdge,
|
|
double *outT,
|
|
bool *snappedPoint,
|
|
bool *snappedTime)
|
|
{
|
|
// Check to see if we need to reinitialize
|
|
Reinit();
|
|
|
|
// First snap to points in mSnapPoints
|
|
*outT = t;
|
|
*snappedPoint = SnapToPoints(currentTrack, t, rightEdge, outT);
|
|
|
|
// Now snap to the time grid
|
|
*snappedTime = false;
|
|
if (mSnapToTime)
|
|
{
|
|
if (*snappedPoint)
|
|
{
|
|
// Since mSnapPoints only contains points on the grid, we're done
|
|
*snappedTime = true;
|
|
}
|
|
else
|
|
{
|
|
// Snap time to the grid
|
|
mConverter.ValueToControls(t, GetActiveProject()->GetSnapTo() == SNAP_NEAREST);
|
|
mConverter.ControlsToValue();
|
|
*outT = mConverter.GetValue();
|
|
*snappedTime = true;
|
|
}
|
|
}
|
|
|
|
return *snappedPoint || *snappedTime;
|
|
}
|
|
|
|
/* static */ wxArrayString SnapManager::GetSnapLabels()
|
|
{
|
|
wxArrayString labels;
|
|
|
|
labels.Add(_("Off"));
|
|
labels.Add(_("Nearest"));
|
|
labels.Add(_("Prior"));
|
|
|
|
return labels;
|
|
}
|
|
|
|
/* static */ wxArrayString SnapManager::GetSnapValues()
|
|
{
|
|
wxArrayString values;
|
|
|
|
values.Add(wxT("Off"));
|
|
values.Add(wxT("Nearest"));
|
|
values.Add(wxT("Prior"));
|
|
|
|
return values;
|
|
}
|
|
|
|
/* static */ const wxString & SnapManager::GetSnapValue(int index)
|
|
{
|
|
wxArrayString values = SnapManager::GetSnapValues();
|
|
|
|
if (index >= 0 && index < (int) values.GetCount())
|
|
{
|
|
return values[index];
|
|
}
|
|
|
|
return values[SNAP_OFF];
|
|
}
|
|
|
|
/* static */ int SnapManager::GetSnapIndex(const wxString & value)
|
|
{
|
|
wxArrayString values = SnapManager::GetSnapValues();
|
|
int index = values.Index(value);
|
|
|
|
if (index != wxNOT_FOUND)
|
|
{
|
|
return index;
|
|
}
|
|
|
|
return SNAP_OFF;
|
|
}
|