ardour/ardour
ardour
/
ardour
13
1
Fork 0
Code Pull Requests Releases Activity

refactoring to prepare for real-time export 

* add a threaded TmpFile Writer
* update API calls to that process_export_fw() can be used as
  process_function

The idea is to re-use export infrastructure from normalization:
export to a tmp-file and then encode target formats after that.
This commit is contained in:
Robin Gareus 2016-07-14 04:34:18 +02:00
parent d46e8a3d8b
commit e55ef88ee9
8 changed files with 231 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/ardour/ardour/audioengine.h
View File

@ -161,7 +161,7 @@ class LIBARDOUR_API AudioEngine : public PortManager, public SessionHandlePtr
(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;

2
libs/ardour/ardour/export_graph_builder.h
View File

@ -41,6 +41,7 @@ namespace AudioGrapher {
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;
}
@ -164,6 +165,7 @@ class LIBARDOUR_API ExportGraphBuilder
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;

7
libs/ardour/ardour/session.h
View File

@ -704,7 +704,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
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;
@ -1230,8 +1230,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
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); }
@ -1268,6 +1268,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
bool _exporting;
bool _export_rolling;
bool _realtime_export;
framepos_t _export_preroll;
framepos_t _export_latency;

1
libs/ardour/export_graph_builder.cc
View File

@ -36,6 +36,7 @@
#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"

1
libs/ardour/session.cc
View File

@ -213,6 +213,7 @@ Session::Session (AudioEngine &eng,
, post_export_position (0)
, _exporting (false)
, _export_rolling (false)
, _realtime_export (false)
, _export_preroll (0)
, _export_latency (0)
, _pre_export_mmc_enabled (false)

74
libs/ardour/session_export.cc
View File

@ -104,13 +104,20 @@ Session::pre_export ()
/** 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;
@ -170,12 +177,19 @@ Session::start_audio_export (framepos_t position)
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) {
@ -201,26 +215,27 @@ Session::process_export (pframes_t nframes)
} 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);
@ -228,29 +243,36 @@ Session::process_export_fw (pframes_t nframes)
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
@ -279,9 +301,13 @@ Session::finalize_audio_export ()
/* 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);

2
libs/audiographer/audiographer/sndfile/tmp_file.h
View File

@ -35,7 +35,7 @@ class TmpFile : public SndfileWriter<T>, public SndfileReader<T>
~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();

171
libs/audiographer/audiographer/sndfile/tmp_file_rt.h Normal file
View File

@ -0,0 +1,171 @@
#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