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
|
/* Copyright 2017, Ableton AG, Berlin. All rights reserved.
*
* 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, see <http://www.gnu.org/licenses/>.
*
* If you would like to incorporate Link into a proprietary software application,
* please contact <link-devs@ableton.com>.
*/
#pragma once
#include <ableton/link/Optional.hpp>
#include <ableton/link/StartStopState.hpp>
#include <ableton/link/Timeline.hpp>
#include <ableton/link/TripleBuffer.hpp>
#include <mutex>
namespace ableton
{
namespace link
{
using OptionalTimeline = Optional<Timeline>;
using OptionalStartStopState = Optional<StartStopState>;
using OptionalClientStartStopState = Optional<ClientStartStopState>;
struct SessionState
{
Timeline timeline;
StartStopState startStopState;
GhostXForm ghostXForm;
};
struct ClientState
{
friend bool operator==(const ClientState& lhs, const ClientState& rhs)
{
return std::tie(lhs.timeline, lhs.startStopState)
== std::tie(rhs.timeline, rhs.startStopState);
}
friend bool operator!=(const ClientState& lhs, const ClientState& rhs)
{
return !(lhs == rhs);
}
Timeline timeline;
ClientStartStopState startStopState;
};
struct ControllerClientState
{
ControllerClientState(ClientState state)
: mState(state)
, mRtState(state)
{
}
template <typename Fn>
void update(Fn fn)
{
std::unique_lock<std::mutex> lock(mMutex);
fn(mState);
mRtState.write(mState);
}
ClientState get() const
{
std::unique_lock<std::mutex> lock(mMutex);
return mState;
}
ClientState getRt() const
{
return mRtState.read();
}
private:
mutable std::mutex mMutex;
ClientState mState;
mutable TripleBuffer<ClientState> mRtState;
};
struct RtClientState
{
Timeline timeline;
ClientStartStopState startStopState;
std::chrono::microseconds timelineTimestamp;
std::chrono::microseconds startStopStateTimestamp;
};
struct IncomingClientState
{
OptionalTimeline timeline;
OptionalClientStartStopState startStopState;
std::chrono::microseconds timelineTimestamp;
};
struct ApiState
{
Timeline timeline;
ApiStartStopState startStopState;
};
} // namespace link
} // namespace ableton
|
