defined MULT16_32_Q15 for OUTSIDE_SPEEX. Fixed stupid IO stride bug.
[speexdsp.git] / include / speex / speex_resampler.h
1 /* Copyright (C) 2007 Jean-Marc Valin
2       
3    File: speex_resampler.h
4    Resampling code
5       
6    The design goals of this code are:
7       - Very fast algorithm
8       - Low memory requirement
9       - Good *perceptual* quality (and not best SNR)
10
11    Redistribution and use in source and binary forms, with or without
12    modification, are permitted provided that the following conditions are
13    met:
14
15    1. Redistributions of source code must retain the above copyright notice,
16    this list of conditions and the following disclaimer.
17
18    2. Redistributions in binary form must reproduce the above copyright
19    notice, this list of conditions and the following disclaimer in the
20    documentation and/or other materials provided with the distribution.
21
22    3. The name of the author may not be used to endorse or promote products
23    derived from this software without specific prior written permission.
24
25    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
28    DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
29    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
30    (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
31    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32    HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
33    STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
34    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
35    POSSIBILITY OF SUCH DAMAGE.
36 */
37
38
39 #ifndef SPEEX_RESAMPLER_H
40 #define SPEEX_RESAMPLER_H
41
42 #ifdef OUTSIDE_SPEEX
43
44 #define spx_int16_t short
45 #ifdef FIXED_POINT
46 #define spx_word16_t short
47 #define spx_word32_t int
48 #else
49 #define spx_word16_t float
50 #define spx_word32_t float
51 #define MULT16_16(a,b) ((a)*(b))
52 #define MULT16_32_Q15(a,b) ((a)*(b))
53 #define PSHR32(a,b) (a)
54 #endif
55
56 #else
57
58 #include "speex/speex_types.h"
59
60 #endif
61
62 #ifdef __cplusplus
63 extern "C" {
64 #endif
65
66 #define SPEEX_RESAMPLER_QUALITY_MAX 10
67 #define SPEEX_RESAMPLER_QUALITY_MIN 0
68 #define SPEEX_RESAMPLER_QUALITY_DEFAULT 4
69 #define SPEEX_RESAMPLER_QUALITY_VOIP 3
70 #define SPEEX_RESAMPLER_QUALITY_DESKTOP 5
71    
72 struct SpeexResamplerState_;
73 typedef struct SpeexResamplerState_ SpeexResamplerState;
74
75 /** Create a new resampler with integer input and output rates.
76  * @param nb_channels Number of channels to be processed
77  * @param in_rate Input sampling rate (integer number of Hz).
78  * @param out_rate Output sampling rate (integer number of Hz).
79  * @param quality Resampling quality between 0 and 10, where 0 has poor quality
80  * and 10 has very high quality.
81  * @return Newly created resampler state
82  * @retval NULL Error: not enough memory
83  */
84 SpeexResamplerState *speex_resampler_init(int nb_channels, 
85                                           int in_rate, 
86                                           int out_rate, 
87                                           int quality);
88
89 /** Create a new resampler with fractional input/output rates. The sampling 
90  * rate ratio is an arbitrary rational number with both the numerator and 
91  * denominator being 32-bit integers.
92  * @param nb_channels Number of channels to be processed
93  * @param ratio_num Numerator of the sampling rate ratio
94  * @param ratio_den Denominator of the sampling rate ratio
95  * @param in_rate Input sampling rate rounded to the nearest integer (in Hz).
96  * @param out_rate Output sampling rate rounded to the nearest integer (in Hz).
97  * @param quality Resampling quality between 0 and 10, where 0 has poor quality
98  * and 10 has very high quality.
99  * @return Newly created resampler state
100  * @retval NULL Error: not enough memory
101  */
102 SpeexResamplerState *speex_resampler_init_frac(int nb_channels, 
103                                                int ratio_num, 
104                                                int ratio_den, 
105                                                int in_rate, 
106                                                int out_rate, 
107                                                int quality);
108
109 /** Destroy a resampler state.
110  * @param st Resampler state
111  */
112 void speex_resampler_destroy(SpeexResamplerState *st);
113
114 /** Resample a float array. The input and output buffers must *not* overlap.
115  * @param st Resampler state
116  * @param channel_index Index of the channel to process for the multi-channel 
117  * base (0 otherwise)
118  * @param in Input buffer
119  * @param in_len Number of input samples in the input buffer. Returns the 
120  * number of samples processed
121  * @param out Output buffer
122  * @param out_len Size of the output buffer. Returns the number of samples written
123  */
124 void speex_resampler_process_float(SpeexResamplerState *st, 
125                                    int channel_index, 
126                                    const float *in, 
127                                    int *in_len, 
128                                    float *out, 
129                                    int *out_len);
130
131 /** Resample an int array. The input and output buffers must *not* overlap.
132  * @param st Resampler state
133  * @param channel_index Index of the channel to process for the multi-channel 
134  * base (0 otherwise)
135  * @param in Input buffer
136  * @param in_len Number of input samples in the input buffer. Returns the number
137  * of samples processed
138  * @param out Output buffer
139  * @param out_len Size of the output buffer. Returns the number of samples written
140  */
141 void speex_resampler_process_int(SpeexResamplerState *st, 
142                                  int channel_index, 
143                                  const spx_int16_t *in, 
144                                  int *in_len, 
145                                  spx_int16_t *out, 
146                                  int *out_len);
147
148 /** Resample an interleaved float array. The input and output buffers must *not* overlap.
149  * @param st Resampler state
150  * @param in Input buffer
151  * @param in_len Number of input samples in the input buffer. Returns the number
152  * of samples processed. This is all per-channel.
153  * @param out Output buffer
154  * @param out_len Size of the output buffer. Returns the number of samples written.
155  * This is all per-channel.
156  */
157 void speex_resampler_process_interleaved_float(SpeexResamplerState *st, 
158                                                const float *in, 
159                                                int *in_len, 
160                                                float *out, 
161                                                int *out_len);
162
163 /** Resample an interleaved int array. The input and output buffers must *not* overlap.
164  * @param st Resampler state
165  * @param in Input buffer
166  * @param in_len Number of input samples in the input buffer. Returns the number
167  * of samples processed. This is all per-channel.
168  * @param out Output buffer
169  * @param out_len Size of the output buffer. Returns the number of samples written.
170  * This is all per-channel.
171  */
172 void speex_resampler_process_interleaved_int(SpeexResamplerState *st, 
173                                              const spx_int16_t *in, 
174                                              int *in_len, 
175                                              spx_int16_t *out, 
176                                              int *out_len);
177
178 /** Set (change) the input/output sampling rates (integer value).
179  * @param st Resampler state
180  * @param in_rate Input sampling rate (integer number of Hz).
181  * @param out_rate Output sampling rate (integer number of Hz).
182  */
183 void speex_resampler_set_rate(SpeexResamplerState *st, 
184                               int in_rate, 
185                               int out_rate);
186
187 /** Get the current input/output sampling rates (integer value).
188  * @param st Resampler state
189  * @param in_rate Input sampling rate (integer number of Hz) copied.
190  * @param out_rate Output sampling rate (integer number of Hz) copied.
191  */
192 void speex_resampler_get_rate(SpeexResamplerState *st, 
193                               int *in_rate, 
194                               int *out_rate);
195
196 /** Set (change) the input/output sampling rates and resampling ratio 
197  * (fractional values in Hz supported).
198  * @param st Resampler state
199  * @param ratio_num Numerator of the sampling rate ratio
200  * @param ratio_den Denominator of the sampling rate ratio
201  * @param in_rate Input sampling rate rounded to the nearest integer (in Hz).
202  * @param out_rate Output sampling rate rounded to the nearest integer (in Hz).
203  */
204 void speex_resampler_set_rate_frac(SpeexResamplerState *st, 
205                                    int ratio_num, 
206                                    int ratio_den, 
207                                    int in_rate, 
208                                    int out_rate);
209
210 /** Get the current resampling ratio. This will be reduced to the least
211  * common denominator.
212  * @param st Resampler state
213  * @param ratio_num Numerator of the sampling rate ratio copied
214  * @param ratio_den Denominator of the sampling rate ratio copied
215  */
216 void speex_resampler_get_ratio(SpeexResamplerState *st, 
217                                    int *ratio_num, 
218                                    int *ratio_den);
219
220 /** Set (change) the conversion quality.
221  * @param st Resampler state
222  * @param quality Resampling quality between 0 and 10, where 0 has poor 
223  * quality and 10 has very high quality.
224  */
225 void speex_resampler_set_quality(SpeexResamplerState *st, 
226                                  int quality);
227
228 /** Get the conversion quality.
229  * @param st Resampler state
230  * @param quality Resampling quality between 0 and 10, where 0 has poor 
231  * quality and 10 has very high quality.
232  */
233 void speex_resampler_get_quality(SpeexResamplerState *st, 
234                                  int *quality);
235
236 /** Set (change) the input stride.
237  * @param st Resampler state
238  * @param stride Input stride
239  */
240 void speex_resampler_set_input_stride(SpeexResamplerState *st, 
241                                       int stride);
242
243 /** Get the input stride.
244  * @param st Resampler state
245  * @param stride Input stride copied
246  */
247 void speex_resampler_get_input_stride(SpeexResamplerState *st, 
248                                       int *stride);
249
250 /** Set (change) the output stride.
251  * @param st Resampler state
252  * @param stride Output stride
253  */
254 void speex_resample_set_output_stride(SpeexResamplerState *st, 
255                                       int stride);
256
257 /** Get the output stride.
258  * @param st Resampler state copied
259  * @param stride Output stride
260  */
261 void speex_resample_get_output_stride(SpeexResamplerState *st, 
262                                       int *stride);
263
264 /** Make sure that the first samples to go out of the resamplers don't have 
265  * leading zeros. This is only useful before starting to use a newly created 
266  * resampler. It is recommended to use that when resampling an audio file, as
267  * it will generate a file with the same length. For real-time processing,
268  * it is probably easier not to use this call (so that the output duration
269  * is the same for the first frame).
270  * @param st Resampler state
271  */
272 void speex_resampler_skip_zeros(SpeexResamplerState *st);
273
274 /** Reset a resampler so a new (unrelated) stream can be processed.
275  * @param st Resampler state
276  */
277 void speex_resampler_reset_mem(SpeexResamplerState *st);
278
279 #ifdef __cplusplus
280 }
281 #endif
282
283 #endif