6e6e23976269ebf1993d6b2ffde69320ec6145bd
[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
33 #include <cmath>
34 #include <limits>
35
36 AUD_SequencerEntry::AUD_SequencerEntry(AUD_Reference<AUD_IFactory> sound, float begin, float end, float skip, int id) :
37         m_status(0),
38         m_pos_status(1),
39         m_sound_status(0),
40         m_id(id),
41         m_sound(sound),
42         m_begin(begin),
43         m_end(end),
44         m_skip(skip),
45         m_muted(false),
46         m_relative(true),
47         m_volume_max(1.0f),
48         m_volume_min(0),
49         m_distance_max(std::numeric_limits<float>::max()),
50         m_distance_reference(1.0f),
51         m_attenuation(1.0f),
52         m_cone_angle_outer(360),
53         m_cone_angle_inner(360),
54         m_cone_volume_outer(0),
55         m_location(3),
56         m_orientation(4)
57 {
58         AUD_Quaternion q;
59         m_orientation.write(q.get());
60         float f = 1;
61         m_volume.write(&f);
62         m_pitch.write(&f);
63
64         pthread_mutexattr_t attr;
65         pthread_mutexattr_init(&attr);
66         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
67
68         pthread_mutex_init(&m_mutex, &attr);
69
70         pthread_mutexattr_destroy(&attr);
71 }
72
73 AUD_SequencerEntry::~AUD_SequencerEntry()
74 {
75         pthread_mutex_destroy(&m_mutex);
76 }
77
78 void AUD_SequencerEntry::lock()
79 {
80         pthread_mutex_lock(&m_mutex);
81 }
82
83 void AUD_SequencerEntry::unlock()
84 {
85         pthread_mutex_unlock(&m_mutex);
86 }
87
88 void AUD_SequencerEntry::setSound(AUD_Reference<AUD_IFactory> sound)
89 {
90         lock();
91
92         if(m_sound.get() != sound.get())
93         {
94                 m_sound = sound;
95                 m_sound_status++;
96         }
97
98         unlock();
99 }
100
101 void AUD_SequencerEntry::move(float begin, float end, float skip)
102 {
103         lock();
104
105         if(m_begin != begin || m_skip != skip || m_end != end)
106         {
107                 m_begin = begin;
108                 m_skip = skip;
109                 m_end = end;
110                 m_pos_status++;
111         }
112
113         unlock();
114 }
115
116 void AUD_SequencerEntry::mute(bool mute)
117 {
118         lock();
119
120         m_muted = mute;
121
122         unlock();
123 }
124
125 int AUD_SequencerEntry::getID() const
126 {
127         return m_id;
128 }
129
130 AUD_AnimateableProperty* AUD_SequencerEntry::getAnimProperty(AUD_AnimateablePropertyType type)
131 {
132         switch(type)
133         {
134         case AUD_AP_VOLUME:
135                 return &m_volume;
136         case AUD_AP_PITCH:
137                 return &m_pitch;
138         case AUD_AP_PANNING:
139                 return &m_panning;
140         case AUD_AP_LOCATION:
141                 return &m_location;
142         case AUD_AP_ORIENTATION:
143                 return &m_orientation;
144         default:
145                 return NULL;
146         }
147 }
148
149 void AUD_SequencerEntry::updateAll(float volume_max, float volume_min, float distance_max,
150                                                                    float distance_reference, float attenuation, float cone_angle_outer,
151                                                                    float cone_angle_inner, float cone_volume_outer)
152 {
153         lock();
154
155         if(volume_max != m_volume_max)
156         {
157                 m_volume_max = volume_max;
158                 m_status++;
159         }
160
161         if(volume_min != m_volume_min)
162         {
163                 m_volume_min = volume_min;
164                 m_status++;
165         }
166
167         if(distance_max != m_distance_max)
168         {
169                 m_distance_max = distance_max;
170                 m_status++;
171         }
172
173         if(distance_reference != m_distance_reference)
174         {
175                 m_distance_reference = distance_reference;
176                 m_status++;
177         }
178
179         if(attenuation != m_attenuation)
180         {
181                 m_attenuation = attenuation;
182                 m_status++;
183         }
184
185         if(cone_angle_outer != m_cone_angle_outer)
186         {
187                 m_cone_angle_outer = cone_angle_outer;
188                 m_status++;
189         }
190
191         if(cone_angle_inner != m_cone_angle_inner)
192         {
193                 m_cone_angle_inner = cone_angle_inner;
194                 m_status++;
195         }
196
197         if(cone_volume_outer != m_cone_volume_outer)
198         {
199                 m_cone_volume_outer = cone_volume_outer;
200                 m_status++;
201         }
202
203         unlock();
204 }
205
206 bool AUD_SequencerEntry::isRelative()
207 {
208         return m_relative;
209 }
210
211 void AUD_SequencerEntry::setRelative(bool relative)
212 {
213         lock();
214
215         if(m_relative != relative)
216         {
217                 m_relative = relative;
218                 m_status++;
219         }
220
221         unlock();
222 }
223
224 float AUD_SequencerEntry::getVolumeMaximum()
225 {
226         return m_volume_max;
227 }
228
229 void AUD_SequencerEntry::setVolumeMaximum(float volume)
230 {
231         lock();
232
233         m_volume_max = volume;
234         m_status++;
235
236         unlock();
237 }
238
239 float AUD_SequencerEntry::getVolumeMinimum()
240 {
241         return m_volume_min;
242 }
243
244 void AUD_SequencerEntry::setVolumeMinimum(float volume)
245 {
246         lock();
247
248         m_volume_min = volume;
249         m_status++;
250
251         unlock();
252 }
253
254 float AUD_SequencerEntry::getDistanceMaximum()
255 {
256         return m_distance_max;
257 }
258
259 void AUD_SequencerEntry::setDistanceMaximum(float distance)
260 {
261         lock();
262
263         m_distance_max = distance;
264         m_status++;
265
266         unlock();
267 }
268
269 float AUD_SequencerEntry::getDistanceReference()
270 {
271         return m_distance_reference;
272 }
273
274 void AUD_SequencerEntry::setDistanceReference(float distance)
275 {
276         lock();
277
278         m_distance_reference = distance;
279         m_status++;
280
281         unlock();
282 }
283
284 float AUD_SequencerEntry::getAttenuation()
285 {
286         return m_attenuation;
287 }
288
289 void AUD_SequencerEntry::setAttenuation(float factor)
290 {
291         lock();
292
293         m_attenuation = factor;
294         m_status++;
295
296         unlock();
297 }
298
299 float AUD_SequencerEntry::getConeAngleOuter()
300 {
301         return m_cone_angle_outer;
302 }
303
304 void AUD_SequencerEntry::setConeAngleOuter(float angle)
305 {
306         lock();
307
308         m_cone_angle_outer = angle;
309         m_status++;
310
311         unlock();
312 }
313
314 float AUD_SequencerEntry::getConeAngleInner()
315 {
316         return m_cone_angle_inner;
317 }
318
319 void AUD_SequencerEntry::setConeAngleInner(float angle)
320 {
321         lock();
322
323         m_cone_angle_inner = angle;
324         m_status++;
325
326         unlock();
327 }
328
329 float AUD_SequencerEntry::getConeVolumeOuter()
330 {
331         return m_cone_volume_outer;
332 }
333
334 void AUD_SequencerEntry::setConeVolumeOuter(float volume)
335 {
336         lock();
337
338         m_cone_volume_outer = volume;
339         m_status++;
340
341         unlock();
342 }