Audaspace:
[blender.git] / intern / audaspace / intern / AUD_SequencerEntry.cpp
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * Copyright 2009-2011 Jörg Hermann Müller
5  *
6  * This file is part of AudaSpace.
7  *
8  * Audaspace is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * AudaSpace is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with Audaspace; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file audaspace/intern/AUD_SequencerEntry.cpp
26  *  \ingroup audaspaceintern
27  */
28
29
30 #include "AUD_SequencerEntry.h"
31 #include "AUD_SequencerReader.h"
32 #include "AUD_MutexLock.h"
33
34 #include <cmath>
35 #include <limits>
36
37 AUD_SequencerEntry::AUD_SequencerEntry(AUD_Reference<AUD_IFactory> sound, float begin, float end, float skip, int id) :
38         m_status(0),
39         m_pos_status(1),
40         m_sound_status(0),
41         m_id(id),
42         m_sound(sound),
43         m_begin(begin),
44         m_end(end),
45         m_skip(skip),
46         m_muted(false),
47         m_relative(true),
48         m_volume_max(1.0f),
49         m_volume_min(0),
50         m_distance_max(std::numeric_limits<float>::max()),
51         m_distance_reference(1.0f),
52         m_attenuation(1.0f),
53         m_cone_angle_outer(360),
54         m_cone_angle_inner(360),
55         m_cone_volume_outer(0),
56         m_location(3),
57         m_orientation(4)
58 {
59         AUD_Quaternion q;
60         m_orientation.write(q.get());
61         float f = 1;
62         m_volume.write(&f);
63         m_pitch.write(&f);
64
65         pthread_mutexattr_t attr;
66         pthread_mutexattr_init(&attr);
67         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
68
69         pthread_mutex_init(&m_mutex, &attr);
70
71         pthread_mutexattr_destroy(&attr);
72 }
73
74 AUD_SequencerEntry::~AUD_SequencerEntry()
75 {
76         pthread_mutex_destroy(&m_mutex);
77 }
78
79 void AUD_SequencerEntry::lock()
80 {
81         pthread_mutex_lock(&m_mutex);
82 }
83
84 void AUD_SequencerEntry::unlock()
85 {
86         pthread_mutex_unlock(&m_mutex);
87 }
88
89 void AUD_SequencerEntry::setSound(AUD_Reference<AUD_IFactory> sound)
90 {
91         AUD_MutexLock lock(*this);
92
93         if(m_sound.get() != sound.get())
94         {
95                 m_sound = sound;
96                 m_sound_status++;
97         }
98 }
99
100 void AUD_SequencerEntry::move(float begin, float end, float skip)
101 {
102         AUD_MutexLock lock(*this);
103
104         if(m_begin != begin || m_skip != skip || m_end != end)
105         {
106                 m_begin = begin;
107                 m_skip = skip;
108                 m_end = end;
109                 m_pos_status++;
110         }
111 }
112
113 void AUD_SequencerEntry::mute(bool mute)
114 {
115         AUD_MutexLock lock(*this);
116
117         m_muted = mute;
118 }
119
120 int AUD_SequencerEntry::getID() const
121 {
122         return m_id;
123 }
124
125 AUD_AnimateableProperty* AUD_SequencerEntry::getAnimProperty(AUD_AnimateablePropertyType type)
126 {
127         switch(type)
128         {
129         case AUD_AP_VOLUME:
130                 return &m_volume;
131         case AUD_AP_PITCH:
132                 return &m_pitch;
133         case AUD_AP_PANNING:
134                 return &m_panning;
135         case AUD_AP_LOCATION:
136                 return &m_location;
137         case AUD_AP_ORIENTATION:
138                 return &m_orientation;
139         default:
140                 return NULL;
141         }
142 }
143
144 void AUD_SequencerEntry::updateAll(float volume_max, float volume_min, float distance_max,
145                                                                    float distance_reference, float attenuation, float cone_angle_outer,
146                                                                    float cone_angle_inner, float cone_volume_outer)
147 {
148         AUD_MutexLock lock(*this);
149
150         if(volume_max != m_volume_max)
151         {
152                 m_volume_max = volume_max;
153                 m_status++;
154         }
155
156         if(volume_min != m_volume_min)
157         {
158                 m_volume_min = volume_min;
159                 m_status++;
160         }
161
162         if(distance_max != m_distance_max)
163         {
164                 m_distance_max = distance_max;
165                 m_status++;
166         }
167
168         if(distance_reference != m_distance_reference)
169         {
170                 m_distance_reference = distance_reference;
171                 m_status++;
172         }
173
174         if(attenuation != m_attenuation)
175         {
176                 m_attenuation = attenuation;
177                 m_status++;
178         }
179
180         if(cone_angle_outer != m_cone_angle_outer)
181         {
182                 m_cone_angle_outer = cone_angle_outer;
183                 m_status++;
184         }
185
186         if(cone_angle_inner != m_cone_angle_inner)
187         {
188                 m_cone_angle_inner = cone_angle_inner;
189                 m_status++;
190         }
191
192         if(cone_volume_outer != m_cone_volume_outer)
193         {
194                 m_cone_volume_outer = cone_volume_outer;
195                 m_status++;
196         }
197 }
198
199 bool AUD_SequencerEntry::isRelative()
200 {
201         return m_relative;
202 }
203
204 void AUD_SequencerEntry::setRelative(bool relative)
205 {
206         AUD_MutexLock lock(*this);
207
208         if(m_relative != relative)
209         {
210                 m_relative = relative;
211                 m_status++;
212         }
213 }
214
215 float AUD_SequencerEntry::getVolumeMaximum()
216 {
217         return m_volume_max;
218 }
219
220 void AUD_SequencerEntry::setVolumeMaximum(float volume)
221 {
222         AUD_MutexLock lock(*this);
223
224         m_volume_max = volume;
225         m_status++;
226 }
227
228 float AUD_SequencerEntry::getVolumeMinimum()
229 {
230         return m_volume_min;
231 }
232
233 void AUD_SequencerEntry::setVolumeMinimum(float volume)
234 {
235         AUD_MutexLock lock(*this);
236
237         m_volume_min = volume;
238         m_status++;
239 }
240
241 float AUD_SequencerEntry::getDistanceMaximum()
242 {
243         return m_distance_max;
244 }
245
246 void AUD_SequencerEntry::setDistanceMaximum(float distance)
247 {
248         AUD_MutexLock lock(*this);
249
250         m_distance_max = distance;
251         m_status++;
252 }
253
254 float AUD_SequencerEntry::getDistanceReference()
255 {
256         return m_distance_reference;
257 }
258
259 void AUD_SequencerEntry::setDistanceReference(float distance)
260 {
261         AUD_MutexLock lock(*this);
262
263         m_distance_reference = distance;
264         m_status++;
265 }
266
267 float AUD_SequencerEntry::getAttenuation()
268 {
269         return m_attenuation;
270 }
271
272 void AUD_SequencerEntry::setAttenuation(float factor)
273 {
274         AUD_MutexLock lock(*this);
275
276         m_attenuation = factor;
277         m_status++;
278 }
279
280 float AUD_SequencerEntry::getConeAngleOuter()
281 {
282         return m_cone_angle_outer;
283 }
284
285 void AUD_SequencerEntry::setConeAngleOuter(float angle)
286 {
287         AUD_MutexLock lock(*this);
288
289         m_cone_angle_outer = angle;
290         m_status++;
291 }
292
293 float AUD_SequencerEntry::getConeAngleInner()
294 {
295         return m_cone_angle_inner;
296 }
297
298 void AUD_SequencerEntry::setConeAngleInner(float angle)
299 {
300         AUD_MutexLock lock(*this);
301
302         m_cone_angle_inner = angle;
303         m_status++;
304 }
305
306 float AUD_SequencerEntry::getConeVolumeOuter()
307 {
308         return m_cone_volume_outer;
309 }
310
311 void AUD_SequencerEntry::setConeVolumeOuter(float volume)
312 {
313         AUD_MutexLock lock(*this);
314
315         m_cone_volume_outer = volume;
316         m_status++;
317 }