source: roaraudio/libroardsp/remove.c @ 4708:c9d40761088a

Last change on this file since 4708:c9d40761088a was 4708:c9d40761088a, checked in by phi, 13 years ago

updated copyright statements

File size: 5.6 KB
Line 
1//remove.c:
2
3/*
4 *      Copyright (C) Philipp 'ph3-der-loewe' Schafft - 2009-2011
5 *
6 *  This file is part of libroardsp a part of RoarAudio,
7 *  a cross-platform sound system for both, home and professional use.
8 *  See README for details.
9 *
10 *  This file is free software; you can redistribute it and/or modify
11 *  it under the terms of the GNU General Public License version 3
12 *  as published by the Free Software Foundation.
13 *
14 *  libroardsp is distributed in the hope that it will be useful,
15 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 *  GNU General Public License for more details.
18 *
19 *  You should have received a copy of the GNU General Public License
20 *  along with this software; see the file COPYING.  If not, write to
21 *  the Free Software Foundation, 51 Franklin Street, Fifth Floor,
22 *  Boston, MA 02110-1301, USA.
23 *
24 */
25
26#include "libroardsp.h"
27
28int roar_remove_init (struct roar_remove_state * state) {
29 if ( state == NULL )
30  return -1;
31
32 memset(state, 0, sizeof(struct roar_remove_state));
33
34 state->old = 65535;
35
36 return 0;
37}
38
39int roar_remove      (void * inout, void * subs, int samples, int bits, struct roar_remove_state * state) {
40 if ( inout == NULL || subs == NULL || samples < 0 )
41  return -1;
42
43 switch (bits) {
44  case  8: return roar_remove_8 (inout, subs, samples, state); break;
45  case 16: return roar_remove_16(inout, subs, samples, state); break;
46  case 32: return roar_remove_32(inout, subs, samples, state); break;
47 }
48
49 return -1;
50}
51
52int roar_remove_8    (int8_t  * inout, int8_t  * subs, int samples, struct roar_remove_state * state) {
53 int i;
54 register int_least16_t s;
55 register int_least16_t peak;
56
57 if ( state == NULL ) {
58  for (i = 0; i < samples; i++) {
59   s  = inout[i];
60   s -= subs[i];
61   inout[i] = s;
62  }
63 } else {
64  peak = 127;
65  for (i = 0; i < samples; i++) {
66   s  = inout[i];
67   s -= subs[i];
68   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
69   if ( s > peak )
70    peak = s;
71  }
72
73  for (i = 0; i < samples; i++) {
74   s  = -subs[i];
75   s *=  127;
76   s /=  peak;
77   s +=  inout[i];
78   inout[i] = s;
79  }
80 }
81
82 return 0;
83}
84
85int roar_remove_16   (int16_t * inout, int16_t * subs, int samples, struct roar_remove_state * state) {
86 int i;
87 register int32_t s;
88 register int32_t peak;
89
90 if ( state == NULL ) {
91  for (i = 0; i < samples; i++) {
92   s  = inout[i];
93   s -= subs[i];
94   inout[i] = s;
95  }
96 } else {
97  peak = 65535;
98  for (i = 0; i < samples; i++) {
99   s  = inout[i];
100   s -= subs[i];
101   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
102   if ( s > peak )
103    peak = s;
104  }
105
106  for (i = 0; i < samples; i++) {
107   s  = -subs[i];
108   s *=  65535;
109   s /=  peak;
110   s +=  inout[i];
111   inout[i] = s;
112  }
113 }
114
115 return 0;
116}
117
118int roar_remove_32   (int32_t * inout, int32_t * subs, int samples, struct roar_remove_state * state) {
119 int i;
120 register int64_t s;
121 register int64_t peak;
122
123 if ( state == NULL ) {
124  for (i = 0; i < samples; i++) {
125   s  = inout[i];
126   s -= subs[i];
127   inout[i] = s;
128  }
129 } else {
130  peak = 4294967295UL;
131  for (i = 0; i < samples; i++) {
132   s  = inout[i];
133   s -= subs[i];
134   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
135   if ( s > peak )
136    peak = s;
137  }
138
139  for (i = 0; i < samples; i++) {
140   s  = -subs[i];
141   s *=  4294967295UL;
142   s /=  peak;
143   s +=  inout[i];
144   inout[i] = s;
145  }
146 }
147
148 return 0;
149}
150
151int roar_remove_so   (void    * subout, void   * in, int samples, int bits, struct roar_remove_state * state) {
152 if ( subout == NULL || in == NULL || samples < 0 )
153  return -1;
154
155 switch (bits) {
156  case  8: return roar_remove_so8 (subout, in, samples, state); break;
157  case 16: return roar_remove_so16(subout, in, samples, state); break;
158  case 32: return roar_remove_so32(subout, in, samples, state); break;
159 }
160
161 return -1;
162}
163
164int roar_remove_so8  (int8_t  * subout, int8_t  * in, int samples, struct roar_remove_state * state) {
165 int i;
166 register int_least16_t s;
167 register int_least16_t peak;
168
169 if ( state == NULL ) {
170  for (i = 0; i < samples; i++) {
171   s  = -subout[i];
172   s +=  in[i];
173   subout[i] = s;
174  }
175 } else {
176  peak = 127;
177  for (i = 0; i < samples; i++) {
178   s  = -subout[i];
179   s +=  in[i];
180   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
181   if ( s > peak )
182    peak = s;
183  }
184
185  for (i = 0; i < samples; i++) {
186   s  = -subout[i];
187   s *=  127;
188   s /=  peak;
189   s +=  in[i];
190   subout[i] = s;
191  }
192 }
193
194 return 0;
195}
196
197int roar_remove_so16 (int16_t * subout, int16_t * in, int samples, struct roar_remove_state * state) {
198 int i;
199 register int32_t s;
200 register int32_t peak;
201
202 if ( state == NULL ) {
203  for (i = 0; i < samples; i++) {
204   s  = -subout[i];
205   s +=  in[i];
206   subout[i] = s;
207  }
208 } else {
209  peak = 65535;
210  for (i = 0; i < samples; i++) {
211   s  = -subout[i];
212   s +=  in[i];
213   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
214   if ( s > peak )
215    peak = s;
216  }
217
218  for (i = 0; i < samples; i++) {
219   s  = -subout[i];
220   s *=  65535;
221   s /=  peak;
222   s +=  in[i];
223   subout[i] = s;
224  }
225 }
226
227 return 0;
228}
229
230int roar_remove_so32 (int32_t * subout, int32_t * in, int samples, struct roar_remove_state * state) {
231 int i;
232 register int64_t s;
233 register int64_t peak;
234
235 if ( state == NULL ) {
236  for (i = 0; i < samples; i++) {
237   s  = -subout[i];
238   s +=  in[i];
239   subout[i] = s;
240  }
241 } else {
242  peak = 2147483647UL;
243  for (i = 0; i < samples; i++) {
244   s  = -subout[i];
245   s +=  in[i];
246   s  = s < 0 ? -s : s; // we true 32 bit, not int operation here
247   if ( s > peak )
248    peak = s;
249  }
250
251  for (i = 0; i < samples; i++) {
252   s  = -subout[i];
253   s *=  2147483647UL;
254   s /=  peak;
255   s +=  in[i];
256   subout[i] = s;
257  }
258 }
259
260 return 0;
261}
262
263//ll
Note: See TracBrowser for help on using the repository browser.