rna polygon access to loop vertex indicies.
[blender-staging.git] / intern / audaspace / FX / AUD_FaderReader.cpp
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * Copyright 2009-2011 Jörg Hermann Müller
7  *
8  * This file is part of AudaSpace.
9  *
10  * Audaspace is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version.
14  *
15  * AudaSpace is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with Audaspace; if not, write to the Free Software Foundation,
22  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file audaspace/FX/AUD_FaderReader.cpp
28  *  \ingroup audfx
29  */
30
31
32 #include "AUD_FaderReader.h"
33
34 #include <cstring>
35
36 AUD_FaderReader::AUD_FaderReader(AUD_IReader* reader, AUD_FadeType type,
37                                                                  float start,float length) :
38                 AUD_EffectReader(reader),
39                 m_type(type),
40                 m_start(start),
41                 m_length(length),
42                 m_empty(true)
43 {
44 }
45
46 void AUD_FaderReader::read(int & length, sample_t* & buffer)
47 {
48         int position = m_reader->getPosition();
49         AUD_Specs specs = m_reader->getSpecs();
50         int samplesize = AUD_SAMPLE_SIZE(specs);
51
52         m_reader->read(length, buffer);
53
54         if((position + length) / (float)specs.rate <= m_start)
55         {
56                 if(m_type != AUD_FADE_OUT)
57                 {
58                         if(m_buffer.getSize() < length * samplesize)
59                         {
60                                 m_buffer.resize(length * samplesize);
61                                 m_empty = false;
62                         }
63
64                         buffer = m_buffer.getBuffer();
65
66                         if(!m_empty)
67                         {
68                                 memset(buffer, 0, length * samplesize);
69                                 m_empty = true;
70                         }
71                 }
72         }
73         else if(position / (float)specs.rate >= m_start+m_length)
74         {
75                 if(m_type == AUD_FADE_OUT)
76                 {
77                         if(m_buffer.getSize() < length * samplesize)
78                         {
79                                 m_buffer.resize(length * samplesize);
80                                 m_empty = false;
81                         }
82
83                         buffer = m_buffer.getBuffer();
84
85                         if(!m_empty)
86                         {
87                                 memset(buffer, 0, length * samplesize);
88                                 m_empty = true;
89                         }
90                 }
91         }
92         else
93         {
94                 if(m_buffer.getSize() < length * samplesize)
95                         m_buffer.resize(length * samplesize);
96
97                 sample_t* buf = m_buffer.getBuffer();
98                 float volume = 1.0f;
99
100                 for(int i = 0; i < length * specs.channels; i++)
101                 {
102                         if(i % specs.channels == 0)
103                         {
104                                 volume = (((position+i)/(float)specs.rate)-m_start) / m_length;
105                                 if(volume > 1.0f)
106                                         volume = 1.0f;
107                                 else if(volume < 0.0f)
108                                         volume = 0.0f;
109
110                                 if(m_type == AUD_FADE_OUT)
111                                         volume = 1.0f - volume;
112                         }
113
114                         buf[i] = buffer[i] * volume;
115                 }
116
117                 buffer = buf;
118                 m_empty = false;
119         }
120 }