void EngineRecord::process(const CSAMPLE* pBuffer, const int iBufferSize) { // if recording is disabled if (m_recReady->get() == RECORD_OFF) { //qDebug("Setting record flag to: OFF"); if (fileOpen()) { closeFile(); //close file and free encoder emit(isRecording(false)); } } // if we are ready for recording, i.e, the output file has been selected, we // open a new file if (m_recReady->get() == RECORD_READY) { updateFromPreferences(); //update file location from pref if (openFile()) { qDebug("Setting record flag to: ON"); m_recReady->slotSet(RECORD_ON); emit(isRecording(true)); //will notify the RecordingManager // Since we just started recording, timeout and clear the metadata. m_iMetaDataLife = kMetaDataLifeTimeout; m_pCurrentTrack = TrackPointer(); if (m_bCueIsEnabled) { openCueFile(); m_cuesamplepos = 0; m_cuetrack = 0; } } else { // Maybe the encoder could not be initialized qDebug("Setting record flag to: OFF"); m_recReady->slotSet(RECORD_OFF); emit(isRecording(false)); } } // If recording is enabled process audio to compressed or uncompressed data. if (m_recReady->get() == RECORD_ON) { if (m_Encoding == ENCODING_WAVE || m_Encoding == ENCODING_AIFF) { if (m_sndfile != NULL) { sf_write_float(m_sndfile, pBuffer, iBufferSize); emit(bytesRecorded(iBufferSize)); } } else { if (m_encoder) { // Compress audio. Encoder will call method 'write()' below to // write a file stream m_encoder->encodeBuffer(pBuffer, iBufferSize); } } if (m_bCueIsEnabled) { if (metaDataHasChanged()) { m_cuetrack++; writeCueLine(); m_cuefile.flush(); } m_cuesamplepos += iBufferSize; } } }
bool ASimModeBase::toggleRecording() { if (isRecording()) stopRecording(); else startRecording(); return isRecording(); }
void DvbStream::recordingState() { int i; for ( i=0; i<(int)out.count(); i++ ) { if ( out.at(i)->hasRec() ) { emit isRecording( true ); return; } } emit isRecording( false ); }
void VideoRecorderControls::submitNewFrame(HdlTexture& texture) { static bool lock = false; if(lock) return; lock = true; if(!isRecording()) { lock = false; throw Exception("VideoRecorderControls::submitNewFrame - Not recording.", __FILE__, __LINE__); } else { try { (*recorder) << texture << OutputDevice::Process; recordingDialog.updateFrameCount(recorder->getNumEncodedFrames()); recordingDialog.updateDuration(recorder->getTotalVideoDurationSec()); } catch(Exception& e) { lock = false; throw e; } } lock = false; }
std::vector<std::vector<int> > SpikeMonitor::getSpikeVector2D() { std::string funcName = "getSpikeVector2D()"; UserErrors::assertTrue(!isRecording(), UserErrors::CANNOT_BE_ON, funcName, "Recording"); UserErrors::assertTrue(getMode()==AER, UserErrors::CAN_ONLY_BE_CALLED_IN_MODE, funcName, funcName, "AER"); return spikeMonitorCorePtr_->getSpikeVector2D(); }
float SpikeMonitor::getNeuronMeanFiringRate(int neurId) { std::string funcName = "getNeuronMeanFiringRate()"; UserErrors::assertTrue(!isRecording(), UserErrors::CANNOT_BE_ON, funcName, "Recording"); return spikeMonitorCorePtr_->getNeuronMeanFiringRate(neurId); }
int SpikeMonitorCore::getNeuronNumSpikes(int neurId) { assert(!isRecording()); assert(neurId>=0 && neurId<nNeurons_); assert(getMode()==AER); return spkVector_[neurId].size(); }
EmulationHandler::~EmulationHandler() { if (isRecording()) clearScript(); delete m_teEmu; delete m_teWid; delete m_log; }
bool RecordingDevice::start(int samples, int sampleRate, int bitDepth, int channels) { ALenum format = Audio::getFormat(bitDepth, channels); if (format == AL_NONE) throw InvalidFormatException(channels, bitDepth); if (samples <= 0) throw love::Exception("Invalid number of samples."); if (sampleRate <= 0) throw love::Exception("Invalid sample rate."); if (isRecording()) stop(); device = alcCaptureOpenDevice(name.c_str(), sampleRate, format, samples); if (device == nullptr) return false; alcCaptureStart(device); this->samples = samples; this->sampleRate = sampleRate; this->bitDepth = bitDepth; this->channels = channels; return true; }
void GraphicsContext::setFillGradient(Ref<Gradient>&& gradient) { m_state.fillGradient = WTFMove(gradient); m_state.fillPattern = nullptr; if (isRecording()) m_displayListRecorder->updateState(m_state, GraphicsContextState::FillGradientChange); // FIXME: also fill pattern? }
void fboRecorder::drawMenuEntry(){ ImGui::TextWrapped("Records the video output and saves it to a video file using a separate thread."); //ImGui::Selectable("Show Gui Window...", &bShowGuiWindow); if (ImGui::ListBoxHeader("Video Recording Mode", 3)){ // manually add new modes here if ( ImGui::Selectable("VIDEOREC_MODE_FILE_H264", fboRecMode==VIDEOREC_MODE_FILE_H264)) { setRecordMode(VIDEOREC_MODE_FILE_H264); } if ( ImGui::Selectable("VIDEOREC_MODE_FILE_PNG", fboRecMode==VIDEOREC_MODE_FILE_PNG)) { setRecordMode(VIDEOREC_MODE_FILE_PNG); } #ifdef KM_ENABLE_SYPHON if ( ImGui::Selectable("VIDEOREC_MODE_SYPHON", fboRecMode==VIDEOREC_MODE_SYPHON)) { setRecordMode(VIDEOREC_MODE_SYPHON); } #endif ImGui::ListBoxFooter(); } ImGui::Checkbox("Use grab screen instead of fbo", &useGrabScreen); ImGui::Checkbox("Show recorded output", &videoRecShowOutput); ImGui::Separator(); if( isEnabled() ){ if(!isRecording()){ if(ImGui::Button("Start Recording")){ startRecording(); } } else { if(ImGui::Button("Stop Recording")){ stopRecording(); } if(fbo.isAllocated()){ ImGui::TextWrapped("Recorded resolution: %gx%gpx", fbo.getWidth(), fbo.getHeight()); } } } switch (fboRecMode) { case VIDEOREC_MODE_FILE_H264 : case VIDEOREC_MODE_FILE_PNG : ImGui::TextWrapped("Video File Settings"); ImGui::InputInt("Bitrate", &videoRecBitRate); ImGui::InputInt("AA quality", &videoRecAA); ImGui::InputInt("Target video FPS", &videoRecFPS); break; #ifdef KM_ENABLE_SYPHON case VIDEOREC_MODE_SYPHON : ImGui::TextWrapped("Syphon Settings (not yet)"); break; #endif default: break; } }
void AutomationPattern::processMidiTime( const MidiTime & time ) { if( ! isRecording() ) { if( time >= 0 && hasAutomation() ) { const float val = valueAt( time ); for( objectVector::iterator it = m_objects.begin(); it != m_objects.end(); ++it ) { if( *it ) { ( *it )->setAutomatedValue( val ); } } } } else { if( time >= 0 && ! m_objects.isEmpty() ) { const float value = static_cast<float>( firstObject()->value<float>() ); if( value != m_lastRecordedValue ) { putValue( time, value, true ); m_lastRecordedValue = value; } else if( valueAt( time ) != value ) { removeValue( time, false ); } } } }
void QedGroupControl::adjustLiveWorldViewStopped(QmcTime::Packet *packet) { if (isActive(packet)) { newButtonState(packet->state, packet->mode, isRecording(packet)); updateTimeButton(); } }
void QedGroupControl::adjustLiveWorldViewForward(QmcTime::Packet *packet) { console->post("QedGroupControl::adjustLiveWorldViewForward"); if (isActive(packet)) newButtonState(packet->state, packet->mode, isRecording(packet)); }
int AudioClassifier<T>::classify() { auto sound = -1; auto ready = classifierReady.load(); if (!ready || isRecording()) return -1; if (noteOnsetDetected()) { switch (currentClassfierType.load()) { case AudioClassifyOptions::ClassifierType::nearestNeighbour: if (reducedVarianceSize > 0) sound = knn.classify(currentInstanceVectorReduced); else sound = knn.classify(currentInstanceVector); break; case AudioClassifyOptions::ClassifierType::naiveBayes: if (reducedVarianceSize > 0) sound = nbc.Classify(currentInstanceVectorReduced); else sound = nbc.Classify(currentInstanceVector); break; default: break; // Sound returned -1 (Invalid label. Valid labels are 0 to numSounds) } } return sound; }
float SpikeMonitorCore::getMinFiringRate(){ assert(!isRecording()); std::vector<float> rates = getAllFiringRatesSorted(); return rates.front(); }
void QedGroupControl::step(QmcTime::Packet *packet) { double stepPosition = QedApp::timevalToSeconds(packet->position); console->post(QedApp::DebugProtocol, "GroupControl::step: stepping to time %.2f, delta=%.2f, state=%s", stepPosition, my.realDelta, timeState()); if ((packet->source == QmcTime::ArchiveSource && ((packet->state == QmcTime::ForwardState && my.timeState != ForwardState) || (packet->state == QmcTime::BackwardState && my.timeState != BackwardState))) || sideStep(stepPosition, my.realPosition, my.realDelta)) return adjustWorldView(packet, false); my.pmtimeState = packet->state; my.position = packet->position; my.realPosition = stepPosition; adjustStep(packet); fetch(); if (isActive(packet)) newButtonState(packet->state, packet->mode, isRecording(packet)); }
void GraphicsContext::setStrokeGradient(Ref<Gradient>&& gradient) { m_state.strokeGradient = WTFMove(gradient); m_state.strokePattern = nullptr; if (isRecording()) m_displayListRecorder->updateState(m_state, GraphicsContextState::StrokeGradientChange); }
void GraphicsContext::setFillPattern(Ref<Pattern>&& pattern) { m_state.fillGradient = nullptr; m_state.fillPattern = WTFMove(pattern); if (isRecording()) m_displayListRecorder->updateState(m_state, GraphicsContextState::FillPatternChange); }
qint64 Recorder::elapsed() const { if (isRecording()) { return _timer.elapsed(); } else { return 0; } }
void RecordingManager::slotIsRecording(bool isRecordingActive) { //qDebug() << "SlotIsRecording " << isRecording; //Notify the GUI controls, see dlgrecording.cpp m_isRecording = isRecordingActive; emit(isRecording(isRecordingActive)); }
std::vector<float> SpikeMonitorCore::getAllFiringRatesSorted() { assert(!isRecording()); // if necessary, get data structures up-to-date sortFiringRates(); return firingRatesSorted_; }
SaveFileForwarder::SaveFileForwarder(const SaveImages::ptr& save_images, const NetworkDispatcher::ptr& dispatcher) : NetworkReceiver{dispatcher}, dptr(save_images) { register_handler(SaveFileProtocol::StartRecording, [this](const NetworkPacket::ptr &) { d->save_images->startRecording(d->imager); }); register_handler(SaveFileProtocol::EndRecording, [this](const NetworkPacket::ptr &) { d->save_images->endRecording(); }); QObject::connect(save_images.get(), &SaveImages::saveFPS, save_images.get(), [this](double fps) { this->dispatcher()->queue_send(SaveFileProtocol::packetsignalSaveFPS() << QVariant{fps}); } ); QObject::connect(save_images.get(), &SaveImages::meanFPS, save_images.get(), [this](double fps) { this->dispatcher()->queue_send(SaveFileProtocol::packetsignalMeanFPS() << QVariant{fps}); } ); QObject::connect(save_images.get(), &SaveImages::savedFrames, save_images.get(), [this](uint64_t frames) { this->dispatcher()->queue_send(SaveFileProtocol::packetsignalSavedFrames() << QVariant{static_cast<qlonglong>(frames)}); } ); QObject::connect(save_images.get(), &SaveImages::droppedFrames, save_images.get(), [this](uint64_t frames) { this->dispatcher()->queue_send(SaveFileProtocol::packetsignalDroppedFrames() << QVariant{static_cast<qlonglong>(frames)}); } ); QObject::connect(save_images.get(), &SaveImages::recording, save_images.get(), [this](const QString &file) { emit isRecording(true); this->dispatcher()->queue_send(SaveFileProtocol::packetsignalRecording() << QVariant{file}); } ); QObject::connect(save_images.get(), &SaveImages::finished, save_images.get(), [this]{ this->dispatcher()->queue_send(SaveFileProtocol::packetsignalFinished()); emit isRecording(false); } ); }
void EmulationHandler::recvEmulation(const char* src, int len ) { QByteArray ar(len); memcpy(ar.data(), src, sizeof(char) * len ); if (isRecording()) m_script->append(ar); emit send(ar); }
QmlProfilerTraceClient::~QmlProfilerTraceClient() { //Disable profiling if started by client //Profiling data will be lost!! if (isRecording()) setRecording(false); delete d; }
float SpikeMonitorCore::getPopMeanFiringRate() { assert(!isRecording()); if (totalTime_==0) return 0.0f; return getPopNumSpikes()*1000.0/(getRecordingTotalTime()*nNeurons_); }
void GraphicsContext::beginTransparencyLayer(float opacity) { if (isRecording()) { m_displayListRecorder->beginTransparencyLayer(opacity); return; } beginPlatformTransparencyLayer(opacity); ++m_transparencyCount; }
void GraphicsContext::setAlpha(float alpha) { m_state.alpha = alpha; if (isRecording()) { m_displayListRecorder->updateState(m_state, GraphicsContextState::AlphaChange); return; } setPlatformAlpha(alpha); }
void QedGroupControl::adjustArchiveWorldViewBackward(QmcTime::Packet *packet, bool setup) { console->post("QedGroupControl::adjustArchiveWorldViewBackward"); if (setup) packet->state = QmcTime::StoppedState; if (isActive(packet)) newButtonState(packet->state, packet->mode, isRecording(packet)); }
bool FlycamOne::stopRecording() { if (isBusy() || isRecording() == false || m_camMode == CamMode_Photo) { return false; } setCommand(Command_StartStop); return true; }