if ((s = session->source_by_path_and_channel (path, n)) == 0) {
source = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createReadable (DataType::AUDIO, *session, path, n,
+ SourceFactory::createReadable (DataType::AUDIO, *session,
+ path, false, n,
(mode == ImportAsTapeTrack
- ? Source::Destructive
+ ? Source::Destructive
: Source::Flag (0)),
true, true));
} else {
try {
- fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (DataType::AUDIO, *session, path, false, session->frame_rate()));
+ fs = boost::dynamic_pointer_cast<AudioFileSource> (
+ SourceFactory::createWritable (DataType::AUDIO, *session,
+ path, true,
+ false, session->frame_rate()));
}
catch (failed_constructor& err) {
path = s;
try {
- fs = boost::dynamic_pointer_cast<AudioFileSource> (SourceFactory::createWritable (DataType::AUDIO, *session, path, false, session->frame_rate()));
+ fs = boost::dynamic_pointer_cast<AudioFileSource> (
+ SourceFactory::createWritable (DataType::AUDIO, *session,
+ path, true,
+ false, session->frame_rate()));
}
catch (failed_constructor& err) {
for (int n = 0; n < sf_info.channels; ++n) {
try {
afs = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createReadable (DataType::AUDIO, *_session, path,
- n, Source::Flag (0), false));
+ SourceFactory::createReadable (DataType::AUDIO, *_session,
+ path, false, n, Source::Flag (0), false));
srclist.push_back(afs);
bool
SoundFileBrowser::on_audio_filter (const FileFilter::Info& filter_info)
{
- return AudioFileSource::safe_file_extension (filter_info.filename);
+ return AudioFileSource::safe_audio_file_extension (filter_info.filename);
}
bool
SoundFileBrowser::on_midi_filter (const FileFilter::Info& filter_info)
{
- return SMFSource::safe_file_extension (filter_info.filename);
+ return SMFSource::safe_midi_file_extension (filter_info.filename);
}
void
src_needed = true;
}
- } else if (SMFSource::safe_file_extension (*i)) {
+ } else if (SMFSource::safe_midi_file_extension (*i)) {
Evoral::SMFReader reader(*i);
if (reader.num_tracks() > 1) {
export_timespan.cc
export_utilities.cc
filename_extensions.cc
+file_source.cc
filesystem_paths.cc
filter.cc
find_session.cc
session_time.cc
session_transport.cc
session_utils.cc
-silentfilesource.cc
smf_source.cc
sndfile_helpers.cc
sndfileimportable.cc
#define __ardour_audiofilesource_h__
#include <exception>
-
#include <time.h>
-
#include <ardour/audiosource.h>
+#include <ardour/file_source.h>
namespace ARDOUR {
-class non_existent_source : public std::exception {
- public:
- virtual const char *what() const throw() { return "audio file does not exist"; }
-};
-
struct SoundFileInfo {
float samplerate;
uint16_t channels;
int64_t timecode;
};
-class AudioFileSource : public AudioSource {
- public:
+class AudioFileSource : public AudioSource, public FileSource {
+public:
virtual ~AudioFileSource ();
bool set_name (const std::string& newname) {
return (set_source_name(newname, destructive()) == 0);
}
- int set_source_name (Glib::ustring newname, bool destructive);
- Glib::ustring path() const { return _path; }
Glib::ustring peak_path (Glib::ustring audio_path);
Glib::ustring find_broken_peakfile (Glib::ustring missing_peak_path,
Glib::ustring audio_path);
- uint16_t channel() const { return _channel; }
-
static void set_peak_dir (Glib::ustring dir) { peak_dir = dir; }
static bool get_soundfile_info (Glib::ustring path, SoundFileInfo& _info, std::string& error);
- static bool safe_file_extension (Glib::ustring path);
-
- void set_allow_remove_if_empty (bool yn);
- void mark_for_remove();
+ bool safe_file_extension (const Glib::ustring& path) const {
+ return safe_audio_file_extension(path);
+ }
/* this block of methods do nothing for regular file sources, but are significant
for files used in destructive recording.
*/
virtual nframes_t last_capture_start_frame() const { return 0; }
- virtual void mark_capture_start (nframes_t) {}
- virtual void mark_capture_end () {}
- virtual void clear_capture_marks() {}
- virtual bool one_of_several_channels () const { return false; }
+ virtual void mark_capture_start (nframes_t) {}
+ virtual void mark_capture_end () {}
+ virtual void clear_capture_marks() {}
+ virtual bool one_of_several_channels () const { return false; }
virtual int update_header (nframes_t when, struct tm&, time_t) = 0;
virtual int flush_header () = 0;
- int move_to_trash (const Glib::ustring& trash_dir_name);
-
- static bool is_empty (Session&, Glib::ustring path);
void mark_streaming_write_completed ();
- void mark_take (Glib::ustring);
- Glib::ustring take_id() const { return _take_id; }
-
- bool is_embedded() const { return _is_embedded; }
-
- static void set_bwf_serial_number (int);
-
- static void set_search_path (Glib::ustring string);
- static void set_header_position_offset (nframes_t offset );
-
int setup_peakfile ();
XMLNode& get_state ();
int set_state (const XMLNode&);
- bool destructive() const { return (_flags & Destructive); }
- virtual bool set_destructive (bool yn) { return false; }
- bool can_truncate_peaks() const { return !destructive(); }
- bool can_be_analysed() const { return _length > 0; }
-
- void mark_immutable ();
+ bool can_truncate_peaks() const { return !destructive(); }
+ bool can_be_analysed() const { return _length > 0; }
+ static bool safe_audio_file_extension (const Glib::ustring& path);
+
+ static bool is_empty (Session&, Glib::ustring path);
+
+ static void set_bwf_serial_number (int);
+ static void set_header_position_offset (nframes_t offset );
+
static sigc::signal<void> HeaderPositionOffsetChanged;
- protected:
-
+protected:
/** Constructor to be called for existing external-to-session files */
- AudioFileSource (Session&, Glib::ustring path, Source::Flag flags);
+ AudioFileSource (Session&, const Glib::ustring& path, bool embedded, Source::Flag flags);
/** Constructor to be called for new in-session files */
- AudioFileSource (Session&, Glib::ustring path, Source::Flag flags,
+ AudioFileSource (Session&, const Glib::ustring& path, bool embedded, Source::Flag flags,
SampleFormat samp_format, HeaderFormat hdr_format);
/** Constructor to be called for existing in-session files */
- AudioFileSource (Session&, const XMLNode&, bool must_exit = true);
+ AudioFileSource (Session&, const XMLNode&, bool must_exist = true);
- int init (Glib::ustring idstr, bool must_exist);
-
- static bool determine_embeddedness (Glib::ustring path);
+ int init (const Glib::ustring& idstr, bool must_exist);
- virtual void set_timeline_position (int64_t pos);
virtual void set_header_timeline_position () = 0;
virtual void handle_header_position_change () {}
-
- bool find (Glib::ustring& path, bool must_exist, bool& is_new, uint16_t& chan);
- bool removable() const;
- bool writable() const { return _flags & Writable; }
+
+ int move_dependents_to_trash();
static Sample* get_interleave_buffer (nframes_t size);
- Glib::ustring _path;
- Glib::ustring _take_id;
- int64_t _timeline_position;
- bool _file_is_new;
- uint16_t _channel;
- bool _is_embedded;
-
static Glib::ustring peak_dir;
- static Glib::ustring search_path;
static char bwf_country_code[3];
static char bwf_organization_code[4];
namespace ARDOUR {
-class AudioSource : public Source, public boost::enable_shared_from_this<ARDOUR::AudioSource>
+class AudioSource :
virtual public Source, public boost::enable_shared_from_this<ARDOUR::AudioSource>
{
public:
AudioSource (Session&, Glib::ustring name);
virtual float sample_rate () const = 0;
- virtual void mark_for_remove() = 0;
virtual void mark_streaming_write_completed () {}
virtual bool can_truncate_peaks() const { return true; }
static bool _build_peakfiles;
bool _peaks_built;
- mutable Glib::Mutex _lock;
mutable Glib::Mutex _peaks_ready_lock;
Glib::ustring peakpath;
Glib::ustring _captured_for;
virtual Glib::ustring find_broken_peakfile (Glib::ustring missing_peak_path,
Glib::ustring audio_path) = 0;
- void update_length (nframes_t pos, nframes_t cnt);
-
virtual int read_peaks_with_fpp (PeakData *peaks,
nframes_t npeaks, nframes_t start, nframes_t cnt,
double samples_per_visual_peak, nframes_t fpp) const;
--- /dev/null
+/*
+ Copyright (C) 2006-2009 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#ifndef __ardour_filesource_h__
+#define __ardour_filesource_h__
+
+#include <exception>
+#include <time.h>
+#include <ardour/source.h>
+
+namespace ARDOUR {
+
+class MissingSource : public std::exception {
+public:
+ virtual const char *what() const throw() { return "source file does not exist"; }
+};
+
+/** A source associated with a file on disk somewhere */
+class FileSource : virtual public Source {
+public:
+ const Glib::ustring& path() const { return _path; }
+
+ virtual bool safe_file_extension (const Glib::ustring& path) const = 0;
+
+ int move_to_trash (const Glib::ustring& trash_dir_name);
+ void mark_take (const Glib::ustring& id);
+ void mark_immutable ();
+
+ const Glib::ustring& take_id () const { return _take_id; }
+ bool is_embedded () const { return _is_embedded; }
+ uint16_t channel() const { return _channel; }
+
+ int set_state (const XMLNode&);
+
+ int set_source_name (const Glib::ustring& newname, bool destructive);
+
+ static void set_search_path (DataType type, const Glib::ustring& path);
+
+protected:
+ FileSource (Session& session, DataType type,
+ const Glib::ustring& path, bool embedded,
+ Source::Flag flags = Source::Flag(0));
+
+ FileSource (Session& session, const XMLNode& node, bool must_exist);
+
+ virtual int init (const Glib::ustring& idstr, bool must_exist);
+
+ virtual int move_dependents_to_trash() { return 0; }
+
+ bool find (DataType type, const Glib::ustring& path,
+ bool must_exist, bool& is_new, uint16_t& chan);
+
+ bool removable () const;
+
+ Glib::ustring _path;
+ Glib::ustring _take_id;
+ bool _file_is_new;
+ uint16_t _channel;
+ bool _is_embedded;
+
+ static map<DataType, Glib::ustring> search_paths;
+};
+
+} // namespace ARDOUR
+
+#endif /* __ardour_filesource_h__ */
+
template<typename T> class MidiRingBuffer;
/** Source for MIDI data */
-class MidiSource : public Source
+class MidiSource : virtual public Source
{
public:
typedef double TimeType;
virtual void append_event_unlocked_beats(const Evoral::Event<double>& ev) = 0;
virtual void append_event_unlocked_frames(const Evoral::Event<nframes_t>& ev) = 0;
- virtual void mark_for_remove() = 0;
virtual void mark_streaming_midi_write_started (NoteMode mode, nframes_t start_time);
virtual void mark_streaming_write_started ();
virtual void mark_streaming_write_completed ();
- uint64_t timeline_position () { return _timeline_position; }
- void set_timeline_position (nframes_t when);
-
virtual void session_saved();
std::string captured_for() const { return _captured_for; }
virtual void destroy_model() = 0;
void set_note_mode(NoteMode mode);
+
+ void set_timeline_position (int64_t pos);
boost::shared_ptr<MidiModel> model() { return _model; }
void set_model(boost::shared_ptr<MidiModel> m) { _model = m; }
nframes_t stamp_offset, nframes_t negative_stamp_offset) const = 0;
virtual nframes_t write_unlocked (MidiRingBuffer<nframes_t>& dst, nframes_t cnt) = 0;
- mutable Glib::Mutex _lock;
std::string _captured_for;
- uint64_t _timeline_position;
mutable uint32_t _read_data_count; ///< modified in read()
mutable uint32_t _write_data_count; ///< modified in write()
ControlOut = 0x4
};
-
Route (Session&, std::string name, int input_min, int input_max, int output_min, int output_max,
Flag flags = Flag(0), DataType default_type = DataType::AUDIO);
Route (Session&, const XMLNode&, DataType default_type = DataType::AUDIO);
/* these are the core of the API of a Route. see the protected sections as well */
- virtual int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
- nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
+ virtual int roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
+ nframes_t offset, int declick, bool can_record, bool rec_monitors_input);
+
+ virtual int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
+ nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
- virtual int no_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
- nframes_t offset, bool state_changing, bool can_record, bool rec_monitors_input);
+ virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
+ nframes_t offset, bool can_record, bool rec_monitors_input);
- virtual int silent_roll (nframes_t nframes, nframes_t start_frame, nframes_t end_frame,
- nframes_t offset, bool can_record, bool rec_monitors_input);
virtual void toggle_monitor_input ();
virtual bool can_record() { return false; }
virtual void set_record_enable (bool yn, void *src) {}
void drop_mix_group (void *);
RouteGroup *mix_group () { return _mix_group; }
- virtual void set_meter_point (MeterPoint, void *src);
- MeterPoint meter_point() const { return _meter_point; }
+ virtual void set_meter_point (MeterPoint, void *src);
+ MeterPoint meter_point() const { return _meter_point; }
/* Processors */
void curve_reallocate ();
protected:
- Flag _flags;
-
- /* tight cache-line access here is more important than sheer speed of
- access.
- */
-
- bool _muted : 1;
- bool _soloed : 1;
- bool _solo_safe : 1;
- bool _recordable : 1;
- bool _mute_affects_pre_fader : 1;
- bool _mute_affects_post_fader : 1;
- bool _mute_affects_control_outs : 1;
- bool _mute_affects_main_outs : 1;
- bool _silent : 1;
- bool _declickable : 1;
- int _pending_declick;
+ nframes_t check_initial_delay (nframes_t, nframes_t&, nframes_t&);
- MeterPoint _meter_point;
-
- gain_t solo_gain;
- gain_t mute_gain;
- gain_t desired_solo_gain;
- gain_t desired_mute_gain;
-
-
-
- nframes_t _initial_delay;
- nframes_t _roll_delay;
- ProcessorList _processors;
- Glib::RWLock _processor_lock;
- IO *_control_outs;
- Glib::Mutex _control_outs_lock;
- RouteGroup *_edit_group;
- RouteGroup *_mix_group;
- std::string _comment;
- bool _have_internal_generator;
+ void passthru (nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset, int declick, bool meter_inputs);
- boost::shared_ptr<ToggleControllable> _solo_control;
- boost::shared_ptr<ToggleControllable> _mute_control;
+ virtual void process_output_buffers (BufferSet& bufs,
+ nframes_t start_frame, nframes_t end_frame,
+ nframes_t nframes, nframes_t offset, bool with_processors, int declick,
+ bool meter);
+
+ Flag _flags;
+ int _pending_declick;
+ MeterPoint _meter_point;
+
+ gain_t solo_gain;
+ gain_t mute_gain;
+ gain_t desired_solo_gain;
+ gain_t desired_mute_gain;
- nframes_t check_initial_delay (nframes_t, nframes_t&, nframes_t&);
+ nframes_t _initial_delay;
+ nframes_t _roll_delay;
+ ProcessorList _processors;
+ Glib::RWLock _processor_lock;
+ IO *_control_outs;
+ Glib::Mutex _control_outs_lock;
+ RouteGroup *_edit_group;
+ RouteGroup *_mix_group;
+ std::string _comment;
+ bool _have_internal_generator;
- void passthru (nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, nframes_t offset, int declick, bool meter_inputs);
+ boost::shared_ptr<ToggleControllable> _solo_control;
+ boost::shared_ptr<ToggleControllable> _mute_control;
- virtual void process_output_buffers (BufferSet& bufs,
- nframes_t start_frame, nframes_t end_frame,
- nframes_t nframes, nframes_t offset, bool with_processors, int declick,
- bool meter);
+ /* tight cache-line access here is more important than sheer speed of access.
+ keep these after things that should be aligned
+ */
+
+ bool _muted : 1;
+ bool _soloed : 1;
+ bool _solo_safe : 1;
+ bool _recordable : 1;
+ bool _mute_affects_pre_fader : 1;
+ bool _mute_affects_post_fader : 1;
+ bool _mute_affects_control_outs : 1;
+ bool _mute_affects_main_outs : 1;
+ bool _silent : 1;
+ bool _declickable : 1;
protected:
static uint32_t order_key_cnt;
- struct ltstr
- {
- bool operator()(const char* s1, const char* s2) const
- {
+ struct ltstr {
+ bool operator()(const char* s1, const char* s2) const {
return strcmp(s1, s2) < 0;
}
};
int reset_processor_counts (ProcessorStreams*); /* locked */
int _reset_processor_counts (ProcessorStreams*); /* unlocked */
- /* processor I/O channels and plugin count handling */
-
+ /** processor I/O channels and plugin count handling */
struct ProcessorCount {
boost::shared_ptr<ARDOUR::Processor> processor;
ChanCount in;
};
int32_t apply_some_processor_counts (std::list<ProcessorCount>& iclist);
- bool check_some_processor_counts (std::list<ProcessorCount>& iclist, ChanCount required_inputs, ProcessorStreams* err_streams);
+ bool check_some_processor_counts (std::list<ProcessorCount>& iclist,
+ ChanCount required_inputs, ProcessorStreams* err_streams);
void set_deferred_state ();
void add_processor_from_xml (const XMLNode&);
SetAudioRange,
SetPlayRange,
- /* only one of each of these events
- can be queued at any one time
- */
+ /* only one of each of these events can be queued at any one time */
StopOnce,
AutoLoop
Clear
};
- Type type;
- Action action;
- nframes_t action_frame;
- nframes_t target_frame;
- double speed;
+ Type type;
+ Action action;
+ nframes_t action_frame;
+ nframes_t target_frame;
+ double speed;
union {
- void* ptr;
- bool yes_or_no;
- nframes_t target2_frame;
- SlaveSource slave;
- Route* route;
+ void* ptr;
+ bool yes_or_no;
+ nframes_t target2_frame;
+ SlaveSource slave;
+ Route* route;
};
- boost::shared_ptr<Region> region;
-
- list<AudioRange> audio_range;
- list<MusicRange> music_range;
+ list<AudioRange> audio_range;
+ list<MusicRange> music_range;
+
+ boost::shared_ptr<Region> region;
Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false)
- : type (t),
- action (a),
- action_frame (when),
- target_frame (where),
- speed (spd),
- yes_or_no (yn) {}
+ : type (t)
+ , action (a)
+ , action_frame (when)
+ , target_frame (where)
+ , speed (spd)
+ , yes_or_no (yn)
+ {}
void set_ptr (void* p) {
ptr = p;
Glib::ustring peak_path (Glib::ustring) const;
- static string change_audio_path_by_name (string oldpath, string oldname, string newname, bool destructive);
- static string change_midi_path_by_name (string oldpath, string oldname, string newname, bool destructive);
+ static string change_source_path_by_name (string oldpath, string oldname, string newname, bool destructive);
string peak_path_from_audio_path (string) const;
- string audio_path_from_name (string, uint32_t nchans, uint32_t chan, bool destructive);
- string midi_path_from_name (string);
+ string new_audio_source_name (const string&, uint32_t nchans, uint32_t chan, bool destructive);
+ string new_midi_source_name (const string&);
+ string new_source_path_from_name (DataType type, const string&);
void process (nframes_t nframes);
bool transport_locked () const;
int wipe ();
- //int wipe_diskstream (AudioDiskstream *);
int remove_region_from_region_list (boost::shared_ptr<Region>);
nframes_t get_maximum_extent () const;
nframes_t current_end_frame() const { return end_location->start(); }
nframes_t current_start_frame() const { return start_location->start(); }
- // "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
+ /// "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
nframes_t frame_rate() const { return _current_frame_rate; }
- // "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
+ /// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
nframes_t nominal_frame_rate() const { return _nominal_frame_rate; }
nframes_t frames_per_hour() const { return _frames_per_hour; }
void remove_event (nframes_t frame, Event::Type type);
void clear_events (Event::Type type);
- nframes_t get_block_size() const { return current_block_size; }
+ nframes_t get_block_size() const { return current_block_size; }
nframes_t worst_output_latency () const { return _worst_output_latency; }
- nframes_t worst_input_latency () const { return _worst_input_latency; }
- nframes_t worst_track_latency () const { return _worst_track_latency; }
+ nframes_t worst_input_latency () const { return _worst_input_latency; }
+ nframes_t worst_track_latency () const { return _worst_track_latency; }
int save_state (std::string snapshot_name, bool pending = false);
int restore_state (std::string snapshot_name);
/// The instant xml file is written to the session directory
void add_instant_xml (XMLNode&, bool write_to_config = true);
- XMLNode * instant_xml (const std::string& str);
+ XMLNode* instant_xml (const std::string& str);
enum StateOfTheState {
Clean = 0x0,
sigc::signal<void,RouteGroup*> edit_group_added;
sigc::signal<void,RouteGroup*> mix_group_added;
- sigc::signal<void> edit_group_removed;
- sigc::signal<void> mix_group_removed;
+ sigc::signal<void> edit_group_removed;
+ sigc::signal<void> mix_group_removed;
void foreach_edit_group (sigc::slot<void,RouteGroup*> sl) {
for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
/* fundamental operations. duh. */
- std::list<boost::shared_ptr<AudioTrack> > new_audio_track (int input_channels, int output_channels, TrackMode mode = Normal, uint32_t how_many = 1);
+ std::list<boost::shared_ptr<AudioTrack> > new_audio_track (
+ int input_channels, int output_channels, TrackMode mode = Normal, uint32_t how_many = 1);
+
RouteList new_audio_route (int input_channels, int output_channels, uint32_t how_many);
- std::list<boost::shared_ptr<MidiTrack> > new_midi_track (TrackMode mode = Normal, uint32_t how_many = 1);
- //boost::shared_ptr<Route> new_midi_route (uint32_t how_many = 1);
+ std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
+ TrackMode mode = Normal, uint32_t how_many = 1);
void remove_route (boost::shared_ptr<Route>);
void resort_routes ();
void sync_time_vars();
void bbt_time (nframes_t when, BBT_Time&);
- void smpte_to_sample( SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes ) const;
- void sample_to_smpte( nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const;
+ void smpte_to_sample(SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const;
+ void sample_to_smpte(nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const;
void smpte_time (SMPTE::Time &);
void smpte_time (nframes_t when, SMPTE::Time&);
void smpte_time_subframes (nframes_t when, SMPTE::Time&);
int remove_last_capture ();
- /* handlers should return -1 for "stop cleanup", 0 for
- "yes, delete this playlist" and 1 for "no, don't delete
- this playlist.
+ /** handlers should return -1 for "stop cleanup",
+ 0 for "yes, delete this playlist",
+ 1 for "no, don't delete this playlist".
*/
-
sigc::signal<int,boost::shared_ptr<ARDOUR::Playlist> > AskAboutPlaylistDeletion;
- /* handlers should return 0 for "ignore the rate mismatch"
- and !0 for "do not use this session"
+ /** handlers should return 0 for "ignore the rate mismatch",
+ !0 for "do not use this session"
*/
-
static sigc::signal<int,nframes_t, nframes_t> AskAboutSampleRateMismatch;
- /* handlers should return !0 for use pending state, 0 for
- ignore it.
+ /** handlers should return !0 for use pending state, 0 for ignore it.
*/
-
static sigc::signal<int> AskAboutPendingState;
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
sigc::signal<void,boost::shared_ptr<Bundle> > BundleAdded;
sigc::signal<void,boost::shared_ptr<Bundle> > BundleRemoved;
- /* MIDI */
+ /* MIDI control */
void midi_panic(void);
int set_mtc_port (string port_tag);
/* clicking */
- boost::shared_ptr<IO> click_io() { return _click_io; }
+ boost::shared_ptr<IO> click_io() { return _click_io; }
/* disk, buffer loads */
bool follow_slave (nframes_t, nframes_t);
void calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta);
void track_slave_state(
- float slave_speed,
+ float slave_speed,
nframes_t slave_transport_frame,
nframes_t this_delta,
- bool starting);
+ bool starting);
void follow_slave_silently(nframes_t nframes, nframes_t offset, float slave_speed);
void set_slave_source (SlaveSource);
}
int get_transport_declick_required () {
-
if (transport_sub_state & PendingDeclickIn) {
transport_sub_state &= ~PendingDeclickIn;
return 1;
}
bool maybe_stop (nframes_t limit) {
- if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
+ if ( (_transport_speed > 0.0f && _transport_frame >= limit)
+ || (_transport_speed < 0.0f && _transport_frame == 0) ) {
stop_transport ();
return true;
}
mutable gint butler_should_do_transport_work;
int butler_request_pipe[2];
- inline bool transport_work_requested() const { return g_atomic_int_get(&butler_should_do_transport_work); }
+ inline bool transport_work_requested() const {
+ return g_atomic_int_get(&butler_should_do_transport_work);
+ }
struct ButlerRequest {
enum Type {
SourceMap get_sources() { return sources; }
private:
-
-
int load_sources (const XMLNode& node);
XMLNode& get_sources_as_xml ();
namespace ARDOUR {
class SilentFileSource : public AudioFileSource {
- public:
- virtual ~SilentFileSource ();
-
+public:
int update_header (nframes_t when, struct tm&, time_t) { return 0; }
int flush_header () { return 0; }
float sample_rate () const { return _sample_rate; }
- void set_length (nframes_t len);
+ void set_length (nframes_t len) { _length = len; }
bool destructive() const { return false; }
bool can_be_analysed() const { return false; }
- protected:
-
- float _sample_rate;
-
- SilentFileSource (Session&, const XMLNode&, nframes_t nframes, float sample_rate);
-
+protected:
friend class SourceFactory;
+ SilentFileSource (Session& s, const XMLNode& x, nframes_t len, float srate)
+ : Source (s, x)
+ , AudioFileSource (s, x, false)
+ , _sample_rate(srate)
+ {
+ _length = len;
+ }
+
nframes_t read_unlocked (Sample *dst, nframes_t start, nframes_t cnt) const {
memset (dst, 0, sizeof (Sample) * cnt);
return cnt;
void set_header_timeline_position () {}
- int read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt, double samples_per_unit, nframes_t fpp) const {
+ int read_peaks_with_fpp (PeakData *peaks, nframes_t npeaks, nframes_t start, nframes_t cnt,
+ double samples_per_unit, nframes_t fpp) const {
memset (peaks, 0, sizeof (PeakData) * npeaks);
return 0;
}
-
+
+ float _sample_rate;
};
} // namespace ARDOUR
*/
-#ifndef __ardour_smf_filesource_h__
-#define __ardour_smf_filesource_h__
+#ifndef __ardour_smf_source_h__
+#define __ardour_smf_source_h__
#include <cstdio>
#include <time.h>
-
-#include <ardour/midi_source.h>
#include <evoral/SMF.hpp>
+#include <ardour/midi_source.h>
+#include <ardour/file_source.h>
namespace Evoral { template<typename T> class Event; }
template<typename T> class MidiRingBuffer;
/** Standard Midi File (Type 0) Source */
-class SMFSource : public MidiSource, public Evoral::SMF {
- public:
+class SMFSource : public MidiSource, public FileSource, public Evoral::SMF {
+public:
/** Constructor for existing external-to-session files */
- SMFSource (Session& session, std::string path, Source::Flag flags = Source::Flag(0));
+ SMFSource (Session& session, const Glib::ustring& path, bool embedded,
+ Source::Flag flags = Source::Flag(0));
- /* Constructor for existing in-session files */
- SMFSource (Session& session, const XMLNode&);
+ /** Constructor for existing in-session files */
+ SMFSource (Session& session, const XMLNode&, bool must_exist = false);
virtual ~SMFSource ();
-
- bool set_name (const std::string& newname) { return (set_source_name(newname, false) == 0); }
- int set_source_name (string newname, bool destructive);
-
- static bool safe_file_extension (const Glib::ustring& path);
- Glib::ustring path() const { return _path; }
+ bool safe_file_extension (const Glib::ustring& path) const {
+ return safe_midi_file_extension(path);
+ }
- void set_allow_remove_if_empty (bool yn);
- void mark_for_remove();
+ bool set_name (const std::string& newname) { return (set_source_name(newname, false) == 0); }
- void append_event_unlocked_beats(const Evoral::Event<double>& ev);
- void append_event_unlocked_frames(const Evoral::Event<nframes_t>& ev);
-
- int move_to_trash (const string trash_dir_name);
+ void append_event_unlocked_beats (const Evoral::Event<double>& ev);
+ void append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev);
void mark_streaming_midi_write_started (NoteMode mode, nframes_t start_time);
void mark_streaming_write_completed ();
- void mark_take (string);
- string take_id() const { return _take_id; }
-
- static void set_search_path (string);
- static void set_header_position_offset (nframes_t offset, bool negative);
-
XMLNode& get_state ();
int set_state (const XMLNode&);
- void load_model(bool lock=true, bool force_reload=false);
- void destroy_model();
+ void load_model (bool lock=true, bool force_reload=false);
+ void destroy_model ();
- void flush_midi();
+ void flush_midi ();
+
+ static void set_header_position_offset (nframes_t offset, bool negative);
- private:
- int init (string idstr, bool must_exist);
+ static bool safe_midi_file_extension (const Glib::ustring& path);
+private:
nframes_t read_unlocked (
MidiRingBuffer<nframes_t>& dst,
nframes_t start,
MidiRingBuffer<nframes_t>& src,
nframes_t cnt);
- bool find (std::string path, bool must_exist, bool& is_new);
- bool removable() const;
- bool writable() const { return _flags & Writable; }
-
- void set_default_controls_interpolation();
-
- Glib::ustring _path;
- string _take_id;
- bool _allow_remove_if_empty;
- double _last_ev_time_beats;
- nframes_t _last_ev_time_frames;
+ void set_default_controls_interpolation ();
- static string _search_path;
+ double _last_ev_time_beats;
+ nframes_t _last_ev_time_frames;
};
}; /* namespace ARDOUR */
-#endif /* __ardour_smf_filesource_h__ */
+#endif /* __ardour_smf_source_h__ */
class SndFileSource : public AudioFileSource {
public:
- /* constructor to be called for existing external-to-session files */
+ /** Constructor to be called for existing external-to-session files */
+ SndFileSource (Session&, const Glib::ustring& path, bool embedded, int chn, Flag flags);
- SndFileSource (Session&, Glib::ustring path, int chn, Flag flags);
-
- /* constructor to be called for new in-session files */
-
- SndFileSource (Session&, Glib::ustring path, SampleFormat samp_format, HeaderFormat hdr_format, nframes_t rate,
- Flag flags = SndFileSource::default_writable_flags);
+ /* Constructor to be called for new in-session files */
+ SndFileSource (Session&, const Glib::ustring& path, bool embedded,
+ SampleFormat samp_format, HeaderFormat hdr_format, nframes_t rate,
+ Flag flags = SndFileSource::default_writable_flags);
- /* constructor to be called for existing in-session files */
-
+ /** Constructor to be called for existing in-session files */
SndFileSource (Session&, const XMLNode&);
~SndFileSource ();
SF_INFO _info;
BroadcastInfo *_broadcast_info;
- void init ();
+ void init_sndfile ();
int open();
int setup_broadcast_info (nframes_t when, struct tm&, time_t);
Destructive = 0x80
};
- Source (Session&, const std::string& name, DataType type, Flag flags=Flag(0));
+ Source (Session&, DataType type, const std::string& name, Flag flags=Flag(0));
Source (Session&, const XMLNode&);
virtual ~Source ();
nframes_t length() const { return _length; }
- virtual Glib::ustring path() const = 0;
+ virtual const Glib::ustring& path() const = 0;
virtual nframes_t natural_position() const { return 0; }
- virtual void mark_for_remove() = 0;
+ void mark_for_remove();
+
virtual void mark_streaming_write_started () {}
virtual void mark_streaming_write_completed () = 0;
XMLNode& get_state ();
int set_state (const XMLNode&);
- virtual bool destructive() const { return false; }
- virtual bool length_mutable() const { return false; }
+ bool destructive() const { return (_flags & Destructive); }
+ bool writable () const { return _flags & Writable; }
+ virtual bool set_destructive (bool yn) { return false; }
+ virtual bool length_mutable() const { return false; }
void use () { _in_use++; }
void disuse () { if (_in_use) { _in_use--; } }
void update_length (nframes_t pos, nframes_t cnt);
+ int64_t timeline_position() const { return _timeline_position; }
+ virtual void set_timeline_position (int64_t pos);
+
+ void set_allow_remove_if_empty (bool yn);
+
virtual const Evoral::TimeConverter<double, nframes_t>& time_converter() const {
return Evoral::IdentityConverter<double, nframes_t>();
}
Flag _flags;
time_t _timestamp;
nframes_t _length;
+ int64_t _timeline_position;
bool _analysed;
+ mutable Glib::Mutex _lock;
mutable Glib::Mutex _analysis_lock;
Glib::Mutex _playlist_lock;
static boost::shared_ptr<Source> createSilent (Session&, const XMLNode& node,
nframes_t nframes, float sample_rate);
- static boost::shared_ptr<Source> createReadable (DataType type, Session&, std::string path,
+ static boost::shared_ptr<Source> createReadable (DataType type, Session&,
+ const std::string& path, bool embedded,
int chn, Source::Flag flags, bool announce = true, bool async = false);
- static boost::shared_ptr<Source> createWritable (DataType type, Session&, std::string name,
+ static boost::shared_ptr<Source> createWritable (DataType type, Session&,
+ const std::string& path, bool embedded,
bool destructive, nframes_t rate, bool announce = true, bool async = false);
static Glib::Cond* PeaksToBuild;
try {
fs = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, _session, prop->value(), false, _session.frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, _session,
+ prop->value(), true,
+ false, _session.frame_rate()));
}
catch (failed_constructor& err) {
boost::shared_ptr<AudioRegion> region;
try {
- region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(),
- region_name_from_path (first_fs->name(), true),
- 0, AudioRegion::Flag (AudioRegion::DefaultFlags|AudioRegion::Automatic|AudioRegion::WholeFile)));
+ region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
+ pending_sources, 0, first_fs->length(),
+ region_name_from_path (first_fs->name(), true), 0,
+ Region::Flag (Region::DefaultFlags|Region::Automatic|Region::WholeFile)));
region->special_set_position (0);
}
catch (failed_constructor& err) {
- error << string_compose (_("%1: cannot create whole-file region from pending capture sources"),
- _name)
- << endmsg;
+ error << string_compose (
+ _("%1: cannot create whole-file region from pending capture sources"),
+ _name) << endmsg;
return -1;
}
try {
- region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (pending_sources, 0, first_fs->length(), region_name_from_path (first_fs->name(), true)));
+ region = boost::dynamic_pointer_cast<AudioRegion> (RegionFactory::create (
+ pending_sources, 0, first_fs->length(),
+ region_name_from_path (first_fs->name(), true)));
}
catch (failed_constructor& err) {
if (*head != 0) {
lrdf_uris* ulist = lrdf_match_multi(*head);
for (uint32_t j = 0; ulist && j < ulist->count; ++j) {
-// cerr << "AND: " << Glib::filename_from_uri(ulist->items[j]) << endl;
members.push_back(Glib::filename_from_uri(ulist->items[j]));
}
lrdf_free_uris(ulist);
using namespace Glib;
ustring AudioFileSource::peak_dir = "";
-ustring AudioFileSource::search_path;
sigc::signal<void> AudioFileSource::HeaderPositionOffsetChanged;
uint64_t AudioFileSource::header_position_offset = 0;
/* XXX maybe this too */
-char AudioFileSource::bwf_serial_number[13] = "000000000000";
+char AudioFileSource::bwf_serial_number[13] = "000000000000";
struct SizedSampleBuffer {
nframes_t size;
Glib::StaticPrivate<SizedSampleBuffer> thread_interleave_buffer = GLIBMM_STATIC_PRIVATE_INIT;
-/** Constructor used for existing internal-to-session files. File must exist. */
-AudioFileSource::AudioFileSource (Session& s, ustring path, Source::Flag flags)
- : AudioSource (s, path)
- , _channel (0)
+/** Constructor used for existing internal-to-session files. */
+AudioFileSource::AudioFileSource (Session& s, const ustring& path, bool embedded, Source::Flag flags)
+ : Source (s, DataType::AUDIO, path, flags)
+ , AudioSource (s, path)
+ , FileSource (s, DataType::AUDIO, path, embedded, flags)
{
- _is_embedded = AudioFileSource::determine_embeddedness (path);
-
if (init (path, true)) {
throw failed_constructor ();
}
-
}
-/** Constructor used for new internal-to-session files. File cannot exist. */
-AudioFileSource::AudioFileSource (Session& s, ustring path, Source::Flag flags,
+/** Constructor used for new internal-to-session files. */
+AudioFileSource::AudioFileSource (Session& s, const ustring& path, bool embedded, Source::Flag flags,
SampleFormat samp_format, HeaderFormat hdr_format)
- : AudioSource (s, path)
- , _channel (0)
+ : Source (s, DataType::AUDIO, path, flags)
+ , AudioSource (s, path)
+ , FileSource (s, DataType::AUDIO, path, embedded, flags)
{
_is_embedded = false;
/** Constructor used for existing internal-to-session files. File must exist. */
AudioFileSource::AudioFileSource (Session& s, const XMLNode& node, bool must_exist)
- : AudioSource (s, node)
- /* _channel is set in set_state() or init() */
+ : Source (s, node)
+ , AudioSource (s, node)
+ , FileSource (s, node, must_exist)
{
if (set_state (node)) {
throw failed_constructor ();
}
- string foo = _name;
-
- if (init (foo, must_exist)) {
+ if (init (_name, must_exist)) {
throw failed_constructor ();
}
}
}
}
-bool
-AudioFileSource::determine_embeddedness (ustring path)
-{
- return (path.find("/") == 0);
-}
-
-bool
-AudioFileSource::removable () const
-{
- return (_flags & Removable) && ((_flags & RemoveAtDestroy) || ((_flags & RemovableIfEmpty) && length() == 0));
-}
-
int
-AudioFileSource::init (ustring pathstr, bool must_exist)
+AudioFileSource::init (const ustring& pathstr, bool must_exist)
{
- _length = 0;
- _timeline_position = 0;
_peaks_built = false;
-
- if (!find (pathstr, must_exist, _file_is_new, _channel)) {
- throw non_existent_source ();
- }
-
- if (_file_is_new && must_exist) {
- return -1;
- }
-
- return 0;
+ return FileSource::init (pathstr, must_exist);
}
-
ustring
AudioFileSource::peak_path (ustring audio_path)
{
int
AudioFileSource::set_state (const XMLNode& node)
{
- const XMLProperty* prop;
-
- if (AudioSource::set_state (node)) {
+ if (Source::set_state (node)) {
return -1;
}
- if ((prop = node.property (X_("channel"))) != 0) {
- _channel = atoi (prop->value());
- } else {
- _channel = 0;
- }
-
- if ((prop = node.property (X_("name"))) != 0) {
- _is_embedded = AudioFileSource::determine_embeddedness (prop->value());
- } else {
- _is_embedded = false;
+ if (AudioSource::set_state (node)) {
+ return -1;
}
-
- if ((prop = node.property (X_("destructive"))) != 0) {
- /* old style, from the period when we had DestructiveFileSource */
- _flags = Flag (_flags | Destructive);
+
+ if (FileSource::set_state (node)) {
+ return -1;
}
return 0;
}
-void
-AudioFileSource::mark_for_remove ()
-{
- // This operation is not allowed for sources for destructive tracks or embedded files.
- // Fortunately mark_for_remove() is never called for embedded files. This function
- // must be fixed if that ever happens.
- if (_flags & Destructive) {
- return;
- }
-
- _flags = Flag (_flags | Removable | RemoveAtDestroy);
-}
-
void
AudioFileSource::mark_streaming_write_completed ()
{
}
}
-void
-AudioFileSource::mark_take (ustring id)
-{
- if (writable()) {
- _take_id = id;
- }
-}
-
int
-AudioFileSource::move_to_trash (const ustring& trash_dir_name)
+AudioFileSource::move_dependents_to_trash()
{
- if (is_embedded()) {
- cerr << "tried to move an embedded region to trash" << endl;
- return -1;
- }
-
- if (!writable()) {
- return -1;
- }
-
- /* don't move the file across filesystems, just stick it in the
- trash_dir_name directory on whichever filesystem it was already on
- */
-
- ustring newpath;
- newpath = Glib::path_get_dirname (_path);
- newpath = Glib::path_get_dirname (newpath);
-
- newpath += string("/") + trash_dir_name + "/";
- newpath += Glib::path_get_basename (_path);
-
- /* the new path already exists, try versioning */
- if (access (newpath.c_str(), F_OK) == 0) {
- char buf[PATH_MAX+1];
- int version = 1;
- ustring newpath_v;
-
- snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
- newpath_v = buf;
-
- while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
- snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
- newpath_v = buf;
- }
-
- if (version == 999) {
- PBD::error << string_compose (
- _("there are already 1000 files with names like %1; versioning discontinued"),
- newpath)
- << endmsg;
- } else {
- newpath = newpath_v;
- }
- }
-
- if (::rename (_path.c_str(), newpath.c_str()) != 0) {
- PBD::error << string_compose (
- _("cannot rename audio file source from %1 to %2 (%3)"),
- _path, newpath, strerror (errno)) << endmsg;
- return -1;
- }
-
- if (::unlink (peakpath.c_str()) != 0) {
- error << string_compose (_("cannot remove peakfile %1 for %2 (%3)"),
- peakpath, _path, strerror (errno))
- << endmsg;
- /* try to back out */
- rename (newpath.c_str(), _path.c_str());
- return -1;
- }
-
- _path = newpath;
- peakpath = "";
-
- /* file can not be removed twice, since the operation is not idempotent */
- _flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
-
- return 0;
-}
-
-bool
-AudioFileSource::find (ustring& pathstr, bool must_exist, bool& isnew, uint16_t& chan)
-{
- ustring::size_type pos;
- bool ret = false;
-
- isnew = false;
-
- if (pathstr[0] != '/') {
-
- /* non-absolute pathname: find pathstr in search path */
-
- vector<ustring> dirs;
- int cnt;
- ustring fullpath;
- ustring keeppath;
-
- if (search_path.length() == 0) {
- error << _("FileSource: search path not set") << endmsg;
- goto out;
- }
-
- split (search_path, dirs, ':');
-
- cnt = 0;
-
- for (vector<ustring>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
- fullpath = *i;
- if (fullpath[fullpath.length()-1] != '/') {
- fullpath += '/';
- }
-
- fullpath += pathstr;
-
- /* i (paul) made a nasty design error by using ':' as a special character in
- Ardour 0.99 .. this hack tries to make things sort of work.
- */
-
- if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
-
- if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
-
- /* its a real file, no problem */
-
- keeppath = fullpath;
- ++cnt;
-
- } else {
-
- if (must_exist) {
-
- /* might be an older session using file:channel syntax. see if the version
- without the :suffix exists
- */
-
- ustring shorter = pathstr.substr (0, pos);
- fullpath = *i;
-
- if (fullpath[fullpath.length()-1] != '/') {
- fullpath += '/';
- }
-
- fullpath += shorter;
-
- if (Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
- chan = atoi (pathstr.substr (pos+1));
- pathstr = shorter;
- keeppath = fullpath;
- ++cnt;
- }
-
- } else {
-
- /* new derived file (e.g. for timefx) being created in a newer session */
-
- }
- }
-
- } else {
-
- if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
- keeppath = fullpath;
- ++cnt;
- }
- }
- }
-
- if (cnt > 1) {
-
- error << string_compose (_("FileSource: \"%1\" is ambigous when searching %2\n\t"), pathstr, search_path) << endmsg;
- goto out;
-
- } else if (cnt == 0) {
-
- if (must_exist) {
- error << string_compose(_("Filesource: cannot find required file (%1): while searching %2"), pathstr, search_path) << endmsg;
- goto out;
- } else {
- isnew = true;
- }
- }
-
- /* Current find() is unable to parse relative path names to yet non-existant
- sources. QuickFix(tm) */
- if (keeppath == "") {
- if (must_exist) {
- error << "AudioFileSource::find(), keeppath = \"\", but the file must exist" << endl;
- } else {
- keeppath = pathstr;
- }
- }
-
- _name = pathstr;
- _path = keeppath;
- ret = true;
-
- } else {
-
- /* external files and/or very very old style sessions include full paths */
-
- /* ugh, handle ':' situation */
-
- if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
-
- ustring shorter = pathstr.substr (0, pos);
-
- if (Glib::file_test (shorter, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
- chan = atoi (pathstr.substr (pos+1));
- pathstr = shorter;
- }
- }
-
- _path = pathstr;
-
- if (is_embedded()) {
- _name = pathstr;
- } else {
- _name = pathstr.substr (pathstr.find_last_of ('/') + 1);
- }
-
- if (!Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
-
- /* file does not exist or we cannot read it */
-
- if (must_exist) {
- error << string_compose(_("Filesource: cannot find required file (%1): %2"), _path, strerror (errno)) << endmsg;
- goto out;
- }
-
- if (errno != ENOENT) {
- error << string_compose(_("Filesource: cannot check for existing file (%1): %2"), _path, strerror (errno)) << endmsg;
- goto out;
- }
-
- /* a new file */
-
- isnew = true;
- ret = true;
-
- } else {
-
- /* already exists */
-
- ret = true;
-
- }
- }
-
- out:
- return ret;
-}
-
-void
-AudioFileSource::set_search_path (ustring p)
-{
- search_path = p;
+ return ::unlink (peakpath.c_str());
}
void
HeaderPositionOffsetChanged ();
}
-void
-AudioFileSource::set_timeline_position (int64_t pos)
-{
- _timeline_position = pos;
-}
-
-void
-AudioFileSource::set_allow_remove_if_empty (bool yn)
-{
- if (!writable()) {
- return;
- }
-
- if (yn) {
- _flags = Flag (_flags | RemovableIfEmpty);
- } else {
- _flags = Flag (_flags & ~RemovableIfEmpty);
- }
-}
-
-int
-AudioFileSource::set_source_name (ustring newname, bool destructive)
-{
- Glib::Mutex::Lock lm (_lock);
- ustring oldpath = _path;
- ustring newpath = Session::change_audio_path_by_name (oldpath, _name, newname, destructive);
-
- if (newpath.empty()) {
- error << string_compose (_("programming error: %1"), "cannot generate a changed audio path") << endmsg;
- return -1;
- }
-
- // Test whether newpath exists, if yes notify the user but continue.
- if (access(newpath.c_str(),F_OK) == 0) {
- error << _("Programming error! Ardour tried to rename a file over another file! It's safe to continue working, but please report this to the developers.") << endmsg;
- return -1;
- }
-
- if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
- error << string_compose (_("cannot rename audio file %1 to %2"), _name, newpath) << endmsg;
- return -1;
- }
-
- _name = Glib::path_get_basename (newpath);
- _path = newpath;
-
- return rename_peakfile (peak_path (_path));
-}
-
bool
AudioFileSource::is_empty (Session& s, ustring path)
{
}
bool
-AudioFileSource::safe_file_extension(ustring file)
+AudioFileSource::safe_audio_file_extension(const ustring& file)
{
const char* suffixes[] = {
".wav", ".WAV",
return false;
}
-void
-AudioFileSource::mark_immutable ()
-{
- /* destructive sources stay writable, and their other flags don't
- change.
- */
-
- if (!(_flags & Destructive)) {
- _flags = Flag (_flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy|CanRename));
- }
-}
-
-
Sample*
AudioFileSource::get_interleave_buffer (nframes_t size)
{
#define _FPP 256
AudioSource::AudioSource (Session& s, ustring name)
- : Source (s, name, DataType::AUDIO)
+ : Source (s, DataType::AUDIO, name)
{
_peaks_built = false;
_peak_byte_max = 0;
{
const XMLProperty* prop;
- Source::set_state (node);
-
if ((prop = node.property ("captured-for")) != 0) {
_captured_for = prop->value();
}
return (end/sizeof(PeakData)) * _FPP;
}
-void
-AudioSource::update_length (nframes_t pos, nframes_t cnt)
-{
- if (pos + cnt > _length) {
- _length = pos+cnt;
- }
-}
-
/* load system configuration first */
- if ( find_file_in_search_path (ardour_search_path() + system_config_search_path(),
+ if (find_file_in_search_path (ardour_search_path() + system_config_search_path(),
"ardour_system.rc", system_rc_file) )
{
XMLTree tree;
--- /dev/null
+/*
+ Copyright (C) 2006-2009 Paul Davis
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+*/
+
+#include <vector>
+
+#include <sys/time.h>
+#include <sys/stat.h>
+#include <stdio.h> // for rename(), sigh
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+
+#include <pbd/convert.h>
+#include <pbd/basename.h>
+#include <pbd/mountpoint.h>
+#include <pbd/stl_delete.h>
+#include <pbd/strsplit.h>
+#include <pbd/shortpath.h>
+#include <pbd/enumwriter.h>
+
+#include <glibmm/miscutils.h>
+#include <glibmm/fileutils.h>
+#include <glibmm/thread.h>
+
+#include <ardour/file_source.h>
+#include <ardour/session.h>
+#include <ardour/session_directory.h>
+#include <ardour/source_factory.h>
+#include <ardour/filename_extensions.h>
+
+#include "i18n.h"
+
+using namespace ARDOUR;
+using namespace PBD;
+using namespace Glib;
+
+static const std::string PATH_SEP = "/"; // I don't do windows
+
+map<DataType, ustring> FileSource::search_paths;
+
+FileSource::FileSource (Session& session, DataType type,
+ const ustring& path, bool embedded, Source::Flag flag)
+ : Source(session, type, path, flag)
+ , _path(path)
+ , _file_is_new(true)
+ , _channel (0)
+ , _is_embedded(embedded)
+{
+}
+
+FileSource::FileSource (Session& session, const XMLNode& node, bool must_exist)
+ : Source(session, node)
+ , _file_is_new(false)
+{
+ _path = _name;
+ _is_embedded = (_path.find(PATH_SEP) != string::npos);
+}
+
+bool
+FileSource::removable () const
+{
+ return (_flags & Removable)
+ && ( (_flags & RemoveAtDestroy)
+ || ((_flags & RemovableIfEmpty) && length() == 0));
+}
+
+int
+FileSource::init (const ustring& pathstr, bool must_exist)
+{
+ _length = 0;
+ _timeline_position = 0;
+
+ if (!find (_type, pathstr, must_exist, _file_is_new, _channel)) {
+ throw MissingSource ();
+ }
+
+ if (_file_is_new && must_exist) {
+ return -1;
+ }
+
+ return 0;
+}
+
+int
+FileSource::set_state (const XMLNode& node)
+{
+ const XMLProperty* prop;
+
+ if ((prop = node.property (X_("channel"))) != 0) {
+ _channel = atoi (prop->value());
+ } else {
+ _channel = 0;
+ }
+
+ _is_embedded = (_name.find(PATH_SEP) == string::npos);
+
+ return 0;
+}
+
+void
+FileSource::mark_take (const ustring& id)
+{
+ if (writable ()) {
+ _take_id = id;
+ }
+}
+
+int
+FileSource::move_to_trash (const ustring& trash_dir_name)
+{
+ if (is_embedded()) {
+ cerr << "tried to move an embedded region to trash" << endl;
+ return -1;
+ }
+
+ if (!writable()) {
+ return -1;
+ }
+
+ /* don't move the file across filesystems, just stick it in the
+ trash_dir_name directory on whichever filesystem it was already on
+ */
+
+ ustring newpath;
+ newpath = Glib::path_get_dirname (_path);
+ newpath = Glib::path_get_dirname (newpath);
+
+ newpath += string(PATH_SEP) + trash_dir_name + PATH_SEP;
+ newpath += Glib::path_get_basename (_path);
+
+ /* the new path already exists, try versioning */
+ if (access (newpath.c_str(), F_OK) == 0) {
+ char buf[PATH_MAX+1];
+ int version = 1;
+ ustring newpath_v;
+
+ snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
+ newpath_v = buf;
+
+ while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
+ snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
+ newpath_v = buf;
+ }
+
+ if (version == 999) {
+ PBD::error << string_compose (
+ _("there are already 1000 files with names like %1; versioning discontinued"),
+ newpath) << endmsg;
+ } else {
+ newpath = newpath_v;
+ }
+ }
+
+ if (::rename (_path.c_str(), newpath.c_str()) != 0) {
+ PBD::error << string_compose (
+ _("cannot rename file source from %1 to %2 (%3)"),
+ _path, newpath, strerror (errno)) << endmsg;
+ return -1;
+ }
+
+ if (move_dependents_to_trash() != 0) {
+ /* try to back out */
+ rename (newpath.c_str(), _path.c_str());
+ return -1;
+ }
+
+ _path = newpath;
+
+ /* file can not be removed twice, since the operation is not idempotent */
+ _flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
+
+ return 0;
+}
+
+/** Find the actual source file based on \a path.
+ *
+ * If the source is embedded, \a path should be a filename (no slashes).
+ * If the source is external, \a path should be a full path.
+ * In either case, _path is set to the complete absolute path of the source file.
+ * \return true iff the file was found.
+ */
+bool
+FileSource::find (DataType type, const ustring& path, bool must_exist, bool& isnew, uint16_t& chan)
+{
+ Glib::ustring search_path = search_paths[type];
+
+ ustring pathstr = path;
+ ustring::size_type pos;
+ bool ret = false;
+
+ isnew = false;
+
+ if (pathstr[0] != '/') {
+
+ /* non-absolute pathname: find pathstr in search path */
+
+ vector<ustring> dirs;
+ int cnt;
+ ustring fullpath;
+ ustring keeppath;
+
+ if (search_path.length() == 0) {
+ error << _("FileSource: search path not set") << endmsg;
+ goto out;
+ }
+
+ split (search_path, dirs, ':');
+
+ cnt = 0;
+
+ for (vector<ustring>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
+ fullpath = *i;
+ if (fullpath[fullpath.length()-1] != '/') {
+ fullpath += '/';
+ }
+
+ fullpath += pathstr;
+
+ /* i (paul) made a nasty design error by using ':' as a special character in
+ Ardour 0.99 .. this hack tries to make things sort of work.
+ */
+
+ if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
+
+ if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
+
+ /* its a real file, no problem */
+
+ keeppath = fullpath;
+ ++cnt;
+
+ } else {
+
+ if (must_exist) {
+
+ /* might be an older session using file:channel syntax. see if the version
+ without the :suffix exists
+ */
+
+ ustring shorter = pathstr.substr (0, pos);
+ fullpath = *i;
+
+ if (fullpath[fullpath.length()-1] != '/') {
+ fullpath += '/';
+ }
+
+ fullpath += shorter;
+
+ if (Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
+ chan = atoi (pathstr.substr (pos+1));
+ pathstr = shorter;
+ keeppath = fullpath;
+ ++cnt;
+ }
+
+ } else {
+
+ /* new derived file (e.g. for timefx) being created in a newer session */
+
+ }
+ }
+
+ } else {
+
+ if (Glib::file_test (fullpath, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
+ keeppath = fullpath;
+ ++cnt;
+ }
+ }
+ }
+
+ if (cnt > 1) {
+
+ error << string_compose (
+ _("FileSource: \"%1\" is ambigous when searching %2\n\t"),
+ pathstr, search_path) << endmsg;
+ goto out;
+
+ } else if (cnt == 0) {
+
+ if (must_exist) {
+ error << string_compose(
+ _("Filesource: cannot find required file (%1): while searching %2"),
+ pathstr, search_path) << endmsg;
+ goto out;
+ } else {
+ isnew = true;
+ }
+ }
+
+ /* Current find() is unable to parse relative path names to yet non-existant
+ sources. QuickFix(tm) */
+ if (keeppath == "") {
+ if (must_exist) {
+ error << "FileSource::find(), keeppath = \"\", but the file must exist" << endl;
+ } else {
+ keeppath = pathstr;
+ }
+ }
+
+ _path = keeppath;
+
+ ret = true;
+
+ } else {
+
+ /* external files and/or very very old style sessions include full paths */
+
+ /* ugh, handle ':' situation */
+
+ if ((pos = pathstr.find_last_of (':')) != ustring::npos) {
+
+ ustring shorter = pathstr.substr (0, pos);
+
+ if (Glib::file_test (shorter, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
+ chan = atoi (pathstr.substr (pos+1));
+ pathstr = shorter;
+ }
+ }
+
+ _path = pathstr;
+
+ if (!Glib::file_test (pathstr, Glib::FILE_TEST_EXISTS|Glib::FILE_TEST_IS_REGULAR)) {
+
+ /* file does not exist or we cannot read it */
+
+ if (must_exist) {
+ error << string_compose(
+ _("Filesource: cannot find required file (%1): %2"),
+ _path, strerror (errno)) << endmsg;
+ goto out;
+ }
+
+ if (errno != ENOENT) {
+ error << string_compose(
+ _("Filesource: cannot check for existing file (%1): %2"),
+ _path, strerror (errno)) << endmsg;
+ goto out;
+ }
+
+ /* a new file */
+ isnew = true;
+ ret = true;
+
+ } else {
+
+ /* already exists */
+ ret = true;
+ }
+ }
+
+ if (_is_embedded) {
+ _name = Glib::path_get_basename (_name);
+ }
+
+out:
+ return ret;
+}
+
+int
+FileSource::set_source_name (const ustring& newname, bool destructive)
+{
+ Glib::Mutex::Lock lm (_lock);
+ ustring oldpath = _path;
+ ustring newpath = Session::change_source_path_by_name (oldpath, _name, newname, destructive);
+
+ if (newpath.empty()) {
+ error << string_compose (_("programming error: %1"), "cannot generate a changed file path") << endmsg;
+ return -1;
+ }
+
+ // Test whether newpath exists, if yes notify the user but continue.
+ if (access(newpath.c_str(),F_OK) == 0) {
+ error << _("Programming error! Ardour tried to rename a file over another file! It's safe to continue working, but please report this to the developers.") << endmsg;
+ return -1;
+ }
+
+ if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
+ error << string_compose (_("cannot rename audio file %1 to %2"), _name, newpath) << endmsg;
+ return -1;
+ }
+
+ _name = Glib::path_get_basename (newpath);
+ _path = newpath;
+
+ return 0;
+}
+
+void
+FileSource::set_search_path (DataType type, const ustring& p)
+{
+ search_paths[type] = p;
+}
+
+void
+FileSource::mark_immutable ()
+{
+ /* destructive sources stay writable, and their other flags don't change. */
+ if (!(_flags & Destructive)) {
+ _flags = Flag (_flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy|CanRename));
+ }
+}
+
try {
nsrcs.push_back (boost::dynamic_pointer_cast<Source> (
- SourceFactory::createWritable (region->data_type(), session, path, false, session.frame_rate())));
+ SourceFactory::createWritable (region->data_type(), session,
+ path, true,
+ false, session.frame_rate())));
}
catch (failed_constructor& err) {
const DataType type = ((*i).rfind(".mid") != string::npos)
? DataType::MIDI : DataType::AUDIO;
- source = SourceFactory::createWritable (
- type,
- sess,
- i->c_str(),
+ source = SourceFactory::createWritable (type, sess,
+ i->c_str(), true,
false, // destructive
- samplerate
- );
+ samplerate);
}
catch (const failed_constructor& err)
{
}
} catch (...) {
- error << "Corrupt MIDI file " << source->path() << endl;
+ error << "Corrupt MIDI file " << source->file_path() << endl;
}
}
sigc::signal<void,MidiSource *> MidiSource::MidiSourceCreated;
MidiSource::MidiSource (Session& s, string name, Source::Flag flags)
- : Source (s, name, DataType::MIDI, flags)
- , _timeline_position(0)
+ : Source (s, DataType::MIDI, name, flags)
, _read_data_count(0)
, _write_data_count(0)
, _converter(s, _timeline_position)
MidiSource::MidiSource (Session& s, const XMLNode& node)
: Source (s, node)
- , _timeline_position(0)
, _read_data_count(0)
, _write_data_count(0)
, _converter(s, _timeline_position)
{
const XMLProperty* prop;
- Source::set_state (node);
-
if ((prop = node.property ("captured-for")) != 0) {
_captured_for = prop->value();
}
}
void
-MidiSource::set_timeline_position (nframes_t when)
+MidiSource::set_timeline_position (int64_t pos)
{
- _timeline_position = when;
- _converter.set_origin(when);
+ Source::set_timeline_position(pos);
+ _converter.set_origin(pos);
}
void
string newpath = _session.session_directory().midi_path().to_string() +"/"+ newname + ".mid";
boost::shared_ptr<MidiSource> newsrc = boost::dynamic_pointer_cast<MidiSource>(
- SourceFactory::createWritable(DataType::MIDI, _session, newpath, 1, 0, true));
+ SourceFactory::createWritable(DataType::MIDI, _session,
+ newpath, true, false, _session.frame_rate()));
newsrc->set_timeline_position(_timeline_position);
_model->write_to(newsrc);
char buf[16];
string subbase;
- assert(base.find("/") == string::npos);
+ if (base.find("/") != string::npos) {
+ base = base.substr(base.find_last_of("/") + 1);
+ }
if (base == "") {
}
/* Source Management */
+
void
Session::add_source (boost::shared_ptr<Source> source)
{
return source;
}
-
boost::shared_ptr<Source>
Session::source_by_path_and_channel (const Glib::ustring& path, uint16_t chn)
{
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
cerr << "comparing " << path << " with " << i->second->name() << endl;
- boost::shared_ptr<AudioFileSource> afs = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
+ boost::shared_ptr<AudioFileSource> afs
+ = boost::dynamic_pointer_cast<AudioFileSource>(i->second);
if (afs && afs->path() == path && chn == afs->channel()) {
return afs;
}
-
}
return boost::shared_ptr<Source>();
}
-Glib::ustring
-Session::peak_path (Glib::ustring base) const
-{
- sys::path peakfile_path(_session_dir->peak_path());
- peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
- return peakfile_path.to_string();
-}
string
-Session::change_audio_path_by_name (string path, string oldname, string newname, bool destructive)
+Session::change_source_path_by_name (string path, string oldname, string newname, bool destructive)
{
string look_for;
string old_basename = PBD::basename_nosuffix (oldname);
/* non-destructive file sources have a name of the form:
- /path/to/NAME-nnnnn(%[LR])?.wav
+ /path/to/NAME-nnnnn(%[LR])?.ext
the task here is to replace NAME with the new name.
*/
if (postfix != string::npos) {
suffix = suffix.substr (postfix);
} else {
- error << "Logic error in Session::change_audio_path_by_name(), please report to the developers" << endl;
+ error << "Logic error in Session::change_source_path_by_name(), please report" << endl;
return "";
}
return path;
}
+/** Return the full path (in some session directory) for a new embedded source.
+ * \a name must be a session-unique name that does not contain slashes
+ * (e.g. as returned by new_*_source_name)
+ */
string
-Session::audio_path_from_name (string name, uint32_t nchan, uint32_t chan, bool destructive)
+Session::new_source_path_from_name (DataType type, const string& name)
+{
+ assert(name.find("/") == string::npos);
+
+ SessionDirectory sdir(get_best_session_directory_for_new_source());
+
+ sys::path p;
+ if (type == DataType::AUDIO) {
+ p = sdir.sound_path();
+ } else if (type == DataType::MIDI) {
+ p = sdir.midi_path();
+ } else {
+ error << "Unknown source type, unable to create file path" << endmsg;
+ return "";
+ }
+
+ p /= name;
+ return p.to_string();
+}
+
+Glib::ustring
+Session::peak_path (Glib::ustring base) const
+{
+ sys::path peakfile_path(_session_dir->peak_path());
+ peakfile_path /= basename_nosuffix (base) + peakfile_suffix;
+ return peakfile_path.to_string();
+}
+
+/** Return a unique name based on \a base for a new internal audio source */
+string
+Session::new_audio_source_name (const string& base, uint32_t nchan, uint32_t chan, bool destructive)
{
string spath;
uint32_t cnt;
string legalized;
buf[0] = '\0';
- legalized = legalize_for_path (name);
-
- /* find a "version" of the file name that doesn't exist in
- any of the possible directories.
- */
+ legalized = legalize_for_path (base);
+ // Find a "version" of the base name that doesn't exist in any of the possible directories.
for (cnt = (destructive ? ++destructive_index : 1); cnt <= limit; ++cnt) {
vector<space_and_path>::iterator i;
spath = sdir.sound_path().to_string();
if (destructive) {
+
if (nchan < 2) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
+ spath.c_str(), cnt, legalized.c_str());
} else if (nchan == 2) {
if (chan == 0) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%L.wav",
+ spath.c_str(), cnt, legalized.c_str());
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%R.wav",
+ spath.c_str(), cnt, legalized.c_str());
}
} else if (nchan < 26) {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav", spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s%%%c.wav",
+ spath.c_str(), cnt, legalized.c_str(), 'a' + chan);
} else {
- snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav", spath.c_str(), cnt, legalized.c_str());
+ snprintf (buf, sizeof(buf), "%s/T%04d-%s.wav",
+ spath.c_str(), cnt, legalized.c_str());
}
} else {
}
if (cnt > limit) {
- error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
+ error << string_compose(
+ _("There are already %1 recordings for %2, which I consider too many."),
+ limit, base) << endmsg;
destroy ();
throw failed_constructor();
}
}
- /* we now have a unique name for the file, but figure out where to
- actually put it.
- */
-
- string foo = buf;
-
- SessionDirectory sdir(get_best_session_directory_for_new_source ());
-
- spath = sdir.sound_path().to_string();
- spath += '/';
-
- string::size_type pos = foo.find_last_of ('/');
-
- if (pos == string::npos) {
- spath += foo;
- } else {
- spath += foo.substr (pos + 1);
- }
-
- return spath;
+ return Glib::path_get_basename(buf);
}
+/** Create a new embedded audio source */
boost::shared_ptr<AudioFileSource>
Session::create_audio_source_for_session (AudioDiskstream& ds, uint32_t chan, bool destructive)
{
- string spath = audio_path_from_name (ds.name(), ds.n_channels().n_audio(), chan, destructive);
+ const size_t n_chans = ds.n_channels().n_audio();
+ const string name = new_audio_source_name (ds.name(), n_chans, chan, destructive);
+ const string path = new_source_path_from_name(DataType::AUDIO, name);
return boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, spath, destructive, frame_rate()));
+ SourceFactory::createWritable (
+ DataType::AUDIO, *this, path, true, destructive, frame_rate()));
}
-// FIXME: _terrible_ code duplication
+/** Return a unique name based on \a base for a new internal MIDI source */
string
-Session::change_midi_path_by_name (string path, string oldname, string newname, bool destructive)
+Session::new_midi_source_name (const string& base)
{
- string look_for;
- string old_basename = PBD::basename_nosuffix (oldname);
- string new_legalized = legalize_for_path (newname);
-
- /* note: we know (or assume) the old path is already valid */
-
- if (destructive) {
-
- /* destructive file sources have a name of the form:
-
- /path/to/Tnnnn-NAME(%[LR])?.wav
-
- the task here is to replace NAME with the new name.
- */
-
- /* find last slash */
-
- string dir;
- string prefix;
- string::size_type slash;
- string::size_type dash;
-
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
-
- /* '-' is not a legal character for the NAME part of the path */
-
- if ((dash = path.find_last_of ('-')) == string::npos) {
- return "";
- }
-
- prefix = path.substr (slash+1, dash-(slash+1));
-
- path = dir;
- path += prefix;
- path += '-';
- path += new_legalized;
- path += ".mid"; /* XXX gag me with a spoon */
-
- } else {
-
- /* non-destructive file sources have a name of the form:
-
- /path/to/NAME-nnnnn(%[LR])?.wav
-
- the task here is to replace NAME with the new name.
- */
-
- string dir;
- string suffix;
- string::size_type slash;
- string::size_type dash;
- string::size_type postfix;
-
- /* find last slash */
-
- if ((slash = path.find_last_of ('/')) == string::npos) {
- return "";
- }
-
- dir = path.substr (0, slash+1);
-
- /* '-' is not a legal character for the NAME part of the path */
-
- if ((dash = path.find_last_of ('-')) == string::npos) {
- return "";
- }
-
- suffix = path.substr (dash+1);
-
- // Suffix is now everything after the dash. Now we need to eliminate
- // the nnnnn part, which is done by either finding a '%' or a '.'
-
- postfix = suffix.find_last_of ("%");
- if (postfix == string::npos) {
- postfix = suffix.find_last_of ('.');
- }
-
- if (postfix != string::npos) {
- suffix = suffix.substr (postfix);
- } else {
- error << "Logic error in Session::change_midi_path_by_name(), please report to the developers" << endl;
- return "";
- }
-
- const uint32_t limit = 10000;
- char buf[PATH_MAX+1];
-
- for (uint32_t cnt = 1; cnt <= limit; ++cnt) {
-
- snprintf (buf, sizeof(buf), "%s%s-%u%s", dir.c_str(), newname.c_str(), cnt, suffix.c_str());
-
- if (access (buf, F_OK) != 0) {
- path = buf;
- break;
- }
- path = "";
- }
-
- if (path == "") {
- error << "FATAL ERROR! Could not find a " << endl;
- }
-
- }
-
- return path;
-}
-
-string
-Session::midi_path_from_name (string name)
-{
- string spath;
uint32_t cnt;
char buf[PATH_MAX+1];
const uint32_t limit = 10000;
string legalized;
buf[0] = '\0';
- legalized = legalize_for_path (name);
-
- /* find a "version" of the file name that doesn't exist in
- any of the possible directories.
- */
+ legalized = legalize_for_path (base);
+ // Find a "version" of the file name that doesn't exist in any of the possible directories.
for (cnt = 1; cnt <= limit; ++cnt) {
vector<space_and_path>::iterator i;
SessionDirectory sdir((*i).path);
sys::path p = sdir.midi_path();
-
p /= legalized;
- spath = p.to_string();
-
- snprintf (buf, sizeof(buf), "%s-%u.mid", spath.c_str(), cnt);
+ snprintf (buf, sizeof(buf), "%s-%u.mid", p.to_string().c_str(), cnt);
if (sys::exists (buf)) {
existing++;
}
if (cnt > limit) {
- error << string_compose(_("There are already %1 recordings for %2, which I consider too many."), limit, name) << endmsg;
+ error << string_compose(
+ _("There are already %1 recordings for %2, which I consider too many."),
+ limit, base) << endmsg;
+ destroy ();
throw failed_constructor();
}
}
- /* we now have a unique name for the file, but figure out where to
- actually put it.
- */
-
- string foo = buf;
-
- SessionDirectory sdir(get_best_session_directory_for_new_source ());
-
- spath = sdir.midi_path().to_string();
- spath += '/';
-
- string::size_type pos = foo.find_last_of ('/');
-
- if (pos == string::npos) {
- spath += foo;
- } else {
- spath += foo.substr (pos + 1);
- }
-
- return spath;
+ return Glib::path_get_basename(buf);
}
+
+/** Create a new embedded MIDI source */
boost::shared_ptr<MidiSource>
Session::create_midi_source_for_session (MidiDiskstream& ds)
{
- string mpath = midi_path_from_name (ds.name());
+ const string name = new_midi_source_name (ds.name());
+ const string path = new_source_path_from_name (DataType::MIDI, name);
- return boost::dynamic_pointer_cast<SMFSource> (SourceFactory::createWritable (DataType::MIDI, *this, mpath, false, frame_rate()));
+ return boost::dynamic_pointer_cast<SMFSource> (
+ SourceFactory::createWritable (
+ DataType::MIDI, *this, path, true, false, frame_rate()));
}
try {
fsource = boost::dynamic_pointer_cast<AudioFileSource> (
- SourceFactory::createWritable (DataType::AUDIO, *this, buf, false, frame_rate()));
+ SourceFactory::createWritable (DataType::AUDIO, *this, buf, true, false, frame_rate()));
}
catch (failed_constructor& err) {
SearchPath sound_search_path;
SearchPath midi_search_path;
- for (
- SearchPath::const_iterator i = search_path.begin();
- i != search_path.end();
- ++i
- )
- {
+ for (SearchPath::const_iterator i = search_path.begin(); i != search_path.end(); ++i) {
sp.path = (*i).to_string ();
sp.blocks = 0; // not needed
session_dirs.push_back (sp);
midi_search_path += sdir.midi_path ();
}
- // set the AudioFileSource and SMFSource search path
-
- AudioFileSource::set_search_path (sound_search_path.to_string ());
- SMFSource::set_search_path (midi_search_path.to_string ());
-
+ // set the search path for each data type
+ FileSource::set_search_path (DataType::AUDIO, sound_search_path.to_string ());
+ SMFSource::set_search_path (DataType::MIDI, midi_search_path.to_string ());
// reset the round-robin soundfile path thingie
-
last_rr_session_dir = session_dirs.begin();
}
for (SourceMap::iterator siter = sources.begin(); siter != sources.end(); ++siter) {
- /* Don't save information about AudioFileSources that are empty */
+ /* Don't save information about non-destructive file sources that are empty */
+ /* FIXME: MIDI breaks if this is made FileSource like it should be... */
boost::shared_ptr<AudioFileSource> fs;
-
if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (siter->second)) != 0) {
-
- /* Don't save sources that are empty, unless they're destructive (which are OK
- if they are empty, because we will re-use them every time.)
- */
-
if (!fs->destructive()) {
if (fs->length() == 0) {
continue;
set_dirty();
for (niter = nlist.begin(); niter != nlist.end(); ++niter) {
-
try {
if ((source = XMLSourceFactory (**niter)) == 0) {
error << _("Session: cannot create Source from XML description.") << endmsg;
}
- }
-
- catch (non_existent_source& err) {
+ } catch (MissingSource& err) {
warning << _("A sound file is missing. It will be replaced by silence.") << endmsg;
source = SourceFactory::createSilent (*this, **niter, max_frames, _current_frame_rate);
}
*/
for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
- boost::shared_ptr<AudioFileSource> fs;
+ boost::shared_ptr<FileSource> fs;
- if ((fs = boost::dynamic_pointer_cast<AudioFileSource> (i->second)) != 0) {
+ if ((fs = boost::dynamic_pointer_cast<FileSource> (i->second)) != 0) {
all_sources.insert (fs->path());
}
}
+++ /dev/null
-/*
- Copyright (C) 2007 Paul Davis
-
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
-
-#include <ardour/silentfilesource.h>
-
-using namespace ARDOUR;
-
-SilentFileSource::SilentFileSource (Session& s, const XMLNode& node, nframes_t len, float sr)
- : AudioFileSource (s, node, false)
-{
- _length = len;
- _sample_rate = sr;
-}
-
-SilentFileSource::~SilentFileSource ()
-{
-}
-
-void
-SilentFileSource::set_length (nframes_t len)
-{
- _length = len;
-}
#include "i18n.h"
using namespace ARDOUR;
-
-string SMFSource::_search_path;
+using namespace Glib;
/** Constructor used for new internal-to-session files. File cannot exist. */
-SMFSource::SMFSource(Session& s, std::string path, Source::Flag flags)
- : MidiSource(s, region_name_from_path(path, false))
+SMFSource::SMFSource (Session& s, const ustring& path, bool embedded, Source::Flag flags)
+ : Source(s, DataType::MIDI, path, flags)
+ , MidiSource(s, path)
+ , FileSource(s, DataType::MIDI, path, embedded, flags)
, Evoral::SMF()
- , _allow_remove_if_empty(true)
, _last_ev_time_beats(0.0)
, _last_ev_time_frames(0)
{
- if (init(path, false)) {
+ if (init(_name, false)) {
throw failed_constructor ();
}
if (create(path)) {
throw failed_constructor ();
}
-
- assert(_name.find("/") == string::npos);
}
-/** Constructor used for existing internal-to-session files. File must exist. */
-SMFSource::SMFSource(Session& s, const XMLNode& node)
- : MidiSource(s, node)
- , _allow_remove_if_empty(true)
+/** Constructor used for existing internal-to-session files. */
+SMFSource::SMFSource (Session& s, const XMLNode& node, bool must_exist)
+ : Source(s, node)
+ , MidiSource(s, node)
+ , FileSource(s, node, must_exist)
, _last_ev_time_beats(0.0)
, _last_ev_time_frames(0)
{
if (open(_path)) {
throw failed_constructor ();
}
-
- assert(_name.find("/") == string::npos);
}
SMFSource::~SMFSource ()
}
}
-bool
-SMFSource::removable () const
-{
- return (_flags & Removable) && ((_flags & RemoveAtDestroy) ||
- ((_flags & RemovableIfEmpty) && is_empty()));
-}
-
-int
-SMFSource::init (string pathstr, bool must_exist)
-{
- bool is_new = false;
-
- if (!find (pathstr, must_exist, is_new)) {
- cerr << "cannot find " << pathstr << " with me = " << must_exist << endl;
- return -1;
- }
-
- if (is_new && must_exist) {
- return -1;
- }
-
- assert(_name.find("/") == string::npos);
- return 0;
-}
-
/** All stamps in audio frames */
nframes_t
SMFSource::read_unlocked (MidiRingBuffer<nframes_t>& dst, nframes_t start, nframes_t dur,
nframes_t stamp_offset, nframes_t negative_stamp_offset) const
{
- //cerr << "SMF read_unlocked " << name() << " read "
- //<< start << ", count=" << dur << ", offset=" << stamp_offset << endl;
-
- int ret;
+ int ret = 0;
uint64_t time = 0; // in SMF ticks, 1 tick per _ppqn
_read_data_count = 0;
/** Append an event with a timestamp in beats (double) */
void
-SMFSource::append_event_unlocked_beats(const Evoral::Event<double>& ev)
+SMFSource::append_event_unlocked_beats (const Evoral::Event<double>& ev)
{
if (ev.size() == 0) {
return;
/** Append an event with a timestamp in frames (nframes_t) */
void
-SMFSource::append_event_unlocked_frames(const Evoral::Event<nframes_t>& ev)
+SMFSource::append_event_unlocked_frames (const Evoral::Event<nframes_t>& ev)
{
if (ev.size() == 0) {
return;
}
}
-
XMLNode&
SMFSource::get_state ()
{
- XMLNode& root (MidiSource::get_state());
- char buf[16];
- snprintf (buf, sizeof (buf), "0x%x", (int)_flags);
- root.add_property ("flags", buf);
- return root;
+ return MidiSource::get_state();
}
int
SMFSource::set_state (const XMLNode& node)
{
- const XMLProperty* prop;
+ if (Source::set_state (node)) {
+ return -1;
+ }
if (MidiSource::set_state (node)) {
return -1;
}
-
- if ((prop = node.property (X_("flags"))) != 0) {
- int ival;
- sscanf (prop->value().c_str(), "0x%x", &ival);
- _flags = Flag (ival);
- } else {
- _flags = Flag (0);
+
+ if (FileSource::set_state (node)) {
+ return -1;
}
- assert(_name.find("/") == string::npos);
-
return 0;
}
-void
-SMFSource::mark_for_remove ()
-{
- if (!writable()) {
- return;
- }
- _flags = Flag (_flags | RemoveAtDestroy);
-}
-
void
SMFSource::mark_streaming_midi_write_started (NoteMode mode, nframes_t start_frame)
{
Evoral::SMF::end_write ();
}
-void
-SMFSource::mark_take (string id)
-{
- if (writable()) {
- _take_id = id;
- }
-}
-
-int
-SMFSource::move_to_trash (const string trash_dir_name)
-{
- if (!writable()) {
- return -1;
- }
-
- /* don't move the file across filesystems, just stick it in the
- trash_dir_name directory on whichever filesystem it was already on
- */
-
- Glib::ustring newpath;
- newpath = Glib::path_get_dirname (_path);
- newpath = Glib::path_get_dirname (newpath);
-
- newpath += string("/") + trash_dir_name + "/";
- newpath += Glib::path_get_basename (_path);
-
- /* the new path already exists, try versioning */
- if (access (newpath.c_str(), F_OK) == 0) {
- char buf[PATH_MAX+1];
- int version = 1;
- string newpath_v;
-
- snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), version);
- newpath_v = buf;
-
- while (access (newpath_v.c_str(), F_OK) == 0 && version < 999) {
- snprintf (buf, sizeof (buf), "%s.%d", newpath.c_str(), ++version);
- newpath_v = buf;
- }
-
- if (version == 999) {
- PBD::error << string_compose (
- _("there are already 1000 files with names like %1; versioning discontinued"),
- newpath) << endmsg;
- } else {
- newpath = newpath_v;
- }
- }
-
- if (::rename (_path.c_str(), newpath.c_str()) != 0) {
- PBD::error << string_compose (
- _("cannot rename midi file source from %1 to %2 (%3)"),
- _path, newpath, strerror (errno)) << endmsg;
- return -1;
- }
-
- _path = newpath;
-
- /* file can not be removed twice, since the operation is not idempotent */
- _flags = Flag (_flags & ~(RemoveAtDestroy|Removable|RemovableIfEmpty));
-
- return 0;
-}
-
bool
-SMFSource::safe_file_extension(const Glib::ustring& file)
+SMFSource::safe_midi_file_extension (const Glib::ustring& file)
{
return (file.rfind(".mid") != Glib::ustring::npos);
}
-// FIXME: Merge this with audiofilesource somehow (make a generic filesource?)
-bool
-SMFSource::find (string pathstr, bool must_exist, bool& isnew)
-{
- bool ret = false;
-
- isnew = false;
-
- if (pathstr[0] != '/') {
-
- /* non-absolute pathname: find pathstr in search path */
-
- vector<string> dirs;
- int cnt;
- string fullpath;
- string keeppath;
-
- if (_search_path.length() == 0) {
- PBD::error << _("FileSource: search path not set") << endmsg;
- goto out;
- }
-
- split (_search_path, dirs, ':');
-
- cnt = 0;
-
- for (vector<string>::iterator i = dirs.begin(); i != dirs.end(); ++i) {
- fullpath = *i;
- if (fullpath[fullpath.length()-1] != '/') {
- fullpath += '/';
- }
- fullpath += pathstr;
-
- if (access (fullpath.c_str(), R_OK) == 0) {
- keeppath = fullpath;
- ++cnt;
- }
- }
-
- if (cnt > 1) {
-
- PBD::error << string_compose (_("FileSource: \"%1\" is ambigous when searching %2\n\t"), pathstr, _search_path) << endmsg;
- goto out;
-
- } else if (cnt == 0) {
-
- if (must_exist) {
- PBD::error << string_compose(_("Filesource: cannot find required file (%1): while searching %2"), pathstr, _search_path) << endmsg;
- goto out;
- } else {
- isnew = true;
- }
- }
-
- _name = pathstr;
- _path = keeppath;
- ret = true;
-
- } else {
-
- /* external files and/or very very old style sessions include full paths */
-
- _path = pathstr;
- _name = pathstr.substr (pathstr.find_last_of ('/') + 1);
-
- if (access (_path.c_str(), R_OK) != 0) {
-
- /* file does not exist or we cannot read it */
-
- if (must_exist) {
- PBD::error << string_compose(_("Filesource: cannot find required file (%1): %2"), _path, strerror (errno)) << endmsg;
- goto out;
- }
-
- if (errno != ENOENT) {
- PBD::error << string_compose(_("Filesource: cannot check for existing file (%1): %2"), _path, strerror (errno)) << endmsg;
- goto out;
- }
-
- /* a new file */
-
- isnew = true;
- ret = true;
-
- } else {
-
- /* already exists */
-
- ret = true;
- }
- }
-
- out:
- return ret;
-}
-
-void
-SMFSource::set_search_path (string p)
-{
- _search_path = p;
-}
-
-
-void
-SMFSource::set_allow_remove_if_empty (bool yn)
-{
- if (writable()) {
- _allow_remove_if_empty = yn;
- }
-}
-
-int
-SMFSource::set_source_name (string newname, bool destructive)
-{
- //Glib::Mutex::Lock lm (_lock); FIXME
- string oldpath = _path;
- string newpath = Session::change_midi_path_by_name (oldpath, _name, newname, destructive);
-
- if (newpath.empty()) {
- PBD::error << string_compose (_("programming error: %1"), "cannot generate a changed midi path") << endmsg;
- return -1;
- }
-
- if (rename (oldpath.c_str(), newpath.c_str()) != 0) {
- PBD::error << string_compose (_("cannot rename midi file for %1 to %2"), _name, newpath) << endmsg;
- return -1;
- }
-
- _name = Glib::path_get_basename (newpath);
- _path = newpath;
-
- return 0;
-}
-
void
-SMFSource::load_model(bool lock, bool force_reload)
+SMFSource::load_model (bool lock, bool force_reload)
{
if (_writing) {
return;
#define LINEAR_INTERPOLATION_MODE_WORKS_PROPERLY 0
void
-SMFSource::set_default_controls_interpolation()
+SMFSource::set_default_controls_interpolation ()
{
// set interpolation style to defaults, can be changed by the GUI later
Evoral::ControlSet::Controls controls = _model->controls();
void
-SMFSource::destroy_model()
+SMFSource::destroy_model ()
{
//cerr << _name << " destroying model " << _model.get() << endl;
_model.reset();
}
void
-SMFSource::flush_midi()
+SMFSource::flush_midi ()
{
Evoral::SMF::end_write();
}
Source::CanRename );
SndFileSource::SndFileSource (Session& s, const XMLNode& node)
- : AudioFileSource (s, node)
+ : Source(s, node)
+ , AudioFileSource (s, node)
{
- init ();
+ init_sndfile ();
if (open()) {
throw failed_constructor ();
}
}
-SndFileSource::SndFileSource (Session& s, ustring path, int chn, Flag flags)
- /* files created this way are never writable or removable */
- : AudioFileSource (s, path, Flag (flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
+/** Files created this way are never writable or removable */
+SndFileSource::SndFileSource (Session& s, const ustring& path, bool embedded, int chn, Flag flags)
+ : Source(s, DataType::AUDIO, path, flags)
+ , AudioFileSource (s, path, embedded,
+ Flag (flags & ~(Writable|Removable|RemovableIfEmpty|RemoveAtDestroy)))
{
_channel = chn;
- init ();
+ init_sndfile ();
if (open()) {
throw failed_constructor ();
}
}
-SndFileSource::SndFileSource (Session& s, ustring path, SampleFormat sfmt, HeaderFormat hf, nframes_t rate, Flag flags)
- : AudioFileSource (s, path, flags, sfmt, hf)
+/** This constructor is used to construct new files, not open existing ones. */
+SndFileSource::SndFileSource (Session& s, const ustring& path, bool embedded,
+ SampleFormat sfmt, HeaderFormat hf, nframes_t rate, Flag flags)
+ : Source(s, DataType::AUDIO, path, flags)
+ , AudioFileSource (s, path, embedded, flags, sfmt, hf)
{
int fmt = 0;
- init ();
-
- /* this constructor is used to construct new files, not open
- existing ones.
- */
+ init_sndfile ();
_file_is_new = true;
}
void
-SndFileSource::init ()
+SndFileSource::init_sndfile ()
{
ustring file;
_timeline_position = header_position_offset;
}
- AudioFileSource::HeaderPositionOffsetChanged.connect (mem_fun (*this, &SndFileSource::handle_header_position_change));
+ AudioFileSource::HeaderPositionOffsetChanged.connect (
+ mem_fun (*this, &SndFileSource::handle_header_position_change));
}
int
using namespace std;
using namespace ARDOUR;
-Source::Source (Session& s, const string& name, DataType type, Flag flags)
+Source::Source (Session& s, DataType type, const string& name, Flag flags)
: SessionObject(s, name)
, _type(type)
, _flags(flags)
+ , _timeline_position(0)
{
_analysed = false;
_timestamp = 0;
: SessionObject(s, "unnamed source")
, _type(DataType::AUDIO)
, _flags (Flag (Writable|CanRename))
+ , _timeline_position(0)
{
_timestamp = 0;
_length = 0;
XMLNode *node = new XMLNode ("Source");
char buf[64];
- node->add_property ("name", _name);
+ node->add_property ("name", name());
node->add_property ("type", _type.to_string());
node->add_property (X_("flags"), enum_2_string (_flags));
_id.print (buf, sizeof (buf));
_flags = Flag (0);
}
+
+ /* old style, from the period when we had DestructiveFileSource */
+ if ((prop = node.property (X_("destructive"))) != 0) {
+ _flags = Flag (_flags | Destructive);
+ }
return 0;
}
Source::update_length (nframes_t pos, nframes_t cnt)
{
if (pos + cnt > _length) {
- _length = pos+cnt;
+ _length = pos + cnt;
}
}
return ok;
}
+void
+Source::mark_for_remove ()
+{
+ // This operation is not allowed for sources for destructive tracks or embedded files.
+ // Fortunately mark_for_remove() is never called for embedded files. This function
+ // must be fixed if that ever happens.
+ if (_flags & Destructive) {
+ return;
+ }
+
+ _flags = Flag (_flags | Removable | RemoveAtDestroy);
+}
+
+void
+Source::set_timeline_position (int64_t pos)
+{
+ _timeline_position = pos;
+}
+
+void
+Source::set_allow_remove_if_empty (bool yn)
+{
+ if (!writable()) {
+ return;
+ }
+
+ if (yn) {
+ _flags = Flag (_flags | RemovableIfEmpty);
+ } else {
+ _flags = Flag (_flags & ~RemovableIfEmpty);
+ }
+}
+
}
boost::shared_ptr<Source>
-SourceFactory::createReadable (DataType type, Session& s, string path, int chn, Source::Flag flags, bool announce, bool defer_peaks)
+SourceFactory::createReadable (DataType type, Session& s, const string& path, bool embedded,
+ int chn, Source::Flag flags, bool announce, bool defer_peaks)
{
if (type == DataType::AUDIO) {
try {
- boost::shared_ptr<Source> ret (new SndFileSource (s, path, chn, flags));
+ boost::shared_ptr<Source> ret (new SndFileSource (s, path, embedded, chn, flags));
if (setup_peakfile (ret, defer_peaks)) {
return boost::shared_ptr<Source>();
catch (failed_constructor& err) {
#ifdef USE_COREAUDIO_FOR_FILES
- boost::shared_ptr<Source> ret (new CoreAudioSource (s, path, chn, flags));
+ boost::shared_ptr<Source> ret (new CoreAudioSource (s, path, embedded, chn, flags));
if (setup_peakfile (ret, defer_peaks)) {
return boost::shared_ptr<Source>();
}
} else if (type == DataType::MIDI) {
- // FIXME: flags?
- boost::shared_ptr<Source> ret (new SMFSource (s, path, SMFSource::Flag(0)));
+ boost::shared_ptr<Source> ret (new SMFSource (s, path, embedded, SMFSource::Flag(0)));
if (announce) {
SourceCreated (ret);
}
boost::shared_ptr<Source>
-SourceFactory::createWritable (DataType type, Session& s, std::string path, bool destructive, nframes_t rate, bool announce, bool defer_peaks)
+SourceFactory::createWritable (DataType type, Session& s, const std::string& path, bool embedded,
+ bool destructive, nframes_t rate, bool announce, bool defer_peaks)
{
/* this might throw failed_constructor(), which is OK */
if (type == DataType::AUDIO) {
- boost::shared_ptr<Source> ret (new SndFileSource (s, path,
+ boost::shared_ptr<Source> ret (new SndFileSource (s, path, embedded,
Config->get_native_file_data_format(),
Config->get_native_file_header_format(),
rate,
} else if (type == DataType::MIDI) {
- boost::shared_ptr<Source> ret (new SMFSource (s, path));
+ boost::shared_ptr<Source> ret (new SMFSource (s, path, embedded, Source::Flag(0)));
// no analysis data - this is a new file
return boost::shared_ptr<Source> ();
}
+
int create(const std::string& path, int track=1, uint16_t ppqn=19200) THROW_FILE_ERROR;
void close() THROW_FILE_ERROR;
- const std::string& path() const { return _path; };
+ const std::string& file_path() const { return _file_path; };
void seek_to_start() const;
int seek_to_track(int track);
void flush() {};
private:
- std::string _path;
+ std::string _file_path;
smf_t* _smf;
smf_track_t* _smf_track;
bool _empty; ///< true iff file contains(non-empty) events
smf_delete(_smf);
}
- _path = path;
- _smf = smf_load(_path.c_str());
+ _file_path = path;
+ _smf = smf_load(_file_path.c_str());
if (_smf == NULL) {
return -1;
}
smf_delete(_smf);
}
- _path = path;
+ _file_path = path;
_smf = smf_new();
if (smf_set_ppqn(_smf, ppqn) != 0) {
SMF::close() THROW_FILE_ERROR
{
if (_smf) {
- if (smf_save(_smf, _path.c_str()) != 0) {
+ if (smf_save(_smf, _file_path.c_str()) != 0) {
throw FileError();
}
smf_delete(_smf);
void
SMF::end_write() THROW_FILE_ERROR
{
- if (smf_save(_smf, _path.c_str()) != 0)
+ if (smf_save(_smf, _file_path.c_str()) != 0)
throw FileError();
}
projects / ardour.git / commitdiff