本文整理汇总了C++中Track类的典型用法代码示例。如果您正苦于以下问题:C++ Track类的具体用法?C++ Track怎么用?C++ Track使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了Track类的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: println
int Manager::manage(){
int i;
Event *runningEvt;
Track *trackPointer;
// creation of tracks
println("creation of tracks");
// SourceTrack
// WE
trackPointer = new SourceTrack(2000, 80, 10, 2);
tracks->add(trackPointer,SourceWE);
// EW
trackPointer = new SourceTrack(400, 30, 10, 2);
tracks->add(trackPointer,SourceEW);
// NS
trackPointer = new SourceTrack(500, 60, 20, 5);
tracks->add(trackPointer,SourceNS1);
trackPointer = new SourceTrack(500, 40, 20, 5);
tracks->add(trackPointer,SourceNS2);
// SN
trackPointer = new SourceTrack(500, 60, 30, 7);
tracks->add(trackPointer,SourceSN1);
trackPointer = new SourceTrack(500, 40, 60, 15);
tracks->add(trackPointer,SourceSN2);
// LinkTrack
// WE
trackPointer = new LinkTrack(300, 60);
tracks->add(trackPointer,LinkWE);
// EW
trackPointer = new LinkTrack(300, 60);
tracks->add(trackPointer,LinkEW);
// SinkTrack
// WE
trackPointer = new SinkTrack(400, 30);
tracks->add(trackPointer,SinkWE);
// EW
trackPointer = new SinkTrack(2000, 80);
tracks->add(trackPointer,SinkEW);
// NS
trackPointer = new SinkTrack(500, 60);
tracks->add(trackPointer,SinkNS1);
trackPointer = new SinkTrack(500, 40);
tracks->add(trackPointer,SinkNS2);
// SN
trackPointer = new SinkTrack(500, 60);
tracks->add(trackPointer,SinkSN1);
trackPointer = new SinkTrack(500, 40);
tracks->add(trackPointer,SinkSN2);
// linking Tracks and configure semaphores
println("linking Tracks and configure semaphores");
// Source WE
tracks->get(SourceWE)->addTargetTracks(tracks->get(LinkWE),8);
tracks->get(SourceWE)->addTargetTracks(tracks->get(SinkNS1),1);
tracks->get(SourceWE)->addTargetTracks(tracks->get(SinkSN1),1);
semaphores->addTrack(tracks->get(SourceWE),DIRWE);
// Source NS1
tracks->get(SourceNS1)->addTargetTracks(tracks->get(LinkWE),8);
tracks->get(SourceNS1)->addTargetTracks(tracks->get(SinkEW),1);
tracks->get(SourceNS1)->addTargetTracks(tracks->get(SinkNS1),1);
semaphores->addTrack(tracks->get(SourceNS1),DIRNS);
// Source SN1
tracks->get(SourceSN1)->addTargetTracks(tracks->get(LinkWE),8);
tracks->get(SourceSN1)->addTargetTracks(tracks->get(SinkSN1),1);
tracks->get(SourceSN1)->addTargetTracks(tracks->get(SinkEW),1);
semaphores->addTrack(tracks->get(SourceSN1),DIRSN);
// Link EW
tracks->get(LinkEW)->addTargetTracks(tracks->get(SinkEW),4);
tracks->get(LinkEW)->addTargetTracks(tracks->get(SinkNS1),3);
tracks->get(LinkEW)->addTargetTracks(tracks->get(SinkSN1),3);
semaphores->addTrack(tracks->get(LinkEW),DIREW);
// Link WE
tracks->get(LinkWE)->addTargetTracks(tracks->get(SinkWE),4);
tracks->get(LinkWE)->addTargetTracks(tracks->get(SinkNS2),3);
tracks->get(LinkWE)->addTargetTracks(tracks->get(SinkSN2),3);
semaphores->addTrack(tracks->get(LinkWE),DIRWE);
// Source NS2
tracks->get(SourceNS2)->addTargetTracks(tracks->get(SinkWE),4);
tracks->get(SourceNS2)->addTargetTracks(tracks->get(LinkEW),3);
tracks->get(SourceNS2)->addTargetTracks(tracks->get(SinkSN2),3);
semaphores->addTrack(tracks->get(SourceNS2),DIRNS);
// Source SN2
tracks->get(SourceSN2)->addTargetTracks(tracks->get(SinkWE),4);
tracks->get(SourceSN2)->addTargetTracks(tracks->get(LinkEW),3);
tracks->get(SourceSN2)->addTargetTracks(tracks->get(SinkNS2),3);
semaphores->addTrack(tracks->get(SourceSN2),DIRSN);
// Source EW
tracks->get(SourceEW)->addTargetTracks(tracks->get(LinkEW),3);
tracks->get(SourceEW)->addTargetTracks(tracks->get(SinkNS2),3);
tracks->get(SourceEW)->addTargetTracks(tracks->get(SinkSN2),4);
semaphores->addTrack(tracks->get(SourceEW),DIREW);
println("Starting main loop");
while (true) {
if (events->empty())
return -1;
runningEvt = events->remove(0);
if (runningEvt->getTime() > simulationTime) {
break;
}
runningEvt->handleEvent(); // Event suicide here runningEvt == NULL
}
for (int i = 0; !tracks->empty(); i++){
//.........这里部分代码省略.........
示例2: assert
void ArenasScreen::buildTrackList()
{
DynamicRibbonWidget* w = this->getWidget<DynamicRibbonWidget>("tracks");
assert( w != NULL );
// Re-build track list everytime (accounts for locking changes, etc.)
w->clearItems();
RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups");
assert( tabs != NULL );
const std::string curr_group_name = tabs->getSelectionIDString(0);
bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER;
if (curr_group_name == ALL_ARENA_GROUPS_ID)
{
const int trackAmount = track_manager->getNumberOfTracks();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack(n);
if (soccer_mode)
{
if(!curr->isSoccer()) continue;
}
else
{
if(!curr->isArena()) continue;
}
if (unlock_manager->getCurrentSlot()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( curr->getName(), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
else
{
const std::vector<int>& currArenas = track_manager->getArenasInGroup(curr_group_name, soccer_mode);
const int trackAmount = currArenas.size();
for (int n=0; n<trackAmount; n++)
{
Track* curr = track_manager->getTrack(currArenas[n]);
if (soccer_mode)
{
if(!curr->isSoccer()) continue;
}
else
{
if(!curr->isArena()) continue;
}
if (unlock_manager->getCurrentSlot()->isLocked(curr->getIdent()))
{
w->addItem( _("Locked : solve active challenges to gain access to more!"),
"locked", curr->getScreenshotFile(), LOCKED_BADGE );
}
else
{
w->addItem( curr->getName(), curr->getIdent(), curr->getScreenshotFile(), 0,
IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE );
}
}
}
w->addItem(_("Random Arena"), "random_track", "/gui/track_random.png");
w->updateItemDisplay();
assert(w->getItems().size() > 0);
}
示例3: compressTexture
void IrrDriver::renderGLSL(float dt)
{
BoundingBoxes.clear();
World *world = World::getWorld(); // Never NULL.
Track *track = world->getTrack();
for (unsigned i = 0; i < PowerupManager::POWERUP_MAX; i++)
{
scene::IMesh *mesh = powerup_manager->m_all_meshes[i];
if (!mesh)
continue;
for (unsigned j = 0; j < mesh->getMeshBufferCount(); j++)
{
scene::IMeshBuffer *mb = mesh->getMeshBuffer(j);
if (!mb)
continue;
for (unsigned k = 0; k < 4; k++)
{
video::ITexture *tex = mb->getMaterial().getTexture(k);
if (!tex)
continue;
compressTexture(tex, true);
}
}
}
// Overrides
video::SOverrideMaterial &overridemat = m_video_driver->getOverrideMaterial();
overridemat.EnablePasses = scene::ESNRP_SOLID | scene::ESNRP_TRANSPARENT;
overridemat.EnableFlags = 0;
if (m_wireframe)
{
overridemat.Material.Wireframe = 1;
overridemat.EnableFlags |= video::EMF_WIREFRAME;
}
if (m_mipviz)
{
overridemat.Material.MaterialType = m_shaders->getShader(ES_MIPVIZ);
overridemat.EnableFlags |= video::EMF_MATERIAL_TYPE;
overridemat.EnablePasses = scene::ESNRP_SOLID;
}
// Get a list of all glowing things. The driver's list contains the static ones,
// here we add items, as they may disappear each frame.
std::vector<GlowData> glows = m_glowing;
ItemManager * const items = ItemManager::get();
const u32 itemcount = items->getNumberOfItems();
u32 i;
for (i = 0; i < itemcount; i++)
{
Item * const item = items->getItem(i);
if (!item) continue;
const Item::ItemType type = item->getType();
if (type != Item::ITEM_NITRO_BIG && type != Item::ITEM_NITRO_SMALL &&
type != Item::ITEM_BONUS_BOX && type != Item::ITEM_BANANA && type != Item::ITEM_BUBBLEGUM)
continue;
LODNode * const lod = (LODNode *) item->getSceneNode();
if (!lod->isVisible()) continue;
const int level = lod->getLevel();
if (level < 0) continue;
scene::ISceneNode * const node = lod->getAllNodes()[level];
node->updateAbsolutePosition();
GlowData dat;
dat.node = node;
dat.r = 1.0f;
dat.g = 1.0f;
dat.b = 1.0f;
const video::SColorf &c = ItemManager::getGlowColor(type);
dat.r = c.getRed();
dat.g = c.getGreen();
dat.b = c.getBlue();
glows.push_back(dat);
}
// Start the RTT for post-processing.
// We do this before beginScene() because we want to capture the glClear()
// because of tracks that do not have skyboxes (generally add-on tracks)
m_post_processing->begin();
RaceGUIBase *rg = world->getRaceGUI();
if (rg) rg->update(dt);
if (!UserConfigParams::m_dynamic_lights)
{
SColor clearColor(0, 150, 150, 150);
if (World::getWorld() != NULL)
clearColor = World::getWorld()->getClearColor();
//.........这里部分代码省略.........
示例4: main
int
main()
{
// setup random number generator
gRandomGenerator = gsl_rng_alloc(gsl_rng_taus);
gsl_rng_set (gRandomGenerator, 0.0);
// created a rapidity cut named "eta", which returns true if the passed track has a
// pseudo-rapidity greater than 0.1
Cut c0("eta", new eta_greator(0.1));
// add some other cuts acting on different ranges
c0.AddCut("zab>2", new eta_greator(2.0))(new eta_greator(5.0))(new eta_greator(8.0));
// Create a pt cut
Cut pt_cut("pt>3", new pt_greator(3.0));
// Create a pt cut
Cut pt_cut("pt>3.0", new pt_greator(3.0));
// add some more cuts to the pt-cut group
// (Cut::AddCut returns an inserter with operator() which
// continues to insert if given a name + function pair)
pt_cut.AddCut("pt>4.0", new pt_greator(4.0))
("pt>6.0", new pt_greator(6.0))
("pt>2.0", new pt_greator(2.0))
("pt>1.0", new pt_greator(1.0));
// create a cutlist
CutList cuts;
cuts.AddCut(pt_cut);
// cuts.AddAction("eta", add_to_histogram_eta_1);
// cuts.AddAction("pt>3 zab>2", add_to_histogram_1);
// cuts.AddAction("pt>3 eta", add_to_histogram_4);
cuts.AddAction("pt>3.0", action_pt_3_0);
cuts.AddAction("pt>4.0", action_pt_4_0);
cuts.AddAction("pt>1.0", action_pt_1_0);
cuts.AddAction("pt>2.0", action_pt_2_0);
cuts.AddAction("pt>6.0", action_pt_6_0);
cuts.AddAction("pt>4.0 pt>2.0", action_pt_4_AND_2);
// cuts.Print();
// generate a random cut
Track track = Generate();
track.print();
std::cout << "Testing Random : " << cuts.Run(track) << std::endl;
for (int i = 0; i < 50; i++) {
Track t = Generate();
// std::cout << "Mass : " << t.m << std::endl;
cuts.Run(t);
}
// std::cout << c0.Run(1.0f) << ' ' << c0.Run(9.0f) << std::endl;
puts("");
std::cout << "Pt > 1.0 Count : " << pt_1_count << std::endl
<< "Pt > 2.0 Count : " << pt_2_count << std::endl
<< "Pt > 3.0 Count : " << pt_3_count << std::endl
<< "Pt > 4.0 Count : " << pt_4_count << std::endl
<< "Pt > 6.0 Count : " << pt_6_count << std::endl;
std::cout << "It works!" << std::endl;
return 0;
}
示例5: double
bool EffectTruncSilence::DoRemoval
(const RegionList &silences, unsigned iGroup, unsigned nGroups, Track *firstTrack, Track *lastTrack,
double &totalCutLen)
{
//
// Now remove the silent regions from all selected / sync-lock selected tracks.
//
// Loop over detected regions in reverse (so cuts don't change time values
// down the line)
int whichReg = 0;
RegionList::const_reverse_iterator rit;
for (rit = silences.rbegin(); rit != silences.rend(); ++rit)
{
const Region ®ion = *rit;
const Region *const r = ®ion;
// Progress dialog and cancellation. Do additional cleanup before return.
const double frac = detectFrac +
(1 - detectFrac) * (iGroup + whichReg / double(silences.size())) / nGroups;
if (TotalProgress(frac))
{
ReplaceProcessedTracks(false);
return false;
}
// Intersection may create regions smaller than allowed; ignore them.
// Allow one nanosecond extra for consistent results with exact milliseconds of allowed silence.
if ((r->end - r->start) < (mInitialAllowedSilence - 0.000000001))
continue;
// Find NEW silence length as requested
double inLength = r->end - r->start;
double outLength;
switch (mActionIndex)
{
case kTruncate:
outLength = std::min(mTruncLongestAllowedSilence, inLength);
break;
case kCompress:
outLength = mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0;
break;
default: // Not currently used.
outLength = std::min(mInitialAllowedSilence +
(inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0,
mTruncLongestAllowedSilence);
}
double cutLen = inLength - outLength;
totalCutLen += cutLen;
TrackListIterator iterOut(mOutputTracks.get());
bool lastSeen = false;
for (Track *t = iterOut.StartWith(firstTrack); t && !lastSeen; t = iterOut.Next())
{
lastSeen = (t == lastTrack);
if (!(t->GetSelected() || t->IsSyncLockSelected()))
continue;
// Don't waste time past the end of a track
if (t->GetEndTime() < r->start)
continue;
double cutStart = (r->start + r->end - cutLen) / 2;
double cutEnd = cutStart + cutLen;
if (t->GetKind() == Track::Wave)
{
// In WaveTracks, clear with a cross-fade
WaveTrack *const wt = static_cast<WaveTrack*>(t);
auto blendFrames = mBlendFrameCount;
// Round start/end times to frame boundaries
cutStart = wt->LongSamplesToTime(wt->TimeToLongSamples(cutStart));
cutEnd = wt->LongSamplesToTime(wt->TimeToLongSamples(cutEnd));
// Make sure the cross-fade does not affect non-silent frames
if (wt->LongSamplesToTime(blendFrames) > inLength)
{
// Result is not more than blendFrames:
blendFrames = wt->TimeToLongSamples(inLength).as_size_t();
}
// Perform cross-fade in memory
Floats buf1{ blendFrames };
Floats buf2{ blendFrames };
auto t1 = wt->TimeToLongSamples(cutStart) - blendFrames / 2;
auto t2 = wt->TimeToLongSamples(cutEnd) - blendFrames / 2;
wt->Get((samplePtr)buf1.get(), floatSample, t1, blendFrames);
wt->Get((samplePtr)buf2.get(), floatSample, t2, blendFrames);
for (decltype(blendFrames) i = 0; i < blendFrames; ++i)
{
buf1[i] = ((blendFrames-i) * buf1[i] + i * buf2[i]) /
(double)blendFrames;
}
// Perform the cut
wt->Clear(cutStart, cutEnd);
//.........这里部分代码省略.........
示例6: DB_TO_LINEAR
bool EffectAutoDuck::Process()
{
sampleCount i;
if (GetNumWaveTracks() == 0 || !mControlTrack)
return false;
bool cancel = false;
sampleCount start =
mControlTrack->TimeToLongSamples(mT0 + mOuterFadeDownLen);
sampleCount end =
mControlTrack->TimeToLongSamples(mT1 - mOuterFadeUpLen);
if (end <= start)
return false;
// the minimum number of samples we have to wait until the maximum
// pause has been exceeded
double maxPause = mMaximumPause;
// We don't fade in until we have time enough to actually fade out again
if (maxPause < mOuterFadeDownLen + mOuterFadeUpLen)
maxPause = mOuterFadeDownLen + mOuterFadeUpLen;
sampleCount minSamplesPause =
mControlTrack->TimeToLongSamples(maxPause);
double threshold = DB_TO_LINEAR(mThresholdDb);
// adjust the threshold so we can compare it to the rmsSum value
threshold = threshold * threshold * kRMSWindowSize;
int rmsPos = 0;
float rmsSum = 0;
float *rmsWindow = new float[kRMSWindowSize];
for (i = 0; i < kRMSWindowSize; i++)
rmsWindow[i] = 0;
float *buf = new float[kBufSize];
bool inDuckRegion = false;
// initialize the following two variables to prevent compiler warning
double duckRegionStart = 0;
sampleCount curSamplesPause = 0;
// to make the progress bar appear more natural, we first look for all
// duck regions and apply them all at once afterwards
AutoDuckRegionArray regions;
sampleCount pos = start;
while (pos < end)
{
sampleCount len = end - pos;
if (len > kBufSize)
len = kBufSize;
mControlTrack->Get((samplePtr)buf, floatSample, pos, (sampleCount)len);
for (i = pos; i < pos + len; i++)
{
rmsSum -= rmsWindow[rmsPos];
rmsWindow[rmsPos] = buf[i - pos] * buf[i - pos];
rmsSum += rmsWindow[rmsPos];
rmsPos = (rmsPos + 1) % kRMSWindowSize;
bool thresholdExceeded = rmsSum > threshold;
if (thresholdExceeded)
{
// everytime the threshold is exceeded, reset our count for
// the number of pause samples
curSamplesPause = 0;
if (!inDuckRegion)
{
// the threshold has been exceeded for the first time, so
// let the duck region begin here
inDuckRegion = true;
duckRegionStart = mControlTrack->LongSamplesToTime(i);
}
}
if (!thresholdExceeded && inDuckRegion)
{
// the threshold has not been exceeded and we are in a duck
// region, but only fade in if the maximum pause has been
// exceeded
curSamplesPause += 1;
if (curSamplesPause >= minSamplesPause)
{
// do the actual duck fade and reset all values
double duckRegionEnd =
mControlTrack->LongSamplesToTime(i - curSamplesPause);
regions.Add(AutoDuckRegion(
duckRegionStart - mOuterFadeDownLen,
duckRegionEnd + mOuterFadeUpLen));
//.........这里部分代码省略.........
示例7: add_to_histogram_1
void
add_to_histogram_1(const Track& track) {
std::cout << "Adding track with pt : " << track.pt() << std::endl;
}
示例8: float
float ContrastDialog::GetDB()
{
// FIXME: what if more than one track?
float rms = float(0.0);
AudacityProject *p = GetActiveProject();
TrackListOfKindIterator iter(Track::Wave, p->GetTracks());
Track *t = iter.First();
if(mT0 > mT1)
{
wxMessageDialog m(NULL, _("Start time after end time!\nPlease enter reasonable times."), _("Error"), wxOK);
m.ShowModal();
return 1234.0; // 'magic number', but the whole +ve dB range will 'almost' never occur
}
if(mT0 < t->GetStartTime())
mT0 = t->GetStartTime();
if(mT1 > t->GetEndTime())
mT1 = t->GetEndTime();
if(mT0 > mT1)
{
wxMessageDialog m(NULL, _("Times are not reasonable!\nPlease enter reasonable times."), _("Error"), wxOK);
m.ShowModal();
return 1234.0;
}
if(mT0 == mT1)
{
wxMessageDialog m(NULL, _("Nothing to measure.\nPlease select a section of a track."), _("Error"), wxOK);
m.ShowModal();
return 1234.0;
}
bool mSelected = false;
while(t) {
if( ((WaveTrack *)t)->GetSelected() )
{
if( mSelected == true ) // already measured one track
{
wxMessageDialog m(NULL, _("You can only measure one track at a time."), _("Error"), wxOK);
m.ShowModal();
return 1234.0;
}
else
{
((WaveTrack *)t)->GetRMS(&rms, mT0, mT1);
mSelected = true;
}
}
t = iter.Next();
}
if( mSelected )
{
if( rms < 1.0E-30 )
return -60.0;
return 20.0*log10(rms);
}
else
{
wxMessageDialog m(NULL, _("Please select something to be measured."), _("Error"), wxOK);
m.ShowModal();
return 1234.0;
}
}
示例9: iter
bool EffectTruncSilence::Process()
{
// Typical fraction of total time taken by detection (better to guess low)
const double detectFrac = .4;
// Copy tracks
this->CopyInputTracks(Track::All);
// Lower bound on the amount of silence to find at a time -- this avoids
// detecting silence repeatedly in low-frequency sounds.
const double minTruncMs = 0.001;
double truncDbSilenceThreshold = Enums::Db2Signal[mTruncDbChoiceIndex];
// Master list of silent regions; it is responsible for deleting them.
// This list should always be kept in order.
RegionList silences;
silences.DeleteContents(true);
// Start with the whole selection silent
Region *sel = new Region;
sel->start = mT0;
sel->end = mT1;
silences.push_back(sel);
// Remove non-silent regions in each track
SelectedTrackListOfKindIterator iter(Track::Wave, mTracks);
int whichTrack = 0;
for (Track *t = iter.First(); t; t = iter.Next())
{
WaveTrack *wt = (WaveTrack *)t;
// Smallest silent region to detect in frames
sampleCount minSilenceFrames =
sampleCount(wxMax( mInitialAllowedSilence, minTruncMs) *
wt->GetRate());
//
// Scan the track for silences
//
RegionList trackSilences;
trackSilences.DeleteContents(true);
sampleCount blockLen = wt->GetMaxBlockSize();
sampleCount start = wt->TimeToLongSamples(mT0);
sampleCount end = wt->TimeToLongSamples(mT1);
// Allocate buffer
float *buffer = new float[blockLen];
sampleCount index = start;
sampleCount silentFrames = 0;
bool cancelled = false;
// Keep position in overall silences list for optimization
RegionList::iterator rit(silences.begin());
while (index < end) {
// Show progress dialog, test for cancellation
cancelled = TotalProgress(
detectFrac * (whichTrack + index / (double)end) /
(double)GetNumWaveTracks());
if (cancelled)
break;
//
// Optimization: if not in a silent region skip ahead to the next one
//
double curTime = wt->LongSamplesToTime(index);
for ( ; rit != silences.end(); ++rit)
{
// Find the first silent region ending after current time
if ((*rit)->end >= curTime)
break;
}
if (rit == silences.end()) {
// No more regions -- no need to process the rest of the track
break;
}
else if ((*rit)->start > curTime) {
// End current silent region, skip ahead
if (silentFrames >= minSilenceFrames) {
Region *r = new Region;
r->start = wt->LongSamplesToTime(index - silentFrames);
r->end = wt->LongSamplesToTime(index);
trackSilences.push_back(r);
}
silentFrames = 0;
index = wt->TimeToLongSamples((*rit)->start);
}
//
// End of optimization
//
// Limit size of current block if we've reached the end
sampleCount count = blockLen;
if ((index + count) > end) {
count = end - index;
}
//.........这里部分代码省略.........
示例10: min
double StretchHandle::GetT1(const Track &track, const ViewInfo &viewInfo)
{
return std::min(track.GetEndTime(), viewInfo.selectedRegion.t1());
}
示例11: sbsms_init
bool EffectSBSMS::Process()
{
if(!bInit) {
sbsms_init(4096);
bInit = TRUE;
}
bool bGoodResult = true;
//Iterate over each track
//Track::All is needed because this effect needs to introduce silence in the group tracks to keep sync
this->CopyInputTracks(Track::All); // Set up mOutputTracks.
TrackListIterator iter(mOutputTracks);
Track* t;
mCurTrackNum = 0;
double maxDuration = 0.0;
if(rateStart == rateEnd)
mTotalStretch = 1.0/rateStart;
else
mTotalStretch = 1.0/(rateEnd-rateStart)*log(rateEnd/rateStart);
// Must sync if selection length will change
bool mustSync = (mTotalStretch != 1.0);
t = iter.First();
while (t != NULL) {
if (t->GetKind() == Track::Label &&
(t->GetSelected() || (mustSync && t->IsSynchroSelected())) )
{
if (!ProcessLabelTrack(t)) {
bGoodResult = false;
break;
}
}
else if (t->GetKind() == Track::Wave && t->GetSelected() )
{
WaveTrack* leftTrack = (WaveTrack*)t;
//Get start and end times from track
mCurT0 = leftTrack->GetStartTime();
mCurT1 = leftTrack->GetEndTime();
//Set the current bounds to whichever left marker is
//greater and whichever right marker is less
mCurT0 = wxMax(mT0, mCurT0);
mCurT1 = wxMin(mT1, mCurT1);
// Process only if the right marker is to the right of the left marker
if (mCurT1 > mCurT0) {
sampleCount start;
sampleCount end;
start = leftTrack->TimeToLongSamples(mCurT0);
end = leftTrack->TimeToLongSamples(mCurT1);
WaveTrack* rightTrack = NULL;
if (leftTrack->GetLinked()) {
double t;
rightTrack = (WaveTrack*)(iter.Next());
//Adjust bounds by the right tracks markers
t = rightTrack->GetStartTime();
t = wxMax(mT0, t);
mCurT0 = wxMin(mCurT0, t);
t = rightTrack->GetEndTime();
t = wxMin(mT1, t);
mCurT1 = wxMax(mCurT1, t);
//Transform the marker timepoints to samples
start = leftTrack->TimeToLongSamples(mCurT0);
end = leftTrack->TimeToLongSamples(mCurT1);
mCurTrackNum++; // Increment for rightTrack, too.
}
sampleCount trackEnd = leftTrack->TimeToLongSamples(leftTrack->GetEndTime());
// SBSMS has a fixed sample rate - we just convert to its sample rate and then convert back
float srIn = leftTrack->GetRate();
float srSBSMS = 44100.0;
// the resampler needs a callback to supply its samples
resampleBuf rb;
sampleCount maxBlockSize = leftTrack->GetMaxBlockSize();
rb.block = maxBlockSize;
rb.buf = (audio*)calloc(rb.block,sizeof(audio));
rb.leftTrack = leftTrack;
rb.rightTrack = rightTrack?rightTrack:leftTrack;
rb.leftBuffer = (float*)calloc(maxBlockSize,sizeof(float));
rb.rightBuffer = (float*)calloc(maxBlockSize,sizeof(float));
rb.offset = start;
rb.end = trackEnd;
rb.ratio = srSBSMS/srIn;
rb.resampler = new Resampler(resampleCB, &rb);
// Samples in selection
sampleCount samplesIn = end-start;
// Samples for SBSMS to process after resampling
//.........这里部分代码省略.........
示例12: max
double StretchHandle::GetT0(const Track &track, const ViewInfo &viewInfo)
{
return std::max(track.GetStartTime(), viewInfo.selectedRegion.t0());
}
示例13: AnalyseEvents
void AnalyseEvents(ExRootTreeReader *treeReader, TestPlots *plots)
{
TClonesArray *branchParticle = treeReader->UseBranch("Particle");
TClonesArray *branchOriginalTrack = treeReader->UseBranch("OriginalTrack");
TClonesArray *branchTrack = treeReader->UseBranch("Track");
Long64_t allEntries = treeReader->GetEntries();
cout << "** Chain contains " << allEntries << " events" << endl;
TLorentzVector momentum;
Bool_t skip;
Long64_t entry;
Int_t i, j, pdgCode;
// Loop over all events
for(entry = 0; entry < 3; ++entry)
{
// Load selected branches with data from specified event
treeReader->ReadEntry(entry);
cout << "Event "<< entry << endl;
// Loop over all tracks in event
for(i = 0; i < branchTrack->GetEntriesFast(); ++i)
{
Track* track = (Track*) branchTrack->At(i);
Track* particle = (Track*) track->Particle.GetObject();
float eta= TMath::Log( TMath::Tan(particle->trkPar[3]/2));
float pt = particle->Charge/(particle->trkPar[4]*cosh(eta));
plots->fOldTrackD0 ->Fill(particle->trkPar[0]);
plots->fOldTrackZ0 ->Fill(particle->trkPar[1]);
plots->fOldTrackPhi->Fill(particle->trkPar[2]);
plots->fOldTrackEta->Fill(eta);
plots->fOldTrackPt ->Fill(pt);
float d0Err = TMath::Sqrt(track->trkCov[0]);
plots->fTrackD0Sig ->Fill(track->trkPar[0]/d0Err);
plots->fTrackD0 ->Fill(track->trkPar[0]);
plots->fTrackZ0 ->Fill(track->trkPar[1]);
plots->fTrackPhi->Fill(track->trkPar[2]);
plots->fTrackEta->Fill(track->P4().Eta());
plots->fTrackPt ->Fill(track->P4().Pt());
plots->fTrackDeltaD0vsEta->Fill( track->P4().Eta(), track->trkPar[0]-particle->trkPar[0]);
plots->fTrackDeltaZ0vsEta->Fill( track->P4().Eta(), track->trkPar[1]-particle->trkPar[1]);
plots->fTrackDeltaPhivsEta->Fill( track->P4().Eta(), track->trkPar[2]-particle->trkPar[2]);
plots->fTrackDeltaThetavsEta->Fill( track->P4().Eta(), track->trkPar[3]-particle->trkPar[3]);
plots->fTrackDeltaPtvsEta->Fill( track->P4().Eta(), (track->P4().Pt()-particle->P4().Pt())/ particle->P4().Pt());
}
// cout << "-- New event -- " << endl;
}
}
示例14: WXUNUSED
UIHandle::Result TrackPanelResizeHandle::Drag
(const TrackPanelMouseEvent &evt, AudacityProject *pProject)
{
auto pTrack = pProject->GetTracks()->Lock(mpTrack);
if ( !pTrack )
return RefreshCode::Cancelled;
const wxMouseEvent &event = evt.event;
TrackList *const tracks = pProject->GetTracks();
int delta = (event.m_y - mMouseClickY);
// On first drag, jump out of minimized mode. Initial height
// will be height of minimized track.
//
// This used to be in HandleResizeClick(), but simply clicking
// on a resize border would switch the minimized state.
if (pTrack->GetMinimized()) {
Track *link = pTrack->GetLink();
pTrack->SetHeight(pTrack->GetHeight());
pTrack->SetMinimized(false);
if (link) {
link->SetHeight(link->GetHeight());
link->SetMinimized(false);
// Initial values must be reset since they weren't based on the
// minimized heights.
mInitialUpperTrackHeight = link->GetHeight();
mInitialTrackHeight = pTrack->GetHeight();
}
}
// Common pieces of code for MONO_WAVE_PAN and otherwise.
auto doResizeBelow = [&] (Track *prev, bool WXUNUSED(vStereo)) {
double proportion = static_cast < double >(mInitialTrackHeight)
/ (mInitialTrackHeight + mInitialUpperTrackHeight);
int newTrackHeight = static_cast < int >
(mInitialTrackHeight + delta * proportion);
int newUpperTrackHeight = static_cast < int >
(mInitialUpperTrackHeight + delta * (1.0 - proportion));
//make sure neither track is smaller than its minimum height
if (newTrackHeight < pTrack->GetMinimizedHeight())
newTrackHeight = pTrack->GetMinimizedHeight();
if (newUpperTrackHeight < prev->GetMinimizedHeight())
newUpperTrackHeight = prev->GetMinimizedHeight();
pTrack->SetHeight(newTrackHeight);
prev->SetHeight(newUpperTrackHeight);
};
auto doResizeBetween = [&] (Track *next, bool WXUNUSED(vStereo)) {
int newUpperTrackHeight = mInitialUpperTrackHeight + delta;
int newTrackHeight = mInitialTrackHeight - delta;
// make sure neither track is smaller than its minimum height
if (newTrackHeight < next->GetMinimizedHeight()) {
newTrackHeight = next->GetMinimizedHeight();
newUpperTrackHeight =
mInitialUpperTrackHeight + mInitialTrackHeight - next->GetMinimizedHeight();
}
if (newUpperTrackHeight < pTrack->GetMinimizedHeight()) {
newUpperTrackHeight = pTrack->GetMinimizedHeight();
newTrackHeight =
mInitialUpperTrackHeight + mInitialTrackHeight - pTrack->GetMinimizedHeight();
}
pTrack->SetHeight(newUpperTrackHeight);
next->SetHeight(newTrackHeight);
};
auto doResize = [&] {
int newTrackHeight = mInitialTrackHeight + delta;
if (newTrackHeight < pTrack->GetMinimizedHeight())
newTrackHeight = pTrack->GetMinimizedHeight();
pTrack->SetHeight(newTrackHeight);
};
//STM: We may be dragging one or two (stereo) tracks.
// If two, resize proportionally if we are dragging the lower track, and
// adjust compensatively if we are dragging the upper track.
switch( mMode )
{
case IsResizingBelowLinkedTracks:
{
Track *prev = tracks->GetPrev(pTrack.get());
doResizeBelow(prev, false);
break;
}
case IsResizingBetweenLinkedTracks:
{
Track *next = tracks->GetNext(pTrack.get());
doResizeBetween(next, false);
break;
}
case IsResizing:
//.........这里部分代码省略.........
示例15: iter
bool EffectSBSMS::Process()
{
bool bGoodResult = true;
//Iterate over each track
//Track::All is needed because this effect needs to introduce silence in the group tracks to keep sync
this->CopyInputTracks(Track::All); // Set up mOutputTracks.
TrackListIterator iter(mOutputTracks);
Track* t;
mCurTrackNum = 0;
double maxDuration = 0.0;
// Must sync if selection length will change
bool mustSync = (rateStart != rateEnd);
Slide rateSlide(rateSlideType,rateStart,rateEnd);
Slide pitchSlide(pitchSlideType,pitchStart,pitchEnd);
mTotalStretch = rateSlide.getTotalStretch();
t = iter.First();
while (t != NULL) {
if (t->GetKind() == Track::Label &&
(t->GetSelected() || (mustSync && t->IsSyncLockSelected())) )
{
if (!ProcessLabelTrack(t)) {
bGoodResult = false;
break;
}
}
else if (t->GetKind() == Track::Wave && t->GetSelected() )
{
WaveTrack* leftTrack = (WaveTrack*)t;
//Get start and end times from track
mCurT0 = leftTrack->GetStartTime();
mCurT1 = leftTrack->GetEndTime();
//Set the current bounds to whichever left marker is
//greater and whichever right marker is less
mCurT0 = wxMax(mT0, mCurT0);
mCurT1 = wxMin(mT1, mCurT1);
// Process only if the right marker is to the right of the left marker
if (mCurT1 > mCurT0) {
sampleCount start;
sampleCount end;
start = leftTrack->TimeToLongSamples(mCurT0);
end = leftTrack->TimeToLongSamples(mCurT1);
WaveTrack* rightTrack = NULL;
if (leftTrack->GetLinked()) {
double t;
rightTrack = (WaveTrack*)(iter.Next());
//Adjust bounds by the right tracks markers
t = rightTrack->GetStartTime();
t = wxMax(mT0, t);
mCurT0 = wxMin(mCurT0, t);
t = rightTrack->GetEndTime();
t = wxMin(mT1, t);
mCurT1 = wxMax(mCurT1, t);
//Transform the marker timepoints to samples
start = leftTrack->TimeToLongSamples(mCurT0);
end = leftTrack->TimeToLongSamples(mCurT1);
mCurTrackNum++; // Increment for rightTrack, too.
}
sampleCount trackStart = leftTrack->TimeToLongSamples(leftTrack->GetStartTime());
sampleCount trackEnd = leftTrack->TimeToLongSamples(leftTrack->GetEndTime());
// SBSMS has a fixed sample rate - we just convert to its sample rate and then convert back
float srTrack = leftTrack->GetRate();
float srProcess = bLinkRatePitch?srTrack:44100.0;
// the resampler needs a callback to supply its samples
ResampleBuf rb;
sampleCount maxBlockSize = leftTrack->GetMaxBlockSize();
rb.blockSize = maxBlockSize;
rb.buf = (audio*)calloc(rb.blockSize,sizeof(audio));
rb.leftTrack = leftTrack;
rb.rightTrack = rightTrack?rightTrack:leftTrack;
rb.leftBuffer = (float*)calloc(maxBlockSize,sizeof(float));
rb.rightBuffer = (float*)calloc(maxBlockSize,sizeof(float));
// Samples in selection
sampleCount samplesIn = end-start;
// Samples for SBSMS to process after resampling
sampleCount samplesToProcess = (sampleCount) ((float)samplesIn*(srProcess/srTrack));
SlideType outSlideType;
SBSMSResampleCB outResampleCB;
sampleCount processPresamples = 0;
sampleCount trackPresamples = 0;
if(bLinkRatePitch) {
rb.bPitch = true;
outSlideType = rateSlideType;
//.........这里部分代码省略.........