Don't overrun buffer on oom if assertions disabled
[libopusenc.git] / src / 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 /********* WARNING: MENTAL SANITY ENDS HERE *************/
45
46 /* If the resampler is defined outside of Speex, we change the symbol names so that
47    there won't be any clash if linking with Speex later on. */
48
49 /* #define RANDOM_PREFIX your software name here */
50 #ifndef RANDOM_PREFIX
51 #error "Please define RANDOM_PREFIX (above) to something specific to your project to prevent symbol name clashes"
52 #endif
53
54 #define CAT_PREFIX2(a,b) a ## b
55 #define CAT_PREFIX(a,b) CAT_PREFIX2(a, b)
56
57 #define speex_resampler_init CAT_PREFIX(RANDOM_PREFIX,_resampler_init)
58 #define speex_resampler_init_frac CAT_PREFIX(RANDOM_PREFIX,_resampler_init_frac)
59 #define speex_resampler_destroy CAT_PREFIX(RANDOM_PREFIX,_resampler_destroy)
60 #define speex_resampler_process_float CAT_PREFIX(RANDOM_PREFIX,_resampler_process_float)
61 #define speex_resampler_process_int CAT_PREFIX(RANDOM_PREFIX,_resampler_process_int)
62 #define speex_resampler_process_interleaved_float CAT_PREFIX(RANDOM_PREFIX,_resampler_process_interleaved_float)
63 #define speex_resampler_process_interleaved_int CAT_PREFIX(RANDOM_PREFIX,_resampler_process_interleaved_int)
64 #define speex_resampler_set_rate CAT_PREFIX(RANDOM_PREFIX,_resampler_set_rate)
65 #define speex_resampler_get_rate CAT_PREFIX(RANDOM_PREFIX,_resampler_get_rate)
66 #define speex_resampler_set_rate_frac CAT_PREFIX(RANDOM_PREFIX,_resampler_set_rate_frac)
67 #define speex_resampler_get_ratio CAT_PREFIX(RANDOM_PREFIX,_resampler_get_ratio)
68 #define speex_resampler_set_quality CAT_PREFIX(RANDOM_PREFIX,_resampler_set_quality)
69 #define speex_resampler_get_quality CAT_PREFIX(RANDOM_PREFIX,_resampler_get_quality)
70 #define speex_resampler_set_input_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_set_input_stride)
71 #define speex_resampler_get_input_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_get_input_stride)
72 #define speex_resampler_set_output_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_set_output_stride)
73 #define speex_resampler_get_output_stride CAT_PREFIX(RANDOM_PREFIX,_resampler_get_output_stride)
74 #define speex_resampler_get_input_latency CAT_PREFIX(RANDOM_PREFIX,_resampler_get_input_latency)
75 #define speex_resampler_get_output_latency CAT_PREFIX(RANDOM_PREFIX,_resampler_get_output_latency)
76 #define speex_resampler_skip_zeros CAT_PREFIX(RANDOM_PREFIX,_resampler_skip_zeros)
77 #define speex_resampler_reset_mem CAT_PREFIX(RANDOM_PREFIX,_resampler_reset_mem)
78 #define speex_resampler_strerror CAT_PREFIX(RANDOM_PREFIX,_resampler_strerror)
79
80 #define spx_int16_t short
81 #define spx_int32_t int
82 #define spx_uint16_t unsigned short
83 #define spx_uint32_t unsigned int
84
85 #else /* OUTSIDE_SPEEX */
86
87 #include "speexdsp_types.h"
88
89 #endif /* OUTSIDE_SPEEX */
90
91 #ifdef __cplusplus
92 extern "C" {
93 #endif
94
95 #define SPEEX_RESAMPLER_QUALITY_MAX 10
96 #define SPEEX_RESAMPLER_QUALITY_MIN 0
97 #define SPEEX_RESAMPLER_QUALITY_DEFAULT 4
98 #define SPEEX_RESAMPLER_QUALITY_VOIP 3
99 #define SPEEX_RESAMPLER_QUALITY_DESKTOP 5
100
101 enum {
102    RESAMPLER_ERR_SUCCESS         = 0,
103    RESAMPLER_ERR_ALLOC_FAILED    = 1,
104    RESAMPLER_ERR_BAD_STATE       = 2,
105    RESAMPLER_ERR_INVALID_ARG     = 3,
106    RESAMPLER_ERR_PTR_OVERLAP     = 4,
107    RESAMPLER_ERR_OVERFLOW        = 5,
108
109    RESAMPLER_ERR_MAX_ERROR
110 };
111
112 struct SpeexResamplerState_;
113 typedef struct SpeexResamplerState_ SpeexResamplerState;
114
115 /** Create a new resampler with integer input and output rates.
116  * @param nb_channels Number of channels to be processed
117  * @param in_rate Input sampling rate (integer number of Hz).
118  * @param out_rate Output sampling rate (integer number of Hz).
119  * @param quality Resampling quality between 0 and 10, where 0 has poor quality
120  * and 10 has very high quality.
121  * @return Newly created resampler state
122  * @retval NULL Error: not enough memory
123  */
124 SpeexResamplerState *speex_resampler_init(spx_uint32_t nb_channels,
125                                           spx_uint32_t in_rate,
126                                           spx_uint32_t out_rate,
127                                           int quality,
128                                           int *err);
129
130 /** Create a new resampler with fractional input/output rates. The sampling
131  * rate ratio is an arbitrary rational number with both the numerator and
132  * denominator being 32-bit integers.
133  * @param nb_channels Number of channels to be processed
134  * @param ratio_num Numerator of the sampling rate ratio
135  * @param ratio_den Denominator of the sampling rate ratio
136  * @param in_rate Input sampling rate rounded to the nearest integer (in Hz).
137  * @param out_rate Output sampling rate rounded to the nearest integer (in Hz).
138  * @param quality Resampling quality between 0 and 10, where 0 has poor quality
139  * and 10 has very high quality.
140  * @return Newly created resampler state
141  * @retval NULL Error: not enough memory
142  */
143 SpeexResamplerState *speex_resampler_init_frac(spx_uint32_t nb_channels,
144                                                spx_uint32_t ratio_num,
145                                                spx_uint32_t ratio_den,
146                                                spx_uint32_t in_rate,
147                                                spx_uint32_t out_rate,
148                                                int quality,
149                                                int *err);
150
151 /** Destroy a resampler state.
152  * @param st Resampler state
153  */
154 void speex_resampler_destroy(SpeexResamplerState *st);
155
156 /** Resample a float array. The input and output buffers must *not* overlap.
157  * @param st Resampler state
158  * @param channel_index Index of the channel to process for the multi-channel
159  * base (0 otherwise)
160  * @param in Input buffer
161  * @param in_len Number of input samples in the input buffer. Returns the
162  * number of samples processed
163  * @param out Output buffer
164  * @param out_len Size of the output buffer. Returns the number of samples written
165  */
166 int speex_resampler_process_float(SpeexResamplerState *st,
167                                    spx_uint32_t channel_index,
168                                    const float *in,
169                                    spx_uint32_t *in_len,
170                                    float *out,
171                                    spx_uint32_t *out_len);
172
173 /** Resample an int array. The input and output buffers must *not* overlap.
174  * @param st Resampler state
175  * @param channel_index Index of the channel to process for the multi-channel
176  * base (0 otherwise)
177  * @param in Input buffer
178  * @param in_len Number of input samples in the input buffer. Returns the number
179  * of samples processed
180  * @param out Output buffer
181  * @param out_len Size of the output buffer. Returns the number of samples written
182  */
183 int speex_resampler_process_int(SpeexResamplerState *st,
184                                  spx_uint32_t channel_index,
185                                  const spx_int16_t *in,
186                                  spx_uint32_t *in_len,
187                                  spx_int16_t *out,
188                                  spx_uint32_t *out_len);
189
190 /** Resample an interleaved float array. The input and output buffers must *not* overlap.
191  * @param st Resampler state
192  * @param in Input buffer
193  * @param in_len Number of input samples in the input buffer. Returns the number
194  * of samples processed. This is all per-channel.
195  * @param out Output buffer
196  * @param out_len Size of the output buffer. Returns the number of samples written.
197  * This is all per-channel.
198  */
199 int speex_resampler_process_interleaved_float(SpeexResamplerState *st,
200                                                const float *in,
201                                                spx_uint32_t *in_len,
202                                                float *out,
203                                                spx_uint32_t *out_len);
204
205 /** Resample an interleaved int array. The input and output buffers must *not* overlap.
206  * @param st Resampler state
207  * @param in Input buffer
208  * @param in_len Number of input samples in the input buffer. Returns the number
209  * of samples processed. This is all per-channel.
210  * @param out Output buffer
211  * @param out_len Size of the output buffer. Returns the number of samples written.
212  * This is all per-channel.
213  */
214 int speex_resampler_process_interleaved_int(SpeexResamplerState *st,
215                                              const spx_int16_t *in,
216                                              spx_uint32_t *in_len,
217                                              spx_int16_t *out,
218                                              spx_uint32_t *out_len);
219
220 /** Set (change) the input/output sampling rates (integer value).
221  * @param st Resampler state
222  * @param in_rate Input sampling rate (integer number of Hz).
223  * @param out_rate Output sampling rate (integer number of Hz).
224  */
225 int speex_resampler_set_rate(SpeexResamplerState *st,
226                               spx_uint32_t in_rate,
227                               spx_uint32_t out_rate);
228
229 /** Get the current input/output sampling rates (integer value).
230  * @param st Resampler state
231  * @param in_rate Input sampling rate (integer number of Hz) copied.
232  * @param out_rate Output sampling rate (integer number of Hz) copied.
233  */
234 void speex_resampler_get_rate(SpeexResamplerState *st,
235                               spx_uint32_t *in_rate,
236                               spx_uint32_t *out_rate);
237
238 /** Set (change) the input/output sampling rates and resampling ratio
239  * (fractional values in Hz supported).
240  * @param st Resampler state
241  * @param ratio_num Numerator of the sampling rate ratio
242  * @param ratio_den Denominator of the sampling rate ratio
243  * @param in_rate Input sampling rate rounded to the nearest integer (in Hz).
244  * @param out_rate Output sampling rate rounded to the nearest integer (in Hz).
245  */
246 int speex_resampler_set_rate_frac(SpeexResamplerState *st,
247                                    spx_uint32_t ratio_num,
248                                    spx_uint32_t ratio_den,
249                                    spx_uint32_t in_rate,
250                                    spx_uint32_t out_rate);
251
252 /** Get the current resampling ratio. This will be reduced to the least
253  * common denominator.
254  * @param st Resampler state
255  * @param ratio_num Numerator of the sampling rate ratio copied
256  * @param ratio_den Denominator of the sampling rate ratio copied
257  */
258 void speex_resampler_get_ratio(SpeexResamplerState *st,
259                                spx_uint32_t *ratio_num,
260                                spx_uint32_t *ratio_den);
261
262 /** Set (change) the conversion quality.
263  * @param st Resampler state
264  * @param quality Resampling quality between 0 and 10, where 0 has poor
265  * quality and 10 has very high quality.
266  */
267 int speex_resampler_set_quality(SpeexResamplerState *st,
268                                  int quality);
269
270 /** Get the conversion quality.
271  * @param st Resampler state
272  * @param quality Resampling quality between 0 and 10, where 0 has poor
273  * quality and 10 has very high quality.
274  */
275 void speex_resampler_get_quality(SpeexResamplerState *st,
276                                  int *quality);
277
278 /** Set (change) the input stride.
279  * @param st Resampler state
280  * @param stride Input stride
281  */
282 void speex_resampler_set_input_stride(SpeexResamplerState *st,
283                                       spx_uint32_t stride);
284
285 /** Get the input stride.
286  * @param st Resampler state
287  * @param stride Input stride copied
288  */
289 void speex_resampler_get_input_stride(SpeexResamplerState *st,
290                                       spx_uint32_t *stride);
291
292 /** Set (change) the output stride.
293  * @param st Resampler state
294  * @param stride Output stride
295  */
296 void speex_resampler_set_output_stride(SpeexResamplerState *st,
297                                       spx_uint32_t stride);
298
299 /** Get the output stride.
300  * @param st Resampler state copied
301  * @param stride Output stride
302  */
303 void speex_resampler_get_output_stride(SpeexResamplerState *st,
304                                       spx_uint32_t *stride);
305
306 /** Get the latency introduced by the resampler measured in input samples.
307  * @param st Resampler state
308  */
309 int speex_resampler_get_input_latency(SpeexResamplerState *st);
310
311 /** Get the latency introduced by the resampler measured in output samples.
312  * @param st Resampler state
313  */
314 int speex_resampler_get_output_latency(SpeexResamplerState *st);
315
316 /** Make sure that the first samples to go out of the resamplers don't have
317  * leading zeros. This is only useful before starting to use a newly created
318  * resampler. It is recommended to use that when resampling an audio file, as
319  * it will generate a file with the same length. For real-time processing,
320  * it is probably easier not to use this call (so that the output duration
321  * is the same for the first frame).
322  * @param st Resampler state
323  */
324 int speex_resampler_skip_zeros(SpeexResamplerState *st);
325
326 /** Reset a resampler so a new (unrelated) stream can be processed.
327  * @param st Resampler state
328  */
329 int speex_resampler_reset_mem(SpeexResamplerState *st);
330
331 /** Returns the English meaning for an error code
332  * @param err Error code
333  * @return English string
334  */
335 const char *speex_resampler_strerror(int err);
336
337 #ifdef __cplusplus
338 }
339 #endif
340
341 #endif