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++){ Track *rdT; rdT = tracks->remove(0); std::cout << "Pista " << tracksNames[i] << "; Entraram " << rdT->getCarsIn() << " carros e sairam " << rdT->getCarsOut() << " carros" << std::endl; std::cout << "\\____Restaram " << rdT->getCarsIn() - rdT->getCarsOut() << " carros" << std::endl; delete rdT; } while (!tracks->empty()) delete tracks->remove(0); delete events; delete semaphores; return 0; }
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); }
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(); glClear(GL_COLOR_BUFFER_BIT); glDepthMask(GL_TRUE); glBindFramebuffer(GL_FRAMEBUFFER, 0); glClearColor(clearColor.getRed() / 255.f, clearColor.getGreen() / 255.f, clearColor.getBlue() / 255.f, clearColor.getAlpha() / 255.f); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); } for(unsigned int cam = 0; cam < Camera::getNumCameras(); cam++) { Camera * const camera = Camera::getCamera(cam); scene::ICameraSceneNode * const camnode = camera->getCameraSceneNode(); std::ostringstream oss; oss << "drawAll() for kart " << cam; PROFILER_PUSH_CPU_MARKER(oss.str().c_str(), (cam+1)*60, 0x00, 0x00); camera->activate(!UserConfigParams::m_dynamic_lights); rg->preRenderCallback(camera); // adjusts start referee m_scene_manager->setActiveCamera(camnode); const core::recti &viewport = camera->getViewport(); if (World::getWorld() && World::getWorld()->getTrack()->hasShadows() && !SphericalHarmonicsTextures.empty()) irr_driver->getSceneManager()->setAmbientLight(SColor(0, 0, 0, 0)); // TODO: put this outside of the rendering loop generateDiffuseCoefficients(); if (!UserConfigParams::m_dynamic_lights) glEnable(GL_FRAMEBUFFER_SRGB); PROFILER_PUSH_CPU_MARKER("Update Light Info", 0xFF, 0x0, 0x0); unsigned plc = UpdateLightsInfo(camnode, dt); PROFILER_POP_CPU_MARKER(); PROFILER_PUSH_CPU_MARKER("Compute camera matrix", 0x0, 0xFF, 0x0); computeCameraMatrix(camnode, viewport.LowerRightCorner.X - viewport.UpperLeftCorner.X, viewport.LowerRightCorner.Y - viewport.UpperLeftCorner.Y); PROFILER_POP_CPU_MARKER(); renderScene(camnode, plc, glows, dt, track->hasShadows(), false); // Render bounding boxes if (irr_driver->getBoundingBoxesViz()) { glUseProgram(UtilShader::ColoredLine::Program); glBindVertexArray(UtilShader::ColoredLine::vao); glBindBuffer(GL_ARRAY_BUFFER, UtilShader::ColoredLine::vbo); UtilShader::ColoredLine::setUniforms(SColor(255, 255, 0, 0)); const float *tmp = BoundingBoxes.data(); for (unsigned int i = 0; i < BoundingBoxes.size(); i += 1024 * 6) { unsigned count = MIN2((int)BoundingBoxes.size() - i, 1024 * 6); glBufferSubData(GL_ARRAY_BUFFER, 0, count * sizeof(float), &tmp[i]); glDrawArrays(GL_LINES, 0, count / 3); } } // Debug physic // Note that drawAll must be called before rendering // the bullet debug view, since otherwise the camera // is not set up properly. This is only used for // the bullet debug view. if (UserConfigParams::m_artist_debug_mode) World::getWorld()->getPhysics()->draw(); if (world != NULL && world->getPhysics() != NULL) { IrrDebugDrawer* debug_drawer = world->getPhysics()->getDebugDrawer(); if (debug_drawer != NULL && debug_drawer->debugEnabled()) { const std::map<video::SColor, std::vector<float> >& lines = debug_drawer->getLines(); std::map<video::SColor, std::vector<float> >::const_iterator it; glUseProgram(UtilShader::ColoredLine::Program); glBindVertexArray(UtilShader::ColoredLine::vao); glBindBuffer(GL_ARRAY_BUFFER, UtilShader::ColoredLine::vbo); for (it = lines.begin(); it != lines.end(); it++) { UtilShader::ColoredLine::setUniforms(it->first); const std::vector<float> &vertex = it->second; const float *tmp = vertex.data(); for (unsigned int i = 0; i < vertex.size(); i += 1024 * 6) { unsigned count = MIN2((int)vertex.size() - i, 1024 * 6); glBufferSubData(GL_ARRAY_BUFFER, 0, count * sizeof(float), &tmp[i]); glDrawArrays(GL_LINES, 0, count / 3); } } glUseProgram(0); glBindVertexArray(0); } } // Render the post-processed scene if (UserConfigParams::m_dynamic_lights) { bool isRace = StateManager::get()->getGameState() == GUIEngine::GAME; FrameBuffer *fbo = m_post_processing->render(camnode, isRace); if (irr_driver->getNormals()) irr_driver->getFBO(FBO_NORMAL_AND_DEPTHS).BlitToDefault(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y); else if (irr_driver->getSSAOViz()) { glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y); m_post_processing->renderPassThrough(m_rtts->getFBO(FBO_HALF1_R).getRTT()[0]); } else if (irr_driver->getRSM()) { glBindFramebuffer(GL_FRAMEBUFFER, 0); glViewport(viewport.UpperLeftCorner.X, viewport.UpperLeftCorner.Y, viewport.LowerRightCorner.X, viewport.LowerRightCorner.Y); m_post_processing->renderPassThrough(m_rtts->getRSM().getRTT()[0]); } else if (irr_driver->getShadowViz()) { renderShadowsDebug(); } else { glEnable(GL_FRAMEBUFFER_SRGB); glBindFramebuffer(GL_FRAMEBUFFER, 0); if (UserConfigParams::m_dynamic_lights) camera->activate(); m_post_processing->renderPassThrough(fbo->getRTT()[0]); glDisable(GL_FRAMEBUFFER_SRGB); } } PROFILER_POP_CPU_MARKER(); } // for i<world->getNumKarts() glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); glUseProgram(0); // Set the viewport back to the full screen for race gui m_video_driver->setViewPort(core::recti(0, 0, UserConfigParams::m_width, UserConfigParams::m_height)); for(unsigned int i=0; i<Camera::getNumCameras(); i++) { Camera *camera = Camera::getCamera(i); std::ostringstream oss; oss << "renderPlayerView() for kart " << i; PROFILER_PUSH_CPU_MARKER(oss.str().c_str(), 0x00, 0x00, (i+1)*60); rg->renderPlayerView(camera, dt); PROFILER_POP_CPU_MARKER(); } // for i<getNumKarts { ScopedGPUTimer Timer(getGPUTimer(Q_GUI)); PROFILER_PUSH_CPU_MARKER("GUIEngine", 0x75, 0x75, 0x75); // Either render the gui, or the global elements of the race gui. GUIEngine::render(dt); PROFILER_POP_CPU_MARKER(); } // Render the profiler if(UserConfigParams::m_profiler_enabled) { PROFILER_DRAW(); } #ifdef DEBUG drawDebugMeshes(); #endif PROFILER_PUSH_CPU_MARKER("EndSccene", 0x45, 0x75, 0x45); m_video_driver->endScene(); PROFILER_POP_CPU_MARKER(); getPostProcessing()->update(dt); }
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; }
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); // Write cross-faded data wt->Set((samplePtr)buf1.get(), floatSample, t1, blendFrames); } else // Non-wave tracks: just do a sync-lock adjust t->SyncLockAdjust(cutEnd, cutStart); } ++whichReg; } return true; }
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)); inDuckRegion = false; } } } pos += len; if (TotalProgress( ((double)(pos-start)) / (end-start) / (GetNumWaveTracks() + 1) )) { cancel = true; break; } } // apply last duck fade, if any if (inDuckRegion) { double duckRegionEnd = mControlTrack->LongSamplesToTime(end - curSamplesPause); regions.Add(AutoDuckRegion( duckRegionStart - mOuterFadeDownLen, duckRegionEnd + mOuterFadeUpLen)); } delete[] buf; delete[] rmsWindow; if (!cancel) { CopyInputTracks(); // Set up mOutputTracks. SelectedTrackListOfKindIterator iter(Track::Wave, mOutputTracks); Track *iterTrack = iter.First(); int trackNumber = 0; while (iterTrack) { wxASSERT(iterTrack->GetKind() == Track::Wave); WaveTrack* t = (WaveTrack*)iterTrack; for (i = 0; i < (int)regions.GetCount(); i++) { const AutoDuckRegion& region = regions[i]; if (ApplyDuckFade(trackNumber, t, region.t0, region.t1)) { cancel = true; break; } } if (cancel) break; iterTrack = iter.Next(); trackNumber++; } } ReplaceProcessedTracks(!cancel); return !cancel; }
void add_to_histogram_1(const Track& track) { std::cout << "Adding track with pt : " << track.pt() << std::endl; }
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; } }
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; } // Fill buffer wt->Get((samplePtr)(buffer), floatSample, index, count); // Look for silences in current block for (sampleCount i = 0; i < count; ++i) { if (fabs(buffer[i]) < truncDbSilenceThreshold) { ++silentFrames; } else { if (silentFrames >= minSilenceFrames) { // Record the silent region Region *r = new Region; r->start = wt->LongSamplesToTime(index + i - silentFrames); r->end = wt->LongSamplesToTime(index + i); trackSilences.push_back(r); } silentFrames = 0; } } // Next block index += count; } delete [] buffer; // Buffer has been freed, so we're OK to return if cancelled if (cancelled) { ReplaceProcessedTracks(false); return false; } if (silentFrames >= minSilenceFrames) { // Track ended in silence -- record region Region *r = new Region; r->start = wt->LongSamplesToTime(index - silentFrames); r->end = wt->LongSamplesToTime(index); trackSilences.push_back(r); } // Intersect with the overall silent region list Intersect(silences, trackSilences); whichTrack++; } // // 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::reverse_iterator rit; double totalCutLen = 0.0; // For cutting selection at the end for (rit = silences.rbegin(); rit != silences.rend(); ++rit) { Region *r = *rit; // Progress dialog and cancellation. Do additional cleanup before return. if (TotalProgress(detectFrac + (1 - detectFrac) * whichReg / (double)silences.size())) { 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 (mProcessIndex) { case 0: outLength = wxMin(mTruncLongestAllowedSilence, inLength); break; case 1: outLength = mInitialAllowedSilence + (inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0; break; default: // Not currently used. outLength = wxMin(mInitialAllowedSilence + (inLength - mInitialAllowedSilence) * mSilenceCompressPercent / 100.0, mTruncLongestAllowedSilence); } double cutLen = inLength - outLength; totalCutLen += cutLen; TrackListIterator iterOut(mOutputTracks); for (Track *t = iterOut.First(); t; t = iterOut.Next()) { // Don't waste time past the end of a track if (t->GetEndTime() < r->start) continue; if (t->GetKind() == Track::Wave && ( t->GetSelected() || t->IsSyncLockSelected())) { // In WaveTracks, clear with a cross-fade WaveTrack *wt = (WaveTrack *)t; sampleCount blendFrames = mBlendFrameCount; double cutStart = (r->start + r->end - cutLen) / 2; double cutEnd = cutStart + cutLen; // 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) { blendFrames = wt->TimeToLongSamples(inLength); } // Perform cross-fade in memory float *buf1 = new float[blendFrames]; float *buf2 = new float[blendFrames]; sampleCount t1 = wt->TimeToLongSamples(cutStart) - blendFrames / 2; sampleCount t2 = wt->TimeToLongSamples(cutEnd) - blendFrames / 2; wt->Get((samplePtr)buf1, floatSample, t1, blendFrames); wt->Get((samplePtr)buf2, floatSample, t2, blendFrames); for (sampleCount i = 0; i < blendFrames; ++i) { buf1[i] = ((blendFrames-i) * buf1[i] + i * buf2[i]) / (double)blendFrames; } // Perform the cut wt->Clear(cutStart, cutEnd); // Write cross-faded data wt->Set((samplePtr)buf1, floatSample, t1, blendFrames); delete [] buf1; delete [] buf2; } else if (t->GetSelected() || t->IsSyncLockSelected()) { // Non-wave tracks: just do a sync-lock adjust double cutStart = (r->start + r->end - cutLen) / 2; double cutEnd = cutStart + cutLen; t->SyncLockAdjust(cutEnd, cutStart); } } ++whichReg; } mT1 -= totalCutLen; ReplaceProcessedTracks(true); return true; }
double StretchHandle::GetT1(const Track &track, const ViewInfo &viewInfo) { return std::min(track.GetEndTime(), viewInfo.selectedRegion.t1()); }
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 sampleCount samplesToProcess = (sampleCount) ((real)samplesIn*(srSBSMS/srIn)); // Samples in output after resampling back sampleCount samplesToGenerate = (sampleCount) ((real)samplesToProcess * mTotalStretch); sampleCount samplesOut = (sampleCount) ((real)samplesIn * mTotalStretch); double duration = (mCurT1-mCurT0) * mTotalStretch; if(duration > maxDuration) maxDuration = duration; TimeWarper *warper = NULL; if (rateStart == rateEnd) { warper = new LinearTimeWarper(mCurT0, mCurT0, mCurT1, mCurT0+maxDuration); } else { warper = new LogarithmicTimeWarper(mCurT0, mCurT1, rateStart, rateEnd); } SetTimeWarper(warper); sbsmsInfo si; si.rs = rb.resampler; si.samplesToProcess = samplesToProcess; si.samplesToGenerate = samplesToGenerate; si.stretch0 = rateStart; si.stretch1 = rateEnd; si.ratio0 = pitchStart; si.ratio1 = pitchEnd; rb.sbsmser = sbsms_create(&samplesCB,&stretchCB,&ratioCB,rightTrack?2:1,quality,bPreAnalyze,true); rb.pitch = pitch_create(rb.sbsmser,&si,srIn/srSBSMS); rb.outputLeftTrack = mFactory->NewWaveTrack(leftTrack->GetSampleFormat(), leftTrack->GetRate()); if(rightTrack) rb.outputRightTrack = mFactory->NewWaveTrack(rightTrack->GetSampleFormat(), rightTrack->GetRate()); sampleCount blockSize = SBSMS_FRAME_SIZE[quality]; rb.outBuf = (audio*)calloc(blockSize,sizeof(audio)); rb.outputLeftBuffer = (float*)calloc(blockSize*2,sizeof(float)); if(rightTrack) rb.outputRightBuffer = (float*)calloc(blockSize*2,sizeof(float)); long pos = 0; long outputCount = -1; // pre analysis real fracPre = 0.0f; if(bPreAnalyze) { fracPre = 0.05f; resampleBuf rbPre; rbPre.block = maxBlockSize; rbPre.buf = (audio*)calloc(rb.block,sizeof(audio)); rbPre.leftTrack = leftTrack; rbPre.rightTrack = rightTrack?rightTrack:leftTrack; rbPre.leftBuffer = (float*)calloc(maxBlockSize,sizeof(float)); rbPre.rightBuffer = (float*)calloc(maxBlockSize,sizeof(float)); rbPre.offset = start; rbPre.end = end; rbPre.ratio = srSBSMS/srIn; rbPre.resampler = new Resampler(resampleCB, &rbPre); si.rs = rbPre.resampler; long pos = 0; long lastPos = 0; long ret = 0; while(lastPos<samplesToProcess) { ret = sbsms_pre_analyze(&samplesCB,&si,rb.sbsmser); lastPos = pos; pos += ret; real completion = (real)lastPos/(real)samplesToProcess; if (TrackProgress(0,fracPre*completion)) return false; } sbsms_pre_analyze_complete(rb.sbsmser); sbsms_reset(rb.sbsmser); si.rs = rb.resampler; } // process while(pos<samplesOut && outputCount) { long frames; if(pos+blockSize>samplesOut) { frames = samplesOut - pos; } else { frames = blockSize; } outputCount = pitch_process(rb.outBuf, frames, rb.pitch); for(int i = 0; i < outputCount; i++) { rb.outputLeftBuffer[i] = rb.outBuf[i][0]; if(rightTrack) rb.outputRightBuffer[i] = rb.outBuf[i][1]; } pos += outputCount; rb.outputLeftTrack->Append((samplePtr)rb.outputLeftBuffer, floatSample, outputCount); if(rightTrack) rb.outputRightTrack->Append((samplePtr)rb.outputRightBuffer, floatSample, outputCount); double frac = (double)pos/(double)samplesOut; int nWhichTrack = mCurTrackNum; if(rightTrack) { nWhichTrack = 2*(mCurTrackNum/2); if (frac < 0.5) frac *= 2.0; // Show twice as far for each track, because we're doing 2 at once. else { nWhichTrack++; frac -= 0.5; frac *= 2.0; // Show twice as far for each track, because we're doing 2 at once. } } if (TrackProgress(nWhichTrack, fracPre + (1.0-fracPre)*frac)) return false; } rb.outputLeftTrack->Flush(); if(rightTrack) rb.outputRightTrack->Flush(); leftTrack->ClearAndPaste(mCurT0, mCurT1, rb.outputLeftTrack, true, false, GetTimeWarper()); if(rightTrack) { rightTrack->ClearAndPaste(mCurT0, mCurT1, rb.outputRightTrack, true, false, GetTimeWarper()); } } mCurTrackNum++; } else if (mustSync && t->IsSynchroSelected()) { t->SyncAdjust(mCurT1, mCurT0 + (mCurT1 - mCurT0) * mTotalStretch); } //Iterate to the next track t = iter.Next(); } if (bGoodResult) ReplaceProcessedTracks(bGoodResult); // Update selection mT0 = mCurT0; mT1 = mCurT0 + maxDuration; return bGoodResult; }
double StretchHandle::GetT0(const Track &track, const ViewInfo &viewInfo) { return std::max(track.GetStartTime(), viewInfo.selectedRegion.t0()); }
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; } }
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: { doResize(); break; } default: // don't refresh in this case. return RefreshCode::RefreshNone; } return RefreshCode::RefreshAll; }
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; outResampleCB = resampleCB; rb.offset = start; rb.end = end; rb.iface = new SBSMSInterfaceSliding(&rateSlide,&pitchSlide, bPitchReferenceInput, samplesToProcess,0, NULL); } else { rb.bPitch = false; outSlideType = (srProcess==srTrack?SlideIdentity:SlideConstant); outResampleCB = postResampleCB; rb.ratio = srProcess/srTrack; rb.quality = new SBSMSQuality(&SBSMSQualityStandard); rb.resampler = new Resampler(resampleCB, &rb, srProcess==srTrack?SlideIdentity:SlideConstant); rb.sbsms = new SBSMS(rightTrack?2:1,rb.quality,true); rb.SBSMSBlockSize = rb.sbsms->getInputFrameSize(); rb.SBSMSBuf = (audio*)calloc(rb.SBSMSBlockSize,sizeof(audio)); processPresamples = wxMin(rb.quality->getMaxPresamples(), (long)((float)(start-trackStart)*(srProcess/srTrack))); trackPresamples = wxMin(start-trackStart, (long)((float)(processPresamples)*(srTrack/srProcess))); rb.offset = start - trackPresamples; rb.end = trackEnd; rb.iface = new SBSMSEffectInterface(rb.resampler, &rateSlide,&pitchSlide, bPitchReferenceInput, samplesToProcess,processPresamples, rb.quality); } Resampler resampler(outResampleCB,&rb,outSlideType); audio outBuf[SBSMSOutBlockSize]; float outBufLeft[2*SBSMSOutBlockSize]; float outBufRight[2*SBSMSOutBlockSize]; // Samples in output after SBSMS sampleCount samplesToOutput = rb.iface->getSamplesToOutput(); // Samples in output after resampling back sampleCount samplesOut = (sampleCount) ((float)samplesToOutput * (srTrack/srProcess)); // Duration in track time double duration = (mCurT1-mCurT0) * mTotalStretch; if(duration > maxDuration) maxDuration = duration; TimeWarper *warper = createTimeWarper(mCurT0,mCurT1,maxDuration,rateStart,rateEnd,rateSlideType); SetTimeWarper(warper); rb.outputLeftTrack = mFactory->NewWaveTrack(leftTrack->GetSampleFormat(), leftTrack->GetRate()); if(rightTrack) rb.outputRightTrack = mFactory->NewWaveTrack(rightTrack->GetSampleFormat(), rightTrack->GetRate()); long pos = 0; long outputCount = -1; // process while(pos<samplesOut && outputCount) { long frames; if(pos+SBSMSOutBlockSize>samplesOut) { frames = samplesOut - pos; } else { frames = SBSMSOutBlockSize; } outputCount = resampler.read(outBuf,frames); for(int i = 0; i < outputCount; i++) { outBufLeft[i] = outBuf[i][0]; if(rightTrack) outBufRight[i] = outBuf[i][1]; } pos += outputCount; rb.outputLeftTrack->Append((samplePtr)outBufLeft, floatSample, outputCount); if(rightTrack) rb.outputRightTrack->Append((samplePtr)outBufRight, floatSample, outputCount); double frac = (double)pos/(double)samplesOut; int nWhichTrack = mCurTrackNum; if(rightTrack) { nWhichTrack = 2*(mCurTrackNum/2); if (frac < 0.5) frac *= 2.0; // Show twice as far for each track, because we're doing 2 at once. else { nWhichTrack++; frac -= 0.5; frac *= 2.0; // Show twice as far for each track, because we're doing 2 at once. } } if (TrackProgress(nWhichTrack, frac)) return false; } rb.outputLeftTrack->Flush(); if(rightTrack) rb.outputRightTrack->Flush(); bool bResult = leftTrack->ClearAndPaste(mCurT0, mCurT1, rb.outputLeftTrack.get(), true, false, GetTimeWarper()); wxASSERT(bResult); // TO DO: Actually handle this. wxUnusedVar(bResult); if(rightTrack) { bResult = rightTrack->ClearAndPaste(mCurT0, mCurT1, rb.outputRightTrack.get(), true, false, GetTimeWarper()); wxASSERT(bResult); // TO DO: Actually handle this. } } mCurTrackNum++; } else if (mustSync && t->IsSyncLockSelected()) { t->SyncLockAdjust(mCurT1, mCurT0 + (mCurT1 - mCurT0) * mTotalStretch); } //Iterate to the next track t = iter.Next(); } if (bGoodResult) ReplaceProcessedTracks(bGoodResult); // Update selection mT0 = mCurT0; mT1 = mCurT0 + maxDuration; return bGoodResult; }
// ---------------------------------------------------------------------------- TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode( TrackObject* parent, const XMLNode& xml_node, ModelDefinitionLoader& model_def_loader) : TrackObjectPresentationSceneNode(xml_node) { std::string name; xml_node.get("name", &name); m_node = irr_driver->getSceneManager()->addEmptySceneNode(); #ifdef DEBUG m_node->setName(("libnode_" + name).c_str()); #endif XMLNode* libroot; std::string lib_path = file_manager->getAsset(FileManager::LIBRARY, name) + "/"; bool create_lod_definitions = true; if (!model_def_loader.containsLibraryNode(name)) { World* world = World::getWorld(); Track* track = NULL; if (world != NULL) track = world->getTrack(); std::string local_lib_node_path; std::string local_script_file_path; if (track != NULL) { local_lib_node_path = track->getTrackFile("library/" + name + "/node.xml"); local_script_file_path = track->getTrackFile("library/" + name + "/scripting.as"); } std::string lib_node_path = lib_path + "node.xml"; std::string lib_script_file_path = lib_path + "scripting.as"; if (local_lib_node_path.size() > 0 && file_manager->fileExists(local_lib_node_path)) { lib_path = track->getTrackFile("library/" + name); libroot = file_manager->createXMLTree(local_lib_node_path); if (track != NULL) World::getWorld()->getScriptEngine()->loadScript(local_script_file_path, false); } else if (file_manager->fileExists(lib_node_path)) { libroot = file_manager->createXMLTree(lib_node_path); if (track != NULL) World::getWorld()->getScriptEngine()->loadScript(lib_script_file_path, false); } else { Log::error("TrackObjectPresentationLibraryNode", "Cannot find library '%s'", lib_node_path.c_str()); return; } if (libroot == NULL) { Log::error("TrackObjectPresentationLibraryNode", "Cannot find library '%s'", lib_node_path.c_str()); return; } file_manager->pushTextureSearchPath(lib_path + "/"); file_manager->pushModelSearchPath(lib_path); material_manager->pushTempMaterial(lib_path + "/materials.xml"); model_def_loader.addToLibrary(name, libroot); // Load LOD groups const XMLNode *lod_xml_node = libroot->getNode("lod"); if (lod_xml_node != NULL) { for (unsigned int i = 0; i < lod_xml_node->getNumNodes(); i++) { const XMLNode* lod_group_xml = lod_xml_node->getNode(i); for (unsigned int j = 0; j < lod_group_xml->getNumNodes(); j++) { model_def_loader.addModelDefinition(lod_group_xml->getNode(j)); } } } } else { libroot = model_def_loader.getLibraryNodes()[name]; assert(libroot != NULL); // LOD definitions are already created, don't create them again create_lod_definitions = false; } m_node->setPosition(m_init_xyz); m_node->setRotation(m_init_hpr); m_node->setScale(m_init_scale); m_node->updateAbsolutePosition(); assert(libroot != NULL); World::getWorld()->getTrack()->loadObjects(libroot, lib_path, model_def_loader, create_lod_definitions, m_node, parent); m_parent = parent; } // TrackObjectPresentationLibraryNode
bool SelectCommand::Apply(CommandExecutionContext context) { wxString mode = GetString(wxT("Mode")); if (mode.IsSameAs(wxT("None"))) { // select none context.proj->OnSelectNone(); } else if (mode.IsSameAs(wxT("All"))) { // select all context.proj->OnSelectAll(); } else if (mode.IsSameAs(wxT("Range"))) { // select range double t0 = GetDouble(wxT("StartTime")); double t1 = GetDouble(wxT("EndTime")); TrackList *tracks = context.proj->GetTracks(); if (t0 < context.proj->GetTracks()->GetMinOffset()) { Error(wxT("Start time is before start of track!")); return false; } if (t1 > context.proj->GetTracks()->GetEndTime()) { Error(wxT("End time is after end of track!")); return false; } context.proj->mViewInfo.sel0 = t0; context.proj->mViewInfo.sel1 = t1; // select specified tracks long firstTrack = GetLong(wxT("FirstTrack")); long lastTrack = GetLong(wxT("LastTrack")); if (firstTrack < 0) { Error(wxT("Trying to select a negatively numbered track!")); return false; } if (lastTrack >= tracks->GetCount()) { Error(wxT("Trying to select higher number track than exists!")); return false; } int index = 0; TrackListIterator iter(tracks); Track *t = iter.First(); while (t) { bool sel = firstTrack <= index && index <= lastTrack; t->SetSelected(sel); if (sel) Status(wxT("Selected track '") + t->GetName() + wxT("'")); t = iter.Next(); ++index; } wxASSERT(index >= lastTrack); } else if (mode.IsSameAs(wxT("Name"))) { wxString name = GetString(wxT("TrackName")); TrackList *tracks = context.proj->GetTracks(); TrackListIterator iter(tracks); Track *t = iter.First(); while (t) { bool sel = t->GetName().IsSameAs(name); t->SetSelected(sel); if (sel) Status(wxT("Selected track '") + t->GetName() + wxT("'")); t = iter.Next(); } } else { Error(wxT("Invalid selection mode!")); return false; } return true; }
GrandPrixData::GrandPrixData(const std::string filename) throw(std::logic_error) { m_filename = filename; m_id = StringUtils::getBasename(StringUtils::removeExtension(filename)); XMLNode* root = file_manager->createXMLTree(file_manager->getAsset(FileManager::GRANDPRIX,filename)); if (!root) { Log::error("GrandPrixData","Error while trying to read grandprix file '%s'", filename.c_str()); throw std::logic_error("File not found"); } bool foundName = false; if (root->getName() == "supertuxkart_grand_prix") { std::string temp_name; if (root->get("name", &temp_name) == 0) { Log::error("GrandPrixData", "Error while trying to read grandprix file '%s' : " "missing 'name' attribute\n", filename.c_str()); delete root; throw std::logic_error("File contents are incomplete or corrupt"); } m_name = temp_name.c_str(); foundName = true; } else { Log::error("GrandPrixData", "Error while trying to read grandprix file '%s' : " "Root node has an unexpected name\n", filename.c_str()); delete root; throw std::logic_error("File contents are incomplete or corrupt"); } const int amount = root->getNumNodes(); for (int i=0; i<amount; i++) { const XMLNode* node = root->getNode(i); // read a track entry if (node->getName() == "track") { std::string trackID; int numLaps; bool reversed = false; const int idFound = node->get("id", &trackID ); const int lapFound = node->get("laps", &numLaps ); // Will stay false if not found node->get("reverse", &reversed ); if (!idFound || !lapFound) { Log::error("GrandPrixData", "Error while trying to read grandprix file '%s' : " "<track> tag does not have idi and laps reverse attributes. \n", filename.c_str()); delete root; throw std::logic_error("File contents are incomplete or corrupt"); } // Make sure the track really is reversible Track* t = track_manager->getTrack(trackID); if (t != NULL && reversed) { reversed = t->reverseAvailable(); } m_tracks.push_back(trackID); m_laps.push_back(numLaps); m_reversed.push_back(reversed); assert(m_tracks.size() == m_laps.size() ); assert(m_laps.size() == m_reversed.size()); } else { std::cerr << "Unknown node in Grand Prix XML file : " << node->getName().c_str() << std::endl; delete root; throw std::runtime_error("Unknown node in sfx XML file"); } }// nend for delete root; // sanity checks if (!foundName) { Log::error("GrandPrixData", "Error while trying to read grandprix file '%s' : " "missing 'name' attribute\n", filename.c_str()); throw std::logic_error("File contents are incomplete or corrupt"); } }
void SegmentMover::mouseReleaseEvent(QMouseEvent *e) { // We only care about the left mouse button. if (e->button() != Qt::LeftButton) return; // No need to propagate. e->accept(); // If we weren't moving anything, bail. if (!getChangingSegment()) return; if (m_changeMade) { QPoint pos = m_canvas->viewportToContents(e->pos()); // Compute how far we've moved vertically. const int startTrackPos = m_canvas->grid().getYBin(m_clickPoint.y()); const int currentTrackPos = m_canvas->grid().getYBin(pos.y()); const int deltaTrack = currentTrackPos - startTrackPos; CompositionModelImpl::ChangingSegmentSet &changingSegments = m_canvas->getModel()->getChangingSegments(); Composition &comp = m_doc->getComposition(); SegmentReconfigureCommand *command = new SegmentReconfigureCommand( changingSegments.size() == 1 ? tr("Move Segment") : tr("Move Segments"), &comp); // For each changing segment for (CompositionModelImpl::ChangingSegmentSet::iterator it = changingSegments.begin(); it != changingSegments.end(); ++it) { ChangingSegmentPtr changingSegment = *it; // The original Segment in the Composition. Segment *segment = changingSegment->getSegment(); // New Track ID TrackId origTrackId = segment->getTrack(); int trackPos = comp.getTrackPositionById(origTrackId) + deltaTrack; if (trackPos < 0) { trackPos = 0; } else if (trackPos >= (int)comp.getNbTracks()) { trackPos = comp.getNbTracks() - 1; } Track *newTrack = comp.getTrackByPosition(trackPos); int newTrackId = origTrackId; if (newTrack) newTrackId = newTrack->getId(); // New start time timeT newStartTime = changingSegment->getStartTime(m_canvas->grid()); // New end time // We absolutely don't want to snap the end time // to the grid. We want it to remain exactly the same // as it was, but relative to the new start time. timeT newEndTime = newStartTime + segment->getEndMarkerTime(false) - segment->getStartTime(); // Add the changed segment to the command command->addSegment(segment, newStartTime, newEndTime, newTrackId); } CommandHistory::getInstance()->addCommand(command); m_changeMade = false; } m_canvas->hideTextFloat(); m_canvas->hideGuides(); m_canvas->getModel()->endChange(); m_canvas->slotUpdateAll(); setChangingSegment(ChangingSegmentPtr()); setContextHelp2(); }
bool EffectChangeSpeed::Process() { // Similar to EffectSoundTouch::Process() // Iterate over each track. // Track::All is needed because this effect needs to introduce // silence in the sync-lock group tracks to keep sync CopyInputTracks(Track::All); // Set up mOutputTracks. bool bGoodResult = true; TrackListIterator iter(mOutputTracks); Track* t; mCurTrackNum = 0; mMaxNewLength = 0.0; mFactor = 100.0 / (100.0 + m_PercentChange); t = iter.First(); while (t != NULL) { if (t->GetKind() == Track::Label) { if (t->GetSelected() || t->IsSyncLockSelected()) { if (!ProcessLabelTrack(t)) { bGoodResult = false; break; } } } else if (t->GetKind() == Track::Wave && t->GetSelected()) { WaveTrack *pOutWaveTrack = (WaveTrack*)t; //Get start and end times from track mCurT0 = pOutWaveTrack->GetStartTime(); mCurT1 = pOutWaveTrack->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) { //Transform the marker timepoints to samples sampleCount start = pOutWaveTrack->TimeToLongSamples(mCurT0); sampleCount end = pOutWaveTrack->TimeToLongSamples(mCurT1); //ProcessOne() (implemented below) processes a single track if (!ProcessOne(pOutWaveTrack, start, end)) { bGoodResult = false; break; } } mCurTrackNum++; } else if (t->IsSyncLockSelected()) { t->SyncLockAdjust(mT1, mT0 + (mT1 - mT0) * mFactor); } //Iterate to the next track t=iter.Next(); } if (bGoodResult) ReplaceProcessedTracks(bGoodResult); // Update selection. mT1 = mT0 + (((mT1 - mT0) * 100.0) / (100.0 + m_PercentChange)); return bGoodResult; }
void add_to_histogram_eta_1(const Track& track) { std::cout << "Track has eta > 0.1 : " << track.eta() << std::endl; }
int ControlToolBar::PlayPlayRegion(const SelectedRegion &selectedRegion, const AudioIOStartStreamOptions &options, PlayMode mode, PlayAppearance appearance, /* = PlayOption::Straight */ bool backwards, /* = false */ bool playWhiteSpace /* = false */) { if (!CanStopAudioStream()) return -1; // Uncomment this for laughs! // backwards = true; double t0 = selectedRegion.t0(); double t1 = selectedRegion.t1(); // SelectedRegion guarantees t0 <= t1, so we need another boolean argument // to indicate backwards play. const bool looped = options.playLooped; if (backwards) std::swap(t0, t1); SetPlay(true, appearance); if (gAudioIO->IsBusy()) { SetPlay(false); return -1; } const bool cutpreview = appearance == PlayAppearance::CutPreview; if (cutpreview && t0==t1) { SetPlay(false); return -1; /* msmeyer: makes no sense */ } AudacityProject *p = GetActiveProject(); if (!p) { SetPlay(false); return -1; // Should never happen, but... } TrackList *t = p->GetTracks(); if (!t) { mPlay->PopUp(); return -1; // Should never happen, but... } p->mLastPlayMode = mode; bool hasaudio = false; TrackListIterator iter(t); for (Track *trk = iter.First(); trk; trk = iter.Next()) { if (trk->GetKind() == Track::Wave #ifdef EXPERIMENTAL_MIDI_OUT || trk->GetKind() == Track::Note #endif ) { hasaudio = true; break; } } double latestEnd = (playWhiteSpace)? t1 : t->GetEndTime(); if (!hasaudio) { SetPlay(false); return -1; // No need to continue without audio tracks } #if defined(EXPERIMENTAL_SEEK_BEHIND_CURSOR) double init_seek = 0.0; #endif if (t1 == t0) { if (looped) { // play selection if there is one, otherwise // set start of play region to project start, // and loop the project from current play position. if ((t0 > p->GetSel0()) && (t0 < p->GetSel1())) { t0 = p->GetSel0(); t1 = p->GetSel1(); } else { // loop the entire project t0 = t->GetStartTime(); t1 = t->GetEndTime(); } } else { // move t0 to valid range if (t0 < 0) { t0 = t->GetStartTime(); } else if (t0 > t->GetEndTime()) { t0 = t->GetEndTime(); } #if defined(EXPERIMENTAL_SEEK_BEHIND_CURSOR) else { init_seek = t0; //AC: init_seek is where playback will 'start' t0 = t->GetStartTime(); } #endif } t1 = t->GetEndTime(); } else { // maybe t1 < t0, with backwards scrubbing for instance if (backwards) std::swap(t0, t1); t0 = std::max(0.0, std::min(t0, latestEnd)); t1 = std::max(0.0, std::min(t1, latestEnd)); if (backwards) std::swap(t0, t1); } int token = -1; bool success = false; if (t1 != t0) { if (cutpreview) { const double tless = std::min(t0, t1); const double tgreater = std::max(t0, t1); double beforeLen, afterLen; gPrefs->Read(wxT("/AudioIO/CutPreviewBeforeLen"), &beforeLen, 2.0); gPrefs->Read(wxT("/AudioIO/CutPreviewAfterLen"), &afterLen, 1.0); double tcp0 = tless-beforeLen; double diff = tgreater - tless; double tcp1 = (tgreater+afterLen) - diff; SetupCutPreviewTracks(tcp0, tless, tgreater, tcp1); if (backwards) std::swap(tcp0, tcp1); if (mCutPreviewTracks) { AudioIOStartStreamOptions myOptions = options; myOptions.cutPreviewGapStart = t0; myOptions.cutPreviewGapLen = t1 - t0; token = gAudioIO->StartStream( mCutPreviewTracks->GetWaveTrackArray(false), WaveTrackArray(), #ifdef EXPERIMENTAL_MIDI_OUT NoteTrackArray(), #endif tcp0, tcp1, myOptions); } else { // Cannot create cut preview tracks, clean up and exit SetPlay(false); SetStop(false); SetRecord(false); return -1; } } else { // Lifted the following into AudacityProject::GetDefaultPlayOptions() /* if (!timetrack) { timetrack = t->GetTimeTrack(); } */ token = gAudioIO->StartStream(t->GetWaveTrackArray(false), WaveTrackArray(), #ifdef EXPERIMENTAL_MIDI_OUT t->GetNoteTrackArray(false), #endif t0, t1, options); } if (token != 0) { success = true; p->SetAudioIOToken(token); mBusyProject = p; #if defined(EXPERIMENTAL_SEEK_BEHIND_CURSOR) //AC: If init_seek was set, now's the time to make it happen. gAudioIO->SeekStream(init_seek); #endif } else { // msmeyer: Show error message if stream could not be opened wxMessageBox( _("Error while opening sound device. " "Please check the playback device settings and the project sample rate."), _("Error"), wxOK | wxICON_EXCLAMATION, this); } } if (!success) { SetPlay(false); SetStop(false); SetRecord(false); return -1; } StartScrollingIfPreferred(); // Let other UI update appearance if (p) p->GetRulerPanel()->HideQuickPlayIndicator(); return token; }
bool EffectTruncSilence::ProcessIndependently() { unsigned nGroups = 0; const bool syncLock = ::GetActiveProject()->IsSyncLocked(); // Check if it's permissible { SelectedTrackListOfKindIterator iter(Track::Wave, inputTracks()); for (Track *track = iter.First(); track; track = iter.Next(true) // skip linked tracks ) { if (syncLock) { Track *const link = track->GetLink(); SyncLockedTracksIterator syncIter(inputTracks()); for (Track *track2 = syncIter.StartWith(track); track2; track2 = syncIter.Next()) { if (track2->GetKind() == Track::Wave && !(track2 == track || track2 == link) && track2->GetSelected()) { ::wxMessageBox(_("When truncating independently, there may only be one selected audio track in each Sync-Locked Track Group.")); return false; } } } ++nGroups; } } if (nGroups == 0) // nothing to do return true; // Now do the work // Copy tracks CopyInputTracks(Track::All); double newT1 = 0.0; { unsigned iGroup = 0; SelectedTrackListOfKindIterator iter(Track::Wave, mOutputTracks.get()); for (Track *track = iter.First(); track; ++iGroup, track = iter.Next(true) // skip linked tracks ) { Track *const link = track->GetLink(); Track *const last = link ? link : track; RegionList silences; if (!FindSilences(silences, mOutputTracks.get(), track, last)) return false; // Treat tracks in the sync lock group only Track *groupFirst, *groupLast; if (syncLock) { SyncLockedTracksIterator syncIter(mOutputTracks.get()); groupFirst = syncIter.StartWith(track); groupLast = syncIter.Last(); } else { groupFirst = track; groupLast = last; } double totalCutLen = 0.0; if (!DoRemoval(silences, iGroup, nGroups, groupFirst, groupLast, totalCutLen)) return false; newT1 = std::max(newT1, mT1 - totalCutLen); } } mT1 = newT1; return true; }
void ControlToolBar::OnRecord(wxCommandEvent &evt) { if (gAudioIO->IsBusy()) { if (!CanStopAudioStream() || 0 == gAudioIO->GetNumCaptureChannels()) mRecord->PopUp(); else mRecord->PushDown(); return; } AudacityProject *p = GetActiveProject(); if( evt.GetInt() == 1 ) // used when called by keyboard shortcut. Default (0) ignored. mRecord->SetShift(true); if( evt.GetInt() == 2 ) mRecord->SetShift(false); SetRecord(true, mRecord->WasShiftDown()); if (p) { TrackList *trackList = p->GetTracks(); TrackListIterator it(trackList); if(it.First() == NULL) mRecord->SetShift(false); double t0 = p->GetSel0(); double t1 = p->GetSel1(); if (t1 == t0) t1 = 1000000000.0; // record for a long, long time (tens of years) /* TODO: set up stereo tracks if that is how the user has set up * their preferences, and choose sample format based on prefs */ WaveTrackArray newRecordingTracks, playbackTracks; #ifdef EXPERIMENTAL_MIDI_OUT NoteTrackArray midiTracks; #endif bool duplex; gPrefs->Read(wxT("/AudioIO/Duplex"), &duplex, true); if(duplex){ playbackTracks = trackList->GetWaveTrackArray(false); #ifdef EXPERIMENTAL_MIDI_OUT midiTracks = trackList->GetNoteTrackArray(false); #endif } else { playbackTracks = WaveTrackArray(); #ifdef EXPERIMENTAL_MIDI_OUT midiTracks = NoteTrackArray(); #endif } // If SHIFT key was down, the user wants append to tracks int recordingChannels = 0; TrackList tracksCopy{}; bool tracksCopied = false; bool shifted = mRecord->WasShiftDown(); if (shifted) { bool sel = false; double allt0 = t0; // Find the maximum end time of selected and all wave tracks // Find whether any tracks were selected. (If any are selected, // record only into them; else if tracks exist, record into all.) for (Track *tt = it.First(); tt; tt = it.Next()) { if (tt->GetKind() == Track::Wave) { WaveTrack *wt = static_cast<WaveTrack *>(tt); if (wt->GetEndTime() > allt0) { allt0 = wt->GetEndTime(); } if (tt->GetSelected()) { sel = true; if (wt->GetEndTime() > t0) { t0 = wt->GetEndTime(); } } } } // Use end time of all wave tracks if none selected if (!sel) { t0 = allt0; } // Pad selected/all wave tracks to make them all the same length // Remove recording tracks from the list of tracks for duplex ("overdub") // playback. for (Track *tt = it.First(); tt; tt = it.Next()) { if (tt->GetKind() == Track::Wave && (tt->GetSelected() || !sel)) { WaveTrack *wt = static_cast<WaveTrack *>(tt); if (duplex) { auto end = playbackTracks.end(); auto it = std::find(playbackTracks.begin(), end, wt); if (it != end) playbackTracks.erase(it); } t1 = wt->GetEndTime(); if (t1 < t0) { if (!tracksCopied) { tracksCopied = true; tracksCopy = *trackList; } auto newTrack = p->GetTrackFactory()->NewWaveTrack(); newTrack->InsertSilence(0.0, t0 - t1); newTrack->Flush(); wt->Clear(t1, t0); bool bResult = wt->Paste(t1, newTrack.get()); wxASSERT(bResult); // TO DO: Actually handle this. wxUnusedVar(bResult); } newRecordingTracks.push_back(wt); } } t1 = 1000000000.0; // record for a long, long time (tens of years) } else { bool recordingNameCustom, useTrackNumber, useDateStamp, useTimeStamp; wxString defaultTrackName, defaultRecordingTrackName; int numTracks = 0; for (Track *tt = it.First(); tt; tt = it.Next()) { if (tt->GetKind() == Track::Wave && !tt->GetLinked()) numTracks++; } numTracks++; recordingChannels = gPrefs->Read(wxT("/AudioIO/RecordChannels"), 2); gPrefs->Read(wxT("/GUI/TrackNames/RecordingNameCustom"), &recordingNameCustom, false); gPrefs->Read(wxT("/GUI/TrackNames/TrackNumber"), &useTrackNumber, false); gPrefs->Read(wxT("/GUI/TrackNames/DateStamp"), &useDateStamp, false); gPrefs->Read(wxT("/GUI/TrackNames/TimeStamp"), &useTimeStamp, false); /* i18n-hint: The default name for an audio track. */ gPrefs->Read(wxT("/GUI/TrackNames/DefaultTrackName"),&defaultTrackName, _("Audio Track")); gPrefs->Read(wxT("/GUI/TrackNames/RecodingTrackName"), &defaultRecordingTrackName, defaultTrackName); wxString baseTrackName = recordingNameCustom? defaultRecordingTrackName : defaultTrackName; for (int c = 0; c < recordingChannels; c++) { auto newTrack = p->GetTrackFactory()->NewWaveTrack(); newTrack->SetOffset(t0); wxString nameSuffix = wxString(wxT("")); if (useTrackNumber) { nameSuffix += wxString::Format(wxT("%d"), numTracks + c); } if (useDateStamp) { if (!nameSuffix.IsEmpty()) { nameSuffix += wxT("_"); } nameSuffix += wxDateTime::Now().FormatISODate(); } if (useTimeStamp) { if (!nameSuffix.IsEmpty()) { nameSuffix += wxT("_"); } nameSuffix += wxDateTime::Now().FormatISOTime(); } // ISO standard would be nice, but ":" is unsafe for file name. nameSuffix.Replace(wxT(":"), wxT("-")); if (baseTrackName.IsEmpty()) { newTrack->SetName(nameSuffix); } else if (nameSuffix.IsEmpty()) { newTrack->SetName(baseTrackName); } else { newTrack->SetName(baseTrackName + wxT("_") + nameSuffix); } if (recordingChannels > 2) newTrack->SetMinimized(true); if (recordingChannels == 2) { if (c == 0) { newTrack->SetChannel(Track::LeftChannel); newTrack->SetLinked(true); } else { newTrack->SetChannel(Track::RightChannel); } } else { newTrack->SetChannel( Track::MonoChannel ); } // Let the list hold the track, and keep a pointer to it newRecordingTracks.push_back( static_cast<WaveTrack*>( trackList->Add( std::move(newTrack)))); } } //Automated Input Level Adjustment Initialization #ifdef EXPERIMENTAL_AUTOMATED_INPUT_LEVEL_ADJUSTMENT gAudioIO->AILAInitialize(); #endif AudioIOStartStreamOptions options(p->GetDefaultPlayOptions()); int token = gAudioIO->StartStream(playbackTracks, newRecordingTracks, #ifdef EXPERIMENTAL_MIDI_OUT midiTracks, #endif t0, t1, options); bool success = (token != 0); if (success) { p->SetAudioIOToken(token); mBusyProject = p; StartScrollingIfPreferred(); } else { if (shifted) { // Restore the tracks to remove any inserted silence if (tracksCopied) *trackList = std::move(tracksCopy); } else { // msmeyer: Delete recently added tracks if opening stream fails for (unsigned int i = 0; i < newRecordingTracks.size(); i++) { trackList->Remove(newRecordingTracks[i]); } } // msmeyer: Show error message if stream could not be opened wxMessageBox(_("Error while opening sound device. Please check the recording device settings and the project sample rate."), _("Error"), wxOK | wxICON_EXCLAMATION, this); SetPlay(false); SetStop(false); SetRecord(false); } } UpdateStatusBar(GetActiveProject()); }
void ArenasScreen::eventCallback(Widget* widget, const std::string& name, const int playerID) { if (name == "tracks") { DynamicRibbonWidget* w2 = dynamic_cast<DynamicRibbonWidget*>(widget); if (w2 == NULL) return; const std::string selection = w2->getSelectionIDString(PLAYER_ID_GAME_MASTER); if (UserConfigParams::logGUI()) std::cout << "Clicked on arena " << selection.c_str() << std::endl; if (selection == "random_track") { RibbonWidget* tabs = this->getWidget<RibbonWidget>("trackgroups"); assert( tabs != NULL ); bool soccer_mode = race_manager->getMinorMode() == RaceManager::MINOR_MODE_SOCCER; std::vector<int> curr_group; if (tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER) == ALL_ARENA_GROUPS_ID) { const std::vector<std::string>& groups = track_manager->getAllArenaGroups(); for (unsigned int i = 0; i < groups.size(); i++) { const std::vector<int>& tmp_group = track_manager->getArenasInGroup(groups[i], soccer_mode); // Append to our main vector curr_group.insert(curr_group.end(), tmp_group.begin(), tmp_group.end()); } } // if on tab "all" else { curr_group = track_manager->getArenasInGroup( tabs->getSelectionIDString(PLAYER_ID_GAME_MASTER), soccer_mode ); } RandomGenerator random; const int randomID = random.get(curr_group.size()); Track* clickedTrack = track_manager->getTrack( curr_group[randomID] ); if (clickedTrack != NULL) { ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() ); new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(), screenshot, 0.8f, 0.7f); } } else if (selection == "locked") { unlock_manager->playLockSound(); } else if (selection == RibbonWidget::NO_ITEM_ID) { } else { Track* clickedTrack = track_manager->getTrack(selection); if (clickedTrack != NULL) { ITexture* screenshot = irr_driver->getTexture( clickedTrack->getScreenshotFile().c_str() ); new TrackInfoDialog(selection, clickedTrack->getIdent(), clickedTrack->getName(), screenshot, 0.8f, 0.7f); } // clickedTrack != NULL } // if random_track } else if (name == "trackgroups") { buildTrackList(); } else if (name == "back") { StateManager::get()->escapePressed(); } } // eventCallback
void GPInfoDialog::addTracks() { const std::vector<std::string> tracks = m_gp.getTrackNames(); const unsigned int track_amount = tracks.size(); int height_of_one_line = std::min((m_lower_bound - m_over_body)/(track_amount+1), (unsigned int)(GUIEngine::getFontHeight()*1.5f)); // Count the number of label already existing labels representing a track unsigned int existing = 0; for (unsigned int i = 0; i < m_widgets.size(); i++) { if (m_widgets.get(i)->m_properties[PROP_ID] == "Track label") existing++; } unsigned int reuse = std::min(existing, track_amount); // m_widgets has the type PtrVector<Widget, HOLD> unsigned int widgets_iter = 0; for (unsigned int i = 0; i < reuse; i++) { Track* track = track_manager->getTrack(tracks[i]); // Find the next widget that is a track label while (m_widgets.get(widgets_iter)->m_properties[PROP_ID] != "Track label") widgets_iter++; Label* widget = dynamic_cast<Label*>(m_widgets.get(widgets_iter)); widget->setText(translations->fribidize(track->getName()), false); widget->move(20, m_over_body + height_of_one_line*i, m_area.getWidth()/2 - 20, height_of_one_line); widgets_iter++; } if (existing < track_amount) { // There are not enough labels for all the track names, so we have to // add some more for (unsigned int i = reuse; i < track_amount; i++) { Track* track = track_manager->getTrack(tracks[i]); assert(track != NULL); Label* widget = new Label(); widget->m_properties[PROP_ID] = "Track label"; widget->setText(translations->fribidize(track->getName()), false); widget->setParent(m_irrlicht_window); m_widgets.push_back(widget); widget->add(); widget->move(20, m_over_body + height_of_one_line*i, m_area.getWidth()/2 - 20, height_of_one_line); } } else if (existing > track_amount) { // There are label which are not necessary anymore so they're deleted for (unsigned int i = widgets_iter; i < m_widgets.size(); i++) { if (m_widgets.get(i)->m_properties[PROP_ID] == "Track label") { m_irrlicht_window->removeChild(m_widgets.get(i)->getIrrlichtElement()); m_widgets.remove(i); i--; } } } }
GPInfoDialog::GPInfoDialog(const std::string& gpIdent, const float w, const float h) : ModalDialog(w, h) { doInit(); m_curr_time = 0.0f; const int y1 = m_area.getHeight()/7; const int y2 = m_area.getHeight()*6/7; m_gp_ident = gpIdent; const GrandPrixData* gp = grand_prix_manager->getGrandPrix(gpIdent); assert (gp != NULL); // ---- GP Name core::rect< s32 > area_top(0, 0, m_area.getWidth(), y1); IGUIStaticText* title = GUIEngine::getGUIEnv()->addStaticText( translations->fribidize(gp->getName()), area_top, false, true, // border, word wrap m_irrlicht_window); title->setTabStop(false); title->setTextAlignment(EGUIA_CENTER, EGUIA_CENTER); // ---- Track listings const std::vector<std::string> tracks = gp->getTrackNames(); const int trackAmount = tracks.size(); int height_of_one_line = (y2 - y1)/(trackAmount+1); const int textHeight = GUIEngine::getFontHeight(); if (height_of_one_line > (int)(textHeight*1.5f)) height_of_one_line = (int)(textHeight*1.5f); bool gp_ok = true; for (int t=0; t<trackAmount; t++) { const int from_y = y1 + height_of_one_line*(t+1); Track* track = track_manager->getTrack(tracks[t]); stringw lineText; if (track == NULL) { lineText = L"MISSING : "; lineText.append( stringw(tracks[t].c_str()) ); gp_ok = false; } else { lineText = track->getName(); } LabelWidget* widget = new LabelWidget(); widget->setText(translations->fribidize(lineText), false); widget->m_x = 20; widget->m_y = from_y; widget->m_w = m_area.getWidth()/2 - 20; widget->m_h = height_of_one_line; widget->setParent(m_irrlicht_window); m_widgets.push_back(widget); widget->add(); // IGUIStaticText* line = GUIEngine::getGUIEnv()->addStaticText( lineText.c_str(), // entry_area, false , true , // border, word wrap // m_irrlicht_window); } // ---- Track screenshot m_screenshot_widget = new IconButtonWidget(IconButtonWidget::SCALE_MODE_KEEP_CUSTOM_ASPECT_RATIO, false /* tab stop */, false /* focusable */, IconButtonWidget::ICON_PATH_TYPE_ABSOLUTE /* Track gives us absolute paths */); // images are saved squared, but must be stretched to 4:3 m_screenshot_widget->setCustomAspectRatio(4.0f / 3.0f); m_screenshot_widget->m_x = m_area.getWidth()/2; m_screenshot_widget->m_y = y1; m_screenshot_widget->m_w = m_area.getWidth()/2; m_screenshot_widget->m_h = y2 - y1 - 10; Track* track = (tracks.size() == 0 ? NULL : track_manager->getTrack(tracks[0])); m_screenshot_widget->m_properties[PROP_ICON] = (track != NULL ? track->getScreenshotFile().c_str() : file_manager->getAsset(FileManager::GUI,"main_help.png")); m_screenshot_widget->setParent(m_irrlicht_window); m_screenshot_widget->add(); m_widgets.push_back(m_screenshot_widget); // ---- Start button ButtonWidget* okBtn = new ButtonWidget(); ButtonWidget* continueBtn = new ButtonWidget(); SavedGrandPrix* saved_gp = SavedGrandPrix::getSavedGP( StateManager::get() ->getActivePlayerProfile(0) ->getUniqueID(), gpIdent, race_manager->getDifficulty(), race_manager->getNumberOfKarts(), race_manager->getNumLocalPlayers()); if (tracks.size() == 0) { okBtn->m_properties[PROP_ID] = "cannot_start"; okBtn->setText(_("Sorry, no tracks available")); } else if (gp_ok) { okBtn->m_properties[PROP_ID] = "start"; okBtn->setText(_("Start Grand Prix")); continueBtn->m_properties[PROP_ID] = "continue"; continueBtn->setText(_("Continue")); } else { okBtn->m_properties[PROP_ID] = "cannot_start"; okBtn->setText(_("This Grand Prix is broken!")); okBtn->setBadge(BAD_BADGE); } if (saved_gp && gp_ok) { continueBtn->m_x = m_area.getWidth()/2 + 110; continueBtn->m_y = y2; continueBtn->m_w = 200; continueBtn->m_h = m_area.getHeight() - y2 - 15; continueBtn->setParent(m_irrlicht_window); m_widgets.push_back(continueBtn); continueBtn->add(); continueBtn->getIrrlichtElement()->setTabStop(true); continueBtn->getIrrlichtElement()->setTabGroup(false); okBtn->m_x = m_area.getWidth()/2 - 310; } else { okBtn->m_x = m_area.getWidth()/2 - 200; } okBtn->m_y = y2; okBtn->m_w = 400; okBtn->m_h = m_area.getHeight() - y2 - 15; okBtn->setParent(m_irrlicht_window); m_widgets.push_back(okBtn); okBtn->add(); okBtn->getIrrlichtElement()->setTabStop(true); okBtn->getIrrlichtElement()->setTabGroup(false); okBtn->setFocusForPlayer( PLAYER_ID_GAME_MASTER ); }
bool EffectNyquist::ProcessOne() { nyx_rval rval; if (GetEffectFlags() & INSERT_EFFECT) { nyx_set_audio_params(mCurTrack[0]->GetRate(), 0); } else { nyx_set_audio_params(mCurTrack[0]->GetRate(), mCurLen); nyx_set_input_audio(StaticGetCallback, (void *)this, mCurNumChannels, mCurLen, mCurTrack[0]->GetRate()); } wxString cmd; if (mDebug) { cmd += wxT("(setf *tracenable* T)\n"); if (mExternal) { cmd += wxT("(setf *breakenable* T)\n"); } } for (unsigned int j = 0; j < mControls.GetCount(); j++) { if (mControls[j].type == NYQ_CTRL_REAL) { // We use Internat::ToString() rather than "%f" here because we // always have to use the dot as decimal separator when giving // numbers to Nyquist, whereas using "%f" will use the user's // decimal separator which may be a comma in some countries. cmd += wxString::Format(wxT("(setf %s %s)\n"), mControls[j].var.c_str(), Internat::ToString(mControls[j].val).c_str()); } else if (mControls[j].type == NYQ_CTRL_INT || mControls[j].type == NYQ_CTRL_CHOICE) { cmd += wxString::Format(wxT("(setf %s %d)\n"), mControls[j].var.c_str(), (int)(mControls[j].val)); } else if (mControls[j].type == NYQ_CTRL_STRING) { wxString str = mControls[j].valStr; str.Replace(wxT("\\"), wxT("\\\\")); str.Replace(wxT("\""), wxT("\\\"")); cmd += wxT("(setf "); // restrict variable names to 7-bit ASCII: cmd += mControls[j].var.c_str(); cmd += wxT(" \""); cmd += str; // unrestricted value will become quoted UTF-8 cmd += wxT("\")\n"); } } if (mIsSal) { wxString str = mCmd; str.Replace(wxT("\\"), wxT("\\\\")); str.Replace(wxT("\""), wxT("\\\"")); // this is tricky: we need SAL to call main so that we can get a // SAL traceback in the event of an error (sal-compile catches the // error and calls sal-error-output), but SAL does not return values. // We will catch the value in a special global aud:result and if no // error occurs, we will grab the value with a LISP expression str += wxT("\nset aud:result = main()\n"); if (mDebug) { // since we're about to evaluate SAL, remove LISP trace enable and // break enable (which stops SAL processing) and turn on SAL stack // trace cmd += wxT("(setf *tracenable* nil)\n"); cmd += wxT("(setf *breakenable* nil)\n"); cmd += wxT("(setf *sal-traceback* t)\n"); } if (mCompiler) { cmd += wxT("(setf *sal-compiler-debug* t)\n"); } cmd += wxT("(setf *sal-call-stack* nil)\n"); // if we do not set this here and an error occurs in main, another // error will be raised when we try to return the value of aud:result // which is unbound cmd += wxT("(setf aud:result nil)\n"); cmd += wxT("(sal-compile-audacity \"") + str + wxT("\" t t nil)\n"); // Capture the value returned by main (saved in aud:result), but // set aud:result to nil so sound results can be evaluated without // retaining audio in memory cmd += wxT("(prog1 aud:result (setf aud:result nil))\n"); } else { cmd += mCmd; } int i; for (i = 0; i < mCurNumChannels; i++) { mCurBuffer[i] = NULL; } rval = nyx_eval_expression(cmd.mb_str(wxConvUTF8)); if (rval == nyx_string) { wxMessageBox(NyquistToWxString(nyx_get_string()), wxT("Nyquist"), wxOK | wxCENTRE, mParent); return true; } if (rval == nyx_double) { wxString str; str.Printf(_("Nyquist returned the value:") + wxString(wxT(" %f")), nyx_get_double()); wxMessageBox(str, wxT("Nyquist"), wxOK | wxCENTRE, mParent); return true; } if (rval == nyx_int) { wxString str; str.Printf(_("Nyquist returned the value:") + wxString(wxT(" %d")), nyx_get_int()); wxMessageBox(str, wxT("Nyquist"), wxOK | wxCENTRE, mParent); return true; } if (rval == nyx_labels) { unsigned int numLabels = nyx_get_num_labels(); unsigned int l; LabelTrack *ltrack = NULL; TrackListIterator iter(mOutputTracks); for (Track *t = iter.First(); t; t = iter.Next()) { if (t->GetKind() == Track::Label) { ltrack = (LabelTrack *)t; break; } } if (!ltrack) { ltrack = mFactory->NewLabelTrack(); this->AddToOutputTracks((Track *)ltrack); } for (l = 0; l < numLabels; l++) { double t0, t1; const char *str; nyx_get_label(l, &t0, &t1, &str); ltrack->AddLabel(t0 + mT0, t1 + mT0, UTF8CTOWX(str)); } return true; } if (rval != nyx_audio) { wxMessageBox(_("Nyquist did not return audio.\n"), wxT("Nyquist"), wxOK | wxCENTRE, mParent); return false; } int outChannels; outChannels = nyx_get_audio_num_channels(); if (outChannels > mCurNumChannels) { wxMessageBox(_("Nyquist returned too many audio channels.\n"), wxT("Nyquist"), wxOK | wxCENTRE, mParent); return false; } double rate = mCurTrack[0]->GetRate(); for (i = 0; i < outChannels; i++) { sampleFormat format = mCurTrack[i]->GetSampleFormat(); if (outChannels == mCurNumChannels) { rate = mCurTrack[i]->GetRate(); } mOutputTrack[i] = mFactory->NewWaveTrack(format, rate); mCurBuffer[i] = NULL; } int success = nyx_get_audio(StaticPutCallback, (void *)this); if (!success) { for(i = 0; i < outChannels; i++) { delete mOutputTrack[i]; mOutputTrack[i] = NULL; } return false; } for (i = 0; i < outChannels; i++) { mOutputTrack[i]->Flush(); if (mCurBuffer[i]) { DeleteSamples(mCurBuffer[i]); } mOutputTime = mOutputTrack[i]->GetEndTime(); } for (i = 0; i < mCurNumChannels; i++) { WaveTrack *out; if (outChannels == mCurNumChannels) { out = mOutputTrack[i]; } else { out = mOutputTrack[0]; } mCurTrack[i]->ClearAndPaste(mT0, mT1, out, false, false); // If we were first in the group adjust non-selected group tracks if (mFirstInGroup) { SyncLockedTracksIterator git(mOutputTracks); Track *t; for (t = git.First(mCurTrack[i]); t; t = git.Next()) { if (!t->GetSelected() && t->IsSyncLockSelected()) { t->SyncLockAdjust(mT1, mT0 + out->GetEndTime()); } } } // Only the first channel can be first in its group mFirstInGroup = false; } for (i = 0; i < outChannels; i++) { delete mOutputTrack[i]; mOutputTrack[i] = NULL; } return true; }
void TrackParameterBox::updateWidgets2() { Track *track = getTrack(); if (!track) return; Instrument *instrument = m_doc->getStudio().getInstrumentFor(track); if (!instrument) return; // *** Track Label QString trackName = strtoqstr(track->getLabel()); if (trackName.isEmpty()) trackName = tr("<untitled>"); else trackName.truncate(20); const int trackNum = track->getPosition() + 1; m_trackLabel->setText(tr("[ Track %1 - %2 ]").arg(trackNum).arg(trackName)); // *** Playback parameters // Device updatePlaybackDevice(instrument->getDevice()->getId()); // Instrument updateInstrument(instrument); // Archive m_archive->setChecked(track->isArchived()); // If the current Instrument is an Audio Instrument... if (instrument->getInstrumentType() == Instrument::Audio) { // Hide irrelevant portions. m_recordingFiltersFrame->setVisible(false); m_staffExportOptionsFrame->setVisible(false); // In the Create segments with... frame, only the color combo is // useful for an Audio track. m_presetLabel->setVisible(false); m_preset->setVisible(false); m_load->setVisible(false); m_clefLabel->setVisible(false); m_clef->setVisible(false); m_transposeLabel->setVisible(false); m_transpose->setVisible(false); m_pitchLabel->setVisible(false); m_lowestLabel->setVisible(false); m_lowest->setVisible(false); m_highestLabel->setVisible(false); m_highest->setVisible(false); } else { // MIDI or soft synth // Show everything. m_recordingFiltersFrame->setVisible(true); m_staffExportOptionsFrame->setVisible(true); // Create segments with... frame m_presetLabel->setVisible(true); m_preset->setVisible(true); m_load->setVisible(true); m_clefLabel->setVisible(true); m_clef->setVisible(true); m_transposeLabel->setVisible(true); m_transpose->setVisible(true); m_pitchLabel->setVisible(true); m_lowestLabel->setVisible(true); m_lowest->setVisible(true); m_highestLabel->setVisible(true); m_highest->setVisible(true); } // *** Recording filters // Device updateRecordingDevice(track->getMidiInputDevice()); // Channel m_recordingChannel->setCurrentIndex((int)track->getMidiInputChannel() + 1); // Thru Routing m_thruRouting->setCurrentIndex((int)track->getThruRouting()); // *** Staff export options // Notation size m_notationSize->setCurrentIndex(track->getStaffSize()); // Bracket type m_bracketType->setCurrentIndex(track->getStaffBracket()); // *** Create segments with // Preset (Label) m_preset->setText(strtoqstr(track->getPresetLabel())); // Clef m_clef->setCurrentIndex(track->getClef()); // Transpose m_transpose->setCurrentIndex( m_transpose->findText(QString("%1").arg(track->getTranspose()))); // Pitch Lowest QSettings settings; settings.beginGroup(GeneralOptionsConfigGroup); const int octaveBase = settings.value("midipitchoctave", -2).toInt() ; settings.endGroup(); const bool includeOctave = false; const Pitch lowest(track->getLowestPlayable(), Accidentals::NoAccidental); // NOTE: this now uses a new, overloaded version of Pitch::getAsString() // that explicitly works with the key of C major, and does not allow the // calling code to specify how the accidentals should be written out. // // Separate the note letter from the octave to avoid undue burden on // translators having to retranslate the same thing but for a number // difference QString tmp = QObject::tr(lowest.getAsString(includeOctave, octaveBase).c_str(), "note name"); tmp += tr(" %1").arg(lowest.getOctave(octaveBase)); m_lowest->setText(tmp); // Pitch Highest const Pitch highest(track->getHighestPlayable(), Accidentals::NoAccidental); tmp = QObject::tr(highest.getAsString(includeOctave, octaveBase).c_str(), "note name"); tmp += tr(" %1").arg(highest.getOctave(octaveBase)); m_highest->setText(tmp); // Color // Note: We only update the combobox contents if there is an actual // change to the document's colors. See slotDocColoursChanged(). m_color->setCurrentIndex(track->getColor()); }
void AnalyseEvents(ExRootTreeReader *treeReader, TestPlots *plots) { TClonesArray *branchParticle = treeReader->UseBranch("Particle"); TClonesArray *branchElectron = treeReader->UseBranch("Electron"); TClonesArray *branchPhoton = treeReader->UseBranch("Photon"); TClonesArray *branchMuon = treeReader->UseBranch("Muon"); TClonesArray *branchTrack = treeReader->UseBranch("Track"); TClonesArray *branchTower = treeReader->UseBranch("Tower"); TClonesArray *branchEFlowTrack = treeReader->UseBranch("EFlowTrack"); TClonesArray *branchEFlowPhoton = treeReader->UseBranch("EFlowPhoton"); TClonesArray *branchEFlowNeutralHadron = treeReader->UseBranch("EFlowNeutralHadron"); TClonesArray *branchJet = treeReader->UseBranch("Jet"); Long64_t allEntries = treeReader->GetEntries(); cout << "** Chain contains " << allEntries << " events" << endl; GenParticle *particle; Electron *electron; Photon *photon; Muon *muon; Track *track; Tower *tower; Jet *jet; TObject *object; TLorentzVector momentum; Float_t Eem, Ehad; Bool_t skip; Long64_t entry; Int_t i, j, pdgCode; // Loop over all events for(entry = 0; entry < allEntries; ++entry) { // Load selected branches with data from specified event treeReader->ReadEntry(entry); // Loop over all electrons in event for(i = 0; i < branchElectron->GetEntriesFast(); ++i) { electron = (Electron*) branchElectron->At(i); particle = (GenParticle*) electron->Particle.GetObject(); plots->fElectronDeltaPT->Fill((particle->PT - electron->PT)/particle->PT); plots->fElectronDeltaEta->Fill((particle->Eta - electron->Eta)/particle->Eta); } // Loop over all photons in event for(i = 0; i < branchPhoton->GetEntriesFast(); ++i) { photon = (Photon*) branchPhoton->At(i); // skip photons with references to multiple particles if(photon->Particles.GetEntriesFast() != 1) continue; particle = (GenParticle*) photon->Particles.At(0); plots->fPhotonDeltaPT->Fill((particle->PT - photon->PT)/particle->PT); plots->fPhotonDeltaEta->Fill((particle->Eta - photon->Eta)/particle->Eta); plots->fPhotonDeltaE->Fill((particle->E - photon->E)/particle->E); } // Loop over all muons in event for(i = 0; i < branchMuon->GetEntriesFast(); ++i) { muon = (Muon*) branchMuon->At(i); particle = (GenParticle*) muon->Particle.GetObject(); plots->fMuonDeltaPT->Fill((particle->PT - muon->PT)/particle->PT); plots->fMuonDeltaEta->Fill((particle->Eta - muon->Eta)/particle->Eta); } // Loop over all tracks in event for(i = 0; i < branchTrack->GetEntriesFast(); ++i) { track = (Track*) branchTrack->At(i); particle = (GenParticle*) track->Particle.GetObject(); plots->fTrackDeltaPT->Fill((particle->PT - track->PT)/particle->PT); plots->fTrackDeltaEta->Fill((particle->Eta - track->Eta)/particle->Eta); } // cout << "-- New event -- " << endl; // Loop over all jets in event for(i = 0; i < branchJet->GetEntriesFast(); ++i) { jet = (Jet*) branchJet->At(i); momentum.SetPxPyPzE(0.0, 0.0, 0.0, 0.0); // cout<<"Looping over jet constituents. Jet pt: "<<jet->PT<<", eta: "<<jet->Eta<<", phi: "<<jet->Phi<<endl; // Loop over all jet's constituents for(j = 0; j < jet->Constituents.GetEntriesFast(); ++j) { object = jet->Constituents.At(j); // Check if the constituent is accessible if(object == 0) continue; if(object->IsA() == GenParticle::Class()) { particle = (GenParticle*) object; // cout << " GenPart pt: " << particle->PT << ", eta: " << particle->Eta << ", phi: " << particle->Phi << endl; momentum += particle->P4(); } else if(object->IsA() == Track::Class()) { track = (Track*) object; // cout << " Track pt: " << track->PT << ", eta: " << track->Eta << ", phi: " << track->Phi << endl; momentum += track->P4(); } else if(object->IsA() == Tower::Class()) { tower = (Tower*) object; // cout << " Tower pt: " << tower->ET << ", eta: " << tower->Eta << ", phi: " << tower->Phi << endl; momentum += tower->P4(); } } plots->fJetDeltaPT->Fill((jet->PT - momentum.Pt())/jet->PT); } } }