diff options
Diffstat (limited to 'lib/rbcodec/codecs/libopus/opus_encoder.c')
-rw-r--r-- | lib/rbcodec/codecs/libopus/opus_encoder.c | 2754 |
1 files changed, 2754 insertions, 0 deletions
diff --git a/lib/rbcodec/codecs/libopus/opus_encoder.c b/lib/rbcodec/codecs/libopus/opus_encoder.c new file mode 100644 index 0000000000..cbeb40aebc --- /dev/null +++ b/lib/rbcodec/codecs/libopus/opus_encoder.c | |||
@@ -0,0 +1,2754 @@ | |||
1 | /* Copyright (c) 2010-2011 Xiph.Org Foundation, Skype Limited | ||
2 | Written by Jean-Marc Valin and Koen Vos */ | ||
3 | /* | ||
4 | Redistribution and use in source and binary forms, with or without | ||
5 | modification, are permitted provided that the following conditions | ||
6 | are met: | ||
7 | |||
8 | - Redistributions of source code must retain the above copyright | ||
9 | notice, this list of conditions and the following disclaimer. | ||
10 | |||
11 | - Redistributions in binary form must reproduce the above copyright | ||
12 | notice, this list of conditions and the following disclaimer in the | ||
13 | documentation and/or other materials provided with the distribution. | ||
14 | |||
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS | ||
16 | ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT | ||
17 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR | ||
18 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER | ||
19 | OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, | ||
20 | EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, | ||
21 | PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR | ||
22 | PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF | ||
23 | LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING | ||
24 | NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | #ifdef HAVE_CONFIG_H | ||
29 | #include "config.h" | ||
30 | #endif | ||
31 | |||
32 | #include <stdarg.h> | ||
33 | #include "celt.h" | ||
34 | #include "entenc.h" | ||
35 | #include "modes.h" | ||
36 | #include "API.h" | ||
37 | #include "stack_alloc.h" | ||
38 | #include "float_cast.h" | ||
39 | #include "opus.h" | ||
40 | #include "arch.h" | ||
41 | #include "pitch.h" | ||
42 | #include "opus_private.h" | ||
43 | #include "os_support.h" | ||
44 | #include "cpu_support.h" | ||
45 | #include "analysis.h" | ||
46 | #include "mathops.h" | ||
47 | #include "tuning_parameters.h" | ||
48 | #ifdef FIXED_POINT | ||
49 | #include "fixed/structs_FIX.h" | ||
50 | #else | ||
51 | #include "float/structs_FLP.h" | ||
52 | #endif | ||
53 | |||
54 | #define MAX_ENCODER_BUFFER 480 | ||
55 | |||
56 | #ifndef DISABLE_FLOAT_API | ||
57 | #define PSEUDO_SNR_THRESHOLD 316.23f /* 10^(25/10) */ | ||
58 | #endif | ||
59 | |||
60 | typedef struct { | ||
61 | opus_val32 XX, XY, YY; | ||
62 | opus_val16 smoothed_width; | ||
63 | opus_val16 max_follower; | ||
64 | } StereoWidthState; | ||
65 | |||
66 | struct OpusEncoder { | ||
67 | int celt_enc_offset; | ||
68 | int silk_enc_offset; | ||
69 | silk_EncControlStruct silk_mode; | ||
70 | int application; | ||
71 | int channels; | ||
72 | int delay_compensation; | ||
73 | int force_channels; | ||
74 | int signal_type; | ||
75 | int user_bandwidth; | ||
76 | int max_bandwidth; | ||
77 | int user_forced_mode; | ||
78 | int voice_ratio; | ||
79 | opus_int32 Fs; | ||
80 | int use_vbr; | ||
81 | int vbr_constraint; | ||
82 | int variable_duration; | ||
83 | opus_int32 bitrate_bps; | ||
84 | opus_int32 user_bitrate_bps; | ||
85 | int lsb_depth; | ||
86 | int encoder_buffer; | ||
87 | int lfe; | ||
88 | int arch; | ||
89 | int use_dtx; /* general DTX for both SILK and CELT */ | ||
90 | #ifndef DISABLE_FLOAT_API | ||
91 | TonalityAnalysisState analysis; | ||
92 | #endif | ||
93 | |||
94 | #define OPUS_ENCODER_RESET_START stream_channels | ||
95 | int stream_channels; | ||
96 | opus_int16 hybrid_stereo_width_Q14; | ||
97 | opus_int32 variable_HP_smth2_Q15; | ||
98 | opus_val16 prev_HB_gain; | ||
99 | opus_val32 hp_mem[4]; | ||
100 | int mode; | ||
101 | int prev_mode; | ||
102 | int prev_channels; | ||
103 | int prev_framesize; | ||
104 | int bandwidth; | ||
105 | /* Bandwidth determined automatically from the rate (before any other adjustment) */ | ||
106 | int auto_bandwidth; | ||
107 | int silk_bw_switch; | ||
108 | /* Sampling rate (at the API level) */ | ||
109 | int first; | ||
110 | opus_val16 * energy_masking; | ||
111 | StereoWidthState width_mem; | ||
112 | opus_val16 delay_buffer[MAX_ENCODER_BUFFER*2]; | ||
113 | #ifndef DISABLE_FLOAT_API | ||
114 | int detected_bandwidth; | ||
115 | int nb_no_activity_frames; | ||
116 | opus_val32 peak_signal_energy; | ||
117 | #endif | ||
118 | int nonfinal_frame; /* current frame is not the final in a packet */ | ||
119 | opus_uint32 rangeFinal; | ||
120 | }; | ||
121 | |||
122 | /* Transition tables for the voice and music. First column is the | ||
123 | middle (memoriless) threshold. The second column is the hysteresis | ||
124 | (difference with the middle) */ | ||
125 | static const opus_int32 mono_voice_bandwidth_thresholds[8] = { | ||
126 | 9000, 700, /* NB<->MB */ | ||
127 | 9000, 700, /* MB<->WB */ | ||
128 | 13500, 1000, /* WB<->SWB */ | ||
129 | 14000, 2000, /* SWB<->FB */ | ||
130 | }; | ||
131 | static const opus_int32 mono_music_bandwidth_thresholds[8] = { | ||
132 | 9000, 700, /* NB<->MB */ | ||
133 | 9000, 700, /* MB<->WB */ | ||
134 | 11000, 1000, /* WB<->SWB */ | ||
135 | 12000, 2000, /* SWB<->FB */ | ||
136 | }; | ||
137 | static const opus_int32 stereo_voice_bandwidth_thresholds[8] = { | ||
138 | 9000, 700, /* NB<->MB */ | ||
139 | 9000, 700, /* MB<->WB */ | ||
140 | 13500, 1000, /* WB<->SWB */ | ||
141 | 14000, 2000, /* SWB<->FB */ | ||
142 | }; | ||
143 | static const opus_int32 stereo_music_bandwidth_thresholds[8] = { | ||
144 | 9000, 700, /* NB<->MB */ | ||
145 | 9000, 700, /* MB<->WB */ | ||
146 | 11000, 1000, /* WB<->SWB */ | ||
147 | 12000, 2000, /* SWB<->FB */ | ||
148 | }; | ||
149 | /* Threshold bit-rates for switching between mono and stereo */ | ||
150 | static const opus_int32 stereo_voice_threshold = 19000; | ||
151 | static const opus_int32 stereo_music_threshold = 17000; | ||
152 | |||
153 | /* Threshold bit-rate for switching between SILK/hybrid and CELT-only */ | ||
154 | static const opus_int32 mode_thresholds[2][2] = { | ||
155 | /* voice */ /* music */ | ||
156 | { 64000, 10000}, /* mono */ | ||
157 | { 44000, 10000}, /* stereo */ | ||
158 | }; | ||
159 | |||
160 | static const opus_int32 fec_thresholds[] = { | ||
161 | 12000, 1000, /* NB */ | ||
162 | 14000, 1000, /* MB */ | ||
163 | 16000, 1000, /* WB */ | ||
164 | 20000, 1000, /* SWB */ | ||
165 | 22000, 1000, /* FB */ | ||
166 | }; | ||
167 | |||
168 | int opus_encoder_get_size(int channels) | ||
169 | { | ||
170 | int silkEncSizeBytes, celtEncSizeBytes; | ||
171 | int ret; | ||
172 | if (channels<1 || channels > 2) | ||
173 | return 0; | ||
174 | ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); | ||
175 | if (ret) | ||
176 | return 0; | ||
177 | silkEncSizeBytes = align(silkEncSizeBytes); | ||
178 | celtEncSizeBytes = celt_encoder_get_size(channels); | ||
179 | return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes; | ||
180 | } | ||
181 | |||
182 | int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application) | ||
183 | { | ||
184 | void *silk_enc; | ||
185 | CELTEncoder *celt_enc; | ||
186 | int err; | ||
187 | int ret, silkEncSizeBytes; | ||
188 | |||
189 | if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| | ||
190 | (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO | ||
191 | && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) | ||
192 | return OPUS_BAD_ARG; | ||
193 | |||
194 | OPUS_CLEAR((char*)st, opus_encoder_get_size(channels)); | ||
195 | /* Create SILK encoder */ | ||
196 | ret = silk_Get_Encoder_Size( &silkEncSizeBytes ); | ||
197 | if (ret) | ||
198 | return OPUS_BAD_ARG; | ||
199 | silkEncSizeBytes = align(silkEncSizeBytes); | ||
200 | st->silk_enc_offset = align(sizeof(OpusEncoder)); | ||
201 | st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes; | ||
202 | silk_enc = (char*)st+st->silk_enc_offset; | ||
203 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); | ||
204 | |||
205 | st->stream_channels = st->channels = channels; | ||
206 | |||
207 | st->Fs = Fs; | ||
208 | |||
209 | st->arch = opus_select_arch(); | ||
210 | |||
211 | ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode ); | ||
212 | if(ret)return OPUS_INTERNAL_ERROR; | ||
213 | |||
214 | /* default SILK parameters */ | ||
215 | st->silk_mode.nChannelsAPI = channels; | ||
216 | st->silk_mode.nChannelsInternal = channels; | ||
217 | st->silk_mode.API_sampleRate = st->Fs; | ||
218 | st->silk_mode.maxInternalSampleRate = 16000; | ||
219 | st->silk_mode.minInternalSampleRate = 8000; | ||
220 | st->silk_mode.desiredInternalSampleRate = 16000; | ||
221 | st->silk_mode.payloadSize_ms = 20; | ||
222 | st->silk_mode.bitRate = 25000; | ||
223 | st->silk_mode.packetLossPercentage = 0; | ||
224 | st->silk_mode.complexity = 9; | ||
225 | st->silk_mode.useInBandFEC = 0; | ||
226 | st->silk_mode.useDTX = 0; | ||
227 | st->silk_mode.useCBR = 0; | ||
228 | st->silk_mode.reducedDependency = 0; | ||
229 | |||
230 | /* Create CELT encoder */ | ||
231 | /* Initialize CELT encoder */ | ||
232 | err = celt_encoder_init(celt_enc, Fs, channels, st->arch); | ||
233 | if(err!=OPUS_OK)return OPUS_INTERNAL_ERROR; | ||
234 | |||
235 | celt_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0)); | ||
236 | celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity)); | ||
237 | |||
238 | st->use_vbr = 1; | ||
239 | /* Makes constrained VBR the default (safer for real-time use) */ | ||
240 | st->vbr_constraint = 1; | ||
241 | st->user_bitrate_bps = OPUS_AUTO; | ||
242 | st->bitrate_bps = 3000+Fs*channels; | ||
243 | st->application = application; | ||
244 | st->signal_type = OPUS_AUTO; | ||
245 | st->user_bandwidth = OPUS_AUTO; | ||
246 | st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
247 | st->force_channels = OPUS_AUTO; | ||
248 | st->user_forced_mode = OPUS_AUTO; | ||
249 | st->voice_ratio = -1; | ||
250 | st->encoder_buffer = st->Fs/100; | ||
251 | st->lsb_depth = 24; | ||
252 | st->variable_duration = OPUS_FRAMESIZE_ARG; | ||
253 | |||
254 | /* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead | ||
255 | + 1.5 ms for SILK resamplers and stereo prediction) */ | ||
256 | st->delay_compensation = st->Fs/250; | ||
257 | |||
258 | st->hybrid_stereo_width_Q14 = 1 << 14; | ||
259 | st->prev_HB_gain = Q15ONE; | ||
260 | st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); | ||
261 | st->first = 1; | ||
262 | st->mode = MODE_HYBRID; | ||
263 | st->bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
264 | |||
265 | #ifndef DISABLE_FLOAT_API | ||
266 | tonality_analysis_init(&st->analysis, st->Fs); | ||
267 | st->analysis.application = st->application; | ||
268 | #endif | ||
269 | |||
270 | return OPUS_OK; | ||
271 | } | ||
272 | |||
273 | static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels) | ||
274 | { | ||
275 | int period; | ||
276 | unsigned char toc; | ||
277 | period = 0; | ||
278 | while (framerate < 400) | ||
279 | { | ||
280 | framerate <<= 1; | ||
281 | period++; | ||
282 | } | ||
283 | if (mode == MODE_SILK_ONLY) | ||
284 | { | ||
285 | toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND)<<5; | ||
286 | toc |= (period-2)<<3; | ||
287 | } else if (mode == MODE_CELT_ONLY) | ||
288 | { | ||
289 | int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND; | ||
290 | if (tmp < 0) | ||
291 | tmp = 0; | ||
292 | toc = 0x80; | ||
293 | toc |= tmp << 5; | ||
294 | toc |= period<<3; | ||
295 | } else /* Hybrid */ | ||
296 | { | ||
297 | toc = 0x60; | ||
298 | toc |= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND)<<4; | ||
299 | toc |= (period-2)<<3; | ||
300 | } | ||
301 | toc |= (channels==2)<<2; | ||
302 | return toc; | ||
303 | } | ||
304 | |||
305 | #ifndef FIXED_POINT | ||
306 | static void silk_biquad_float( | ||
307 | const opus_val16 *in, /* I: Input signal */ | ||
308 | const opus_int32 *B_Q28, /* I: MA coefficients [3] */ | ||
309 | const opus_int32 *A_Q28, /* I: AR coefficients [2] */ | ||
310 | opus_val32 *S, /* I/O: State vector [2] */ | ||
311 | opus_val16 *out, /* O: Output signal */ | ||
312 | const opus_int32 len, /* I: Signal length (must be even) */ | ||
313 | int stride | ||
314 | ) | ||
315 | { | ||
316 | /* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */ | ||
317 | opus_int k; | ||
318 | opus_val32 vout; | ||
319 | opus_val32 inval; | ||
320 | opus_val32 A[2], B[3]; | ||
321 | |||
322 | A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28))); | ||
323 | A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28))); | ||
324 | B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28))); | ||
325 | B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28))); | ||
326 | B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28))); | ||
327 | |||
328 | /* Negate A_Q28 values and split in two parts */ | ||
329 | |||
330 | for( k = 0; k < len; k++ ) { | ||
331 | /* S[ 0 ], S[ 1 ]: Q12 */ | ||
332 | inval = in[ k*stride ]; | ||
333 | vout = S[ 0 ] + B[0]*inval; | ||
334 | |||
335 | S[ 0 ] = S[1] - vout*A[0] + B[1]*inval; | ||
336 | |||
337 | S[ 1 ] = - vout*A[1] + B[2]*inval + VERY_SMALL; | ||
338 | |||
339 | /* Scale back to Q0 and saturate */ | ||
340 | out[ k*stride ] = vout; | ||
341 | } | ||
342 | } | ||
343 | #endif | ||
344 | |||
345 | static void hp_cutoff(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs, int arch) | ||
346 | { | ||
347 | opus_int32 B_Q28[ 3 ], A_Q28[ 2 ]; | ||
348 | opus_int32 Fc_Q19, r_Q28, r_Q22; | ||
349 | (void)arch; | ||
350 | |||
351 | silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) ); | ||
352 | Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 ); | ||
353 | silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 ); | ||
354 | |||
355 | r_Q28 = SILK_FIX_CONST( 1.0, 28 ) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 ); | ||
356 | |||
357 | /* b = r * [ 1; -2; 1 ]; */ | ||
358 | /* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */ | ||
359 | B_Q28[ 0 ] = r_Q28; | ||
360 | B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 ); | ||
361 | B_Q28[ 2 ] = r_Q28; | ||
362 | |||
363 | /* -r * ( 2 - Fc * Fc ); */ | ||
364 | r_Q22 = silk_RSHIFT( r_Q28, 6 ); | ||
365 | A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0, 22 ) ); | ||
366 | A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 ); | ||
367 | |||
368 | #ifdef FIXED_POINT | ||
369 | if( channels == 1 ) { | ||
370 | silk_biquad_alt_stride1( in, B_Q28, A_Q28, hp_mem, out, len ); | ||
371 | } else { | ||
372 | silk_biquad_alt_stride2( in, B_Q28, A_Q28, hp_mem, out, len, arch ); | ||
373 | } | ||
374 | #else | ||
375 | silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels ); | ||
376 | if( channels == 2 ) { | ||
377 | silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels ); | ||
378 | } | ||
379 | #endif | ||
380 | } | ||
381 | |||
382 | #ifdef FIXED_POINT | ||
383 | static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs) | ||
384 | { | ||
385 | int c, i; | ||
386 | int shift; | ||
387 | |||
388 | /* Approximates -round(log2(6.3*cutoff_Hz/Fs)) */ | ||
389 | shift=celt_ilog2(Fs/(cutoff_Hz*4)); | ||
390 | for (c=0;c<channels;c++) | ||
391 | { | ||
392 | for (i=0;i<len;i++) | ||
393 | { | ||
394 | opus_val32 x, y; | ||
395 | x = SHL32(EXTEND32(in[channels*i+c]), 14); | ||
396 | y = x-hp_mem[2*c]; | ||
397 | hp_mem[2*c] = hp_mem[2*c] + PSHR32(x - hp_mem[2*c], shift); | ||
398 | out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 14), 32767)); | ||
399 | } | ||
400 | } | ||
401 | } | ||
402 | |||
403 | #else | ||
404 | static void dc_reject(const opus_val16 *in, opus_int32 cutoff_Hz, opus_val16 *out, opus_val32 *hp_mem, int len, int channels, opus_int32 Fs) | ||
405 | { | ||
406 | int i; | ||
407 | float coef, coef2; | ||
408 | coef = 6.3f*cutoff_Hz/Fs; | ||
409 | coef2 = 1-coef; | ||
410 | if (channels==2) | ||
411 | { | ||
412 | float m0, m2; | ||
413 | m0 = hp_mem[0]; | ||
414 | m2 = hp_mem[2]; | ||
415 | for (i=0;i<len;i++) | ||
416 | { | ||
417 | opus_val32 x0, x1, out0, out1; | ||
418 | x0 = in[2*i+0]; | ||
419 | x1 = in[2*i+1]; | ||
420 | out0 = x0-m0; | ||
421 | out1 = x1-m2; | ||
422 | m0 = coef*x0 + VERY_SMALL + coef2*m0; | ||
423 | m2 = coef*x1 + VERY_SMALL + coef2*m2; | ||
424 | out[2*i+0] = out0; | ||
425 | out[2*i+1] = out1; | ||
426 | } | ||
427 | hp_mem[0] = m0; | ||
428 | hp_mem[2] = m2; | ||
429 | } else { | ||
430 | float m0; | ||
431 | m0 = hp_mem[0]; | ||
432 | for (i=0;i<len;i++) | ||
433 | { | ||
434 | opus_val32 x, y; | ||
435 | x = in[i]; | ||
436 | y = x-m0; | ||
437 | m0 = coef*x + VERY_SMALL + coef2*m0; | ||
438 | out[i] = y; | ||
439 | } | ||
440 | hp_mem[0] = m0; | ||
441 | } | ||
442 | } | ||
443 | #endif | ||
444 | |||
445 | static void stereo_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2, | ||
446 | int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs) | ||
447 | { | ||
448 | int i; | ||
449 | int overlap; | ||
450 | int inc; | ||
451 | inc = 48000/Fs; | ||
452 | overlap=overlap48/inc; | ||
453 | g1 = Q15ONE-g1; | ||
454 | g2 = Q15ONE-g2; | ||
455 | for (i=0;i<overlap;i++) | ||
456 | { | ||
457 | opus_val32 diff; | ||
458 | opus_val16 g, w; | ||
459 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); | ||
460 | g = SHR32(MAC16_16(MULT16_16(w,g2), | ||
461 | Q15ONE-w, g1), 15); | ||
462 | diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); | ||
463 | diff = MULT16_16_Q15(g, diff); | ||
464 | out[i*channels] = out[i*channels] - diff; | ||
465 | out[i*channels+1] = out[i*channels+1] + diff; | ||
466 | } | ||
467 | for (;i<frame_size;i++) | ||
468 | { | ||
469 | opus_val32 diff; | ||
470 | diff = EXTRACT16(HALF32((opus_val32)in[i*channels] - (opus_val32)in[i*channels+1])); | ||
471 | diff = MULT16_16_Q15(g2, diff); | ||
472 | out[i*channels] = out[i*channels] - diff; | ||
473 | out[i*channels+1] = out[i*channels+1] + diff; | ||
474 | } | ||
475 | } | ||
476 | |||
477 | static void gain_fade(const opus_val16 *in, opus_val16 *out, opus_val16 g1, opus_val16 g2, | ||
478 | int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs) | ||
479 | { | ||
480 | int i; | ||
481 | int inc; | ||
482 | int overlap; | ||
483 | int c; | ||
484 | inc = 48000/Fs; | ||
485 | overlap=overlap48/inc; | ||
486 | if (channels==1) | ||
487 | { | ||
488 | for (i=0;i<overlap;i++) | ||
489 | { | ||
490 | opus_val16 g, w; | ||
491 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); | ||
492 | g = SHR32(MAC16_16(MULT16_16(w,g2), | ||
493 | Q15ONE-w, g1), 15); | ||
494 | out[i] = MULT16_16_Q15(g, in[i]); | ||
495 | } | ||
496 | } else { | ||
497 | for (i=0;i<overlap;i++) | ||
498 | { | ||
499 | opus_val16 g, w; | ||
500 | w = MULT16_16_Q15(window[i*inc], window[i*inc]); | ||
501 | g = SHR32(MAC16_16(MULT16_16(w,g2), | ||
502 | Q15ONE-w, g1), 15); | ||
503 | out[i*2] = MULT16_16_Q15(g, in[i*2]); | ||
504 | out[i*2+1] = MULT16_16_Q15(g, in[i*2+1]); | ||
505 | } | ||
506 | } | ||
507 | c=0;do { | ||
508 | for (i=overlap;i<frame_size;i++) | ||
509 | { | ||
510 | out[i*channels+c] = MULT16_16_Q15(g2, in[i*channels+c]); | ||
511 | } | ||
512 | } | ||
513 | while (++c<channels); | ||
514 | } | ||
515 | |||
516 | OpusEncoder *opus_encoder_create(opus_int32 Fs, int channels, int application, int *error) | ||
517 | { | ||
518 | int ret; | ||
519 | OpusEncoder *st; | ||
520 | if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)||(channels!=1&&channels!=2)|| | ||
521 | (application != OPUS_APPLICATION_VOIP && application != OPUS_APPLICATION_AUDIO | ||
522 | && application != OPUS_APPLICATION_RESTRICTED_LOWDELAY)) | ||
523 | { | ||
524 | if (error) | ||
525 | *error = OPUS_BAD_ARG; | ||
526 | return NULL; | ||
527 | } | ||
528 | st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels)); | ||
529 | if (st == NULL) | ||
530 | { | ||
531 | if (error) | ||
532 | *error = OPUS_ALLOC_FAIL; | ||
533 | return NULL; | ||
534 | } | ||
535 | ret = opus_encoder_init(st, Fs, channels, application); | ||
536 | if (error) | ||
537 | *error = ret; | ||
538 | if (ret != OPUS_OK) | ||
539 | { | ||
540 | opus_free(st); | ||
541 | st = NULL; | ||
542 | } | ||
543 | return st; | ||
544 | } | ||
545 | |||
546 | static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes) | ||
547 | { | ||
548 | if(!frame_size)frame_size=st->Fs/400; | ||
549 | if (st->user_bitrate_bps==OPUS_AUTO) | ||
550 | return 60*st->Fs/frame_size + st->Fs*st->channels; | ||
551 | else if (st->user_bitrate_bps==OPUS_BITRATE_MAX) | ||
552 | return max_data_bytes*8*st->Fs/frame_size; | ||
553 | else | ||
554 | return st->user_bitrate_bps; | ||
555 | } | ||
556 | |||
557 | #ifndef DISABLE_FLOAT_API | ||
558 | #ifdef FIXED_POINT | ||
559 | #define PCM2VAL(x) FLOAT2INT16(x) | ||
560 | #else | ||
561 | #define PCM2VAL(x) SCALEIN(x) | ||
562 | #endif | ||
563 | |||
564 | void downmix_float(const void *_x, opus_val32 *y, int subframe, int offset, int c1, int c2, int C) | ||
565 | { | ||
566 | const float *x; | ||
567 | int j; | ||
568 | |||
569 | x = (const float *)_x; | ||
570 | for (j=0;j<subframe;j++) | ||
571 | y[j] = PCM2VAL(x[(j+offset)*C+c1]); | ||
572 | if (c2>-1) | ||
573 | { | ||
574 | for (j=0;j<subframe;j++) | ||
575 | y[j] += PCM2VAL(x[(j+offset)*C+c2]); | ||
576 | } else if (c2==-2) | ||
577 | { | ||
578 | int c; | ||
579 | for (c=1;c<C;c++) | ||
580 | { | ||
581 | for (j=0;j<subframe;j++) | ||
582 | y[j] += PCM2VAL(x[(j+offset)*C+c]); | ||
583 | } | ||
584 | } | ||
585 | } | ||
586 | #endif | ||
587 | |||
588 | void downmix_int(const void *_x, opus_val32 *y, int subframe, int offset, int c1, int c2, int C) | ||
589 | { | ||
590 | const opus_int16 *x; | ||
591 | int j; | ||
592 | |||
593 | x = (const opus_int16 *)_x; | ||
594 | for (j=0;j<subframe;j++) | ||
595 | y[j] = x[(j+offset)*C+c1]; | ||
596 | if (c2>-1) | ||
597 | { | ||
598 | for (j=0;j<subframe;j++) | ||
599 | y[j] += x[(j+offset)*C+c2]; | ||
600 | } else if (c2==-2) | ||
601 | { | ||
602 | int c; | ||
603 | for (c=1;c<C;c++) | ||
604 | { | ||
605 | for (j=0;j<subframe;j++) | ||
606 | y[j] += x[(j+offset)*C+c]; | ||
607 | } | ||
608 | } | ||
609 | } | ||
610 | |||
611 | opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs) | ||
612 | { | ||
613 | int new_size; | ||
614 | if (frame_size<Fs/400) | ||
615 | return -1; | ||
616 | if (variable_duration == OPUS_FRAMESIZE_ARG) | ||
617 | new_size = frame_size; | ||
618 | else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS && variable_duration <= OPUS_FRAMESIZE_120_MS) | ||
619 | { | ||
620 | if (variable_duration <= OPUS_FRAMESIZE_40_MS) | ||
621 | new_size = (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS); | ||
622 | else | ||
623 | new_size = (variable_duration-OPUS_FRAMESIZE_2_5_MS-2)*Fs/50; | ||
624 | } | ||
625 | else | ||
626 | return -1; | ||
627 | if (new_size>frame_size) | ||
628 | return -1; | ||
629 | if (400*new_size!=Fs && 200*new_size!=Fs && 100*new_size!=Fs && | ||
630 | 50*new_size!=Fs && 25*new_size!=Fs && 50*new_size!=3*Fs && | ||
631 | 50*new_size!=4*Fs && 50*new_size!=5*Fs && 50*new_size!=6*Fs) | ||
632 | return -1; | ||
633 | return new_size; | ||
634 | } | ||
635 | |||
636 | opus_val16 compute_stereo_width(const opus_val16 *pcm, int frame_size, opus_int32 Fs, StereoWidthState *mem) | ||
637 | { | ||
638 | opus_val32 xx, xy, yy; | ||
639 | opus_val16 sqrt_xx, sqrt_yy; | ||
640 | opus_val16 qrrt_xx, qrrt_yy; | ||
641 | int frame_rate; | ||
642 | int i; | ||
643 | opus_val16 short_alpha; | ||
644 | |||
645 | frame_rate = Fs/frame_size; | ||
646 | short_alpha = Q15ONE - MULT16_16(25, Q15ONE)/IMAX(50,frame_rate); | ||
647 | xx=xy=yy=0; | ||
648 | /* Unroll by 4. The frame size is always a multiple of 4 *except* for | ||
649 | 2.5 ms frames at 12 kHz. Since this setting is very rare (and very | ||
650 | stupid), we just discard the last two samples. */ | ||
651 | for (i=0;i<frame_size-3;i+=4) | ||
652 | { | ||
653 | opus_val32 pxx=0; | ||
654 | opus_val32 pxy=0; | ||
655 | opus_val32 pyy=0; | ||
656 | opus_val16 x, y; | ||
657 | x = pcm[2*i]; | ||
658 | y = pcm[2*i+1]; | ||
659 | pxx = SHR32(MULT16_16(x,x),2); | ||
660 | pxy = SHR32(MULT16_16(x,y),2); | ||
661 | pyy = SHR32(MULT16_16(y,y),2); | ||
662 | x = pcm[2*i+2]; | ||
663 | y = pcm[2*i+3]; | ||
664 | pxx += SHR32(MULT16_16(x,x),2); | ||
665 | pxy += SHR32(MULT16_16(x,y),2); | ||
666 | pyy += SHR32(MULT16_16(y,y),2); | ||
667 | x = pcm[2*i+4]; | ||
668 | y = pcm[2*i+5]; | ||
669 | pxx += SHR32(MULT16_16(x,x),2); | ||
670 | pxy += SHR32(MULT16_16(x,y),2); | ||
671 | pyy += SHR32(MULT16_16(y,y),2); | ||
672 | x = pcm[2*i+6]; | ||
673 | y = pcm[2*i+7]; | ||
674 | pxx += SHR32(MULT16_16(x,x),2); | ||
675 | pxy += SHR32(MULT16_16(x,y),2); | ||
676 | pyy += SHR32(MULT16_16(y,y),2); | ||
677 | |||
678 | xx += SHR32(pxx, 10); | ||
679 | xy += SHR32(pxy, 10); | ||
680 | yy += SHR32(pyy, 10); | ||
681 | } | ||
682 | #ifndef FIXED_POINT | ||
683 | if (!(xx < 1e9f) || celt_isnan(xx) || !(yy < 1e9f) || celt_isnan(yy)) | ||
684 | { | ||
685 | xy = xx = yy = 0; | ||
686 | } | ||
687 | #endif | ||
688 | mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX); | ||
689 | mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY); | ||
690 | mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY); | ||
691 | mem->XX = MAX32(0, mem->XX); | ||
692 | mem->XY = MAX32(0, mem->XY); | ||
693 | mem->YY = MAX32(0, mem->YY); | ||
694 | if (MAX32(mem->XX, mem->YY)>QCONST16(8e-4f, 18)) | ||
695 | { | ||
696 | opus_val16 corr; | ||
697 | opus_val16 ldiff; | ||
698 | opus_val16 width; | ||
699 | sqrt_xx = celt_sqrt(mem->XX); | ||
700 | sqrt_yy = celt_sqrt(mem->YY); | ||
701 | qrrt_xx = celt_sqrt(sqrt_xx); | ||
702 | qrrt_yy = celt_sqrt(sqrt_yy); | ||
703 | /* Inter-channel correlation */ | ||
704 | mem->XY = MIN32(mem->XY, sqrt_xx*sqrt_yy); | ||
705 | corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16); | ||
706 | /* Approximate loudness difference */ | ||
707 | ldiff = MULT16_16(Q15ONE, ABS16(qrrt_xx-qrrt_yy))/(EPSILON+qrrt_xx+qrrt_yy); | ||
708 | width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff); | ||
709 | /* Smoothing over one second */ | ||
710 | mem->smoothed_width += (width-mem->smoothed_width)/frame_rate; | ||
711 | /* Peak follower */ | ||
712 | mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width); | ||
713 | } | ||
714 | /*printf("%f %f %f %f %f ", corr/(float)Q15ONE, ldiff/(float)Q15ONE, width/(float)Q15ONE, mem->smoothed_width/(float)Q15ONE, mem->max_follower/(float)Q15ONE);*/ | ||
715 | return EXTRACT16(MIN32(Q15ONE, MULT16_16(20, mem->max_follower))); | ||
716 | } | ||
717 | |||
718 | static int decide_fec(int useInBandFEC, int PacketLoss_perc, int last_fec, int mode, int *bandwidth, opus_int32 rate) | ||
719 | { | ||
720 | int orig_bandwidth; | ||
721 | if (!useInBandFEC || PacketLoss_perc == 0 || mode == MODE_CELT_ONLY) | ||
722 | return 0; | ||
723 | orig_bandwidth = *bandwidth; | ||
724 | for (;;) | ||
725 | { | ||
726 | opus_int32 hysteresis; | ||
727 | opus_int32 LBRR_rate_thres_bps; | ||
728 | /* Compute threshold for using FEC at the current bandwidth setting */ | ||
729 | LBRR_rate_thres_bps = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND)]; | ||
730 | hysteresis = fec_thresholds[2*(*bandwidth - OPUS_BANDWIDTH_NARROWBAND) + 1]; | ||
731 | if (last_fec == 1) LBRR_rate_thres_bps -= hysteresis; | ||
732 | if (last_fec == 0) LBRR_rate_thres_bps += hysteresis; | ||
733 | LBRR_rate_thres_bps = silk_SMULWB( silk_MUL( LBRR_rate_thres_bps, | ||
734 | 125 - silk_min( PacketLoss_perc, 25 ) ), SILK_FIX_CONST( 0.01, 16 ) ); | ||
735 | /* If loss <= 5%, we look at whether we have enough rate to enable FEC. | ||
736 | If loss > 5%, we decrease the bandwidth until we can enable FEC. */ | ||
737 | if (rate > LBRR_rate_thres_bps) | ||
738 | return 1; | ||
739 | else if (PacketLoss_perc <= 5) | ||
740 | return 0; | ||
741 | else if (*bandwidth > OPUS_BANDWIDTH_NARROWBAND) | ||
742 | (*bandwidth)--; | ||
743 | else | ||
744 | break; | ||
745 | } | ||
746 | /* Couldn't find any bandwidth to enable FEC, keep original bandwidth. */ | ||
747 | *bandwidth = orig_bandwidth; | ||
748 | return 0; | ||
749 | } | ||
750 | |||
751 | static int compute_silk_rate_for_hybrid(int rate, int bandwidth, int frame20ms, int vbr, int fec, int channels) { | ||
752 | int entry; | ||
753 | int i; | ||
754 | int N; | ||
755 | int silk_rate; | ||
756 | static int rate_table[][5] = { | ||
757 | /* |total| |-------- SILK------------| | ||
758 | |-- No FEC -| |--- FEC ---| | ||
759 | 10ms 20ms 10ms 20ms */ | ||
760 | { 0, 0, 0, 0, 0}, | ||
761 | {12000, 10000, 10000, 11000, 11000}, | ||
762 | {16000, 13500, 13500, 15000, 15000}, | ||
763 | {20000, 16000, 16000, 18000, 18000}, | ||
764 | {24000, 18000, 18000, 21000, 21000}, | ||
765 | {32000, 22000, 22000, 28000, 28000}, | ||
766 | {64000, 38000, 38000, 50000, 50000} | ||
767 | }; | ||
768 | /* Do the allocation per-channel. */ | ||
769 | rate /= channels; | ||
770 | entry = 1 + frame20ms + 2*fec; | ||
771 | N = sizeof(rate_table)/sizeof(rate_table[0]); | ||
772 | for (i=1;i<N;i++) | ||
773 | { | ||
774 | if (rate_table[i][0] > rate) break; | ||
775 | } | ||
776 | if (i == N) | ||
777 | { | ||
778 | silk_rate = rate_table[i-1][entry]; | ||
779 | /* For now, just give 50% of the extra bits to SILK. */ | ||
780 | silk_rate += (rate-rate_table[i-1][0])/2; | ||
781 | } else { | ||
782 | opus_int32 lo, hi, x0, x1; | ||
783 | lo = rate_table[i-1][entry]; | ||
784 | hi = rate_table[i][entry]; | ||
785 | x0 = rate_table[i-1][0]; | ||
786 | x1 = rate_table[i][0]; | ||
787 | silk_rate = (lo*(x1-rate) + hi*(rate-x0))/(x1-x0); | ||
788 | } | ||
789 | if (!vbr) | ||
790 | { | ||
791 | /* Tiny boost to SILK for CBR. We should probably tune this better. */ | ||
792 | silk_rate += 100; | ||
793 | } | ||
794 | if (bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND) | ||
795 | silk_rate += 300; | ||
796 | silk_rate *= channels; | ||
797 | /* Small adjustment for stereo (calibrated for 32 kb/s, haven't tried other bitrates). */ | ||
798 | if (channels == 2 && rate >= 12000) | ||
799 | silk_rate -= 1000; | ||
800 | return silk_rate; | ||
801 | } | ||
802 | |||
803 | /* Returns the equivalent bitrate corresponding to 20 ms frames, | ||
804 | complexity 10 VBR operation. */ | ||
805 | static opus_int32 compute_equiv_rate(opus_int32 bitrate, int channels, | ||
806 | int frame_rate, int vbr, int mode, int complexity, int loss) | ||
807 | { | ||
808 | opus_int32 equiv; | ||
809 | equiv = bitrate; | ||
810 | /* Take into account overhead from smaller frames. */ | ||
811 | if (frame_rate > 50) | ||
812 | equiv -= (40*channels+20)*(frame_rate - 50); | ||
813 | /* CBR is about a 8% penalty for both SILK and CELT. */ | ||
814 | if (!vbr) | ||
815 | equiv -= equiv/12; | ||
816 | /* Complexity makes about 10% difference (from 0 to 10) in general. */ | ||
817 | equiv = equiv * (90+complexity)/100; | ||
818 | if (mode == MODE_SILK_ONLY || mode == MODE_HYBRID) | ||
819 | { | ||
820 | /* SILK complexity 0-1 uses the non-delayed-decision NSQ, which | ||
821 | costs about 20%. */ | ||
822 | if (complexity<2) | ||
823 | equiv = equiv*4/5; | ||
824 | equiv -= equiv*loss/(6*loss + 10); | ||
825 | } else if (mode == MODE_CELT_ONLY) { | ||
826 | /* CELT complexity 0-4 doesn't have the pitch filter, which costs | ||
827 | about 10%. */ | ||
828 | if (complexity<5) | ||
829 | equiv = equiv*9/10; | ||
830 | } else { | ||
831 | /* Mode not known yet */ | ||
832 | /* Half the SILK loss*/ | ||
833 | equiv -= equiv*loss/(12*loss + 20); | ||
834 | } | ||
835 | return equiv; | ||
836 | } | ||
837 | |||
838 | #ifndef DISABLE_FLOAT_API | ||
839 | |||
840 | static int is_digital_silence(const opus_val16* pcm, int frame_size, int channels, int lsb_depth) | ||
841 | { | ||
842 | int silence = 0; | ||
843 | opus_val32 sample_max = 0; | ||
844 | #ifdef MLP_TRAINING | ||
845 | return 0; | ||
846 | #endif | ||
847 | sample_max = celt_maxabs16(pcm, frame_size*channels); | ||
848 | |||
849 | #ifdef FIXED_POINT | ||
850 | silence = (sample_max == 0); | ||
851 | (void)lsb_depth; | ||
852 | #else | ||
853 | silence = (sample_max <= (opus_val16) 1 / (1 << lsb_depth)); | ||
854 | #endif | ||
855 | |||
856 | return silence; | ||
857 | } | ||
858 | |||
859 | #ifdef FIXED_POINT | ||
860 | static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch) | ||
861 | { | ||
862 | int i; | ||
863 | opus_val32 sample_max; | ||
864 | int max_shift; | ||
865 | int shift; | ||
866 | opus_val32 energy = 0; | ||
867 | int len = frame_size*channels; | ||
868 | (void)arch; | ||
869 | /* Max amplitude in the signal */ | ||
870 | sample_max = celt_maxabs16(pcm, len); | ||
871 | |||
872 | /* Compute the right shift required in the MAC to avoid an overflow */ | ||
873 | max_shift = celt_ilog2(len); | ||
874 | shift = IMAX(0, (celt_ilog2(sample_max) << 1) + max_shift - 28); | ||
875 | |||
876 | /* Compute the energy */ | ||
877 | for (i=0; i<len; i++) | ||
878 | energy += SHR32(MULT16_16(pcm[i], pcm[i]), shift); | ||
879 | |||
880 | /* Normalize energy by the frame size and left-shift back to the original position */ | ||
881 | energy /= len; | ||
882 | energy = SHL32(energy, shift); | ||
883 | |||
884 | return energy; | ||
885 | } | ||
886 | #else | ||
887 | static opus_val32 compute_frame_energy(const opus_val16 *pcm, int frame_size, int channels, int arch) | ||
888 | { | ||
889 | int len = frame_size*channels; | ||
890 | return celt_inner_prod(pcm, pcm, len, arch)/len; | ||
891 | } | ||
892 | #endif | ||
893 | |||
894 | /* Decides if DTX should be turned on (=1) or off (=0) */ | ||
895 | static int decide_dtx_mode(float activity_probability, /* probability that current frame contains speech/music */ | ||
896 | int *nb_no_activity_frames, /* number of consecutive frames with no activity */ | ||
897 | opus_val32 peak_signal_energy, /* peak energy of desired signal detected so far */ | ||
898 | const opus_val16 *pcm, /* input pcm signal */ | ||
899 | int frame_size, /* frame size */ | ||
900 | int channels, | ||
901 | int is_silence, /* only digital silence detected in this frame */ | ||
902 | int arch | ||
903 | ) | ||
904 | { | ||
905 | opus_val32 noise_energy; | ||
906 | |||
907 | if (!is_silence) | ||
908 | { | ||
909 | if (activity_probability < DTX_ACTIVITY_THRESHOLD) /* is noise */ | ||
910 | { | ||
911 | noise_energy = compute_frame_energy(pcm, frame_size, channels, arch); | ||
912 | |||
913 | /* but is sufficiently quiet */ | ||
914 | is_silence = peak_signal_energy >= (PSEUDO_SNR_THRESHOLD * noise_energy); | ||
915 | } | ||
916 | } | ||
917 | |||
918 | if (is_silence) | ||
919 | { | ||
920 | /* The number of consecutive DTX frames should be within the allowed bounds */ | ||
921 | (*nb_no_activity_frames)++; | ||
922 | |||
923 | if (*nb_no_activity_frames > NB_SPEECH_FRAMES_BEFORE_DTX) | ||
924 | { | ||
925 | if (*nb_no_activity_frames <= (NB_SPEECH_FRAMES_BEFORE_DTX + MAX_CONSECUTIVE_DTX)) | ||
926 | /* Valid frame for DTX! */ | ||
927 | return 1; | ||
928 | else | ||
929 | (*nb_no_activity_frames) = NB_SPEECH_FRAMES_BEFORE_DTX; | ||
930 | } | ||
931 | } else | ||
932 | (*nb_no_activity_frames) = 0; | ||
933 | |||
934 | return 0; | ||
935 | } | ||
936 | |||
937 | #endif | ||
938 | |||
939 | static opus_int32 encode_multiframe_packet(OpusEncoder *st, | ||
940 | const opus_val16 *pcm, | ||
941 | int nb_frames, | ||
942 | int frame_size, | ||
943 | unsigned char *data, | ||
944 | opus_int32 out_data_bytes, | ||
945 | int to_celt, | ||
946 | int lsb_depth, | ||
947 | int float_api) | ||
948 | { | ||
949 | int i; | ||
950 | int ret = 0; | ||
951 | VARDECL(unsigned char, tmp_data); | ||
952 | int bak_mode, bak_bandwidth, bak_channels, bak_to_mono; | ||
953 | VARDECL(OpusRepacketizer, rp); | ||
954 | int max_header_bytes; | ||
955 | opus_int32 bytes_per_frame; | ||
956 | opus_int32 cbr_bytes; | ||
957 | opus_int32 repacketize_len; | ||
958 | int tmp_len; | ||
959 | ALLOC_STACK; | ||
960 | |||
961 | /* Worst cases: | ||
962 | * 2 frames: Code 2 with different compressed sizes | ||
963 | * >2 frames: Code 3 VBR */ | ||
964 | max_header_bytes = nb_frames == 2 ? 3 : (2+(nb_frames-1)*2); | ||
965 | |||
966 | if (st->use_vbr || st->user_bitrate_bps==OPUS_BITRATE_MAX) | ||
967 | repacketize_len = out_data_bytes; | ||
968 | else { | ||
969 | cbr_bytes = 3*st->bitrate_bps/(3*8*st->Fs/(frame_size*nb_frames)); | ||
970 | repacketize_len = IMIN(cbr_bytes, out_data_bytes); | ||
971 | } | ||
972 | bytes_per_frame = IMIN(1276, 1+(repacketize_len-max_header_bytes)/nb_frames); | ||
973 | |||
974 | ALLOC(tmp_data, nb_frames*bytes_per_frame, unsigned char); | ||
975 | ALLOC(rp, 1, OpusRepacketizer); | ||
976 | opus_repacketizer_init(rp); | ||
977 | |||
978 | bak_mode = st->user_forced_mode; | ||
979 | bak_bandwidth = st->user_bandwidth; | ||
980 | bak_channels = st->force_channels; | ||
981 | |||
982 | st->user_forced_mode = st->mode; | ||
983 | st->user_bandwidth = st->bandwidth; | ||
984 | st->force_channels = st->stream_channels; | ||
985 | |||
986 | bak_to_mono = st->silk_mode.toMono; | ||
987 | if (bak_to_mono) | ||
988 | st->force_channels = 1; | ||
989 | else | ||
990 | st->prev_channels = st->stream_channels; | ||
991 | |||
992 | for (i=0;i<nb_frames;i++) | ||
993 | { | ||
994 | st->silk_mode.toMono = 0; | ||
995 | st->nonfinal_frame = i<(nb_frames-1); | ||
996 | |||
997 | /* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */ | ||
998 | if (to_celt && i==nb_frames-1) | ||
999 | st->user_forced_mode = MODE_CELT_ONLY; | ||
1000 | |||
1001 | tmp_len = opus_encode_native(st, pcm+i*(st->channels*frame_size), frame_size, | ||
1002 | tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth, NULL, 0, 0, 0, 0, | ||
1003 | NULL, float_api); | ||
1004 | |||
1005 | if (tmp_len<0) | ||
1006 | { | ||
1007 | RESTORE_STACK; | ||
1008 | return OPUS_INTERNAL_ERROR; | ||
1009 | } | ||
1010 | |||
1011 | ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len); | ||
1012 | |||
1013 | if (ret<0) | ||
1014 | { | ||
1015 | RESTORE_STACK; | ||
1016 | return OPUS_INTERNAL_ERROR; | ||
1017 | } | ||
1018 | } | ||
1019 | |||
1020 | ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr); | ||
1021 | |||
1022 | if (ret<0) | ||
1023 | { | ||
1024 | RESTORE_STACK; | ||
1025 | return OPUS_INTERNAL_ERROR; | ||
1026 | } | ||
1027 | |||
1028 | /* Discard configs that were forced locally for the purpose of repacketization */ | ||
1029 | st->user_forced_mode = bak_mode; | ||
1030 | st->user_bandwidth = bak_bandwidth; | ||
1031 | st->force_channels = bak_channels; | ||
1032 | st->silk_mode.toMono = bak_to_mono; | ||
1033 | |||
1034 | RESTORE_STACK; | ||
1035 | return ret; | ||
1036 | } | ||
1037 | |||
1038 | static int compute_redundancy_bytes(opus_int32 max_data_bytes, opus_int32 bitrate_bps, int frame_rate, int channels) | ||
1039 | { | ||
1040 | int redundancy_bytes_cap; | ||
1041 | int redundancy_bytes; | ||
1042 | opus_int32 redundancy_rate; | ||
1043 | int base_bits; | ||
1044 | opus_int32 available_bits; | ||
1045 | base_bits = (40*channels+20); | ||
1046 | |||
1047 | /* Equivalent rate for 5 ms frames. */ | ||
1048 | redundancy_rate = bitrate_bps + base_bits*(200 - frame_rate); | ||
1049 | /* For VBR, further increase the bitrate if we can afford it. It's pretty short | ||
1050 | and we'll avoid artefacts. */ | ||
1051 | redundancy_rate = 3*redundancy_rate/2; | ||
1052 | redundancy_bytes = redundancy_rate/1600; | ||
1053 | |||
1054 | /* Compute the max rate we can use given CBR or VBR with cap. */ | ||
1055 | available_bits = max_data_bytes*8 - 2*base_bits; | ||
1056 | redundancy_bytes_cap = (available_bits*240/(240+48000/frame_rate) + base_bits)/8; | ||
1057 | redundancy_bytes = IMIN(redundancy_bytes, redundancy_bytes_cap); | ||
1058 | /* It we can't get enough bits for redundancy to be worth it, rely on the decoder PLC. */ | ||
1059 | if (redundancy_bytes > 4 + 8*channels) | ||
1060 | redundancy_bytes = IMIN(257, redundancy_bytes); | ||
1061 | else | ||
1062 | redundancy_bytes = 0; | ||
1063 | return redundancy_bytes; | ||
1064 | } | ||
1065 | |||
1066 | opus_int32 opus_encode_native(OpusEncoder *st, const opus_val16 *pcm, int frame_size, | ||
1067 | unsigned char *data, opus_int32 out_data_bytes, int lsb_depth, | ||
1068 | const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2, | ||
1069 | int analysis_channels, downmix_func downmix, int float_api) | ||
1070 | { | ||
1071 | void *silk_enc; | ||
1072 | CELTEncoder *celt_enc; | ||
1073 | int i; | ||
1074 | int ret=0; | ||
1075 | opus_int32 nBytes; | ||
1076 | ec_enc enc; | ||
1077 | int bytes_target; | ||
1078 | int prefill=0; | ||
1079 | int start_band = 0; | ||
1080 | int redundancy = 0; | ||
1081 | int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */ | ||
1082 | int celt_to_silk = 0; | ||
1083 | VARDECL(opus_val16, pcm_buf); | ||
1084 | int nb_compr_bytes; | ||
1085 | int to_celt = 0; | ||
1086 | opus_uint32 redundant_rng = 0; | ||
1087 | int cutoff_Hz, hp_freq_smth1; | ||
1088 | int voice_est; /* Probability of voice in Q7 */ | ||
1089 | opus_int32 equiv_rate; | ||
1090 | int delay_compensation; | ||
1091 | int frame_rate; | ||
1092 | opus_int32 max_rate; /* Max bitrate we're allowed to use */ | ||
1093 | int curr_bandwidth; | ||
1094 | opus_val16 HB_gain; | ||
1095 | opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */ | ||
1096 | int total_buffer; | ||
1097 | opus_val16 stereo_width; | ||
1098 | const CELTMode *celt_mode; | ||
1099 | #ifndef DISABLE_FLOAT_API | ||
1100 | AnalysisInfo analysis_info; | ||
1101 | int analysis_read_pos_bak=-1; | ||
1102 | int analysis_read_subframe_bak=-1; | ||
1103 | int is_silence = 0; | ||
1104 | #endif | ||
1105 | VARDECL(opus_val16, tmp_prefill); | ||
1106 | |||
1107 | ALLOC_STACK; | ||
1108 | |||
1109 | max_data_bytes = IMIN(1276, out_data_bytes); | ||
1110 | |||
1111 | st->rangeFinal = 0; | ||
1112 | if (frame_size <= 0 || max_data_bytes <= 0) | ||
1113 | { | ||
1114 | RESTORE_STACK; | ||
1115 | return OPUS_BAD_ARG; | ||
1116 | } | ||
1117 | |||
1118 | /* Cannot encode 100 ms in 1 byte */ | ||
1119 | if (max_data_bytes==1 && st->Fs==(frame_size*10)) | ||
1120 | { | ||
1121 | RESTORE_STACK; | ||
1122 | return OPUS_BUFFER_TOO_SMALL; | ||
1123 | } | ||
1124 | |||
1125 | silk_enc = (char*)st+st->silk_enc_offset; | ||
1126 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); | ||
1127 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) | ||
1128 | delay_compensation = 0; | ||
1129 | else | ||
1130 | delay_compensation = st->delay_compensation; | ||
1131 | |||
1132 | lsb_depth = IMIN(lsb_depth, st->lsb_depth); | ||
1133 | |||
1134 | celt_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode)); | ||
1135 | #ifndef DISABLE_FLOAT_API | ||
1136 | analysis_info.valid = 0; | ||
1137 | #ifdef FIXED_POINT | ||
1138 | if (st->silk_mode.complexity >= 10 && st->Fs>=16000) | ||
1139 | #else | ||
1140 | if (st->silk_mode.complexity >= 7 && st->Fs>=16000) | ||
1141 | #endif | ||
1142 | { | ||
1143 | if (is_digital_silence(pcm, frame_size, st->channels, lsb_depth)) | ||
1144 | { | ||
1145 | is_silence = 1; | ||
1146 | } else { | ||
1147 | analysis_read_pos_bak = st->analysis.read_pos; | ||
1148 | analysis_read_subframe_bak = st->analysis.read_subframe; | ||
1149 | run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size, | ||
1150 | c1, c2, analysis_channels, st->Fs, | ||
1151 | lsb_depth, downmix, &analysis_info); | ||
1152 | } | ||
1153 | |||
1154 | /* Track the peak signal energy */ | ||
1155 | if (!is_silence && analysis_info.activity_probability > DTX_ACTIVITY_THRESHOLD) | ||
1156 | st->peak_signal_energy = MAX32(MULT16_32_Q15(QCONST16(0.999f, 15), st->peak_signal_energy), | ||
1157 | compute_frame_energy(pcm, frame_size, st->channels, st->arch)); | ||
1158 | } | ||
1159 | #else | ||
1160 | (void)analysis_pcm; | ||
1161 | (void)analysis_size; | ||
1162 | (void)c1; | ||
1163 | (void)c2; | ||
1164 | (void)analysis_channels; | ||
1165 | (void)downmix; | ||
1166 | #endif | ||
1167 | |||
1168 | #ifndef DISABLE_FLOAT_API | ||
1169 | /* Reset voice_ratio if this frame is not silent or if analysis is disabled. | ||
1170 | * Otherwise, preserve voice_ratio from the last non-silent frame */ | ||
1171 | if (!is_silence) | ||
1172 | st->voice_ratio = -1; | ||
1173 | |||
1174 | st->detected_bandwidth = 0; | ||
1175 | if (analysis_info.valid) | ||
1176 | { | ||
1177 | int analysis_bandwidth; | ||
1178 | if (st->signal_type == OPUS_AUTO) | ||
1179 | { | ||
1180 | float prob; | ||
1181 | if (st->prev_mode == 0) | ||
1182 | prob = analysis_info.music_prob; | ||
1183 | else if (st->prev_mode == MODE_CELT_ONLY) | ||
1184 | prob = analysis_info.music_prob_max; | ||
1185 | else | ||
1186 | prob = analysis_info.music_prob_min; | ||
1187 | st->voice_ratio = (int)floor(.5+100*(1-prob)); | ||
1188 | } | ||
1189 | |||
1190 | analysis_bandwidth = analysis_info.bandwidth; | ||
1191 | if (analysis_bandwidth<=12) | ||
1192 | st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND; | ||
1193 | else if (analysis_bandwidth<=14) | ||
1194 | st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; | ||
1195 | else if (analysis_bandwidth<=16) | ||
1196 | st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1197 | else if (analysis_bandwidth<=18) | ||
1198 | st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; | ||
1199 | else | ||
1200 | st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
1201 | } | ||
1202 | #else | ||
1203 | st->voice_ratio = -1; | ||
1204 | #endif | ||
1205 | |||
1206 | if (st->channels==2 && st->force_channels!=1) | ||
1207 | stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem); | ||
1208 | else | ||
1209 | stereo_width = 0; | ||
1210 | total_buffer = delay_compensation; | ||
1211 | st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes); | ||
1212 | |||
1213 | frame_rate = st->Fs/frame_size; | ||
1214 | if (!st->use_vbr) | ||
1215 | { | ||
1216 | int cbrBytes; | ||
1217 | /* Multiply by 12 to make sure the division is exact. */ | ||
1218 | int frame_rate12 = 12*st->Fs/frame_size; | ||
1219 | /* We need to make sure that "int" values always fit in 16 bits. */ | ||
1220 | cbrBytes = IMIN( (12*st->bitrate_bps/8 + frame_rate12/2)/frame_rate12, max_data_bytes); | ||
1221 | st->bitrate_bps = cbrBytes*(opus_int32)frame_rate12*8/12; | ||
1222 | /* Make sure we provide at least one byte to avoid failing. */ | ||
1223 | max_data_bytes = IMAX(1, cbrBytes); | ||
1224 | } | ||
1225 | if (max_data_bytes<3 || st->bitrate_bps < 3*frame_rate*8 | ||
1226 | || (frame_rate<50 && (max_data_bytes*frame_rate<300 || st->bitrate_bps < 2400))) | ||
1227 | { | ||
1228 | /*If the space is too low to do something useful, emit 'PLC' frames.*/ | ||
1229 | int tocmode = st->mode; | ||
1230 | int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND : st->bandwidth; | ||
1231 | int packet_code = 0; | ||
1232 | int num_multiframes = 0; | ||
1233 | |||
1234 | if (tocmode==0) | ||
1235 | tocmode = MODE_SILK_ONLY; | ||
1236 | if (frame_rate>100) | ||
1237 | tocmode = MODE_CELT_ONLY; | ||
1238 | /* 40 ms -> 2 x 20 ms if in CELT_ONLY or HYBRID mode */ | ||
1239 | if (frame_rate==25 && tocmode!=MODE_SILK_ONLY) | ||
1240 | { | ||
1241 | frame_rate = 50; | ||
1242 | packet_code = 1; | ||
1243 | } | ||
1244 | |||
1245 | /* >= 60 ms frames */ | ||
1246 | if (frame_rate<=16) | ||
1247 | { | ||
1248 | /* 1 x 60 ms, 2 x 40 ms, 2 x 60 ms */ | ||
1249 | if (out_data_bytes==1 || (tocmode==MODE_SILK_ONLY && frame_rate!=10)) | ||
1250 | { | ||
1251 | tocmode = MODE_SILK_ONLY; | ||
1252 | |||
1253 | packet_code = frame_rate <= 12; | ||
1254 | frame_rate = frame_rate == 12 ? 25 : 16; | ||
1255 | } | ||
1256 | else | ||
1257 | { | ||
1258 | num_multiframes = 50/frame_rate; | ||
1259 | frame_rate = 50; | ||
1260 | packet_code = 3; | ||
1261 | } | ||
1262 | } | ||
1263 | |||
1264 | if(tocmode==MODE_SILK_ONLY&&bw>OPUS_BANDWIDTH_WIDEBAND) | ||
1265 | bw=OPUS_BANDWIDTH_WIDEBAND; | ||
1266 | else if (tocmode==MODE_CELT_ONLY&&bw==OPUS_BANDWIDTH_MEDIUMBAND) | ||
1267 | bw=OPUS_BANDWIDTH_NARROWBAND; | ||
1268 | else if (tocmode==MODE_HYBRID&&bw<=OPUS_BANDWIDTH_SUPERWIDEBAND) | ||
1269 | bw=OPUS_BANDWIDTH_SUPERWIDEBAND; | ||
1270 | |||
1271 | data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels); | ||
1272 | data[0] |= packet_code; | ||
1273 | |||
1274 | ret = packet_code <= 1 ? 1 : 2; | ||
1275 | |||
1276 | max_data_bytes = IMAX(max_data_bytes, ret); | ||
1277 | |||
1278 | if (packet_code==3) | ||
1279 | data[1] = num_multiframes; | ||
1280 | |||
1281 | if (!st->use_vbr) | ||
1282 | { | ||
1283 | ret = opus_packet_pad(data, ret, max_data_bytes); | ||
1284 | if (ret == OPUS_OK) | ||
1285 | ret = max_data_bytes; | ||
1286 | else | ||
1287 | ret = OPUS_INTERNAL_ERROR; | ||
1288 | } | ||
1289 | RESTORE_STACK; | ||
1290 | return ret; | ||
1291 | } | ||
1292 | max_rate = frame_rate*max_data_bytes*8; | ||
1293 | |||
1294 | /* Equivalent 20-ms rate for mode/channel/bandwidth decisions */ | ||
1295 | equiv_rate = compute_equiv_rate(st->bitrate_bps, st->channels, st->Fs/frame_size, | ||
1296 | st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage); | ||
1297 | |||
1298 | if (st->signal_type == OPUS_SIGNAL_VOICE) | ||
1299 | voice_est = 127; | ||
1300 | else if (st->signal_type == OPUS_SIGNAL_MUSIC) | ||
1301 | voice_est = 0; | ||
1302 | else if (st->voice_ratio >= 0) | ||
1303 | { | ||
1304 | voice_est = st->voice_ratio*327>>8; | ||
1305 | /* For AUDIO, never be more than 90% confident of having speech */ | ||
1306 | if (st->application == OPUS_APPLICATION_AUDIO) | ||
1307 | voice_est = IMIN(voice_est, 115); | ||
1308 | } else if (st->application == OPUS_APPLICATION_VOIP) | ||
1309 | voice_est = 115; | ||
1310 | else | ||
1311 | voice_est = 48; | ||
1312 | |||
1313 | if (st->force_channels!=OPUS_AUTO && st->channels == 2) | ||
1314 | { | ||
1315 | st->stream_channels = st->force_channels; | ||
1316 | } else { | ||
1317 | #ifdef FUZZING | ||
1318 | /* Random mono/stereo decision */ | ||
1319 | if (st->channels == 2 && (rand()&0x1F)==0) | ||
1320 | st->stream_channels = 3-st->stream_channels; | ||
1321 | #else | ||
1322 | /* Rate-dependent mono-stereo decision */ | ||
1323 | if (st->channels == 2) | ||
1324 | { | ||
1325 | opus_int32 stereo_threshold; | ||
1326 | stereo_threshold = stereo_music_threshold + ((voice_est*voice_est*(stereo_voice_threshold-stereo_music_threshold))>>14); | ||
1327 | if (st->stream_channels == 2) | ||
1328 | stereo_threshold -= 1000; | ||
1329 | else | ||
1330 | stereo_threshold += 1000; | ||
1331 | st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1; | ||
1332 | } else { | ||
1333 | st->stream_channels = st->channels; | ||
1334 | } | ||
1335 | #endif | ||
1336 | } | ||
1337 | /* Update equivalent rate for channels decision. */ | ||
1338 | equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size, | ||
1339 | st->use_vbr, 0, st->silk_mode.complexity, st->silk_mode.packetLossPercentage); | ||
1340 | |||
1341 | /* Mode selection depending on application and signal type */ | ||
1342 | if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY) | ||
1343 | { | ||
1344 | st->mode = MODE_CELT_ONLY; | ||
1345 | } else if (st->user_forced_mode == OPUS_AUTO) | ||
1346 | { | ||
1347 | #ifdef FUZZING | ||
1348 | /* Random mode switching */ | ||
1349 | if ((rand()&0xF)==0) | ||
1350 | { | ||
1351 | if ((rand()&0x1)==0) | ||
1352 | st->mode = MODE_CELT_ONLY; | ||
1353 | else | ||
1354 | st->mode = MODE_SILK_ONLY; | ||
1355 | } else { | ||
1356 | if (st->prev_mode==MODE_CELT_ONLY) | ||
1357 | st->mode = MODE_CELT_ONLY; | ||
1358 | else | ||
1359 | st->mode = MODE_SILK_ONLY; | ||
1360 | } | ||
1361 | #else | ||
1362 | opus_int32 mode_voice, mode_music; | ||
1363 | opus_int32 threshold; | ||
1364 | |||
1365 | /* Interpolate based on stereo width */ | ||
1366 | mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0]) | ||
1367 | + MULT16_32_Q15(stereo_width,mode_thresholds[1][0])); | ||
1368 | mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1]) | ||
1369 | + MULT16_32_Q15(stereo_width,mode_thresholds[1][1])); | ||
1370 | /* Interpolate based on speech/music probability */ | ||
1371 | threshold = mode_music + ((voice_est*voice_est*(mode_voice-mode_music))>>14); | ||
1372 | /* Bias towards SILK for VoIP because of some useful features */ | ||
1373 | if (st->application == OPUS_APPLICATION_VOIP) | ||
1374 | threshold += 8000; | ||
1375 | |||
1376 | /*printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);*/ | ||
1377 | /* Hysteresis */ | ||
1378 | if (st->prev_mode == MODE_CELT_ONLY) | ||
1379 | threshold -= 4000; | ||
1380 | else if (st->prev_mode>0) | ||
1381 | threshold += 4000; | ||
1382 | |||
1383 | st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY: MODE_SILK_ONLY; | ||
1384 | |||
1385 | /* When FEC is enabled and there's enough packet loss, use SILK */ | ||
1386 | if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4) | ||
1387 | st->mode = MODE_SILK_ONLY; | ||
1388 | /* When encoding voice and DTX is enabled but the generalized DTX cannot be used, | ||
1389 | because of complexity and sampling frequency settings, switch to SILK DTX and | ||
1390 | set the encoder to SILK mode */ | ||
1391 | #ifndef DISABLE_FLOAT_API | ||
1392 | st->silk_mode.useDTX = st->use_dtx && !(analysis_info.valid || is_silence); | ||
1393 | #else | ||
1394 | st->silk_mode.useDTX = st->use_dtx; | ||
1395 | #endif | ||
1396 | if (st->silk_mode.useDTX && voice_est > 100) | ||
1397 | st->mode = MODE_SILK_ONLY; | ||
1398 | #endif | ||
1399 | |||
1400 | /* If max_data_bytes represents less than 6 kb/s, switch to CELT-only mode */ | ||
1401 | if (max_data_bytes < (frame_rate > 50 ? 9000 : 6000)*frame_size / (st->Fs * 8)) | ||
1402 | st->mode = MODE_CELT_ONLY; | ||
1403 | } else { | ||
1404 | st->mode = st->user_forced_mode; | ||
1405 | } | ||
1406 | |||
1407 | /* Override the chosen mode to make sure we meet the requested frame size */ | ||
1408 | if (st->mode != MODE_CELT_ONLY && frame_size < st->Fs/100) | ||
1409 | st->mode = MODE_CELT_ONLY; | ||
1410 | if (st->lfe) | ||
1411 | st->mode = MODE_CELT_ONLY; | ||
1412 | |||
1413 | if (st->prev_mode > 0 && | ||
1414 | ((st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) || | ||
1415 | (st->mode == MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY))) | ||
1416 | { | ||
1417 | redundancy = 1; | ||
1418 | celt_to_silk = (st->mode != MODE_CELT_ONLY); | ||
1419 | if (!celt_to_silk) | ||
1420 | { | ||
1421 | /* Switch to SILK/hybrid if frame size is 10 ms or more*/ | ||
1422 | if (frame_size >= st->Fs/100) | ||
1423 | { | ||
1424 | st->mode = st->prev_mode; | ||
1425 | to_celt = 1; | ||
1426 | } else { | ||
1427 | redundancy=0; | ||
1428 | } | ||
1429 | } | ||
1430 | } | ||
1431 | |||
1432 | /* When encoding multiframes, we can ask for a switch to CELT only in the last frame. This switch | ||
1433 | * is processed above as the requested mode shouldn't interrupt stereo->mono transition. */ | ||
1434 | if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0 | ||
1435 | && st->mode != MODE_CELT_ONLY && st->prev_mode != MODE_CELT_ONLY) | ||
1436 | { | ||
1437 | /* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */ | ||
1438 | st->silk_mode.toMono = 1; | ||
1439 | st->stream_channels = 2; | ||
1440 | } else { | ||
1441 | st->silk_mode.toMono = 0; | ||
1442 | } | ||
1443 | |||
1444 | /* Update equivalent rate with mode decision. */ | ||
1445 | equiv_rate = compute_equiv_rate(st->bitrate_bps, st->stream_channels, st->Fs/frame_size, | ||
1446 | st->use_vbr, st->mode, st->silk_mode.complexity, st->silk_mode.packetLossPercentage); | ||
1447 | |||
1448 | if (st->mode != MODE_CELT_ONLY && st->prev_mode == MODE_CELT_ONLY) | ||
1449 | { | ||
1450 | silk_EncControlStruct dummy; | ||
1451 | silk_InitEncoder( silk_enc, st->arch, &dummy); | ||
1452 | prefill=1; | ||
1453 | } | ||
1454 | |||
1455 | /* Automatic (rate-dependent) bandwidth selection */ | ||
1456 | if (st->mode == MODE_CELT_ONLY || st->first || st->silk_mode.allowBandwidthSwitch) | ||
1457 | { | ||
1458 | const opus_int32 *voice_bandwidth_thresholds, *music_bandwidth_thresholds; | ||
1459 | opus_int32 bandwidth_thresholds[8]; | ||
1460 | int bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
1461 | |||
1462 | if (st->channels==2 && st->force_channels!=1) | ||
1463 | { | ||
1464 | voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds; | ||
1465 | music_bandwidth_thresholds = stereo_music_bandwidth_thresholds; | ||
1466 | } else { | ||
1467 | voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds; | ||
1468 | music_bandwidth_thresholds = mono_music_bandwidth_thresholds; | ||
1469 | } | ||
1470 | /* Interpolate bandwidth thresholds depending on voice estimation */ | ||
1471 | for (i=0;i<8;i++) | ||
1472 | { | ||
1473 | bandwidth_thresholds[i] = music_bandwidth_thresholds[i] | ||
1474 | + ((voice_est*voice_est*(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14); | ||
1475 | } | ||
1476 | do { | ||
1477 | int threshold, hysteresis; | ||
1478 | threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)]; | ||
1479 | hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND)+1]; | ||
1480 | if (!st->first) | ||
1481 | { | ||
1482 | if (st->auto_bandwidth >= bandwidth) | ||
1483 | threshold -= hysteresis; | ||
1484 | else | ||
1485 | threshold += hysteresis; | ||
1486 | } | ||
1487 | if (equiv_rate >= threshold) | ||
1488 | break; | ||
1489 | } while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND); | ||
1490 | /* We don't use mediumband anymore, except when explicitly requested or during | ||
1491 | mode transitions. */ | ||
1492 | if (bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) | ||
1493 | bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1494 | st->bandwidth = st->auto_bandwidth = bandwidth; | ||
1495 | /* Prevents any transition to SWB/FB until the SILK layer has fully | ||
1496 | switched to WB mode and turned the variable LP filter off */ | ||
1497 | if (!st->first && st->mode != MODE_CELT_ONLY && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) | ||
1498 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1499 | } | ||
1500 | |||
1501 | if (st->bandwidth>st->max_bandwidth) | ||
1502 | st->bandwidth = st->max_bandwidth; | ||
1503 | |||
1504 | if (st->user_bandwidth != OPUS_AUTO) | ||
1505 | st->bandwidth = st->user_bandwidth; | ||
1506 | |||
1507 | /* This prevents us from using hybrid at unsafe CBR/max rates */ | ||
1508 | if (st->mode != MODE_CELT_ONLY && max_rate < 15000) | ||
1509 | { | ||
1510 | st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND); | ||
1511 | } | ||
1512 | |||
1513 | /* Prevents Opus from wasting bits on frequencies that are above | ||
1514 | the Nyquist rate of the input signal */ | ||
1515 | if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND) | ||
1516 | st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; | ||
1517 | if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND) | ||
1518 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1519 | if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND) | ||
1520 | st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; | ||
1521 | if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND) | ||
1522 | st->bandwidth = OPUS_BANDWIDTH_NARROWBAND; | ||
1523 | #ifndef DISABLE_FLOAT_API | ||
1524 | /* Use detected bandwidth to reduce the encoded bandwidth. */ | ||
1525 | if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO) | ||
1526 | { | ||
1527 | int min_detected_bandwidth; | ||
1528 | /* Makes bandwidth detection more conservative just in case the detector | ||
1529 | gets it wrong when we could have coded a high bandwidth transparently. | ||
1530 | When operating in SILK/hybrid mode, we don't go below wideband to avoid | ||
1531 | more complicated switches that require redundancy. */ | ||
1532 | if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY) | ||
1533 | min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND; | ||
1534 | else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY) | ||
1535 | min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; | ||
1536 | else if (equiv_rate <= 30000*st->stream_channels) | ||
1537 | min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1538 | else if (equiv_rate <= 44000*st->stream_channels) | ||
1539 | min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND; | ||
1540 | else | ||
1541 | min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
1542 | |||
1543 | st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth); | ||
1544 | st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth); | ||
1545 | } | ||
1546 | #endif | ||
1547 | st->silk_mode.LBRR_coded = decide_fec(st->silk_mode.useInBandFEC, st->silk_mode.packetLossPercentage, | ||
1548 | st->silk_mode.LBRR_coded, st->mode, &st->bandwidth, equiv_rate); | ||
1549 | celt_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth)); | ||
1550 | |||
1551 | /* CELT mode doesn't support mediumband, use wideband instead */ | ||
1552 | if (st->mode == MODE_CELT_ONLY && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) | ||
1553 | st->bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1554 | if (st->lfe) | ||
1555 | st->bandwidth = OPUS_BANDWIDTH_NARROWBAND; | ||
1556 | |||
1557 | curr_bandwidth = st->bandwidth; | ||
1558 | |||
1559 | /* Chooses the appropriate mode for speech | ||
1560 | *NEVER* switch to/from CELT-only mode here as this will invalidate some assumptions */ | ||
1561 | if (st->mode == MODE_SILK_ONLY && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND) | ||
1562 | st->mode = MODE_HYBRID; | ||
1563 | if (st->mode == MODE_HYBRID && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND) | ||
1564 | st->mode = MODE_SILK_ONLY; | ||
1565 | |||
1566 | /* Can't support higher than >60 ms frames, and >20 ms when in Hybrid or CELT-only modes */ | ||
1567 | if ((frame_size > st->Fs/50 && (st->mode != MODE_SILK_ONLY)) || frame_size > 3*st->Fs/50) | ||
1568 | { | ||
1569 | int enc_frame_size; | ||
1570 | int nb_frames; | ||
1571 | |||
1572 | if (st->mode == MODE_SILK_ONLY) | ||
1573 | { | ||
1574 | if (frame_size == 2*st->Fs/25) /* 80 ms -> 2x 40 ms */ | ||
1575 | enc_frame_size = st->Fs/25; | ||
1576 | else if (frame_size == 3*st->Fs/25) /* 120 ms -> 2x 60 ms */ | ||
1577 | enc_frame_size = 3*st->Fs/50; | ||
1578 | else /* 100 ms -> 5x 20 ms */ | ||
1579 | enc_frame_size = st->Fs/50; | ||
1580 | } | ||
1581 | else | ||
1582 | enc_frame_size = st->Fs/50; | ||
1583 | |||
1584 | nb_frames = frame_size/enc_frame_size; | ||
1585 | |||
1586 | #ifndef DISABLE_FLOAT_API | ||
1587 | if (analysis_read_pos_bak!= -1) | ||
1588 | { | ||
1589 | st->analysis.read_pos = analysis_read_pos_bak; | ||
1590 | st->analysis.read_subframe = analysis_read_subframe_bak; | ||
1591 | } | ||
1592 | #endif | ||
1593 | |||
1594 | ret = encode_multiframe_packet(st, pcm, nb_frames, enc_frame_size, data, | ||
1595 | out_data_bytes, to_celt, lsb_depth, float_api); | ||
1596 | |||
1597 | RESTORE_STACK; | ||
1598 | return ret; | ||
1599 | } | ||
1600 | |||
1601 | /* For the first frame at a new SILK bandwidth */ | ||
1602 | if (st->silk_bw_switch) | ||
1603 | { | ||
1604 | redundancy = 1; | ||
1605 | celt_to_silk = 1; | ||
1606 | st->silk_bw_switch = 0; | ||
1607 | /* Do a prefill without reseting the sampling rate control. */ | ||
1608 | prefill=2; | ||
1609 | } | ||
1610 | |||
1611 | /* If we decided to go with CELT, make sure redundancy is off, no matter what | ||
1612 | we decided earlier. */ | ||
1613 | if (st->mode == MODE_CELT_ONLY) | ||
1614 | redundancy = 0; | ||
1615 | |||
1616 | if (redundancy) | ||
1617 | { | ||
1618 | redundancy_bytes = compute_redundancy_bytes(max_data_bytes, st->bitrate_bps, frame_rate, st->stream_channels); | ||
1619 | if (redundancy_bytes == 0) | ||
1620 | redundancy = 0; | ||
1621 | } | ||
1622 | |||
1623 | /* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */ | ||
1624 | bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8)) - 1; | ||
1625 | |||
1626 | data += 1; | ||
1627 | |||
1628 | ec_enc_init(&enc, data, max_data_bytes-1); | ||
1629 | |||
1630 | ALLOC(pcm_buf, (total_buffer+frame_size)*st->channels, opus_val16); | ||
1631 | OPUS_COPY(pcm_buf, &st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels], total_buffer*st->channels); | ||
1632 | |||
1633 | if (st->mode == MODE_CELT_ONLY) | ||
1634 | hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); | ||
1635 | else | ||
1636 | hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15; | ||
1637 | |||
1638 | st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15, | ||
1639 | hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) ); | ||
1640 | |||
1641 | /* convert from log scale to Hertz */ | ||
1642 | cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 ) ); | ||
1643 | |||
1644 | if (st->application == OPUS_APPLICATION_VOIP) | ||
1645 | { | ||
1646 | hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs, st->arch); | ||
1647 | } else { | ||
1648 | dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs); | ||
1649 | } | ||
1650 | #ifndef FIXED_POINT | ||
1651 | if (float_api) | ||
1652 | { | ||
1653 | opus_val32 sum; | ||
1654 | sum = celt_inner_prod(&pcm_buf[total_buffer*st->channels], &pcm_buf[total_buffer*st->channels], frame_size*st->channels, st->arch); | ||
1655 | /* This should filter out both NaNs and ridiculous signals that could | ||
1656 | cause NaNs further down. */ | ||
1657 | if (!(sum < 1e9f) || celt_isnan(sum)) | ||
1658 | { | ||
1659 | OPUS_CLEAR(&pcm_buf[total_buffer*st->channels], frame_size*st->channels); | ||
1660 | st->hp_mem[0] = st->hp_mem[1] = st->hp_mem[2] = st->hp_mem[3] = 0; | ||
1661 | } | ||
1662 | } | ||
1663 | #endif | ||
1664 | |||
1665 | |||
1666 | /* SILK processing */ | ||
1667 | HB_gain = Q15ONE; | ||
1668 | if (st->mode != MODE_CELT_ONLY) | ||
1669 | { | ||
1670 | opus_int32 total_bitRate, celt_rate; | ||
1671 | opus_int activity; | ||
1672 | #ifdef FIXED_POINT | ||
1673 | const opus_int16 *pcm_silk; | ||
1674 | #else | ||
1675 | VARDECL(opus_int16, pcm_silk); | ||
1676 | ALLOC(pcm_silk, st->channels*frame_size, opus_int16); | ||
1677 | #endif | ||
1678 | |||
1679 | activity = VAD_NO_DECISION; | ||
1680 | #ifndef DISABLE_FLOAT_API | ||
1681 | if( analysis_info.valid ) { | ||
1682 | /* Inform SILK about the Opus VAD decision */ | ||
1683 | activity = ( analysis_info.activity_probability >= DTX_ACTIVITY_THRESHOLD ); | ||
1684 | } | ||
1685 | #endif | ||
1686 | |||
1687 | /* Distribute bits between SILK and CELT */ | ||
1688 | total_bitRate = 8 * bytes_target * frame_rate; | ||
1689 | if( st->mode == MODE_HYBRID ) { | ||
1690 | /* Base rate for SILK */ | ||
1691 | st->silk_mode.bitRate = compute_silk_rate_for_hybrid(total_bitRate, | ||
1692 | curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded, | ||
1693 | st->stream_channels); | ||
1694 | if (!st->energy_masking) | ||
1695 | { | ||
1696 | /* Increasingly attenuate high band when it gets allocated fewer bits */ | ||
1697 | celt_rate = total_bitRate - st->silk_mode.bitRate; | ||
1698 | HB_gain = Q15ONE - SHR32(celt_exp2(-celt_rate * QCONST16(1.f/1024, 10)), 1); | ||
1699 | } | ||
1700 | } else { | ||
1701 | /* SILK gets all bits */ | ||
1702 | st->silk_mode.bitRate = total_bitRate; | ||
1703 | } | ||
1704 | |||
1705 | /* Surround masking for SILK */ | ||
1706 | if (st->energy_masking && st->use_vbr && !st->lfe) | ||
1707 | { | ||
1708 | opus_val32 mask_sum=0; | ||
1709 | opus_val16 masking_depth; | ||
1710 | opus_int32 rate_offset; | ||
1711 | int c; | ||
1712 | int end = 17; | ||
1713 | opus_int16 srate = 16000; | ||
1714 | if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND) | ||
1715 | { | ||
1716 | end = 13; | ||
1717 | srate = 8000; | ||
1718 | } else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) | ||
1719 | { | ||
1720 | end = 15; | ||
1721 | srate = 12000; | ||
1722 | } | ||
1723 | for (c=0;c<st->channels;c++) | ||
1724 | { | ||
1725 | for(i=0;i<end;i++) | ||
1726 | { | ||
1727 | opus_val16 mask; | ||
1728 | mask = MAX16(MIN16(st->energy_masking[21*c+i], | ||
1729 | QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT)); | ||
1730 | if (mask > 0) | ||
1731 | mask = HALF16(mask); | ||
1732 | mask_sum += mask; | ||
1733 | } | ||
1734 | } | ||
1735 | /* Conservative rate reduction, we cut the masking in half */ | ||
1736 | masking_depth = mask_sum / end*st->channels; | ||
1737 | masking_depth += QCONST16(.2f, DB_SHIFT); | ||
1738 | rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT); | ||
1739 | rate_offset = MAX32(rate_offset, -2*st->silk_mode.bitRate/3); | ||
1740 | /* Split the rate change between the SILK and CELT part for hybrid. */ | ||
1741 | if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND || st->bandwidth==OPUS_BANDWIDTH_FULLBAND) | ||
1742 | st->silk_mode.bitRate += 3*rate_offset/5; | ||
1743 | else | ||
1744 | st->silk_mode.bitRate += rate_offset; | ||
1745 | } | ||
1746 | |||
1747 | st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs; | ||
1748 | st->silk_mode.nChannelsAPI = st->channels; | ||
1749 | st->silk_mode.nChannelsInternal = st->stream_channels; | ||
1750 | if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { | ||
1751 | st->silk_mode.desiredInternalSampleRate = 8000; | ||
1752 | } else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { | ||
1753 | st->silk_mode.desiredInternalSampleRate = 12000; | ||
1754 | } else { | ||
1755 | celt_assert( st->mode == MODE_HYBRID || curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND ); | ||
1756 | st->silk_mode.desiredInternalSampleRate = 16000; | ||
1757 | } | ||
1758 | if( st->mode == MODE_HYBRID ) { | ||
1759 | /* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */ | ||
1760 | st->silk_mode.minInternalSampleRate = 16000; | ||
1761 | } else { | ||
1762 | st->silk_mode.minInternalSampleRate = 8000; | ||
1763 | } | ||
1764 | |||
1765 | st->silk_mode.maxInternalSampleRate = 16000; | ||
1766 | if (st->mode == MODE_SILK_ONLY) | ||
1767 | { | ||
1768 | opus_int32 effective_max_rate = max_rate; | ||
1769 | if (frame_rate > 50) | ||
1770 | effective_max_rate = effective_max_rate*2/3; | ||
1771 | if (effective_max_rate < 8000) | ||
1772 | { | ||
1773 | st->silk_mode.maxInternalSampleRate = 12000; | ||
1774 | st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate); | ||
1775 | } | ||
1776 | if (effective_max_rate < 7000) | ||
1777 | { | ||
1778 | st->silk_mode.maxInternalSampleRate = 8000; | ||
1779 | st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate); | ||
1780 | } | ||
1781 | } | ||
1782 | |||
1783 | st->silk_mode.useCBR = !st->use_vbr; | ||
1784 | |||
1785 | /* Call SILK encoder for the low band */ | ||
1786 | |||
1787 | /* Max bits for SILK, counting ToC, redundancy bytes, and optionally redundancy. */ | ||
1788 | st->silk_mode.maxBits = (max_data_bytes-1)*8; | ||
1789 | if (redundancy && redundancy_bytes >= 2) | ||
1790 | { | ||
1791 | /* Counting 1 bit for redundancy position and 20 bits for flag+size (only for hybrid). */ | ||
1792 | st->silk_mode.maxBits -= redundancy_bytes*8 + 1; | ||
1793 | if (st->mode == MODE_HYBRID) | ||
1794 | st->silk_mode.maxBits -= 20; | ||
1795 | } | ||
1796 | if (st->silk_mode.useCBR) | ||
1797 | { | ||
1798 | if (st->mode == MODE_HYBRID) | ||
1799 | { | ||
1800 | st->silk_mode.maxBits = IMIN(st->silk_mode.maxBits, st->silk_mode.bitRate * frame_size / st->Fs); | ||
1801 | } | ||
1802 | } else { | ||
1803 | /* Constrained VBR. */ | ||
1804 | if (st->mode == MODE_HYBRID) | ||
1805 | { | ||
1806 | /* Compute SILK bitrate corresponding to the max total bits available */ | ||
1807 | opus_int32 maxBitRate = compute_silk_rate_for_hybrid(st->silk_mode.maxBits*st->Fs / frame_size, | ||
1808 | curr_bandwidth, st->Fs == 50 * frame_size, st->use_vbr, st->silk_mode.LBRR_coded, | ||
1809 | st->stream_channels); | ||
1810 | st->silk_mode.maxBits = maxBitRate * frame_size / st->Fs; | ||
1811 | } | ||
1812 | } | ||
1813 | |||
1814 | if (prefill) | ||
1815 | { | ||
1816 | opus_int32 zero=0; | ||
1817 | int prefill_offset; | ||
1818 | /* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode | ||
1819 | a discontinuity. The exact location is what we need to avoid leaving any "gap" | ||
1820 | in the audio when mixing with the redundant CELT frame. Here we can afford to | ||
1821 | overwrite st->delay_buffer because the only thing that uses it before it gets | ||
1822 | rewritten is tmp_prefill[] and even then only the part after the ramp really | ||
1823 | gets used (rather than sent to the encoder and discarded) */ | ||
1824 | prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400); | ||
1825 | gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset, | ||
1826 | 0, Q15ONE, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs); | ||
1827 | OPUS_CLEAR(st->delay_buffer, prefill_offset); | ||
1828 | #ifdef FIXED_POINT | ||
1829 | pcm_silk = st->delay_buffer; | ||
1830 | #else | ||
1831 | for (i=0;i<st->encoder_buffer*st->channels;i++) | ||
1832 | pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]); | ||
1833 | #endif | ||
1834 | silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL, &zero, prefill, activity ); | ||
1835 | /* Prevent a second switch in the real encode call. */ | ||
1836 | st->silk_mode.opusCanSwitch = 0; | ||
1837 | } | ||
1838 | |||
1839 | #ifdef FIXED_POINT | ||
1840 | pcm_silk = pcm_buf+total_buffer*st->channels; | ||
1841 | #else | ||
1842 | for (i=0;i<frame_size*st->channels;i++) | ||
1843 | pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]); | ||
1844 | #endif | ||
1845 | ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0, activity ); | ||
1846 | if( ret ) { | ||
1847 | /*fprintf (stderr, "SILK encode error: %d\n", ret);*/ | ||
1848 | /* Handle error */ | ||
1849 | RESTORE_STACK; | ||
1850 | return OPUS_INTERNAL_ERROR; | ||
1851 | } | ||
1852 | |||
1853 | /* Extract SILK internal bandwidth for signaling in first byte */ | ||
1854 | if( st->mode == MODE_SILK_ONLY ) { | ||
1855 | if( st->silk_mode.internalSampleRate == 8000 ) { | ||
1856 | curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND; | ||
1857 | } else if( st->silk_mode.internalSampleRate == 12000 ) { | ||
1858 | curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND; | ||
1859 | } else if( st->silk_mode.internalSampleRate == 16000 ) { | ||
1860 | curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND; | ||
1861 | } | ||
1862 | } else { | ||
1863 | celt_assert( st->silk_mode.internalSampleRate == 16000 ); | ||
1864 | } | ||
1865 | |||
1866 | st->silk_mode.opusCanSwitch = st->silk_mode.switchReady && !st->nonfinal_frame; | ||
1867 | |||
1868 | if (nBytes==0) | ||
1869 | { | ||
1870 | st->rangeFinal = 0; | ||
1871 | data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); | ||
1872 | RESTORE_STACK; | ||
1873 | return 1; | ||
1874 | } | ||
1875 | |||
1876 | /* FIXME: How do we allocate the redundancy for CBR? */ | ||
1877 | if (st->silk_mode.opusCanSwitch) | ||
1878 | { | ||
1879 | redundancy_bytes = compute_redundancy_bytes(max_data_bytes, st->bitrate_bps, frame_rate, st->stream_channels); | ||
1880 | redundancy = (redundancy_bytes != 0); | ||
1881 | celt_to_silk = 0; | ||
1882 | st->silk_bw_switch = 1; | ||
1883 | } | ||
1884 | } | ||
1885 | |||
1886 | /* CELT processing */ | ||
1887 | { | ||
1888 | int endband=21; | ||
1889 | |||
1890 | switch(curr_bandwidth) | ||
1891 | { | ||
1892 | case OPUS_BANDWIDTH_NARROWBAND: | ||
1893 | endband = 13; | ||
1894 | break; | ||
1895 | case OPUS_BANDWIDTH_MEDIUMBAND: | ||
1896 | case OPUS_BANDWIDTH_WIDEBAND: | ||
1897 | endband = 17; | ||
1898 | break; | ||
1899 | case OPUS_BANDWIDTH_SUPERWIDEBAND: | ||
1900 | endband = 19; | ||
1901 | break; | ||
1902 | case OPUS_BANDWIDTH_FULLBAND: | ||
1903 | endband = 21; | ||
1904 | break; | ||
1905 | } | ||
1906 | celt_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband)); | ||
1907 | celt_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels)); | ||
1908 | } | ||
1909 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)); | ||
1910 | if (st->mode != MODE_SILK_ONLY) | ||
1911 | { | ||
1912 | opus_val32 celt_pred=2; | ||
1913 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); | ||
1914 | /* We may still decide to disable prediction later */ | ||
1915 | if (st->silk_mode.reducedDependency) | ||
1916 | celt_pred = 0; | ||
1917 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred)); | ||
1918 | |||
1919 | if (st->mode == MODE_HYBRID) | ||
1920 | { | ||
1921 | if( st->use_vbr ) { | ||
1922 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate)); | ||
1923 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(0)); | ||
1924 | } | ||
1925 | } else { | ||
1926 | if (st->use_vbr) | ||
1927 | { | ||
1928 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(1)); | ||
1929 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint)); | ||
1930 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps)); | ||
1931 | } | ||
1932 | } | ||
1933 | } | ||
1934 | |||
1935 | ALLOC(tmp_prefill, st->channels*st->Fs/400, opus_val16); | ||
1936 | if (st->mode != MODE_SILK_ONLY && st->mode != st->prev_mode && st->prev_mode > 0) | ||
1937 | { | ||
1938 | OPUS_COPY(tmp_prefill, &st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels], st->channels*st->Fs/400); | ||
1939 | } | ||
1940 | |||
1941 | if (st->channels*(st->encoder_buffer-(frame_size+total_buffer)) > 0) | ||
1942 | { | ||
1943 | OPUS_MOVE(st->delay_buffer, &st->delay_buffer[st->channels*frame_size], st->channels*(st->encoder_buffer-frame_size-total_buffer)); | ||
1944 | OPUS_COPY(&st->delay_buffer[st->channels*(st->encoder_buffer-frame_size-total_buffer)], | ||
1945 | &pcm_buf[0], | ||
1946 | (frame_size+total_buffer)*st->channels); | ||
1947 | } else { | ||
1948 | OPUS_COPY(st->delay_buffer, &pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels], st->encoder_buffer*st->channels); | ||
1949 | } | ||
1950 | /* gain_fade() and stereo_fade() need to be after the buffer copying | ||
1951 | because we don't want any of this to affect the SILK part */ | ||
1952 | if( st->prev_HB_gain < Q15ONE || HB_gain < Q15ONE ) { | ||
1953 | gain_fade(pcm_buf, pcm_buf, | ||
1954 | st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs); | ||
1955 | } | ||
1956 | st->prev_HB_gain = HB_gain; | ||
1957 | if (st->mode != MODE_HYBRID || st->stream_channels==1) | ||
1958 | { | ||
1959 | if (equiv_rate > 32000) | ||
1960 | st->silk_mode.stereoWidth_Q14 = 16384; | ||
1961 | else if (equiv_rate < 16000) | ||
1962 | st->silk_mode.stereoWidth_Q14 = 0; | ||
1963 | else | ||
1964 | st->silk_mode.stereoWidth_Q14 = 16384 - 2048*(opus_int32)(32000-equiv_rate)/(equiv_rate-14000); | ||
1965 | } | ||
1966 | if( !st->energy_masking && st->channels == 2 ) { | ||
1967 | /* Apply stereo width reduction (at low bitrates) */ | ||
1968 | if( st->hybrid_stereo_width_Q14 < (1 << 14) || st->silk_mode.stereoWidth_Q14 < (1 << 14) ) { | ||
1969 | opus_val16 g1, g2; | ||
1970 | g1 = st->hybrid_stereo_width_Q14; | ||
1971 | g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14); | ||
1972 | #ifdef FIXED_POINT | ||
1973 | g1 = g1==16384 ? Q15ONE : SHL16(g1,1); | ||
1974 | g2 = g2==16384 ? Q15ONE : SHL16(g2,1); | ||
1975 | #else | ||
1976 | g1 *= (1.f/16384); | ||
1977 | g2 *= (1.f/16384); | ||
1978 | #endif | ||
1979 | stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap, | ||
1980 | frame_size, st->channels, celt_mode->window, st->Fs); | ||
1981 | st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14; | ||
1982 | } | ||
1983 | } | ||
1984 | |||
1985 | if ( st->mode != MODE_CELT_ONLY && ec_tell(&enc)+17+20*(st->mode == MODE_HYBRID) <= 8*(max_data_bytes-1)) | ||
1986 | { | ||
1987 | /* For SILK mode, the redundancy is inferred from the length */ | ||
1988 | if (st->mode == MODE_HYBRID) | ||
1989 | ec_enc_bit_logp(&enc, redundancy, 12); | ||
1990 | if (redundancy) | ||
1991 | { | ||
1992 | int max_redundancy; | ||
1993 | ec_enc_bit_logp(&enc, celt_to_silk, 1); | ||
1994 | if (st->mode == MODE_HYBRID) | ||
1995 | { | ||
1996 | /* Reserve the 8 bits needed for the redundancy length, | ||
1997 | and at least a few bits for CELT if possible */ | ||
1998 | max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+8+3+7)>>3); | ||
1999 | } | ||
2000 | else | ||
2001 | max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3); | ||
2002 | /* Target the same bit-rate for redundancy as for the rest, | ||
2003 | up to a max of 257 bytes */ | ||
2004 | redundancy_bytes = IMIN(max_redundancy, redundancy_bytes); | ||
2005 | redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes)); | ||
2006 | if (st->mode == MODE_HYBRID) | ||
2007 | ec_enc_uint(&enc, redundancy_bytes-2, 256); | ||
2008 | } | ||
2009 | } else { | ||
2010 | redundancy = 0; | ||
2011 | } | ||
2012 | |||
2013 | if (!redundancy) | ||
2014 | { | ||
2015 | st->silk_bw_switch = 0; | ||
2016 | redundancy_bytes = 0; | ||
2017 | } | ||
2018 | if (st->mode != MODE_CELT_ONLY)start_band=17; | ||
2019 | |||
2020 | if (st->mode == MODE_SILK_ONLY) | ||
2021 | { | ||
2022 | ret = (ec_tell(&enc)+7)>>3; | ||
2023 | ec_enc_done(&enc); | ||
2024 | nb_compr_bytes = ret; | ||
2025 | } else { | ||
2026 | nb_compr_bytes = (max_data_bytes-1)-redundancy_bytes; | ||
2027 | ec_enc_shrink(&enc, nb_compr_bytes); | ||
2028 | } | ||
2029 | |||
2030 | #ifndef DISABLE_FLOAT_API | ||
2031 | if (redundancy || st->mode != MODE_SILK_ONLY) | ||
2032 | celt_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info)); | ||
2033 | #endif | ||
2034 | if (st->mode == MODE_HYBRID) { | ||
2035 | SILKInfo info; | ||
2036 | info.signalType = st->silk_mode.signalType; | ||
2037 | info.offset = st->silk_mode.offset; | ||
2038 | celt_encoder_ctl(celt_enc, CELT_SET_SILK_INFO(&info)); | ||
2039 | } | ||
2040 | |||
2041 | /* 5 ms redundant frame for CELT->SILK */ | ||
2042 | if (redundancy && celt_to_silk) | ||
2043 | { | ||
2044 | int err; | ||
2045 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); | ||
2046 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); | ||
2047 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)); | ||
2048 | err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL); | ||
2049 | if (err < 0) | ||
2050 | { | ||
2051 | RESTORE_STACK; | ||
2052 | return OPUS_INTERNAL_ERROR; | ||
2053 | } | ||
2054 | celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); | ||
2055 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); | ||
2056 | } | ||
2057 | |||
2058 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band)); | ||
2059 | |||
2060 | if (st->mode != MODE_SILK_ONLY) | ||
2061 | { | ||
2062 | if (st->mode != st->prev_mode && st->prev_mode > 0) | ||
2063 | { | ||
2064 | unsigned char dummy[2]; | ||
2065 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); | ||
2066 | |||
2067 | /* Prefilling */ | ||
2068 | celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL); | ||
2069 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); | ||
2070 | } | ||
2071 | /* If false, we already busted the budget and we'll end up with a "PLC frame" */ | ||
2072 | if (ec_tell(&enc) <= 8*nb_compr_bytes) | ||
2073 | { | ||
2074 | /* Set the bitrate again if it was overridden in the redundancy code above*/ | ||
2075 | if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr) | ||
2076 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps-st->silk_mode.bitRate)); | ||
2077 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(st->use_vbr)); | ||
2078 | ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL, nb_compr_bytes, &enc); | ||
2079 | if (ret < 0) | ||
2080 | { | ||
2081 | RESTORE_STACK; | ||
2082 | return OPUS_INTERNAL_ERROR; | ||
2083 | } | ||
2084 | /* Put CELT->SILK redundancy data in the right place. */ | ||
2085 | if (redundancy && celt_to_silk && st->mode==MODE_HYBRID && st->use_vbr) | ||
2086 | { | ||
2087 | OPUS_MOVE(data+ret, data+nb_compr_bytes, redundancy_bytes); | ||
2088 | nb_compr_bytes = nb_compr_bytes+redundancy_bytes; | ||
2089 | } | ||
2090 | } | ||
2091 | } | ||
2092 | |||
2093 | /* 5 ms redundant frame for SILK->CELT */ | ||
2094 | if (redundancy && !celt_to_silk) | ||
2095 | { | ||
2096 | int err; | ||
2097 | unsigned char dummy[2]; | ||
2098 | int N2, N4; | ||
2099 | N2 = st->Fs/200; | ||
2100 | N4 = st->Fs/400; | ||
2101 | |||
2102 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); | ||
2103 | celt_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)); | ||
2104 | celt_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)); | ||
2105 | celt_encoder_ctl(celt_enc, OPUS_SET_VBR(0)); | ||
2106 | celt_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)); | ||
2107 | |||
2108 | if (st->mode == MODE_HYBRID) | ||
2109 | { | ||
2110 | /* Shrink packet to what the encoder actually used. */ | ||
2111 | nb_compr_bytes = ret; | ||
2112 | ec_enc_shrink(&enc, nb_compr_bytes); | ||
2113 | } | ||
2114 | /* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */ | ||
2115 | celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2-N4), N4, dummy, 2, NULL); | ||
2116 | |||
2117 | err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels*(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL); | ||
2118 | if (err < 0) | ||
2119 | { | ||
2120 | RESTORE_STACK; | ||
2121 | return OPUS_INTERNAL_ERROR; | ||
2122 | } | ||
2123 | celt_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)); | ||
2124 | } | ||
2125 | |||
2126 | |||
2127 | |||
2128 | /* Signalling the mode in the first byte */ | ||
2129 | data--; | ||
2130 | data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); | ||
2131 | |||
2132 | st->rangeFinal = enc.rng ^ redundant_rng; | ||
2133 | |||
2134 | if (to_celt) | ||
2135 | st->prev_mode = MODE_CELT_ONLY; | ||
2136 | else | ||
2137 | st->prev_mode = st->mode; | ||
2138 | st->prev_channels = st->stream_channels; | ||
2139 | st->prev_framesize = frame_size; | ||
2140 | |||
2141 | st->first = 0; | ||
2142 | |||
2143 | /* DTX decision */ | ||
2144 | #ifndef DISABLE_FLOAT_API | ||
2145 | if (st->use_dtx && (analysis_info.valid || is_silence)) | ||
2146 | { | ||
2147 | if (decide_dtx_mode(analysis_info.activity_probability, &st->nb_no_activity_frames, | ||
2148 | st->peak_signal_energy, pcm, frame_size, st->channels, is_silence, st->arch)) | ||
2149 | { | ||
2150 | st->rangeFinal = 0; | ||
2151 | data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels); | ||
2152 | RESTORE_STACK; | ||
2153 | return 1; | ||
2154 | } | ||
2155 | } | ||
2156 | #endif | ||
2157 | |||
2158 | /* In the unlikely case that the SILK encoder busted its target, tell | ||
2159 | the decoder to call the PLC */ | ||
2160 | if (ec_tell(&enc) > (max_data_bytes-1)*8) | ||
2161 | { | ||
2162 | if (max_data_bytes < 2) | ||
2163 | { | ||
2164 | RESTORE_STACK; | ||
2165 | return OPUS_BUFFER_TOO_SMALL; | ||
2166 | } | ||
2167 | data[1] = 0; | ||
2168 | ret = 1; | ||
2169 | st->rangeFinal = 0; | ||
2170 | } else if (st->mode==MODE_SILK_ONLY&&!redundancy) | ||
2171 | { | ||
2172 | /*When in LPC only mode it's perfectly | ||
2173 | reasonable to strip off trailing zero bytes as | ||
2174 | the required range decoder behavior is to | ||
2175 | fill these in. This can't be done when the MDCT | ||
2176 | modes are used because the decoder needs to know | ||
2177 | the actual length for allocation purposes.*/ | ||
2178 | while(ret>2&&data[ret]==0)ret--; | ||
2179 | } | ||
2180 | /* Count ToC and redundancy */ | ||
2181 | ret += 1+redundancy_bytes; | ||
2182 | if (!st->use_vbr) | ||
2183 | { | ||
2184 | if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK) | ||
2185 | { | ||
2186 | RESTORE_STACK; | ||
2187 | return OPUS_INTERNAL_ERROR; | ||
2188 | } | ||
2189 | ret = max_data_bytes; | ||
2190 | } | ||
2191 | RESTORE_STACK; | ||
2192 | return ret; | ||
2193 | } | ||
2194 | |||
2195 | #ifdef FIXED_POINT | ||
2196 | |||
2197 | #ifndef DISABLE_FLOAT_API | ||
2198 | opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size, | ||
2199 | unsigned char *data, opus_int32 max_data_bytes) | ||
2200 | { | ||
2201 | int i, ret; | ||
2202 | int frame_size; | ||
2203 | VARDECL(opus_int16, in); | ||
2204 | ALLOC_STACK; | ||
2205 | |||
2206 | frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs); | ||
2207 | if (frame_size <= 0) | ||
2208 | { | ||
2209 | RESTORE_STACK; | ||
2210 | return OPUS_BAD_ARG; | ||
2211 | } | ||
2212 | ALLOC(in, frame_size*st->channels, opus_int16); | ||
2213 | |||
2214 | for (i=0;i<frame_size*st->channels;i++) | ||
2215 | in[i] = FLOAT2INT16(pcm[i]); | ||
2216 | ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, | ||
2217 | pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1); | ||
2218 | RESTORE_STACK; | ||
2219 | return ret; | ||
2220 | } | ||
2221 | #endif | ||
2222 | |||
2223 | opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size, | ||
2224 | unsigned char *data, opus_int32 out_data_bytes) | ||
2225 | { | ||
2226 | int frame_size; | ||
2227 | frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs); | ||
2228 | return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16, | ||
2229 | pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0); | ||
2230 | } | ||
2231 | |||
2232 | #else | ||
2233 | opus_int32 opus_encode(OpusEncoder *st, const opus_int16 *pcm, int analysis_frame_size, | ||
2234 | unsigned char *data, opus_int32 max_data_bytes) | ||
2235 | { | ||
2236 | int i, ret; | ||
2237 | int frame_size; | ||
2238 | VARDECL(float, in); | ||
2239 | ALLOC_STACK; | ||
2240 | |||
2241 | frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs); | ||
2242 | if (frame_size <= 0) | ||
2243 | { | ||
2244 | RESTORE_STACK; | ||
2245 | return OPUS_BAD_ARG; | ||
2246 | } | ||
2247 | ALLOC(in, frame_size*st->channels, float); | ||
2248 | |||
2249 | for (i=0;i<frame_size*st->channels;i++) | ||
2250 | in[i] = (1.0f/32768)*pcm[i]; | ||
2251 | ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, | ||
2252 | pcm, analysis_frame_size, 0, -2, st->channels, downmix_int, 0); | ||
2253 | RESTORE_STACK; | ||
2254 | return ret; | ||
2255 | } | ||
2256 | opus_int32 opus_encode_float(OpusEncoder *st, const float *pcm, int analysis_frame_size, | ||
2257 | unsigned char *data, opus_int32 out_data_bytes) | ||
2258 | { | ||
2259 | int frame_size; | ||
2260 | frame_size = frame_size_select(analysis_frame_size, st->variable_duration, st->Fs); | ||
2261 | return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24, | ||
2262 | pcm, analysis_frame_size, 0, -2, st->channels, downmix_float, 1); | ||
2263 | } | ||
2264 | #endif | ||
2265 | |||
2266 | |||
2267 | int opus_encoder_ctl(OpusEncoder *st, int request, ...) | ||
2268 | { | ||
2269 | int ret; | ||
2270 | CELTEncoder *celt_enc; | ||
2271 | va_list ap; | ||
2272 | |||
2273 | ret = OPUS_OK; | ||
2274 | va_start(ap, request); | ||
2275 | |||
2276 | celt_enc = (CELTEncoder*)((char*)st+st->celt_enc_offset); | ||
2277 | |||
2278 | switch (request) | ||
2279 | { | ||
2280 | case OPUS_SET_APPLICATION_REQUEST: | ||
2281 | { | ||
2282 | opus_int32 value = va_arg(ap, opus_int32); | ||
2283 | if ( (value != OPUS_APPLICATION_VOIP && value != OPUS_APPLICATION_AUDIO | ||
2284 | && value != OPUS_APPLICATION_RESTRICTED_LOWDELAY) | ||
2285 | || (!st->first && st->application != value)) | ||
2286 | { | ||
2287 | ret = OPUS_BAD_ARG; | ||
2288 | break; | ||
2289 | } | ||
2290 | st->application = value; | ||
2291 | #ifndef DISABLE_FLOAT_API | ||
2292 | st->analysis.application = value; | ||
2293 | #endif | ||
2294 | } | ||
2295 | break; | ||
2296 | case OPUS_GET_APPLICATION_REQUEST: | ||
2297 | { | ||
2298 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2299 | if (!value) | ||
2300 | { | ||
2301 | goto bad_arg; | ||
2302 | } | ||
2303 | *value = st->application; | ||
2304 | } | ||
2305 | break; | ||
2306 | case OPUS_SET_BITRATE_REQUEST: | ||
2307 | { | ||
2308 | opus_int32 value = va_arg(ap, opus_int32); | ||
2309 | if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX) | ||
2310 | { | ||
2311 | if (value <= 0) | ||
2312 | goto bad_arg; | ||
2313 | else if (value <= 500) | ||
2314 | value = 500; | ||
2315 | else if (value > (opus_int32)300000*st->channels) | ||
2316 | value = (opus_int32)300000*st->channels; | ||
2317 | } | ||
2318 | st->user_bitrate_bps = value; | ||
2319 | } | ||
2320 | break; | ||
2321 | case OPUS_GET_BITRATE_REQUEST: | ||
2322 | { | ||
2323 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2324 | if (!value) | ||
2325 | { | ||
2326 | goto bad_arg; | ||
2327 | } | ||
2328 | *value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276); | ||
2329 | } | ||
2330 | break; | ||
2331 | case OPUS_SET_FORCE_CHANNELS_REQUEST: | ||
2332 | { | ||
2333 | opus_int32 value = va_arg(ap, opus_int32); | ||
2334 | if((value<1 || value>st->channels) && value != OPUS_AUTO) | ||
2335 | { | ||
2336 | goto bad_arg; | ||
2337 | } | ||
2338 | st->force_channels = value; | ||
2339 | } | ||
2340 | break; | ||
2341 | case OPUS_GET_FORCE_CHANNELS_REQUEST: | ||
2342 | { | ||
2343 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2344 | if (!value) | ||
2345 | { | ||
2346 | goto bad_arg; | ||
2347 | } | ||
2348 | *value = st->force_channels; | ||
2349 | } | ||
2350 | break; | ||
2351 | case OPUS_SET_MAX_BANDWIDTH_REQUEST: | ||
2352 | { | ||
2353 | opus_int32 value = va_arg(ap, opus_int32); | ||
2354 | if (value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) | ||
2355 | { | ||
2356 | goto bad_arg; | ||
2357 | } | ||
2358 | st->max_bandwidth = value; | ||
2359 | if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { | ||
2360 | st->silk_mode.maxInternalSampleRate = 8000; | ||
2361 | } else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { | ||
2362 | st->silk_mode.maxInternalSampleRate = 12000; | ||
2363 | } else { | ||
2364 | st->silk_mode.maxInternalSampleRate = 16000; | ||
2365 | } | ||
2366 | } | ||
2367 | break; | ||
2368 | case OPUS_GET_MAX_BANDWIDTH_REQUEST: | ||
2369 | { | ||
2370 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2371 | if (!value) | ||
2372 | { | ||
2373 | goto bad_arg; | ||
2374 | } | ||
2375 | *value = st->max_bandwidth; | ||
2376 | } | ||
2377 | break; | ||
2378 | case OPUS_SET_BANDWIDTH_REQUEST: | ||
2379 | { | ||
2380 | opus_int32 value = va_arg(ap, opus_int32); | ||
2381 | if ((value < OPUS_BANDWIDTH_NARROWBAND || value > OPUS_BANDWIDTH_FULLBAND) && value != OPUS_AUTO) | ||
2382 | { | ||
2383 | goto bad_arg; | ||
2384 | } | ||
2385 | st->user_bandwidth = value; | ||
2386 | if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND) { | ||
2387 | st->silk_mode.maxInternalSampleRate = 8000; | ||
2388 | } else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND) { | ||
2389 | st->silk_mode.maxInternalSampleRate = 12000; | ||
2390 | } else { | ||
2391 | st->silk_mode.maxInternalSampleRate = 16000; | ||
2392 | } | ||
2393 | } | ||
2394 | break; | ||
2395 | case OPUS_GET_BANDWIDTH_REQUEST: | ||
2396 | { | ||
2397 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2398 | if (!value) | ||
2399 | { | ||
2400 | goto bad_arg; | ||
2401 | } | ||
2402 | *value = st->bandwidth; | ||
2403 | } | ||
2404 | break; | ||
2405 | case OPUS_SET_DTX_REQUEST: | ||
2406 | { | ||
2407 | opus_int32 value = va_arg(ap, opus_int32); | ||
2408 | if(value<0 || value>1) | ||
2409 | { | ||
2410 | goto bad_arg; | ||
2411 | } | ||
2412 | st->use_dtx = value; | ||
2413 | } | ||
2414 | break; | ||
2415 | case OPUS_GET_DTX_REQUEST: | ||
2416 | { | ||
2417 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2418 | if (!value) | ||
2419 | { | ||
2420 | goto bad_arg; | ||
2421 | } | ||
2422 | *value = st->use_dtx; | ||
2423 | } | ||
2424 | break; | ||
2425 | case OPUS_SET_COMPLEXITY_REQUEST: | ||
2426 | { | ||
2427 | opus_int32 value = va_arg(ap, opus_int32); | ||
2428 | if(value<0 || value>10) | ||
2429 | { | ||
2430 | goto bad_arg; | ||
2431 | } | ||
2432 | st->silk_mode.complexity = value; | ||
2433 | celt_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value)); | ||
2434 | } | ||
2435 | break; | ||
2436 | case OPUS_GET_COMPLEXITY_REQUEST: | ||
2437 | { | ||
2438 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2439 | if (!value) | ||
2440 | { | ||
2441 | goto bad_arg; | ||
2442 | } | ||
2443 | *value = st->silk_mode.complexity; | ||
2444 | } | ||
2445 | break; | ||
2446 | case OPUS_SET_INBAND_FEC_REQUEST: | ||
2447 | { | ||
2448 | opus_int32 value = va_arg(ap, opus_int32); | ||
2449 | if(value<0 || value>1) | ||
2450 | { | ||
2451 | goto bad_arg; | ||
2452 | } | ||
2453 | st->silk_mode.useInBandFEC = value; | ||
2454 | } | ||
2455 | break; | ||
2456 | case OPUS_GET_INBAND_FEC_REQUEST: | ||
2457 | { | ||
2458 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2459 | if (!value) | ||
2460 | { | ||
2461 | goto bad_arg; | ||
2462 | } | ||
2463 | *value = st->silk_mode.useInBandFEC; | ||
2464 | } | ||
2465 | break; | ||
2466 | case OPUS_SET_PACKET_LOSS_PERC_REQUEST: | ||
2467 | { | ||
2468 | opus_int32 value = va_arg(ap, opus_int32); | ||
2469 | if (value < 0 || value > 100) | ||
2470 | { | ||
2471 | goto bad_arg; | ||
2472 | } | ||
2473 | st->silk_mode.packetLossPercentage = value; | ||
2474 | celt_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value)); | ||
2475 | } | ||
2476 | break; | ||
2477 | case OPUS_GET_PACKET_LOSS_PERC_REQUEST: | ||
2478 | { | ||
2479 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2480 | if (!value) | ||
2481 | { | ||
2482 | goto bad_arg; | ||
2483 | } | ||
2484 | *value = st->silk_mode.packetLossPercentage; | ||
2485 | } | ||
2486 | break; | ||
2487 | case OPUS_SET_VBR_REQUEST: | ||
2488 | { | ||
2489 | opus_int32 value = va_arg(ap, opus_int32); | ||
2490 | if(value<0 || value>1) | ||
2491 | { | ||
2492 | goto bad_arg; | ||
2493 | } | ||
2494 | st->use_vbr = value; | ||
2495 | st->silk_mode.useCBR = 1-value; | ||
2496 | } | ||
2497 | break; | ||
2498 | case OPUS_GET_VBR_REQUEST: | ||
2499 | { | ||
2500 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2501 | if (!value) | ||
2502 | { | ||
2503 | goto bad_arg; | ||
2504 | } | ||
2505 | *value = st->use_vbr; | ||
2506 | } | ||
2507 | break; | ||
2508 | case OPUS_SET_VOICE_RATIO_REQUEST: | ||
2509 | { | ||
2510 | opus_int32 value = va_arg(ap, opus_int32); | ||
2511 | if (value<-1 || value>100) | ||
2512 | { | ||
2513 | goto bad_arg; | ||
2514 | } | ||
2515 | st->voice_ratio = value; | ||
2516 | } | ||
2517 | break; | ||
2518 | case OPUS_GET_VOICE_RATIO_REQUEST: | ||
2519 | { | ||
2520 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2521 | if (!value) | ||
2522 | { | ||
2523 | goto bad_arg; | ||
2524 | } | ||
2525 | *value = st->voice_ratio; | ||
2526 | } | ||
2527 | break; | ||
2528 | case OPUS_SET_VBR_CONSTRAINT_REQUEST: | ||
2529 | { | ||
2530 | opus_int32 value = va_arg(ap, opus_int32); | ||
2531 | if(value<0 || value>1) | ||
2532 | { | ||
2533 | goto bad_arg; | ||
2534 | } | ||
2535 | st->vbr_constraint = value; | ||
2536 | } | ||
2537 | break; | ||
2538 | case OPUS_GET_VBR_CONSTRAINT_REQUEST: | ||
2539 | { | ||
2540 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2541 | if (!value) | ||
2542 | { | ||
2543 | goto bad_arg; | ||
2544 | } | ||
2545 | *value = st->vbr_constraint; | ||
2546 | } | ||
2547 | break; | ||
2548 | case OPUS_SET_SIGNAL_REQUEST: | ||
2549 | { | ||
2550 | opus_int32 value = va_arg(ap, opus_int32); | ||
2551 | if(value!=OPUS_AUTO && value!=OPUS_SIGNAL_VOICE && value!=OPUS_SIGNAL_MUSIC) | ||
2552 | { | ||
2553 | goto bad_arg; | ||
2554 | } | ||
2555 | st->signal_type = value; | ||
2556 | } | ||
2557 | break; | ||
2558 | case OPUS_GET_SIGNAL_REQUEST: | ||
2559 | { | ||
2560 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2561 | if (!value) | ||
2562 | { | ||
2563 | goto bad_arg; | ||
2564 | } | ||
2565 | *value = st->signal_type; | ||
2566 | } | ||
2567 | break; | ||
2568 | case OPUS_GET_LOOKAHEAD_REQUEST: | ||
2569 | { | ||
2570 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2571 | if (!value) | ||
2572 | { | ||
2573 | goto bad_arg; | ||
2574 | } | ||
2575 | *value = st->Fs/400; | ||
2576 | if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY) | ||
2577 | *value += st->delay_compensation; | ||
2578 | } | ||
2579 | break; | ||
2580 | case OPUS_GET_SAMPLE_RATE_REQUEST: | ||
2581 | { | ||
2582 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2583 | if (!value) | ||
2584 | { | ||
2585 | goto bad_arg; | ||
2586 | } | ||
2587 | *value = st->Fs; | ||
2588 | } | ||
2589 | break; | ||
2590 | case OPUS_GET_FINAL_RANGE_REQUEST: | ||
2591 | { | ||
2592 | opus_uint32 *value = va_arg(ap, opus_uint32*); | ||
2593 | if (!value) | ||
2594 | { | ||
2595 | goto bad_arg; | ||
2596 | } | ||
2597 | *value = st->rangeFinal; | ||
2598 | } | ||
2599 | break; | ||
2600 | case OPUS_SET_LSB_DEPTH_REQUEST: | ||
2601 | { | ||
2602 | opus_int32 value = va_arg(ap, opus_int32); | ||
2603 | if (value<8 || value>24) | ||
2604 | { | ||
2605 | goto bad_arg; | ||
2606 | } | ||
2607 | st->lsb_depth=value; | ||
2608 | } | ||
2609 | break; | ||
2610 | case OPUS_GET_LSB_DEPTH_REQUEST: | ||
2611 | { | ||
2612 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2613 | if (!value) | ||
2614 | { | ||
2615 | goto bad_arg; | ||
2616 | } | ||
2617 | *value = st->lsb_depth; | ||
2618 | } | ||
2619 | break; | ||
2620 | case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST: | ||
2621 | { | ||
2622 | opus_int32 value = va_arg(ap, opus_int32); | ||
2623 | if (value != OPUS_FRAMESIZE_ARG && value != OPUS_FRAMESIZE_2_5_MS && | ||
2624 | value != OPUS_FRAMESIZE_5_MS && value != OPUS_FRAMESIZE_10_MS && | ||
2625 | value != OPUS_FRAMESIZE_20_MS && value != OPUS_FRAMESIZE_40_MS && | ||
2626 | value != OPUS_FRAMESIZE_60_MS && value != OPUS_FRAMESIZE_80_MS && | ||
2627 | value != OPUS_FRAMESIZE_100_MS && value != OPUS_FRAMESIZE_120_MS) | ||
2628 | { | ||
2629 | goto bad_arg; | ||
2630 | } | ||
2631 | st->variable_duration = value; | ||
2632 | } | ||
2633 | break; | ||
2634 | case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST: | ||
2635 | { | ||
2636 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2637 | if (!value) | ||
2638 | { | ||
2639 | goto bad_arg; | ||
2640 | } | ||
2641 | *value = st->variable_duration; | ||
2642 | } | ||
2643 | break; | ||
2644 | case OPUS_SET_PREDICTION_DISABLED_REQUEST: | ||
2645 | { | ||
2646 | opus_int32 value = va_arg(ap, opus_int32); | ||
2647 | if (value > 1 || value < 0) | ||
2648 | goto bad_arg; | ||
2649 | st->silk_mode.reducedDependency = value; | ||
2650 | } | ||
2651 | break; | ||
2652 | case OPUS_GET_PREDICTION_DISABLED_REQUEST: | ||
2653 | { | ||
2654 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2655 | if (!value) | ||
2656 | goto bad_arg; | ||
2657 | *value = st->silk_mode.reducedDependency; | ||
2658 | } | ||
2659 | break; | ||
2660 | case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST: | ||
2661 | { | ||
2662 | opus_int32 value = va_arg(ap, opus_int32); | ||
2663 | if(value<0 || value>1) | ||
2664 | { | ||
2665 | goto bad_arg; | ||
2666 | } | ||
2667 | celt_encoder_ctl(celt_enc, OPUS_SET_PHASE_INVERSION_DISABLED(value)); | ||
2668 | } | ||
2669 | break; | ||
2670 | case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST: | ||
2671 | { | ||
2672 | opus_int32 *value = va_arg(ap, opus_int32*); | ||
2673 | if (!value) | ||
2674 | { | ||
2675 | goto bad_arg; | ||
2676 | } | ||
2677 | celt_encoder_ctl(celt_enc, OPUS_GET_PHASE_INVERSION_DISABLED(value)); | ||
2678 | } | ||
2679 | break; | ||
2680 | case OPUS_RESET_STATE: | ||
2681 | { | ||
2682 | void *silk_enc; | ||
2683 | silk_EncControlStruct dummy; | ||
2684 | char *start; | ||
2685 | silk_enc = (char*)st+st->silk_enc_offset; | ||
2686 | #ifndef DISABLE_FLOAT_API | ||
2687 | tonality_analysis_reset(&st->analysis); | ||
2688 | #endif | ||
2689 | |||
2690 | start = (char*)&st->OPUS_ENCODER_RESET_START; | ||
2691 | OPUS_CLEAR(start, sizeof(OpusEncoder) - (start - (char*)st)); | ||
2692 | |||
2693 | celt_encoder_ctl(celt_enc, OPUS_RESET_STATE); | ||
2694 | silk_InitEncoder( silk_enc, st->arch, &dummy ); | ||
2695 | st->stream_channels = st->channels; | ||
2696 | st->hybrid_stereo_width_Q14 = 1 << 14; | ||
2697 | st->prev_HB_gain = Q15ONE; | ||
2698 | st->first = 1; | ||
2699 | st->mode = MODE_HYBRID; | ||
2700 | st->bandwidth = OPUS_BANDWIDTH_FULLBAND; | ||
2701 | st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 ); | ||
2702 | } | ||
2703 | break; | ||
2704 | case OPUS_SET_FORCE_MODE_REQUEST: | ||
2705 | { | ||
2706 | opus_int32 value = va_arg(ap, opus_int32); | ||
2707 | if ((value < MODE_SILK_ONLY || value > MODE_CELT_ONLY) && value != OPUS_AUTO) | ||
2708 | { | ||
2709 | goto bad_arg; | ||
2710 | } | ||
2711 | st->user_forced_mode = value; | ||
2712 | } | ||
2713 | break; | ||
2714 | case OPUS_SET_LFE_REQUEST: | ||
2715 | { | ||
2716 | opus_int32 value = va_arg(ap, opus_int32); | ||
2717 | st->lfe = value; | ||
2718 | ret = celt_encoder_ctl(celt_enc, OPUS_SET_LFE(value)); | ||
2719 | } | ||
2720 | break; | ||
2721 | case OPUS_SET_ENERGY_MASK_REQUEST: | ||
2722 | { | ||
2723 | opus_val16 *value = va_arg(ap, opus_val16*); | ||
2724 | st->energy_masking = value; | ||
2725 | ret = celt_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value)); | ||
2726 | } | ||
2727 | break; | ||
2728 | |||
2729 | case CELT_GET_MODE_REQUEST: | ||
2730 | { | ||
2731 | const CELTMode ** value = va_arg(ap, const CELTMode**); | ||
2732 | if (!value) | ||
2733 | { | ||
2734 | goto bad_arg; | ||
2735 | } | ||
2736 | ret = celt_encoder_ctl(celt_enc, CELT_GET_MODE(value)); | ||
2737 | } | ||
2738 | break; | ||
2739 | default: | ||
2740 | /* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/ | ||
2741 | ret = OPUS_UNIMPLEMENTED; | ||
2742 | break; | ||
2743 | } | ||
2744 | va_end(ap); | ||
2745 | return ret; | ||
2746 | bad_arg: | ||
2747 | va_end(ap); | ||
2748 | return OPUS_BAD_ARG; | ||
2749 | } | ||
2750 | |||
2751 | void opus_encoder_destroy(OpusEncoder *st) | ||
2752 | { | ||
2753 | opus_free(st); | ||
2754 | } | ||