summaryrefslogtreecommitdiff
path: root/libs/ardour/ardour/source.h
blob: d6c68edf9036a19746ec8ddf1b4466ebb63fca36 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
/*
    Copyright (C) 2000 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_source_h__
#define __ardour_source_h__

#include <string>
#include <set>

#include <boost/utility.hpp>
#include <sigc++/signal.h>
#include "pbd/statefuldestructible.h" 

#include "ardour/ardour.h"
#include "ardour/session_object.h"
#include "ardour/data_type.h"
#include "ardour/readable.h"

namespace ARDOUR {

class Session;
class Playlist;

class Source : public SessionObject, public boost::noncopyable
{
  public:
	enum Flag {
		Writable = 0x1,
		CanRename = 0x2,
		Broadcast = 0x4,
		Removable = 0x8,
		RemovableIfEmpty = 0x10,
		RemoveAtDestroy = 0x20,
		NoPeakFile = 0x40,
		Destructive = 0x80
	};

	Source (Session&, DataType type, const std::string& name, Flag flags=Flag(0));
	Source (Session&, const XMLNode&);
	
	virtual ~Source ();
	
	DataType type() { return _type; }

	time_t timestamp() const { return _timestamp; }
	void stamp (time_t when) { _timestamp = when; }
	
	virtual sframes_t length (sframes_t pos) const = 0;
	virtual void      update_length (sframes_t pos, sframes_t cnt) = 0;
	
	virtual const Glib::ustring& path() const = 0;

	virtual nframes64_t natural_position() const { return 0; }

	void mark_for_remove();
	
	virtual void mark_streaming_write_started () {}
	virtual void mark_streaming_write_completed () = 0;

	virtual void session_saved() {}
	
	XMLNode& get_state ();
	int set_state (const XMLNode&);
	
	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 add_playlist (boost::shared_ptr<ARDOUR::Playlist>);
	void remove_playlist (boost::weak_ptr<ARDOUR::Playlist>);

	uint32_t used() const;

	static sigc::signal<void,Source*>             SourceCreated;
	sigc::signal<void,boost::shared_ptr<Source> > Switched;

	bool has_been_analysed() const;
	virtual bool can_be_analysed() const { return false; } 
	virtual void set_been_analysed (bool yn);
	virtual bool check_for_analysis_data_on_disk();

	sigc::signal<void> AnalysisChanged;
	
	AnalysisFeatureList transients;
	std::string get_transients_path() const;
	int load_transients (const std::string&);
	
	sframes_t    timeline_position() const { return _timeline_position; }
	virtual void set_timeline_position (sframes_t pos);
	
	void set_allow_remove_if_empty (bool yn);
	
	Glib::Mutex& mutex()       { return _lock; }
	Flag         flags() const { return _flags; }

  protected:
	DataType            _type;
	Flag                _flags;
	time_t              _timestamp;
	sframes_t           _timeline_position;
	bool                _analysed;
	mutable Glib::Mutex _lock;
	mutable Glib::Mutex _analysis_lock;
	Glib::Mutex         _playlist_lock;
	
	typedef std::map<boost::shared_ptr<ARDOUR::Playlist>, uint32_t > PlaylistMap;
	PlaylistMap _playlists;

  private:
	uint32_t _in_use;
};

}

#endif /* __ardour_source_h__ */