(the regular process() call to session->process() is not made)
*/
- PBD::Signal1<int, pframes_t> Freewheel;
+ PBD::Signal1<void, pframes_t> Freewheel;
PBD::Signal0<void> Xrun;
template <typename T> class SndfileWriter;
template <typename T> class SilenceTrimmer;
template <typename T> class TmpFile;
+ template <typename T> class TmpFileRt;
template <typename T> class Threader;
template <typename T> class AllocatingProcessContext;
}
typedef boost::shared_ptr<AudioGrapher::LoudnessReader> LoudnessReaderPtr;
typedef boost::shared_ptr<AudioGrapher::Normalizer> NormalizerPtr;
typedef boost::shared_ptr<AudioGrapher::TmpFile<Sample> > TmpFilePtr;
+ typedef boost::shared_ptr<AudioGrapher::TmpFileRt<Sample> > TmpFileRtPtr;
typedef boost::shared_ptr<AudioGrapher::Threader<Sample> > ThreaderPtr;
typedef boost::shared_ptr<AudioGrapher::AllocatingProcessContext<Sample> > BufferPtr;
boost::shared_ptr<ExportHandler> get_export_handler ();
boost::shared_ptr<ExportStatus> get_export_status ();
- int start_audio_export (framepos_t position);
+ int start_audio_export (framepos_t position, bool realtime = false);
PBD::Signal1<int, framecnt_t> ProcessExport;
static PBD::Signal2<void,std::string, std::string> Exported;
void process_without_events (pframes_t);
void process_with_events (pframes_t);
void process_audition (pframes_t);
- int process_export (pframes_t);
- int process_export_fw (pframes_t);
+ void process_export (pframes_t);
+ void process_export_fw (pframes_t);
void block_processing() { g_atomic_int_set (&processing_prohibited, 1); }
void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
bool _exporting;
bool _export_rolling;
+ bool _realtime_export;
framepos_t _export_preroll;
framepos_t _export_latency;
#include "audiographer/general/silence_trimmer.h"
#include "audiographer/general/threader.h"
#include "audiographer/sndfile/tmp_file.h"
+#include "audiographer/sndfile/tmp_file_rt.h"
#include "audiographer/sndfile/sndfile_writer.h"
#include "ardour/audioengine.h"
, post_export_position (0)
, _exporting (false)
, _export_rolling (false)
+ , _realtime_export (false)
, _export_preroll (0)
, _export_latency (0)
, _pre_export_mmc_enabled (false)
/** Called for each range that is being exported */
int
-Session::start_audio_export (framepos_t position)
+Session::start_audio_export (framepos_t position, bool realtime)
{
if (!_exporting) {
pre_export ();
}
- _export_preroll = Config->get_export_preroll() * nominal_frame_rate ();
+ _realtime_export = realtime;
+
+ if (realtime) {
+ _export_preroll = nominal_frame_rate ();
+ } else {
+ _export_preroll = Config->get_export_preroll() * nominal_frame_rate ();
+ }
+
if (_export_preroll == 0) {
// must be > 0 so that transport is started in sync.
_export_preroll = 1;
return -1;
}
- _engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1));
- _export_rolling = true;
- return _engine.freewheel (true);
+ if (_realtime_export) {
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ _export_rolling = true;
+ process_function = &Session::process_export_fw;
+ return 0;
+ } else {
+ _engine.Freewheel.connect_same_thread (export_freewheel_connection, boost::bind (&Session::process_export_fw, this, _1));
+ _export_rolling = true;
+ return _engine.freewheel (true);
+ }
}
-int
+void
Session::process_export (pframes_t nframes)
{
if (_export_rolling && export_status->stop) {
} catch (std::exception & e) {
error << string_compose (_("Export ended unexpectedly: %1"), e.what()) << endmsg;
export_status->abort (true);
- return -1;
}
-
- return 0;
}
-int
+void
Session::process_export_fw (pframes_t nframes)
{
if (_export_preroll > 0) {
- _engine.main_thread()->get_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->get_buffers ();
+ }
fail_roll (nframes);
- _engine.main_thread()->drop_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->drop_buffers ();
+ }
_export_preroll -= std::min ((framepos_t)nframes, _export_preroll);
if (_export_preroll > 0) {
// clear out buffers (reverb tails etc).
- return 0;
+ return;
}
set_transport_speed (1.0, 0, false);
g_atomic_int_set (&_butler->should_do_transport_work, 0);
post_transport ();
- return 0;
+ return;
}
if (_export_latency > 0) {
framepos_t remain = std::min ((framepos_t)nframes, _export_latency);
- _engine.main_thread()->get_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->get_buffers ();
+ }
process_without_events (remain);
- _engine.main_thread()->drop_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->drop_buffers ();
+ }
_export_latency -= remain;
nframes -= remain;
if (nframes == 0) {
- return 0;
+ return;
}
}
-
- _engine.main_thread()->get_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->get_buffers ();
+ }
process_export (nframes);
- _engine.main_thread()->drop_buffers ();
+ if (!_realtime_export) {
+ _engine.main_thread()->drop_buffers ();
+ }
- return 0;
+ return;
}
int
/* Clean up */
- _engine.freewheel (false);
-
- export_freewheel_connection.disconnect();
+ if (_realtime_export) {
+ Glib::Threads::Mutex::Lock lm (AudioEngine::instance()->process_lock ());
+ process_function = &Session::process_with_events;
+ } else {
+ _engine.freewheel (false);
+ export_freewheel_connection.disconnect();
+ }
_mmc->enable_send (_pre_export_mmc_enabled);
~TmpFile()
{
/* explicitly close first, some OS (yes I'm looking at you windows)
- * cannot delet files that are still open
+ * cannot delete files that are still open
*/
if (!filename.empty()) {
SndfileBase::close();
--- /dev/null
+#ifndef AUDIOGRAPHER_TMP_FILE_RT_H
+#define AUDIOGRAPHER_TMP_FILE_RT_H
+
+#include <cstdio>
+#include <string>
+
+#include <glib.h>
+#include "pbd/gstdio_compat.h"
+#include "pbd/ringbuffer.h"
+
+#include "audiographer/flag_debuggable.h"
+#include "audiographer/sink.h"
+#include "sndfile_reader.h"
+
+namespace AudioGrapher
+{
+
+/// A temporary file deleted after this class is destructed
+template<typename T = DefaultSampleType>
+class TmpFileRt
+ : public virtual SndfileReader<T>
+ , public virtual SndfileBase
+ , public Sink<T>
+ , public FlagDebuggable<>
+{
+ public:
+
+ /// \a filename_template must match the requirements for mkstemp, i.e. end in "XXXXXX"
+ TmpFileRt (char * filename_template, int format, ChannelCount channels, framecnt_t samplerate)
+ : SndfileHandle (g_mkstemp(filename_template), true, SndfileBase::ReadWrite, format, channels, samplerate)
+ , filename (filename_template)
+ , _rb (samplerate * channels)
+ {
+ init ();
+ }
+
+ using SndfileHandle::operator=;
+
+ ~TmpFileRt()
+ {
+ end_write ();
+ /* explicitly close first, some OS (yes I'm looking at you windows)
+ * cannot delete files that are still open
+ */
+ if (!filename.empty()) {
+ SndfileBase::close();
+ std::remove(filename.c_str());
+ }
+ pthread_mutex_destroy (&_disk_thread_lock);
+ pthread_cond_destroy (&_data_ready);
+ }
+
+ framecnt_t get_frames_written() const { return frames_written; }
+ void reset_frames_written_count() { frames_written = 0; }
+
+ /// Writes data to file
+ void process (ProcessContext<T> const & c)
+ {
+ check_flags (*this, c);
+
+ if (SndfileReader<T>::throw_level (ThrowStrict) && c.channels() != channels()) {
+ throw Exception (*this, boost::str (boost::format
+ ("Wrong number of channels given to process(), %1% instead of %2%")
+ % c.channels() % channels()));
+ }
+
+ if (SndfileReader<T>::throw_level (ThrowProcess) && _rb.write_space() < c.frames()) {
+ throw Exception (*this, boost::str (boost::format
+ ("Could not write data to ringbuffer/output file (%1%)")
+ % strError()));
+ }
+
+ _rb.write (c.data(), c.frames());
+
+ if (pthread_mutex_trylock (&_disk_thread_lock) == 0) {
+ pthread_cond_signal (&_data_ready);
+ pthread_mutex_unlock (&_disk_thread_lock);
+ }
+
+ if (c.has_flag(ProcessContext<T>::EndOfInput)) {
+ end_write (); // XXX not rt-safe -- TODO add API call to flush
+ FileWritten (filename);
+ }
+ }
+
+ using Sink<T>::process;
+
+ PBD::Signal1<void, std::string> FileWritten;
+
+ void disk_thread ()
+ {
+ const size_t chunksize = 8192; // samples
+ T *framebuf = (T*) malloc (chunksize * sizeof (T));
+
+ pthread_mutex_lock (&_disk_thread_lock);
+
+ while (1) {
+ if (!_capture) {
+ break;
+ }
+ if (_rb.read_space () >= chunksize) {
+ _rb.read (framebuf, chunksize);
+ framecnt_t const written = write (framebuf, chunksize);
+ assert (written == chunksize);
+ frames_written += written;
+ }
+ pthread_cond_wait (&_data_ready, &_disk_thread_lock);
+ }
+
+ // flush ringbuffer
+ while (_rb.read_space () > 0) {
+ size_t remain = std::min ((size_t)_rb.read_space (), chunksize);
+ _rb.read (framebuf, remain);
+ framecnt_t const written = write (framebuf, remain);
+ frames_written += written;
+ }
+ writeSync();
+
+ pthread_mutex_unlock (&_disk_thread_lock);
+ free (framebuf);
+ }
+
+ protected:
+ std::string filename;
+ framecnt_t frames_written;
+
+ bool _capture;
+ RingBuffer<T> _rb;
+
+ pthread_mutex_t _disk_thread_lock;
+ pthread_cond_t _data_ready;
+ pthread_t _thread_id;
+
+ static void * _disk_thread (void *arg)
+ {
+ TmpFileRt *d = static_cast<TmpFileRt *>(arg);
+ d->disk_thread ();
+ pthread_exit (0);
+ return 0;
+ }
+
+ void end_write () {
+ pthread_mutex_lock (&_disk_thread_lock);
+ if (!_capture) {
+ pthread_mutex_unlock (&_disk_thread_lock);
+ return;
+ }
+ _capture = false;
+ pthread_cond_signal (&_data_ready);
+ pthread_mutex_unlock (&_disk_thread_lock);
+ pthread_join (_thread_id, NULL);
+ }
+
+ void init()
+ {
+ frames_written = 0;
+ _capture = true;
+ add_supported_flag (ProcessContext<T>::EndOfInput);
+ pthread_mutex_init (&_disk_thread_lock, 0);
+ pthread_cond_init (&_data_ready, 0);
+
+ pthread_create (&_thread_id, NULL, _disk_thread, this);
+ }
+
+ private:
+ TmpFileRt (TmpFileRt const & other) : SndfileHandle (other) {}
+};
+
+} // namespace
+
+#endif // AUDIOGRAPHER_TMP_FILE_RT_H
projects / ardour.git / commitdiff