src/opus_encoder.c

Bug Summary

File:	libs/opus-1.1-p2/src/opus_encoder.c
Location:	line 918, column 7
Description:	Value stored to 'corr' is never read

Annotated Source Code

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_H1
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 "opus_private.h"
42	#include "os_support.h"
43	#include "cpu_support.h"
44	#include "analysis.h"
45	#include "mathops.h"
46	#include "tuning_parameters.h"
47	#ifdef FIXED_POINT
48	#include "fixed/structs_FIX.h"
49	#else
50	#include "float/structs_FLP.h"
51	#endif
52
53	#define MAX_ENCODER_BUFFER480 480
54
55	typedef struct {
56	opus_val32 XX, XY, YY;
57	opus_val16 smoothed_width;
58	opus_val16 max_follower;
59	} StereoWidthState;
60
61	struct OpusEncoder {
62	int celt_enc_offset;
63	int silk_enc_offset;
64	silk_EncControlStruct silk_mode;
65	int application;
66	int channels;
67	int delay_compensation;
68	int force_channels;
69	int signal_type;
70	int user_bandwidth;
71	int max_bandwidth;
72	int user_forced_mode;
73	int voice_ratio;
74	opus_int32 Fs;
75	int use_vbr;
76	int vbr_constraint;
77	int variable_duration;
78	opus_int32 bitrate_bps;
79	opus_int32 user_bitrate_bps;
80	int lsb_depth;
81	int encoder_buffer;
82	int lfe;
83
84	#define OPUS_ENCODER_RESET_STARTstream_channels stream_channels
85	int stream_channels;
86	opus_int16 hybrid_stereo_width_Q14;
87	opus_int32 variable_HP_smth2_Q15;
88	opus_val16 prev_HB_gain;
89	opus_val32 hp_mem[4];
90	int mode;
91	int prev_mode;
92	int prev_channels;
93	int prev_framesize;
94	int bandwidth;
95	int silk_bw_switch;
96	/* Sampling rate (at the API level) */
97	int first;
98	opus_val16 * energy_masking;
99	StereoWidthState width_mem;
100	opus_val16 delay_buffer[MAX_ENCODER_BUFFER480*2];
101	#ifndef DISABLE_FLOAT_API
102	TonalityAnalysisState analysis;
103	int detected_bandwidth;
104	int analysis_offset;
105	#endif
106	opus_uint32 rangeFinal;
107	int arch;
108	};
109
110	/* Transition tables for the voice and music. First column is the
111	middle (memoriless) threshold. The second column is the hysteresis
112	(difference with the middle) */
113	static const opus_int32 mono_voice_bandwidth_thresholds[8] = {
114	11000, 1000, /* NB<->MB */
115	14000, 1000, /* MB<->WB */
116	17000, 1000, /* WB<->SWB */
117	21000, 2000, /* SWB<->FB */
118	};
119	static const opus_int32 mono_music_bandwidth_thresholds[8] = {
120	12000, 1000, /* NB<->MB */
121	15000, 1000, /* MB<->WB */
122	18000, 2000, /* WB<->SWB */
123	22000, 2000, /* SWB<->FB */
124	};
125	static const opus_int32 stereo_voice_bandwidth_thresholds[8] = {
126	11000, 1000, /* NB<->MB */
127	14000, 1000, /* MB<->WB */
128	21000, 2000, /* WB<->SWB */
129	28000, 2000, /* SWB<->FB */
130	};
131	static const opus_int32 stereo_music_bandwidth_thresholds[8] = {
132	12000, 1000, /* NB<->MB */
133	18000, 2000, /* MB<->WB */
134	21000, 2000, /* WB<->SWB */
135	30000, 2000, /* SWB<->FB */
136	};
137	/* Threshold bit-rates for switching between mono and stereo */
138	static const opus_int32 stereo_voice_threshold = 30000;
139	static const opus_int32 stereo_music_threshold = 30000;
140
141	/* Threshold bit-rate for switching between SILK/hybrid and CELT-only */
142	static const opus_int32 mode_thresholds[2][2] = {
143	/* voice / / music */
144	{ 64000, 16000}, /* mono */
145	{ 36000, 16000}, /* stereo */
146	};
147
148	int opus_encoder_get_size(int channels)
149	{
150	int silkEncSizeBytes, celtEncSizeBytes;
151	int ret;
152	if (channels<1 \|\| channels > 2)
153	return 0;
154	ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
155	if (ret)
156	return 0;
157	silkEncSizeBytes = align(silkEncSizeBytes);
158	celtEncSizeBytes = celt_encoder_get_size(channels);
159	return align(sizeof(OpusEncoder))+silkEncSizeBytes+celtEncSizeBytes;
160	}
161
162	int opus_encoder_init(OpusEncoder* st, opus_int32 Fs, int channels, int application)
163	{
164	void *silk_enc;
165	CELTEncoderOpusCustomEncoder *celt_enc;
166	int err;
167	int ret, silkEncSizeBytes;
168
169	if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)\|\|(channels!=1&&channels!=2)\|\|
170	(application != OPUS_APPLICATION_VOIP2048 && application != OPUS_APPLICATION_AUDIO2049
171	&& application != OPUS_APPLICATION_RESTRICTED_LOWDELAY2051))
172	return OPUS_BAD_ARG-1;
173
174	OPUS_CLEAR((char)st, opus_encoder_get_size(channels))(memset(((char)st), 0, (opus_encoder_get_size(channels))sizeof (((char*)st))));
175	/* Create SILK encoder */
176	ret = silk_Get_Encoder_Size( &silkEncSizeBytes );
177	if (ret)
178	return OPUS_BAD_ARG-1;
179	silkEncSizeBytes = align(silkEncSizeBytes);
180	st->silk_enc_offset = align(sizeof(OpusEncoder));
181	st->celt_enc_offset = st->silk_enc_offset+silkEncSizeBytes;
182	silk_enc = (char*)st+st->silk_enc_offset;
183	celt_enc = (CELTEncoderOpusCustomEncoder)((char)st+st->celt_enc_offset);
184
185	st->stream_channels = st->channels = channels;
186
187	st->Fs = Fs;
188
189	st->arch = opus_select_arch();
190
191	ret = silk_InitEncoder( silk_enc, st->arch, &st->silk_mode );
192	if(ret)return OPUS_INTERNAL_ERROR-3;
193
194	/* default SILK parameters */
195	st->silk_mode.nChannelsAPI = channels;
196	st->silk_mode.nChannelsInternal = channels;
197	st->silk_mode.API_sampleRate = st->Fs;
198	st->silk_mode.maxInternalSampleRate = 16000;
199	st->silk_mode.minInternalSampleRate = 8000;
200	st->silk_mode.desiredInternalSampleRate = 16000;
201	st->silk_mode.payloadSize_ms = 20;
202	st->silk_mode.bitRate = 25000;
203	st->silk_mode.packetLossPercentage = 0;
204	st->silk_mode.complexity = 9;
205	st->silk_mode.useInBandFEC = 0;
206	st->silk_mode.useDTX = 0;
207	st->silk_mode.useCBR = 0;
208	st->silk_mode.reducedDependency = 0;
209
210	/* Create CELT encoder */
211	/* Initialize CELT encoder */
212	err = celt_encoder_init(celt_enc, Fs, channels, st->arch);
213	if(err!=OPUS_OK0)return OPUS_INTERNAL_ERROR-3;
214
215	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_SIGNALLING(0)10016, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
216	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(st->silk_mode.complexity)4010, (((void)((st->silk_mode.complexity) == (opus_int32)0 )), (opus_int32)(st->silk_mode.complexity)));
217
218	st->use_vbr = 1;
219	/* Makes constrained VBR the default (safer for real-time use) */
220	st->vbr_constraint = 1;
221	st->user_bitrate_bps = OPUS_AUTO-1000;
222	st->bitrate_bps = 3000+Fs*channels;
223	st->application = application;
224	st->signal_type = OPUS_AUTO-1000;
225	st->user_bandwidth = OPUS_AUTO-1000;
226	st->max_bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
227	st->force_channels = OPUS_AUTO-1000;
228	st->user_forced_mode = OPUS_AUTO-1000;
229	st->voice_ratio = -1;
230	st->encoder_buffer = st->Fs/100;
231	st->lsb_depth = 24;
232	st->variable_duration = OPUS_FRAMESIZE_ARG5000;
233
234	/* Delay compensation of 4 ms (2.5 ms for SILK's extra look-ahead
235	+ 1.5 ms for SILK resamplers and stereo prediction) */
236	st->delay_compensation = st->Fs/250;
237
238	st->hybrid_stereo_width_Q14 = 1 << 14;
239	st->prev_HB_gain = Q15ONE1.0f;
240	st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 )((opus_int32)((opus_uint32)(silk_lin2log( 60 ))<<(8)));
241	st->first = 1;
242	st->mode = MODE_HYBRID1001;
243	st->bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
244
245	return OPUS_OK0;
246	}
247
248	static unsigned char gen_toc(int mode, int framerate, int bandwidth, int channels)
249	{
250	int period;
251	unsigned char toc;
252	period = 0;
253	while (framerate < 400)
254	{
255	framerate <<= 1;
256	period++;
257	}
258	if (mode == MODE_SILK_ONLY1000)
259	{
260	toc = (bandwidth-OPUS_BANDWIDTH_NARROWBAND1101)<<5;
261	toc \|= (period-2)<<3;
262	} else if (mode == MODE_CELT_ONLY1002)
263	{
264	int tmp = bandwidth-OPUS_BANDWIDTH_MEDIUMBAND1102;
265	if (tmp < 0)
266	tmp = 0;
267	toc = 0x80;
268	toc \|= tmp << 5;
269	toc \|= period<<3;
270	} else /* Hybrid */
271	{
272	toc = 0x60;
273	toc \|= (bandwidth-OPUS_BANDWIDTH_SUPERWIDEBAND1104)<<4;
274	toc \|= (period-2)<<3;
275	}
276	toc \|= (channels==2)<<2;
277	return toc;
278	}
279
280	#ifndef FIXED_POINT
281	static void silk_biquad_float(
282	const opus_val16 in, / I: Input signal */
283	const opus_int32 B_Q28, / I: MA coefficients [3] */
284	const opus_int32 A_Q28, / I: AR coefficients [2] */
285	opus_val32 S, / I/O: State vector [2] */
286	opus_val16 out, / O: Output signal */
287	const opus_int32 len, /* I: Signal length (must be even) */
288	int stride
289	)
290	{
291	/* DIRECT FORM II TRANSPOSED (uses 2 element state vector) */
292	opus_intint k;
293	opus_val32 vout;
294	opus_val32 inval;
295	opus_val32 A[2], B[3];
296
297	A[0] = (opus_val32)(A_Q28[0] * (1.f/((opus_int32)1<<28)));
298	A[1] = (opus_val32)(A_Q28[1] * (1.f/((opus_int32)1<<28)));
299	B[0] = (opus_val32)(B_Q28[0] * (1.f/((opus_int32)1<<28)));
300	B[1] = (opus_val32)(B_Q28[1] * (1.f/((opus_int32)1<<28)));
301	B[2] = (opus_val32)(B_Q28[2] * (1.f/((opus_int32)1<<28)));
302
303	/* Negate A_Q28 values and split in two parts */
304
305	for( k = 0; k < len; k++ ) {
306	/* S[ 0 ], S[ 1 ]: Q12 */
307	inval = in[ k*stride ];
308	vout = S[ 0 ] + B[0]*inval;
309
310	S[ 0 ] = S[1] - voutA[0] + B[1]inval;
311
312	S[ 1 ] = - voutA[1] + B[2]inval + VERY_SMALL1e-30f;
313
314	/* Scale back to Q0 and saturate */
315	out[ k*stride ] = vout;
316	}
317	}
318	#endif
319
320	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)
321	{
322	opus_int32 B_Q28[ 3 ], A_Q28[ 2 ];
323	opus_int32 Fc_Q19, r_Q28, r_Q22;
324
325	silk_assert( cutoff_Hz <= silk_int32_MAX / SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ) );
326	Fc_Q19 = silk_DIV32_16( silk_SMULBB( SILK_FIX_CONST( 1.5 * 3.14159 / 1000, 19 ), cutoff_Hz ), Fs/1000 )((opus_int32)((((opus_int32)((opus_int16)(((opus_int32)((1.5 * 3.14159 / 1000) * ((long long)1 << (19)) + 0.5)))) * ( opus_int32)((opus_int16)(cutoff_Hz)))) / (Fs/1000)));
327	silk_assert( Fc_Q19 > 0 && Fc_Q19 < 32768 );
328
329	r_Q28 = SILK_FIX_CONST( 1.0, 28 )((opus_int32)((1.0) * ((long long)1 << (28)) + 0.5)) - silk_MUL( SILK_FIX_CONST( 0.92, 9 ), Fc_Q19 )((((opus_int32)((0.92) * ((long long)1 << (9)) + 0.5))) * (Fc_Q19));
330
331	/* b = r * [ 1; -2; 1 ]; */
332	/* a = [ 1; -2 * r * ( 1 - 0.5 * Fc^2 ); r^2 ]; */
333	B_Q28[ 0 ] = r_Q28;
334	B_Q28[ 1 ] = silk_LSHIFT( -r_Q28, 1 )((opus_int32)((opus_uint32)(-r_Q28)<<(1)));
335	B_Q28[ 2 ] = r_Q28;
336
337	/* -r * ( 2 - Fc * Fc ); */
338	r_Q22 = silk_RSHIFT( r_Q28, 6 )((r_Q28)>>(6));
339	A_Q28[ 0 ] = silk_SMULWW( r_Q22, silk_SMULWW( Fc_Q19, Fc_Q19 ) - SILK_FIX_CONST( 2.0, 22 ) )((((((((r_Q22)) >> 16) * (opus_int32)((opus_int16)((((( (((((Fc_Q19)) >> 16) * (opus_int32)((opus_int16)((Fc_Q19 )))) + (((((Fc_Q19)) & 0x0000FFFF) * (opus_int32)((opus_int16 )((Fc_Q19)))) >> 16)))) + ((((Fc_Q19)) * (((16) == 1 ? ( ((Fc_Q19)) >> 1) + (((Fc_Q19)) & 1) : ((((Fc_Q19)) >> ((16) - 1)) + 1) >> 1))))) - ((opus_int32)((2.0) * ((long long)1 << (22)) + 0.5)))))) + (((((r_Q22)) & 0x0000FFFF ) * (opus_int32)((opus_int16)((((((((((Fc_Q19)) >> 16) * (opus_int32)((opus_int16)((Fc_Q19)))) + (((((Fc_Q19)) & 0x0000FFFF ) * (opus_int32)((opus_int16)((Fc_Q19)))) >> 16)))) + ( (((Fc_Q19)) * (((16) == 1 ? (((Fc_Q19)) >> 1) + (((Fc_Q19 )) & 1) : ((((Fc_Q19)) >> ((16) - 1)) + 1) >> 1))))) - ((opus_int32)((2.0) * ((long long)1 << (22)) + 0.5)))))) >> 16)))) + ((((r_Q22)) * (((16) == 1 ? (((( (((((((Fc_Q19)) >> 16) * (opus_int32)((opus_int16)((Fc_Q19 )))) + (((((Fc_Q19)) & 0x0000FFFF) * (opus_int32)((opus_int16 )((Fc_Q19)))) >> 16)))) + ((((Fc_Q19)) * (((16) == 1 ? ( ((Fc_Q19)) >> 1) + (((Fc_Q19)) & 1) : ((((Fc_Q19)) >> ((16) - 1)) + 1) >> 1))))) - ((opus_int32)((2.0) * ((long long)1 << (22)) + 0.5)))) >> 1) + (((((((((((Fc_Q19 )) >> 16) * (opus_int32)((opus_int16)((Fc_Q19)))) + ((( ((Fc_Q19)) & 0x0000FFFF) * (opus_int32)((opus_int16)((Fc_Q19 )))) >> 16)))) + ((((Fc_Q19)) * (((16) == 1 ? (((Fc_Q19 )) >> 1) + (((Fc_Q19)) & 1) : ((((Fc_Q19)) >> ((16) - 1)) + 1) >> 1))))) - ((opus_int32)((2.0) * ((long long)1 << (22)) + 0.5)))) & 1) : ((((((((((((Fc_Q19 )) >> 16) * (opus_int32)((opus_int16)((Fc_Q19)))) + ((( ((Fc_Q19)) & 0x0000FFFF) * (opus_int32)((opus_int16)((Fc_Q19 )))) >> 16)))) + ((((Fc_Q19)) * (((16) == 1 ? (((Fc_Q19 )) >> 1) + (((Fc_Q19)) & 1) : ((((Fc_Q19)) >> ((16) - 1)) + 1) >> 1))))) - ((opus_int32)((2.0) * ((long long)1 << (22)) + 0.5)))) >> ((16) - 1)) + 1) >> 1)))));
340	A_Q28[ 1 ] = silk_SMULWW( r_Q22, r_Q22 )((((((((r_Q22)) >> 16) * (opus_int32)((opus_int16)((r_Q22 )))) + (((((r_Q22)) & 0x0000FFFF) * (opus_int32)((opus_int16 )((r_Q22)))) >> 16)))) + ((((r_Q22)) * (((16) == 1 ? (( (r_Q22)) >> 1) + (((r_Q22)) & 1) : ((((r_Q22)) >> ((16) - 1)) + 1) >> 1)))));
341
342	#ifdef FIXED_POINT
343	silk_biquad_alt( in, B_Q28, A_Q28, hp_mem, out, len, channels );
344	if( channels == 2 ) {
345	silk_biquad_alt( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
346	}
347	#else
348	silk_biquad_float( in, B_Q28, A_Q28, hp_mem, out, len, channels );
349	if( channels == 2 ) {
350	silk_biquad_float( in+1, B_Q28, A_Q28, hp_mem+2, out+1, len, channels );
351	}
352	#endif
353	}
354
355	#ifdef FIXED_POINT
356	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)
357	{
358	int c, i;
359	int shift;
360
361	/* Approximates -round(log2(4.cutoff_Hz/Fs)) /
362	shift=celt_ilog2(Fs/(cutoff_Hz*3));
363	for (c=0;c<channels;c++)
364	{
365	for (i=0;i<len;i++)
366	{
367	opus_val32 x, tmp, y;
368	x = SHL32(EXTEND32(in[channelsi+c]), 15)((in[channelsi+c]));
369	/* First stage */
370	tmp = x-hp_mem[2*c];
371	hp_mem[2c] = hp_mem[2c] + PSHR32(x - hp_mem[2c], shift)(x - hp_mem[2c]);
372	/* Second stage */
373	y = tmp - hp_mem[2*c+1];
374	hp_mem[2c+1] = hp_mem[2c+1] + PSHR32(tmp - hp_mem[2c+1], shift)(tmp - hp_mem[2c+1]);
375	out[channels*i+c] = EXTRACT16(SATURATE(PSHR32(y, 15), 32767))(((y)));
376	}
377	}
378	}
379
380	#else
381	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)
382	{
383	int c, i;
384	float coef;
385
386	coef = 4.0f*cutoff_Hz/Fs;
387	for (c=0;c<channels;c++)
388	{
389	for (i=0;i<len;i++)
390	{
391	opus_val32 x, tmp, y;
392	x = in[channels*i+c];
393	/* First stage */
394	tmp = x-hp_mem[2*c];
395	hp_mem[2c] = hp_mem[2c] + coef(x - hp_mem[2c]) + VERY_SMALL1e-30f;
396	/* Second stage */
397	y = tmp - hp_mem[2*c+1];
398	hp_mem[2c+1] = hp_mem[2c+1] + coef(tmp - hp_mem[2c+1]) + VERY_SMALL1e-30f;
399	out[channels*i+c] = y;
400	}
401	}
402	}
403	#endif
404
405	static void stereo_fade(const opus_val16 in, opus_val16 out, opus_val16 g1, opus_val16 g2,
406	int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
407	{
408	int i;
409	int overlap;
410	int inc;
411	inc = 48000/Fs;
412	overlap=overlap48/inc;
413	g1 = Q15ONE1.0f-g1;
414	g2 = Q15ONE1.0f-g2;
415	for (i=0;i<overlap;i++)
416	{
417	opus_val32 diff;
418	opus_val16 g, w;
419	w = MULT16_16_Q15(window[iinc], window[iinc])((window[iinc])(window[i*inc]));
420	g = SHR32(MAC16_16(MULT16_16(w,g2),(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)))
421	Q15ONE-w, g1), 15)(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)));
422	diff = EXTRACT16(HALF32((opus_val32)in[ichannels] - (opus_val32)in[ichannels+1]))((.5f((opus_val32)in[ichannels] - (opus_val32)in[i*channels +1])));
423	diff = MULT16_16_Q15(g, diff)((g)*(diff));
424	out[ichannels] = out[ichannels] - diff;
425	out[ichannels+1] = out[ichannels+1] + diff;
426	}
427	for (;i<frame_size;i++)
428	{
429	opus_val32 diff;
430	diff = EXTRACT16(HALF32((opus_val32)in[ichannels] - (opus_val32)in[ichannels+1]))((.5f((opus_val32)in[ichannels] - (opus_val32)in[i*channels +1])));
431	diff = MULT16_16_Q15(g2, diff)((g2)*(diff));
432	out[ichannels] = out[ichannels] - diff;
433	out[ichannels+1] = out[ichannels+1] + diff;
434	}
435	}
436
437	static void gain_fade(const opus_val16 in, opus_val16 out, opus_val16 g1, opus_val16 g2,
438	int overlap48, int frame_size, int channels, const opus_val16 *window, opus_int32 Fs)
439	{
440	int i;
441	int inc;
442	int overlap;
443	int c;
444	inc = 48000/Fs;
445	overlap=overlap48/inc;
446	if (channels==1)
447	{
448	for (i=0;i<overlap;i++)
449	{
450	opus_val16 g, w;
451	w = MULT16_16_Q15(window[iinc], window[iinc])((window[iinc])(window[i*inc]));
452	g = SHR32(MAC16_16(MULT16_16(w,g2),(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)))
453	Q15ONE-w, g1), 15)(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)));
454	out[i] = MULT16_16_Q15(g, in[i])((g)*(in[i]));
455	}
456	} else {
457	for (i=0;i<overlap;i++)
458	{
459	opus_val16 g, w;
460	w = MULT16_16_Q15(window[iinc], window[iinc])((window[iinc])(window[i*inc]));
461	g = SHR32(MAC16_16(MULT16_16(w,g2),(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)))
462	Q15ONE-w, g1), 15)(((((opus_val32)(w)(opus_val32)(g2)))+(opus_val32)(1.0f -w) (opus_val32)(g1)));
463	out[i2] = MULT16_16_Q15(g, in[i2])((g)(in[i2]));
464	out[i2+1] = MULT16_16_Q15(g, in[i2+1])((g)(in[i2+1]));
465	}
466	}
467	c=0;do {
468	for (i=overlap;i<frame_size;i++)
469	{
470	out[ichannels+c] = MULT16_16_Q15(g2, in[ichannels+c])((g2)(in[ichannels+c]));
471	}
472	}
473	while (++c<channels);
474	}
475
476	OpusEncoder opus_encoder_create(opus_int32 Fs, int channels, int application, int error)
477	{
478	int ret;
479	OpusEncoder *st;
480	if((Fs!=48000&&Fs!=24000&&Fs!=16000&&Fs!=12000&&Fs!=8000)\|\|(channels!=1&&channels!=2)\|\|
481	(application != OPUS_APPLICATION_VOIP2048 && application != OPUS_APPLICATION_AUDIO2049
482	&& application != OPUS_APPLICATION_RESTRICTED_LOWDELAY2051))
483	{
484	if (error)
485	*error = OPUS_BAD_ARG-1;
486	return NULL((void*)0);
487	}
488	st = (OpusEncoder *)opus_alloc(opus_encoder_get_size(channels));
489	if (st == NULL((void*)0))
490	{
491	if (error)
492	*error = OPUS_ALLOC_FAIL-7;
493	return NULL((void*)0);
494	}
495	ret = opus_encoder_init(st, Fs, channels, application);
496	if (error)
497	*error = ret;
498	if (ret != OPUS_OK0)
499	{
500	opus_free(st);
501	st = NULL((void*)0);
502	}
503	return st;
504	}
505
506	static opus_int32 user_bitrate_to_bitrate(OpusEncoder *st, int frame_size, int max_data_bytes)
507	{
508	if(!frame_size)frame_size=st->Fs/400;
509	if (st->user_bitrate_bps==OPUS_AUTO-1000)
510	return 60st->Fs/frame_size + st->Fsst->channels;
511	else if (st->user_bitrate_bps==OPUS_BITRATE_MAX-1)
512	return max_data_bytes8st->Fs/frame_size;
513	else
514	return st->user_bitrate_bps;
515	}
516
517	#ifndef DISABLE_FLOAT_API
518	/* Don't use more than 60 ms for the frame size analysis */
519	#define MAX_DYNAMIC_FRAMESIZE24 24
520	/* Estimates how much the bitrate will be boosted based on the sub-frame energy */
521	static float transient_boost(const float E, const float E_1, int LM, int maxM)
522	{
523	int i;
524	int M;
525	float sumE=0, sumE_1=0;
526	float metric;
527
528	M = IMIN(maxM, (1<<LM)+1)((maxM) < ((1<<LM)+1) ? (maxM) : ((1<<LM)+1));
529	for (i=0;i<M;i++)
530	{
531	sumE += E[i];
532	sumE_1 += E_1[i];
533	}
534	metric = sumEsumE_1/(MM);
535	/*if (LM==3)
536	printf("%f\n", metric);*/
537	/return metric>10 ? 1 : 0;/
538	/return MAX16(0,1-exp(-.25(metric-2.)));*/
539	return MIN16(1,(float)sqrt(MAX16(0,.05f(metric-2))))((1) < ((float)sqrt(((0) > (.05f(metric-2)) ? (0) : (.05f (metric-2))))) ? (1) : ((float)sqrt(((0) > (.05f(metric- 2)) ? (0) : (.05f*(metric-2))))));
540	}
541
542	/* Viterbi decoding trying to find the best frame size combination using look-ahead
543
544	State numbering:
545	0: unused
546	1: 2.5 ms
547	2: 5 ms (#1)
548	3: 5 ms (#2)
549	4: 10 ms (#1)
550	5: 10 ms (#2)
551	6: 10 ms (#3)
552	7: 10 ms (#4)
553	8: 20 ms (#1)
554	9: 20 ms (#2)
555	10: 20 ms (#3)
556	11: 20 ms (#4)
557	12: 20 ms (#5)
558	13: 20 ms (#6)
559	14: 20 ms (#7)
560	15: 20 ms (#8)
561	*/
562	static int transient_viterbi(const float E, const float E_1, int N, int frame_cost, int rate)
563	{
564	int i;
565	float cost[MAX_DYNAMIC_FRAMESIZE24][16];
566	int states[MAX_DYNAMIC_FRAMESIZE24][16];
567	float best_cost;
568	int best_state;
569	float factor;
570	/* Take into account that we damp VBR in the 32 kb/s to 64 kb/s range. */
571	if (rate<80)
572	factor=0;
573	else if (rate>160)
574	factor=1;
575	else
576	factor = (rate-80.f)/80.f;
577	/* Makes variable framesize less aggressive at lower bitrates, but I can't
578	find any valid theoretical justification for this (other than it seems
579	to help) */
580	for (i=0;i<16;i++)
581	{
582	/* Impossible state */
583	states[0][i] = -1;
584	cost[0][i] = 1e10;
585	}
586	for (i=0;i<4;i++)
587	{
588	cost[0][1<<i] = (frame_cost + rate(1<<i))(1+factor*transient_boost(E, E_1, i, N+1));
589	states[0][1<<i] = i;
590	}
591	for (i=1;i<N;i++)
592	{
593	int j;
594
595	/* Follow continuations */
596	for (j=2;j<16;j++)
597	{
598	cost[i][j] = cost[i-1][j-1];
599	states[i][j] = j-1;
600	}
601
602	/* New frames */
603	for(j=0;j<4;j++)
604	{
605	int k;
606	float min_cost;
607	float curr_cost;
608	states[i][1<<j] = 1;
609	min_cost = cost[i-1][1];
610	for(k=1;k<4;k++)
611	{
612	float tmp = cost[i-1][(1<<(k+1))-1];
613	if (tmp < min_cost)
614	{
615	states[i][1<<j] = (1<<(k+1))-1;
616	min_cost = tmp;
617	}
618	}
619	curr_cost = (frame_cost + rate(1<<j))(1+factor*transient_boost(E+i, E_1+i, j, N-i+1));
620	cost[i][1<<j] = min_cost;
621	/* If part of the frame is outside the analysis window, only count part of the cost */
622	if (N-i < (1<<j))
623	cost[i][1<<j] += curr_cost*(float)(N-i)/(1<<j);
624	else
625	cost[i][1<<j] += curr_cost;
626	}
627	}
628
629	best_state=1;
630	best_cost = cost[N-1][1];
631	/* Find best end state (doesn't force a frame to end at N-1) */
632	for (i=2;i<16;i++)
633	{
634	if (cost[N-1][i]<best_cost)
635	{
636	best_cost = cost[N-1][i];
637	best_state = i;
638	}
639	}
640
641	/* Follow transitions back */
642	for (i=N-1;i>=0;i--)
643	{
644	/printf("%d ", best_state);/
645	best_state = states[i][best_state];
646	}
647	/printf("%d\n", best_state);/
648	return best_state;
649	}
650
651	int optimize_framesize(const opus_val16 *x, int len, int C, opus_int32 Fs,
652	int bitrate, opus_val16 tonality, float *mem, int buffering,
653	downmix_func downmix)
654	{
655	int N;
656	int i;
657	float e[MAX_DYNAMIC_FRAMESIZE24+4];
658	float e_1[MAX_DYNAMIC_FRAMESIZE24+3];
659	opus_val32 memx;
660	int bestLM=0;
661	int subframe;
662	int pos;
663	VARDECL(opus_val32, sub);
664
665	subframe = Fs/400;
666	ALLOC(sub, subframe, opus_val32)opus_val32 sub[subframe];
667	e[0]=mem[0];
668	e_1[0]=1.f/(EPSILON1e-15f+mem[0]);
669	if (buffering)
670	{
671	/* Consider the CELT delay when not in restricted-lowdelay */
672	/* We assume the buffering is between 2.5 and 5 ms */
673	int offset = 2*subframe - buffering;
674	celt_assert(offset>=0 && offset <= subframe);
675	x += C*offset;
676	len -= offset;
677	e[1]=mem[1];
678	e_1[1]=1.f/(EPSILON1e-15f+mem[1]);
679	e[2]=mem[2];
680	e_1[2]=1.f/(EPSILON1e-15f+mem[2]);
681	pos = 3;
682	} else {
683	pos=1;
684	}
685	N=IMIN(len/subframe, MAX_DYNAMIC_FRAMESIZE)((len/subframe) < (24) ? (len/subframe) : (24));
686	/* Just silencing a warning, it's really initialized later */
687	memx = 0;
688	for (i=0;i<N;i++)
689	{
690	float tmp;
691	opus_val32 tmpx;
692	int j;
693	tmp=EPSILON1e-15f;
694
695	downmix(x, sub, subframe, i*subframe, 0, -2, C);
696	if (i==0)
697	memx = sub[0];
698	for (j=0;j<subframe;j++)
699	{
700	tmpx = sub[j];
701	tmp += (tmpx-memx)*(float)(tmpx-memx);
702	memx = tmpx;
703	}
704	e[i+pos] = tmp;
705	e_1[i+pos] = 1.f/tmp;
706	}
707	/* Hack to get 20 ms working with APPLICATION_AUDIO
708	The real problem is that the corresponding memory needs to use 1.5 ms
709	from this frame and 1 ms from the next frame */
710	e[i+pos] = e[i+pos-1];
711	if (buffering)
712	N=IMIN(MAX_DYNAMIC_FRAMESIZE, N+2)((24) < (N+2) ? (24) : (N+2));
713	bestLM = transient_viterbi(e, e_1, N, (int)((1.f+.5ftonality)(60*C+40)), bitrate/400);
714	mem[0] = e[1<<bestLM];
715	if (buffering)
716	{
717	mem[1] = e[(1<<bestLM)+1];
718	mem[2] = e[(1<<bestLM)+2];
719	}
720	return bestLM;
721	}
722
723	#endif
724
725	#ifndef DISABLE_FLOAT_API
726	#ifdef FIXED_POINT
727	#define PCM2VAL(x)((x)*32768.f) FLOAT2INT16(x)
728	#else
729	#define PCM2VAL(x)((x)32768.f) SCALEIN(x)((x)32768.f)
730	#endif
731	void downmix_float(const void _x, opus_val32 sub, int subframe, int offset, int c1, int c2, int C)
732	{
733	const float *x;
734	opus_val32 scale;
735	int j;
736	x = (const float *)_x;
737	for (j=0;j<subframe;j++)
738	sub[j] = PCM2VAL(x[(j+offset)C+c1])((x[(j+offset)C+c1])*32768.f);
739	if (c2>-1)
740	{
741	for (j=0;j<subframe;j++)
742	sub[j] += PCM2VAL(x[(j+offset)C+c2])((x[(j+offset)C+c2])*32768.f);
743	} else if (c2==-2)
744	{
745	int c;
746	for (c=1;c<C;c++)
747	{
748	for (j=0;j<subframe;j++)
749	sub[j] += PCM2VAL(x[(j+offset)C+c])((x[(j+offset)C+c])*32768.f);
750	}
751	}
752	#ifdef FIXED_POINT
753	scale = (1<<SIG_SHIFT);
754	#else
755	scale = 1.f;
756	#endif
757	if (C==-2)
758	scale /= C;
759	else
760	scale /= 2;
761	for (j=0;j<subframe;j++)
762	sub[j] *= scale;
763	}
764	#endif
765
766	void downmix_int(const void _x, opus_val32 sub, int subframe, int offset, int c1, int c2, int C)
767	{
768	const opus_int16 *x;
769	opus_val32 scale;
770	int j;
771	x = (const opus_int16 *)_x;
772	for (j=0;j<subframe;j++)
773	sub[j] = x[(j+offset)*C+c1];
774	if (c2>-1)
775	{
776	for (j=0;j<subframe;j++)
777	sub[j] += x[(j+offset)*C+c2];
778	} else if (c2==-2)
779	{
780	int c;
781	for (c=1;c<C;c++)
782	{
783	for (j=0;j<subframe;j++)
784	sub[j] += x[(j+offset)*C+c];
785	}
786	}
787	#ifdef FIXED_POINT
788	scale = (1<<SIG_SHIFT);
789	#else
790	scale = 1.f/32768;
791	#endif
792	if (C==-2)
793	scale /= C;
794	else
795	scale /= 2;
796	for (j=0;j<subframe;j++)
797	sub[j] *= scale;
798	}
799
800	opus_int32 frame_size_select(opus_int32 frame_size, int variable_duration, opus_int32 Fs)
801	{
802	int new_size;
803	if (frame_size<Fs/400)
804	return -1;
805	if (variable_duration == OPUS_FRAMESIZE_ARG5000)
806	new_size = frame_size;
807	else if (variable_duration == OPUS_FRAMESIZE_VARIABLE5010)
808	new_size = Fs/50;
809	else if (variable_duration >= OPUS_FRAMESIZE_2_5_MS5001 && variable_duration <= OPUS_FRAMESIZE_60_MS5006)
810	new_size = IMIN(3Fs/50, (Fs/400)<<(variable_duration-OPUS_FRAMESIZE_2_5_MS))((3Fs/50) < ((Fs/400)<<(variable_duration-5001)) ? ( 3*Fs/50) : ((Fs/400)<<(variable_duration-5001)));
811	else
812	return -1;
813	if (new_size>frame_size)
814	return -1;
815	if (400new_size!=Fs && 200new_size!=Fs && 100*new_size!=Fs &&
816	50new_size!=Fs && 25new_size!=Fs && 50new_size!=3Fs)
817	return -1;
818	return new_size;
819	}
820
821	opus_int32 compute_frame_size(const void *analysis_pcm, int frame_size,
822	int variable_duration, int C, opus_int32 Fs, int bitrate_bps,
823	int delay_compensation, downmix_func downmix
824	#ifndef DISABLE_FLOAT_API
825	, float *subframe_mem
826	#endif
827	)
828	{
829	#ifndef DISABLE_FLOAT_API
830	if (variable_duration == OPUS_FRAMESIZE_VARIABLE5010 && frame_size >= Fs/200)
831	{
832	int LM = 3;
833	LM = optimize_framesize(analysis_pcm, frame_size, C, Fs, bitrate_bps,
834	0, subframe_mem, delay_compensation, downmix);
835	while ((Fs/400<<LM)>frame_size)
836	LM--;
837	frame_size = (Fs/400<<LM);
838	} else
839	#endif
840	{
841	frame_size = frame_size_select(frame_size, variable_duration, Fs);
842	}
843	if (frame_size<0)
844	return -1;
845	return frame_size;
846	}
847
848	opus_val16 compute_stereo_width(const opus_val16 pcm, int frame_size, opus_int32 Fs, StereoWidthState mem)
849	{
850	opus_val16 corr;
851	opus_val16 ldiff;
852	opus_val16 width;
853	opus_val32 xx, xy, yy;
854	opus_val16 sqrt_xx, sqrt_yy;
855	opus_val16 qrrt_xx, qrrt_yy;
856	int frame_rate;
857	int i;
858	opus_val16 short_alpha;
859
860	frame_rate = Fs/frame_size;
861	short_alpha = Q15ONE1.0f - 25*Q15ONE1.0f/IMAX(50,frame_rate)((50) > (frame_rate) ? (50) : (frame_rate));
862	xx=xy=yy=0;
863	for (i=0;i<frame_size;i+=4)
864	{
865	opus_val32 pxx=0;
866	opus_val32 pxy=0;
867	opus_val32 pyy=0;
868	opus_val16 x, y;
869	x = pcm[2*i];
870	y = pcm[2*i+1];
871	pxx = SHR32(MULT16_16(x,x),2)(((opus_val32)(x)*(opus_val32)(x)));
872	pxy = SHR32(MULT16_16(x,y),2)(((opus_val32)(x)*(opus_val32)(y)));
873	pyy = SHR32(MULT16_16(y,y),2)(((opus_val32)(y)*(opus_val32)(y)));
874	x = pcm[2*i+2];
875	y = pcm[2*i+3];
876	pxx += SHR32(MULT16_16(x,x),2)(((opus_val32)(x)*(opus_val32)(x)));
877	pxy += SHR32(MULT16_16(x,y),2)(((opus_val32)(x)*(opus_val32)(y)));
878	pyy += SHR32(MULT16_16(y,y),2)(((opus_val32)(y)*(opus_val32)(y)));
879	x = pcm[2*i+4];
880	y = pcm[2*i+5];
881	pxx += SHR32(MULT16_16(x,x),2)(((opus_val32)(x)*(opus_val32)(x)));
882	pxy += SHR32(MULT16_16(x,y),2)(((opus_val32)(x)*(opus_val32)(y)));
883	pyy += SHR32(MULT16_16(y,y),2)(((opus_val32)(y)*(opus_val32)(y)));
884	x = pcm[2*i+6];
885	y = pcm[2*i+7];
886	pxx += SHR32(MULT16_16(x,x),2)(((opus_val32)(x)*(opus_val32)(x)));
887	pxy += SHR32(MULT16_16(x,y),2)(((opus_val32)(x)*(opus_val32)(y)));
888	pyy += SHR32(MULT16_16(y,y),2)(((opus_val32)(y)*(opus_val32)(y)));
889
890	xx += SHR32(pxx, 10)(pxx);
891	xy += SHR32(pxy, 10)(pxy);
892	yy += SHR32(pyy, 10)(pyy);
893	}
894	mem->XX += MULT16_32_Q15(short_alpha, xx-mem->XX)((short_alpha)*(xx-mem->XX));
895	mem->XY += MULT16_32_Q15(short_alpha, xy-mem->XY)((short_alpha)*(xy-mem->XY));
896	mem->YY += MULT16_32_Q15(short_alpha, yy-mem->YY)((short_alpha)*(yy-mem->YY));
897	mem->XX = MAX32(0, mem->XX)((0) > (mem->XX) ? (0) : (mem->XX));
898	mem->XY = MAX32(0, mem->XY)((0) > (mem->XY) ? (0) : (mem->XY));
899	mem->YY = MAX32(0, mem->YY)((0) > (mem->YY) ? (0) : (mem->YY));
900	if (MAX32(mem->XX, mem->YY)((mem->XX) > (mem->YY) ? (mem->XX) : (mem->YY) )>QCONST16(8e-4f, 18)(8e-4f))
901	{
902	sqrt_xx = celt_sqrt(mem->XX)((float)sqrt(mem->XX));
903	sqrt_yy = celt_sqrt(mem->YY)((float)sqrt(mem->YY));
904	qrrt_xx = celt_sqrt(sqrt_xx)((float)sqrt(sqrt_xx));
905	qrrt_yy = celt_sqrt(sqrt_yy)((float)sqrt(sqrt_yy));
906	/* Inter-channel correlation */
907	mem->XY = MIN32(mem->XY, sqrt_xxsqrt_yy)((mem->XY) < (sqrt_xxsqrt_yy) ? (mem->XY) : (sqrt_xx *sqrt_yy));
908	corr = SHR32(frac_div32(mem->XY,EPSILON+MULT16_16(sqrt_xx,sqrt_yy)),16)(((float)(mem->XY)/(1e-15f +((opus_val32)(sqrt_xx)*(opus_val32 )(sqrt_yy)))));
909	/* Approximate loudness difference */
910	ldiff = Q15ONE1.0f*ABS16(qrrt_xx-qrrt_yy)((qrrt_xx-qrrt_yy) < 0 ? (-(qrrt_xx-qrrt_yy)) : (qrrt_xx-qrrt_yy ))/(EPSILON1e-15f+qrrt_xx+qrrt_yy);
911	width = MULT16_16_Q15(celt_sqrt(QCONST32(1.f,30)-MULT16_16(corr,corr)), ldiff)((((float)sqrt((1.f)-((opus_val32)(corr)(opus_val32)(corr))) ))(ldiff));
912	/* Smoothing over one second */
913	mem->smoothed_width += (width-mem->smoothed_width)/frame_rate;
914	/* Peak follower */
915	mem->max_follower = MAX16(mem->max_follower-QCONST16(.02f,15)/frame_rate, mem->smoothed_width)((mem->max_follower-(.02f)/frame_rate) > (mem->smoothed_width ) ? (mem->max_follower-(.02f)/frame_rate) : (mem->smoothed_width ));
916	} else {
917	width = 0;
918	corr=Q15ONE1.0f;
	Value stored to 'corr' is never read
919	ldiff=0;
920	}
921	/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);/
922	return EXTRACT16(MIN32(Q15ONE,20mem->max_follower))(((1.0f) < (20mem->max_follower) ? (1.0f) : (20*mem-> max_follower)));
923	}
924
925	opus_int32 opus_encode_native(OpusEncoder st, const opus_val16 pcm, int frame_size,
926	unsigned char *data, opus_int32 out_data_bytes, int lsb_depth,
927	const void *analysis_pcm, opus_int32 analysis_size, int c1, int c2, int analysis_channels, downmix_func downmix)
928	{
929	void *silk_enc;
930	CELTEncoderOpusCustomEncoder *celt_enc;
931	int i;
932	int ret=0;
933	opus_int32 nBytes;
934	ec_enc enc;
935	int bytes_target;
936	int prefill=0;
937	int start_band = 0;
938	int redundancy = 0;
939	int redundancy_bytes = 0; /* Number of bytes to use for redundancy frame */
940	int celt_to_silk = 0;
941	VARDECL(opus_val16, pcm_buf);
942	int nb_compr_bytes;
943	int to_celt = 0;
944	opus_uint32 redundant_rng = 0;
945	int cutoff_Hz, hp_freq_smth1;
946	int voice_est; /* Probability of voice in Q7 */
947	opus_int32 equiv_rate;
948	int delay_compensation;
949	int frame_rate;
950	opus_int32 max_rate; /* Max bitrate we're allowed to use */
951	int curr_bandwidth;
952	opus_val16 HB_gain;
953	opus_int32 max_data_bytes; /* Max number of bytes we're allowed to use */
954	int total_buffer;
955	opus_val16 stereo_width;
956	const CELTModeOpusCustomMode *celt_mode;
957	AnalysisInfo analysis_info;
958	int analysis_read_pos_bak=-1;
959	int analysis_read_subframe_bak=-1;
960	VARDECL(opus_val16, tmp_prefill);
961
962	ALLOC_STACK;
963
964	max_data_bytes = IMIN(1276, out_data_bytes)((1276) < (out_data_bytes) ? (1276) : (out_data_bytes));
965
966	st->rangeFinal = 0;
967	if ((!st->variable_duration && 400frame_size != st->Fs && 200frame_size != st->Fs && 100*frame_size != st->Fs &&
968	50frame_size != st->Fs && 25frame_size != st->Fs && 50frame_size != 3st->Fs)
969	\|\| (400*frame_size < st->Fs)
970	\|\| max_data_bytes<=0
971	)
972	{
973	RESTORE_STACK;
974	return OPUS_BAD_ARG-1;
975	}
976	silk_enc = (char*)st+st->silk_enc_offset;
977	celt_enc = (CELTEncoderOpusCustomEncoder)((char)st+st->celt_enc_offset);
978	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
979	delay_compensation = 0;
980	else
981	delay_compensation = st->delay_compensation;
982
983	lsb_depth = IMIN(lsb_depth, st->lsb_depth)((lsb_depth) < (st->lsb_depth) ? (lsb_depth) : (st-> lsb_depth));
984
985	analysis_info.valid = 0;
986	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_GET_MODE(&celt_mode)10015, ((&celt_mode) + ((&celt_mode) - (const OpusCustomMode **)(&celt_mode))));
987	#ifndef DISABLE_FLOAT_API
988	#ifdef FIXED_POINT
989	if (st->silk_mode.complexity >= 10 && st->Fs==48000)
990	#else
991	if (st->silk_mode.complexity >= 7 && st->Fs==48000)
992	#endif
993	{
994	analysis_read_pos_bak = st->analysis.read_pos;
995	analysis_read_subframe_bak = st->analysis.read_subframe;
996	run_analysis(&st->analysis, celt_mode, analysis_pcm, analysis_size, frame_size,
997	c1, c2, analysis_channels, st->Fs,
998	lsb_depth, downmix, &analysis_info);
999	}
1000	#endif
1001
1002	st->voice_ratio = -1;
1003
1004	#ifndef DISABLE_FLOAT_API
1005	st->detected_bandwidth = 0;
1006	if (analysis_info.valid)
1007	{
1008	int analysis_bandwidth;
1009	if (st->signal_type == OPUS_AUTO-1000)
1010	st->voice_ratio = (int)floor(.5+100*(1-analysis_info.music_prob));
1011
1012	analysis_bandwidth = analysis_info.bandwidth;
1013	if (analysis_bandwidth<=12)
1014	st->detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND1101;
1015	else if (analysis_bandwidth<=14)
1016	st->detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND1102;
1017	else if (analysis_bandwidth<=16)
1018	st->detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1019	else if (analysis_bandwidth<=18)
1020	st->detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND1104;
1021	else
1022	st->detected_bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
1023	}
1024	#endif
1025
1026	if (st->channels==2 && st->force_channels!=1)
1027	stereo_width = compute_stereo_width(pcm, frame_size, st->Fs, &st->width_mem);
1028	else
1029	stereo_width = 0;
1030	total_buffer = delay_compensation;
1031	st->bitrate_bps = user_bitrate_to_bitrate(st, frame_size, max_data_bytes);
1032
1033	frame_rate = st->Fs/frame_size;
1034	if (max_data_bytes<3 \|\| st->bitrate_bps < 3frame_rate8
1035	\|\| (frame_rate<50 && (max_data_bytes*frame_rate<300 \|\| st->bitrate_bps < 2400)))
1036	{
1037	/If the space is too low to do something useful, emit 'PLC' frames./
1038	int tocmode = st->mode;
1039	int bw = st->bandwidth == 0 ? OPUS_BANDWIDTH_NARROWBAND1101 : st->bandwidth;
1040	if (tocmode==0)
1041	tocmode = MODE_SILK_ONLY1000;
1042	if (frame_rate>100)
1043	tocmode = MODE_CELT_ONLY1002;
1044	if (frame_rate < 50)
1045	tocmode = MODE_SILK_ONLY1000;
1046	if(tocmode==MODE_SILK_ONLY1000&&bw>OPUS_BANDWIDTH_WIDEBAND1103)
1047	bw=OPUS_BANDWIDTH_WIDEBAND1103;
1048	else if (tocmode==MODE_CELT_ONLY1002&&bw==OPUS_BANDWIDTH_MEDIUMBAND1102)
1049	bw=OPUS_BANDWIDTH_NARROWBAND1101;
1050	else if (bw<=OPUS_BANDWIDTH_SUPERWIDEBAND1104)
1051	bw=OPUS_BANDWIDTH_SUPERWIDEBAND1104;
1052	data[0] = gen_toc(tocmode, frame_rate, bw, st->stream_channels);
1053	RESTORE_STACK;
1054	return 1;
1055	}
1056	if (!st->use_vbr)
1057	{
1058	int cbrBytes;
1059	cbrBytes = IMIN( (st->bitrate_bps + 4frame_rate)/(8frame_rate) , max_data_bytes)(((st->bitrate_bps + 4frame_rate)/(8frame_rate)) < (max_data_bytes ) ? ((st->bitrate_bps + 4frame_rate)/(8frame_rate)) : (max_data_bytes ));
1060	st->bitrate_bps = cbrBytes * (8*frame_rate);
1061	max_data_bytes = cbrBytes;
1062	}
1063	max_rate = frame_ratemax_data_bytes8;
1064
1065	/* Equivalent 20-ms rate for mode/channel/bandwidth decisions */
1066	equiv_rate = st->bitrate_bps - (40st->channels+20)(st->Fs/frame_size - 50);
1067
1068	if (st->signal_type == OPUS_SIGNAL_VOICE3001)
1069	voice_est = 127;
1070	else if (st->signal_type == OPUS_SIGNAL_MUSIC3002)
1071	voice_est = 0;
1072	else if (st->voice_ratio >= 0)
1073	{
1074	voice_est = st->voice_ratio*327>>8;
1075	/* For AUDIO, never be more than 90% confident of having speech */
1076	if (st->application == OPUS_APPLICATION_AUDIO2049)
1077	voice_est = IMIN(voice_est, 115)((voice_est) < (115) ? (voice_est) : (115));
1078	} else if (st->application == OPUS_APPLICATION_VOIP2048)
1079	voice_est = 115;
1080	else
1081	voice_est = 48;
1082
1083	if (st->force_channels!=OPUS_AUTO-1000 && st->channels == 2)
1084	{
1085	st->stream_channels = st->force_channels;
1086	} else {
1087	#ifdef FUZZING
1088	/* Random mono/stereo decision */
1089	if (st->channels == 2 && (rand()&0x1F)==0)
1090	st->stream_channels = 3-st->stream_channels;
1091	#else
1092	/* Rate-dependent mono-stereo decision */
1093	if (st->channels == 2)
1094	{
1095	opus_int32 stereo_threshold;
1096	stereo_threshold = stereo_music_threshold + ((voice_estvoice_est(stereo_voice_threshold-stereo_music_threshold))>>14);
1097	if (st->stream_channels == 2)
1098	stereo_threshold -= 1000;
1099	else
1100	stereo_threshold += 1000;
1101	st->stream_channels = (equiv_rate > stereo_threshold) ? 2 : 1;
1102	} else {
1103	st->stream_channels = st->channels;
1104	}
1105	#endif
1106	}
1107	equiv_rate = st->bitrate_bps - (40st->stream_channels+20)(st->Fs/frame_size - 50);
1108
1109	/* Mode selection depending on application and signal type */
1110	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
1111	{
1112	st->mode = MODE_CELT_ONLY1002;
1113	} else if (st->user_forced_mode == OPUS_AUTO-1000)
1114	{
1115	#ifdef FUZZING
1116	/* Random mode switching */
1117	if ((rand()&0xF)==0)
1118	{
1119	if ((rand()&0x1)==0)
1120	st->mode = MODE_CELT_ONLY1002;
1121	else
1122	st->mode = MODE_SILK_ONLY1000;
1123	} else {
1124	if (st->prev_mode==MODE_CELT_ONLY1002)
1125	st->mode = MODE_CELT_ONLY1002;
1126	else
1127	st->mode = MODE_SILK_ONLY1000;
1128	}
1129	#else
1130	opus_int32 mode_voice, mode_music;
1131	opus_int32 threshold;
1132
1133	/* Interpolate based on stereo width */
1134	mode_voice = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[0][0])((1.0f -stereo_width)*(mode_thresholds[0][0]))
1135	+ MULT16_32_Q15(stereo_width,mode_thresholds[1][0])((stereo_width)*(mode_thresholds[1][0])));
1136	mode_music = (opus_int32)(MULT16_32_Q15(Q15ONE-stereo_width,mode_thresholds[1][1])((1.0f -stereo_width)*(mode_thresholds[1][1]))
1137	+ MULT16_32_Q15(stereo_width,mode_thresholds[1][1])((stereo_width)*(mode_thresholds[1][1])));
1138	/* Interpolate based on speech/music probability */
1139	threshold = mode_music + ((voice_estvoice_est(mode_voice-mode_music))>>14);
1140	/* Bias towards SILK for VoIP because of some useful features */
1141	if (st->application == OPUS_APPLICATION_VOIP2048)
1142	threshold += 8000;
1143
1144	/printf("%f %d\n", stereo_width/(float)Q15ONE, threshold);/
1145	/* Hysteresis */
1146	if (st->prev_mode == MODE_CELT_ONLY1002)
1147	threshold -= 4000;
1148	else if (st->prev_mode>0)
1149	threshold += 4000;
1150
1151	st->mode = (equiv_rate >= threshold) ? MODE_CELT_ONLY1002: MODE_SILK_ONLY1000;
1152
1153	/* When FEC is enabled and there's enough packet loss, use SILK */
1154	if (st->silk_mode.useInBandFEC && st->silk_mode.packetLossPercentage > (128-voice_est)>>4)
1155	st->mode = MODE_SILK_ONLY1000;
1156	/* When encoding voice and DTX is enabled, set the encoder to SILK mode (at least for now) */
1157	if (st->silk_mode.useDTX && voice_est > 100)
1158	st->mode = MODE_SILK_ONLY1000;
1159	#endif
1160	} else {
1161	st->mode = st->user_forced_mode;
1162	}
1163
1164	/* Override the chosen mode to make sure we meet the requested frame size */
1165	if (st->mode != MODE_CELT_ONLY1002 && frame_size < st->Fs/100)
1166	st->mode = MODE_CELT_ONLY1002;
1167	if (st->lfe)
1168	st->mode = MODE_CELT_ONLY1002;
1169	/* If max_data_bytes represents less than 8 kb/s, switch to CELT-only mode */
1170	if (max_data_bytes < (frame_rate > 50 ? 12000 : 8000)frame_size / (st->Fs 8))
1171	st->mode = MODE_CELT_ONLY1002;
1172
1173	if (st->stream_channels == 1 && st->prev_channels ==2 && st->silk_mode.toMono==0
1174	&& st->mode != MODE_CELT_ONLY1002 && st->prev_mode != MODE_CELT_ONLY1002)
1175	{
1176	/* Delay stereo->mono transition by two frames so that SILK can do a smooth downmix */
1177	st->silk_mode.toMono = 1;
1178	st->stream_channels = 2;
1179	} else {
1180	st->silk_mode.toMono = 0;
1181	}
1182
1183	if (st->prev_mode > 0 &&
1184	((st->mode != MODE_CELT_ONLY1002 && st->prev_mode == MODE_CELT_ONLY1002) \|\|
1185	(st->mode == MODE_CELT_ONLY1002 && st->prev_mode != MODE_CELT_ONLY1002)))
1186	{
1187	redundancy = 1;
1188	celt_to_silk = (st->mode != MODE_CELT_ONLY1002);
1189	if (!celt_to_silk)
1190	{
1191	/* Switch to SILK/hybrid if frame size is 10 ms or more*/
1192	if (frame_size >= st->Fs/100)
1193	{
1194	st->mode = st->prev_mode;
1195	to_celt = 1;
1196	} else {
1197	redundancy=0;
1198	}
1199	}
1200	}
1201	/* For the first frame at a new SILK bandwidth */
1202	if (st->silk_bw_switch)
1203	{
1204	redundancy = 1;
1205	celt_to_silk = 1;
1206	st->silk_bw_switch = 0;
1207	prefill=1;
1208	}
1209
1210	if (redundancy)
1211	{
1212	/* Fair share of the max size allowed */
1213	redundancy_bytes = IMIN(257, max_data_bytes(opus_int32)(st->Fs/200)/(frame_size+st->Fs/200))((257) < (max_data_bytes(opus_int32)(st->Fs/200)/(frame_size +st->Fs/200)) ? (257) : (max_data_bytes*(opus_int32)(st-> Fs/200)/(frame_size+st->Fs/200)));
1214	/* For VBR, target the actual bitrate (subject to the limit above) */
1215	if (st->use_vbr)
1216	redundancy_bytes = IMIN(redundancy_bytes, st->bitrate_bps/1600)((redundancy_bytes) < (st->bitrate_bps/1600) ? (redundancy_bytes ) : (st->bitrate_bps/1600));
1217	}
1218
1219	if (st->mode != MODE_CELT_ONLY1002 && st->prev_mode == MODE_CELT_ONLY1002)
1220	{
1221	silk_EncControlStruct dummy;
1222	silk_InitEncoder( silk_enc, st->arch, &dummy);
1223	prefill=1;
1224	}
1225
1226	/* Automatic (rate-dependent) bandwidth selection */
1227	if (st->mode == MODE_CELT_ONLY1002 \|\| st->first \|\| st->silk_mode.allowBandwidthSwitch)
1228	{
1229	const opus_int32 voice_bandwidth_thresholds, music_bandwidth_thresholds;
1230	opus_int32 bandwidth_thresholds[8];
1231	int bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
1232	opus_int32 equiv_rate2;
1233
1234	equiv_rate2 = equiv_rate;
1235	if (st->mode != MODE_CELT_ONLY1002)
1236	{
1237	/* Adjust the threshold +/- 10% depending on complexity */
1238	equiv_rate2 = equiv_rate2 * (45+st->silk_mode.complexity)/50;
1239	/* CBR is less efficient by ~1 kb/s */
1240	if (!st->use_vbr)
1241	equiv_rate2 -= 1000;
1242	}
1243	if (st->channels==2 && st->force_channels!=1)
1244	{
1245	voice_bandwidth_thresholds = stereo_voice_bandwidth_thresholds;
1246	music_bandwidth_thresholds = stereo_music_bandwidth_thresholds;
1247	} else {
1248	voice_bandwidth_thresholds = mono_voice_bandwidth_thresholds;
1249	music_bandwidth_thresholds = mono_music_bandwidth_thresholds;
1250	}
1251	/* Interpolate bandwidth thresholds depending on voice estimation */
1252	for (i=0;i<8;i++)
1253	{
1254	bandwidth_thresholds[i] = music_bandwidth_thresholds[i]
1255	+ ((voice_estvoice_est(voice_bandwidth_thresholds[i]-music_bandwidth_thresholds[i]))>>14);
1256	}
1257	do {
1258	int threshold, hysteresis;
1259	threshold = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND1102)];
1260	hysteresis = bandwidth_thresholds[2*(bandwidth-OPUS_BANDWIDTH_MEDIUMBAND1102)+1];
1261	if (!st->first)
1262	{
1263	if (st->bandwidth >= bandwidth)
1264	threshold -= hysteresis;
1265	else
1266	threshold += hysteresis;
1267	}
1268	if (equiv_rate2 >= threshold)
1269	break;
1270	} while (--bandwidth>OPUS_BANDWIDTH_NARROWBAND1101);
1271	st->bandwidth = bandwidth;
1272	/* Prevents any transition to SWB/FB until the SILK layer has fully
1273	switched to WB mode and turned the variable LP filter off */
1274	if (!st->first && st->mode != MODE_CELT_ONLY1002 && !st->silk_mode.inWBmodeWithoutVariableLP && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND1103)
1275	st->bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1276	}
1277
1278	if (st->bandwidth>st->max_bandwidth)
1279	st->bandwidth = st->max_bandwidth;
1280
1281	if (st->user_bandwidth != OPUS_AUTO-1000)
1282	st->bandwidth = st->user_bandwidth;
1283
1284	/* This prevents us from using hybrid at unsafe CBR/max rates */
1285	if (st->mode != MODE_CELT_ONLY1002 && max_rate < 15000)
1286	{
1287	st->bandwidth = IMIN(st->bandwidth, OPUS_BANDWIDTH_WIDEBAND)((st->bandwidth) < (1103) ? (st->bandwidth) : (1103) );
1288	}
1289
1290	/* Prevents Opus from wasting bits on frequencies that are above
1291	the Nyquist rate of the input signal */
1292	if (st->Fs <= 24000 && st->bandwidth > OPUS_BANDWIDTH_SUPERWIDEBAND1104)
1293	st->bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND1104;
1294	if (st->Fs <= 16000 && st->bandwidth > OPUS_BANDWIDTH_WIDEBAND1103)
1295	st->bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1296	if (st->Fs <= 12000 && st->bandwidth > OPUS_BANDWIDTH_MEDIUMBAND1102)
1297	st->bandwidth = OPUS_BANDWIDTH_MEDIUMBAND1102;
1298	if (st->Fs <= 8000 && st->bandwidth > OPUS_BANDWIDTH_NARROWBAND1101)
1299	st->bandwidth = OPUS_BANDWIDTH_NARROWBAND1101;
1300	#ifndef DISABLE_FLOAT_API
1301	/* Use detected bandwidth to reduce the encoded bandwidth. */
1302	if (st->detected_bandwidth && st->user_bandwidth == OPUS_AUTO-1000)
1303	{
1304	int min_detected_bandwidth;
1305	/* Makes bandwidth detection more conservative just in case the detector
1306	gets it wrong when we could have coded a high bandwidth transparently.
1307	When operating in SILK/hybrid mode, we don't go below wideband to avoid
1308	more complicated switches that require redundancy. */
1309	if (equiv_rate <= 18000*st->stream_channels && st->mode == MODE_CELT_ONLY1002)
1310	min_detected_bandwidth = OPUS_BANDWIDTH_NARROWBAND1101;
1311	else if (equiv_rate <= 24000*st->stream_channels && st->mode == MODE_CELT_ONLY1002)
1312	min_detected_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND1102;
1313	else if (equiv_rate <= 30000*st->stream_channels)
1314	min_detected_bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1315	else if (equiv_rate <= 44000*st->stream_channels)
1316	min_detected_bandwidth = OPUS_BANDWIDTH_SUPERWIDEBAND1104;
1317	else
1318	min_detected_bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
1319
1320	st->detected_bandwidth = IMAX(st->detected_bandwidth, min_detected_bandwidth)((st->detected_bandwidth) > (min_detected_bandwidth) ? ( st->detected_bandwidth) : (min_detected_bandwidth));
1321	st->bandwidth = IMIN(st->bandwidth, st->detected_bandwidth)((st->bandwidth) < (st->detected_bandwidth) ? (st-> bandwidth) : (st->detected_bandwidth));
1322	}
1323	#endif
1324	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_LSB_DEPTH(lsb_depth)4036, (((void)((lsb_depth) == (opus_int32)0)), (opus_int32)(lsb_depth )));
1325
1326	/* CELT mode doesn't support mediumband, use wideband instead */
1327	if (st->mode == MODE_CELT_ONLY1002 && st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND1102)
1328	st->bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1329	if (st->lfe)
1330	st->bandwidth = OPUS_BANDWIDTH_NARROWBAND1101;
1331
1332	/* Can't support higher than wideband for >20 ms frames */
1333	if (frame_size > st->Fs/50 && (st->mode == MODE_CELT_ONLY1002 \|\| st->bandwidth > OPUS_BANDWIDTH_WIDEBAND1103))
1334	{
1335	VARDECL(unsigned char, tmp_data);
1336	int nb_frames;
1337	int bak_mode, bak_bandwidth, bak_channels, bak_to_mono;
1338	VARDECL(OpusRepacketizer, rp);
1339	opus_int32 bytes_per_frame;
1340	opus_int32 repacketize_len;
1341
1342	#ifndef DISABLE_FLOAT_API
1343	if (analysis_read_pos_bak!= -1)
1344	{
1345	st->analysis.read_pos = analysis_read_pos_bak;
1346	st->analysis.read_subframe = analysis_read_subframe_bak;
1347	}
1348	#endif
1349
1350	nb_frames = frame_size > st->Fs/25 ? 3 : 2;
1351	bytes_per_frame = IMIN(1276,(out_data_bytes-3)/nb_frames)((1276) < ((out_data_bytes-3)/nb_frames) ? (1276) : ((out_data_bytes -3)/nb_frames));
1352
1353	ALLOC(tmp_data, nb_framesbytes_per_frame, unsigned char)unsigned char tmp_data[nb_framesbytes_per_frame];
1354
1355	ALLOC(rp, 1, OpusRepacketizer)OpusRepacketizer rp[1];
1356	opus_repacketizer_init(rp);
1357
1358	bak_mode = st->user_forced_mode;
1359	bak_bandwidth = st->user_bandwidth;
1360	bak_channels = st->force_channels;
1361
1362	st->user_forced_mode = st->mode;
1363	st->user_bandwidth = st->bandwidth;
1364	st->force_channels = st->stream_channels;
1365	bak_to_mono = st->silk_mode.toMono;
1366
1367	if (bak_to_mono)
1368	st->force_channels = 1;
1369	else
1370	st->prev_channels = st->stream_channels;
1371	for (i=0;i<nb_frames;i++)
1372	{
1373	int tmp_len;
1374	st->silk_mode.toMono = 0;
1375	/* When switching from SILK/Hybrid to CELT, only ask for a switch at the last frame */
1376	if (to_celt && i==nb_frames-1)
1377	st->user_forced_mode = MODE_CELT_ONLY1002;
1378	tmp_len = opus_encode_native(st, pcm+i(st->channelsst->Fs/50), st->Fs/50,
1379	tmp_data+i*bytes_per_frame, bytes_per_frame, lsb_depth,
1380	NULL((void*)0), 0, c1, c2, analysis_channels, downmix);
1381	if (tmp_len<0)
1382	{
1383	RESTORE_STACK;
1384	return OPUS_INTERNAL_ERROR-3;
1385	}
1386	ret = opus_repacketizer_cat(rp, tmp_data+i*bytes_per_frame, tmp_len);
1387	if (ret<0)
1388	{
1389	RESTORE_STACK;
1390	return OPUS_INTERNAL_ERROR-3;
1391	}
1392	}
1393	if (st->use_vbr)
1394	repacketize_len = out_data_bytes;
1395	else
1396	repacketize_len = IMIN(3st->bitrate_bps/(3850/nb_frames), out_data_bytes)((3st->bitrate_bps/(3850/nb_frames)) < (out_data_bytes ) ? (3st->bitrate_bps/(38*50/nb_frames)) : (out_data_bytes ));
1397	ret = opus_repacketizer_out_range_impl(rp, 0, nb_frames, data, repacketize_len, 0, !st->use_vbr);
1398	if (ret<0)
1399	{
1400	RESTORE_STACK;
1401	return OPUS_INTERNAL_ERROR-3;
1402	}
1403	st->user_forced_mode = bak_mode;
1404	st->user_bandwidth = bak_bandwidth;
1405	st->force_channels = bak_channels;
1406	st->silk_mode.toMono = bak_to_mono;
1407	RESTORE_STACK;
1408	return ret;
1409	}
1410	curr_bandwidth = st->bandwidth;
1411
1412	/* Chooses the appropriate mode for speech
1413	NEVER switch to/from CELT-only mode here as this will invalidate some assumptions */
1414	if (st->mode == MODE_SILK_ONLY1000 && curr_bandwidth > OPUS_BANDWIDTH_WIDEBAND1103)
1415	st->mode = MODE_HYBRID1001;
1416	if (st->mode == MODE_HYBRID1001 && curr_bandwidth <= OPUS_BANDWIDTH_WIDEBAND1103)
1417	st->mode = MODE_SILK_ONLY1000;
1418
1419	/* printf("%d %d %d %d\n", st->bitrate_bps, st->stream_channels, st->mode, curr_bandwidth); */
1420	bytes_target = IMIN(max_data_bytes-redundancy_bytes, st->bitrate_bps * frame_size / (st->Fs * 8))((max_data_bytes-redundancy_bytes) < (st->bitrate_bps * frame_size / (st->Fs * 8)) ? (max_data_bytes-redundancy_bytes ) : (st->bitrate_bps * frame_size / (st->Fs * 8))) - 1;
1421
1422	data += 1;
1423
1424	ec_enc_init(&enc, data, max_data_bytes-1);
1425
1426	ALLOC(pcm_buf, (total_buffer+frame_size)st->channels, opus_val16)opus_val16 pcm_buf[(total_buffer+frame_size)st->channels];
1427	for (i=0;i<total_buffer*st->channels;i++)
1428	pcm_buf[i] = st->delay_buffer[(st->encoder_buffer-total_buffer)*st->channels+i];
1429
1430	if (st->mode == MODE_CELT_ONLY1002)
1431	hp_freq_smth1 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 )((opus_int32)((opus_uint32)(silk_lin2log( 60 ))<<(8)));
1432	else
1433	hp_freq_smth1 = ((silk_encoder*)silk_enc)->state_Fxx[0].sCmn.variable_HP_smth1_Q15;
1434
1435	st->variable_HP_smth2_Q15 = silk_SMLAWB( st->variable_HP_smth2_Q15,((st->variable_HP_smth2_Q15) + ((((hp_freq_smth1 - st-> variable_HP_smth2_Q15) >> 16) * (opus_int32)((opus_int16 )(((opus_int32)((0.015f) * ((long long)1 << (16)) + 0.5 ))))) + ((((hp_freq_smth1 - st->variable_HP_smth2_Q15) & 0x0000FFFF) * (opus_int32)((opus_int16)(((opus_int32)((0.015f ) * ((long long)1 << (16)) + 0.5))))) >> 16)))
1436	hp_freq_smth1 - st->variable_HP_smth2_Q15, SILK_FIX_CONST( VARIABLE_HP_SMTH_COEF2, 16 ) )((st->variable_HP_smth2_Q15) + ((((hp_freq_smth1 - st-> variable_HP_smth2_Q15) >> 16) * (opus_int32)((opus_int16 )(((opus_int32)((0.015f) * ((long long)1 << (16)) + 0.5 ))))) + ((((hp_freq_smth1 - st->variable_HP_smth2_Q15) & 0x0000FFFF) * (opus_int32)((opus_int16)(((opus_int32)((0.015f ) * ((long long)1 << (16)) + 0.5))))) >> 16)));
1437
1438	/* convert from log scale to Hertz */
1439	cutoff_Hz = silk_log2lin( silk_RSHIFT( st->variable_HP_smth2_Q15, 8 )((st->variable_HP_smth2_Q15)>>(8)) );
1440
1441	if (st->application == OPUS_APPLICATION_VOIP2048)
1442	{
1443	hp_cutoff(pcm, cutoff_Hz, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1444	} else {
1445	dc_reject(pcm, 3, &pcm_buf[total_buffer*st->channels], st->hp_mem, frame_size, st->channels, st->Fs);
1446	}
1447
1448
1449
1450	/* SILK processing */
1451	HB_gain = Q15ONE1.0f;
1452	if (st->mode != MODE_CELT_ONLY1002)
1453	{
1454	opus_int32 total_bitRate, celt_rate;
1455	#ifdef FIXED_POINT
1456	const opus_int16 *pcm_silk;
1457	#else
1458	VARDECL(opus_int16, pcm_silk);
1459	ALLOC(pcm_silk, st->channelsframe_size, opus_int16)opus_int16 pcm_silk[st->channelsframe_size];
1460	#endif
1461
1462	/* Distribute bits between SILK and CELT */
1463	total_bitRate = 8 * bytes_target * frame_rate;
1464	if( st->mode == MODE_HYBRID1001 ) {
1465	int HB_gain_ref;
1466	/* Base rate for SILK */
1467	st->silk_mode.bitRate = st->stream_channels * ( 5000 + 1000 * ( st->Fs == 100 * frame_size ) );
1468	if( curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND1104 ) {
1469	/* SILK gets 2/3 of the remaining bits */
1470	st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 2 / 3;
1471	} else { /* FULLBAND */
1472	/* SILK gets 3/5 of the remaining bits */
1473	st->silk_mode.bitRate += ( total_bitRate - st->silk_mode.bitRate ) * 3 / 5;
1474	}
1475	/* Don't let SILK use more than 80% */
1476	if( st->silk_mode.bitRate > total_bitRate * 4/5 ) {
1477	st->silk_mode.bitRate = total_bitRate * 4/5;
1478	}
1479	if (!st->energy_masking)
1480	{
1481	/* Increasingly attenuate high band when it gets allocated fewer bits */
1482	celt_rate = total_bitRate - st->silk_mode.bitRate;
1483	HB_gain_ref = (curr_bandwidth == OPUS_BANDWIDTH_SUPERWIDEBAND1104) ? 3000 : 3600;
1484	HB_gain = SHL32((opus_val32)celt_rate, 9)((opus_val32)celt_rate) / SHR32((opus_val32)celt_rate + st->stream_channels * HB_gain_ref, 6)((opus_val32)celt_rate + st->stream_channels * HB_gain_ref );
1485	HB_gain = HB_gain < Q15ONE1.0f*6/7 ? HB_gain + Q15ONE1.0f/7 : Q15ONE1.0f;
1486	}
1487	} else {
1488	/* SILK gets all bits */
1489	st->silk_mode.bitRate = total_bitRate;
1490	}
1491
1492	/* Surround masking for SILK */
1493	if (st->energy_masking && st->use_vbr && !st->lfe)
1494	{
1495	opus_val32 mask_sum=0;
1496	opus_val16 masking_depth;
1497	opus_int32 rate_offset;
1498	int c;
1499	int end = 17;
1500	opus_int16 srate = 16000;
1501	if (st->bandwidth == OPUS_BANDWIDTH_NARROWBAND1101)
1502	{
1503	end = 13;
1504	srate = 8000;
1505	} else if (st->bandwidth == OPUS_BANDWIDTH_MEDIUMBAND1102)
1506	{
1507	end = 15;
1508	srate = 12000;
1509	}
1510	for (c=0;c<st->channels;c++)
1511	{
1512	for(i=0;i<end;i++)
1513	{
1514	opus_val16 mask;
1515	mask = MAX16(MIN16(st->energy_masking[21c+i],((((st->energy_masking[21c+i]) < ((.5f)) ? (st->energy_masking [21c+i]) : ((.5f)))) > (-(2.0f)) ? (((st->energy_masking [21c+i]) < ((.5f)) ? (st->energy_masking[21*c+i]) : (( .5f)))) : (-(2.0f)))
1516	QCONST16(.5f, DB_SHIFT)), -QCONST16(2.0f, DB_SHIFT))((((st->energy_masking[21c+i]) < ((.5f)) ? (st->energy_masking [21c+i]) : ((.5f)))) > (-(2.0f)) ? (((st->energy_masking [21c+i]) < ((.5f)) ? (st->energy_masking[21c+i]) : (( .5f)))) : (-(2.0f)));
1517	if (mask > 0)
1518	mask = HALF16(mask)(.5f*(mask));
1519	mask_sum += mask;
1520	}
1521	}
1522	/* Conservative rate reduction, we cut the masking in half */
1523	masking_depth = mask_sum / end*st->channels;
1524	masking_depth += QCONST16(.2f, DB_SHIFT)(.2f);
1525	rate_offset = (opus_int32)PSHR32(MULT16_16(srate, masking_depth), DB_SHIFT)(((opus_val32)(srate)*(opus_val32)(masking_depth)));
1526	rate_offset = MAX32(rate_offset, -2st->silk_mode.bitRate/3)((rate_offset) > (-2st->silk_mode.bitRate/3) ? (rate_offset ) : (-2*st->silk_mode.bitRate/3));
1527	/* Split the rate change between the SILK and CELT part for hybrid. */
1528	if (st->bandwidth==OPUS_BANDWIDTH_SUPERWIDEBAND1104 \|\| st->bandwidth==OPUS_BANDWIDTH_FULLBAND1105)
1529	st->silk_mode.bitRate += 3*rate_offset/5;
1530	else
1531	st->silk_mode.bitRate += rate_offset;
1532	bytes_target += rate_offset * frame_size / (8 * st->Fs);
1533	}
1534
1535	st->silk_mode.payloadSize_ms = 1000 * frame_size / st->Fs;
1536	st->silk_mode.nChannelsAPI = st->channels;
1537	st->silk_mode.nChannelsInternal = st->stream_channels;
1538	if (curr_bandwidth == OPUS_BANDWIDTH_NARROWBAND1101) {
1539	st->silk_mode.desiredInternalSampleRate = 8000;
1540	} else if (curr_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND1102) {
1541	st->silk_mode.desiredInternalSampleRate = 12000;
1542	} else {
1543	silk_assert( st->mode == MODE_HYBRID \|\| curr_bandwidth == OPUS_BANDWIDTH_WIDEBAND );
1544	st->silk_mode.desiredInternalSampleRate = 16000;
1545	}
1546	if( st->mode == MODE_HYBRID1001 ) {
1547	/* Don't allow bandwidth reduction at lowest bitrates in hybrid mode */
1548	st->silk_mode.minInternalSampleRate = 16000;
1549	} else {
1550	st->silk_mode.minInternalSampleRate = 8000;
1551	}
1552
1553	if (st->mode == MODE_SILK_ONLY1000)
1554	{
1555	opus_int32 effective_max_rate = max_rate;
1556	st->silk_mode.maxInternalSampleRate = 16000;
1557	if (frame_rate > 50)
1558	effective_max_rate = effective_max_rate*2/3;
1559	if (effective_max_rate < 13000)
1560	{
1561	st->silk_mode.maxInternalSampleRate = 12000;
1562	st->silk_mode.desiredInternalSampleRate = IMIN(12000, st->silk_mode.desiredInternalSampleRate)((12000) < (st->silk_mode.desiredInternalSampleRate) ? ( 12000) : (st->silk_mode.desiredInternalSampleRate));
1563	}
1564	if (effective_max_rate < 9600)
1565	{
1566	st->silk_mode.maxInternalSampleRate = 8000;
1567	st->silk_mode.desiredInternalSampleRate = IMIN(8000, st->silk_mode.desiredInternalSampleRate)((8000) < (st->silk_mode.desiredInternalSampleRate) ? ( 8000) : (st->silk_mode.desiredInternalSampleRate));
1568	}
1569	} else {
1570	st->silk_mode.maxInternalSampleRate = 16000;
1571	}
1572
1573	st->silk_mode.useCBR = !st->use_vbr;
1574
1575	/* Call SILK encoder for the low band */
1576	nBytes = IMIN(1275, max_data_bytes-1-redundancy_bytes)((1275) < (max_data_bytes-1-redundancy_bytes) ? (1275) : ( max_data_bytes-1-redundancy_bytes));
1577
1578	st->silk_mode.maxBits = nBytes*8;
1579	/* Only allow up to 90% of the bits for hybrid mode*/
1580	if (st->mode == MODE_HYBRID1001)
1581	st->silk_mode.maxBits = (opus_int32)st->silk_mode.maxBits*9/10;
1582	if (st->silk_mode.useCBR)
1583	{
1584	st->silk_mode.maxBits = (st->silk_mode.bitRate * frame_size / (st->Fs * 8))*8;
1585	/* Reduce the initial target to make it easier to reach the CBR rate */
1586	st->silk_mode.bitRate = IMAX(1, st->silk_mode.bitRate-2000)((1) > (st->silk_mode.bitRate-2000) ? (1) : (st->silk_mode .bitRate-2000));
1587	}
1588
1589	if (prefill)
1590	{
1591	opus_int32 zero=0;
1592	int prefill_offset;
1593	/* Use a smooth onset for the SILK prefill to avoid the encoder trying to encode
1594	a discontinuity. The exact location is what we need to avoid leaving any "gap"
1595	in the audio when mixing with the redundant CELT frame. Here we can afford to
1596	overwrite st->delay_buffer because the only thing that uses it before it gets
1597	rewritten is tmp_prefill[] and even then only the part after the ramp really
1598	gets used (rather than sent to the encoder and discarded) */
1599	prefill_offset = st->channels*(st->encoder_buffer-st->delay_compensation-st->Fs/400);
1600	gain_fade(st->delay_buffer+prefill_offset, st->delay_buffer+prefill_offset,
1601	0, Q15ONE1.0f, celt_mode->overlap, st->Fs/400, st->channels, celt_mode->window, st->Fs);
1602	for(i=0;i<prefill_offset;i++)
1603	st->delay_buffer[i]=0;
1604	#ifdef FIXED_POINT
1605	pcm_silk = st->delay_buffer;
1606	#else
1607	for (i=0;i<st->encoder_buffer*st->channels;i++)
1608	pcm_silk[i] = FLOAT2INT16(st->delay_buffer[i]);
1609	#endif
1610	silk_Encode( silk_enc, &st->silk_mode, pcm_silk, st->encoder_buffer, NULL((void*)0), &zero, 1 );
1611	}
1612
1613	#ifdef FIXED_POINT
1614	pcm_silk = pcm_buf+total_buffer*st->channels;
1615	#else
1616	for (i=0;i<frame_size*st->channels;i++)
1617	pcm_silk[i] = FLOAT2INT16(pcm_buf[total_buffer*st->channels + i]);
1618	#endif
1619	ret = silk_Encode( silk_enc, &st->silk_mode, pcm_silk, frame_size, &enc, &nBytes, 0 );
1620	if( ret ) {
1621	/fprintf (stderr, "SILK encode error: %d\n", ret);/
1622	/* Handle error */
1623	RESTORE_STACK;
1624	return OPUS_INTERNAL_ERROR-3;
1625	}
1626	if (nBytes==0)
1627	{
1628	st->rangeFinal = 0;
1629	data[-1] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1630	RESTORE_STACK;
1631	return 1;
1632	}
1633	/* Extract SILK internal bandwidth for signaling in first byte */
1634	if( st->mode == MODE_SILK_ONLY1000 ) {
1635	if( st->silk_mode.internalSampleRate == 8000 ) {
1636	curr_bandwidth = OPUS_BANDWIDTH_NARROWBAND1101;
1637	} else if( st->silk_mode.internalSampleRate == 12000 ) {
1638	curr_bandwidth = OPUS_BANDWIDTH_MEDIUMBAND1102;
1639	} else if( st->silk_mode.internalSampleRate == 16000 ) {
1640	curr_bandwidth = OPUS_BANDWIDTH_WIDEBAND1103;
1641	}
1642	} else {
1643	silk_assert( st->silk_mode.internalSampleRate == 16000 );
1644	}
1645
1646	st->silk_mode.opusCanSwitch = st->silk_mode.switchReady;
1647	/* FIXME: How do we allocate the redundancy for CBR? */
1648	if (st->silk_mode.opusCanSwitch)
1649	{
1650	redundancy = 1;
1651	celt_to_silk = 0;
1652	st->silk_bw_switch = 1;
1653	}
1654	}
1655
1656	/* CELT processing */
1657	{
1658	int endband=21;
1659
1660	switch(curr_bandwidth)
1661	{
1662	case OPUS_BANDWIDTH_NARROWBAND1101:
1663	endband = 13;
1664	break;
1665	case OPUS_BANDWIDTH_MEDIUMBAND1102:
1666	case OPUS_BANDWIDTH_WIDEBAND1103:
1667	endband = 17;
1668	break;
1669	case OPUS_BANDWIDTH_SUPERWIDEBAND1104:
1670	endband = 19;
1671	break;
1672	case OPUS_BANDWIDTH_FULLBAND1105:
1673	endband = 21;
1674	break;
1675	}
1676	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_END_BAND(endband)10012, (((void)((endband) == (opus_int32)0)), (opus_int32)(endband )));
1677	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_CHANNELS(st->stream_channels)10008, (((void)((st->stream_channels) == (opus_int32)0)), ( opus_int32)(st->stream_channels)));
1678	}
1679	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_BITRATE(OPUS_BITRATE_MAX)4002, (((void)((-1) == (opus_int32)0)), (opus_int32)(-1)));
1680	if (st->mode != MODE_SILK_ONLY1000)
1681	{
1682	opus_val32 celt_pred=2;
1683	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_VBR(0)4006, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1684	/* We may still decide to disable prediction later */
1685	if (st->silk_mode.reducedDependency)
1686	celt_pred = 0;
1687	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_PREDICTION(celt_pred)10002, (((void)((celt_pred) == (opus_int32)0)), (opus_int32)( celt_pred)));
1688
1689	if (st->mode == MODE_HYBRID1001)
1690	{
1691	int len;
1692
1693	len = (ec_tell(&enc)+7)>>3;
1694	if (redundancy)
1695	len += st->mode == MODE_HYBRID1001 ? 3 : 1;
1696	if( st->use_vbr ) {
1697	nb_compr_bytes = len + bytes_target - (st->silk_mode.bitRate * frame_size) / (8 * st->Fs);
1698	} else {
1699	/* check if SILK used up too much */
1700	nb_compr_bytes = len > bytes_target ? len : bytes_target;
1701	}
1702	} else {
1703	if (st->use_vbr)
1704	{
1705	opus_int32 bonus=0;
1706	#ifndef DISABLE_FLOAT_API
1707	if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE5010 && frame_size != st->Fs/50)
1708	{
1709	bonus = (60st->stream_channels+40)(st->Fs/frame_size-50);
1710	if (analysis_info.valid)
1711	bonus = (opus_int32)(bonus(1.f+.5fanalysis_info.tonality));
1712	}
1713	#endif
1714	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_VBR(1)4006, (((void)((1) == (opus_int32)0)), (opus_int32)(1)));
1715	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_VBR_CONSTRAINT(st->vbr_constraint)4020, (((void)((st->vbr_constraint) == (opus_int32)0)), (opus_int32 )(st->vbr_constraint)));
1716	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_BITRATE(st->bitrate_bps+bonus)4002, (((void)((st->bitrate_bps+bonus) == (opus_int32)0)), (opus_int32)(st->bitrate_bps+bonus)));
1717	nb_compr_bytes = max_data_bytes-1-redundancy_bytes;
1718	} else {
1719	nb_compr_bytes = bytes_target;
1720	}
1721	}
1722
1723	} else {
1724	nb_compr_bytes = 0;
1725	}
1726
1727	ALLOC(tmp_prefill, st->channelsst->Fs/400, opus_val16)opus_val16 tmp_prefill[st->channelsst->Fs/400];
1728	if (st->mode != MODE_SILK_ONLY1000 && st->mode != st->prev_mode && st->prev_mode > 0)
1729	{
1730	for (i=0;i<st->channels*st->Fs/400;i++)
1731	tmp_prefill[i] = st->delay_buffer[(st->encoder_buffer-total_buffer-st->Fs/400)*st->channels + i];
1732	}
1733
1734	for (i=0;i<st->channels*(st->encoder_buffer-(frame_size+total_buffer));i++)
1735	st->delay_buffer[i] = st->delay_buffer[i+st->channels*frame_size];
1736	for (;i<st->encoder_buffer*st->channels;i++)
1737	st->delay_buffer[i] = pcm_buf[(frame_size+total_buffer-st->encoder_buffer)*st->channels+i];
1738
1739	/* gain_fade() and stereo_fade() need to be after the buffer copying
1740	because we don't want any of this to affect the SILK part */
1741	if( st->prev_HB_gain < Q15ONE1.0f \|\| HB_gain < Q15ONE1.0f ) {
1742	gain_fade(pcm_buf, pcm_buf,
1743	st->prev_HB_gain, HB_gain, celt_mode->overlap, frame_size, st->channels, celt_mode->window, st->Fs);
1744	}
1745	st->prev_HB_gain = HB_gain;
1746	if (st->mode != MODE_HYBRID1001 \|\| st->stream_channels==1)
1747	st->silk_mode.stereoWidth_Q14 = IMIN((1<<14),2IMAX(0,equiv_rate-30000))(((1<<14)) < (2((0) > (equiv_rate-30000) ? (0) : (equiv_rate-30000))) ? ((1<<14)) : (2*((0) > (equiv_rate -30000) ? (0) : (equiv_rate-30000))));
1748	if( !st->energy_masking && st->channels == 2 ) {
1749	/* Apply stereo width reduction (at low bitrates) */
1750	if( st->hybrid_stereo_width_Q14 < (1 << 14) \|\| st->silk_mode.stereoWidth_Q14 < (1 << 14) ) {
1751	opus_val16 g1, g2;
1752	g1 = st->hybrid_stereo_width_Q14;
1753	g2 = (opus_val16)(st->silk_mode.stereoWidth_Q14);
1754	#ifdef FIXED_POINT
1755	g1 = g1==16384 ? Q15ONE1.0f : SHL16(g1,1)(g1);
1756	g2 = g2==16384 ? Q15ONE1.0f : SHL16(g2,1)(g2);
1757	#else
1758	g1 *= (1.f/16384);
1759	g2 *= (1.f/16384);
1760	#endif
1761	stereo_fade(pcm_buf, pcm_buf, g1, g2, celt_mode->overlap,
1762	frame_size, st->channels, celt_mode->window, st->Fs);
1763	st->hybrid_stereo_width_Q14 = st->silk_mode.stereoWidth_Q14;
1764	}
1765	}
1766
1767	if ( st->mode != MODE_CELT_ONLY1002 && ec_tell(&enc)+17+20(st->mode == MODE_HYBRID1001) <= 8(max_data_bytes-1))
1768	{
1769	/* For SILK mode, the redundancy is inferred from the length */
1770	if (st->mode == MODE_HYBRID1001 && (redundancy \|\| ec_tell(&enc)+37 <= 8*nb_compr_bytes))
1771	ec_enc_bit_logp(&enc, redundancy, 12);
1772	if (redundancy)
1773	{
1774	int max_redundancy;
1775	ec_enc_bit_logp(&enc, celt_to_silk, 1);
1776	if (st->mode == MODE_HYBRID1001)
1777	max_redundancy = (max_data_bytes-1)-nb_compr_bytes;
1778	else
1779	max_redundancy = (max_data_bytes-1)-((ec_tell(&enc)+7)>>3);
1780	/* Target the same bit-rate for redundancy as for the rest,
1781	up to a max of 257 bytes */
1782	redundancy_bytes = IMIN(max_redundancy, st->bitrate_bps/1600)((max_redundancy) < (st->bitrate_bps/1600) ? (max_redundancy ) : (st->bitrate_bps/1600));
1783	redundancy_bytes = IMIN(257, IMAX(2, redundancy_bytes))((257) < (((2) > (redundancy_bytes) ? (2) : (redundancy_bytes ))) ? (257) : (((2) > (redundancy_bytes) ? (2) : (redundancy_bytes ))));
1784	if (st->mode == MODE_HYBRID1001)
1785	ec_enc_uint(&enc, redundancy_bytes-2, 256);
1786	}
1787	} else {
1788	redundancy = 0;
1789	}
1790
1791	if (!redundancy)
1792	{
1793	st->silk_bw_switch = 0;
1794	redundancy_bytes = 0;
1795	}
1796	if (st->mode != MODE_CELT_ONLY1002)start_band=17;
1797
1798	if (st->mode == MODE_SILK_ONLY1000)
1799	{
1800	ret = (ec_tell(&enc)+7)>>3;
1801	ec_enc_done(&enc);
1802	nb_compr_bytes = ret;
1803	} else {
1804	nb_compr_bytes = IMIN((max_data_bytes-1)-redundancy_bytes, nb_compr_bytes)(((max_data_bytes-1)-redundancy_bytes) < (nb_compr_bytes) ? ((max_data_bytes-1)-redundancy_bytes) : (nb_compr_bytes));
1805	ec_enc_shrink(&enc, nb_compr_bytes);
1806	}
1807
1808	#ifndef DISABLE_FLOAT_API
1809	if (redundancy \|\| st->mode != MODE_SILK_ONLY1000)
1810	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_ANALYSIS(&analysis_info)10022, ((&analysis_info) + ((&analysis_info) - (const AnalysisInfo*)(&analysis_info))));
1811	#endif
1812
1813	/* 5 ms redundant frame for CELT->SILK */
1814	if (redundancy && celt_to_silk)
1815	{
1816	int err;
1817	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)10010, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1818	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_VBR(0)4006, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1819	err = celt_encode_with_ec(celt_enc, pcm_buf, st->Fs/200, data+nb_compr_bytes, redundancy_bytes, NULL((void*)0));
1820	if (err < 0)
1821	{
1822	RESTORE_STACK;
1823	return OPUS_INTERNAL_ERROR-3;
1824	}
1825	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)4031, ((&redundant_rng) + ((&redundant_rng) - (opus_uint32 *)(&redundant_rng))));
1826	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_RESET_STATE4028);
1827	}
1828
1829	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_START_BAND(start_band)10010, (((void)((start_band) == (opus_int32)0)), (opus_int32) (start_band)));
1830
1831	if (st->mode != MODE_SILK_ONLY1000)
1832	{
1833	if (st->mode != st->prev_mode && st->prev_mode > 0)
1834	{
1835	unsigned char dummy[2];
1836	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_RESET_STATE4028);
1837
1838	/* Prefilling */
1839	celt_encode_with_ec(celt_enc, tmp_prefill, st->Fs/400, dummy, 2, NULL((void*)0));
1840	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)10002, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1841	}
1842	/* If false, we already busted the budget and we'll end up with a "PLC packet" */
1843	if (ec_tell(&enc) <= 8*nb_compr_bytes)
1844	{
1845	ret = celt_encode_with_ec(celt_enc, pcm_buf, frame_size, NULL((void*)0), nb_compr_bytes, &enc);
1846	if (ret < 0)
1847	{
1848	RESTORE_STACK;
1849	return OPUS_INTERNAL_ERROR-3;
1850	}
1851	}
1852	}
1853
1854	/* 5 ms redundant frame for SILK->CELT */
1855	if (redundancy && !celt_to_silk)
1856	{
1857	int err;
1858	unsigned char dummy[2];
1859	int N2, N4;
1860	N2 = st->Fs/200;
1861	N4 = st->Fs/400;
1862
1863	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_RESET_STATE4028);
1864	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_START_BAND(0)10010, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1865	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_SET_PREDICTION(0)10002, (((void)((0) == (opus_int32)0)), (opus_int32)(0)));
1866
1867	/* NOTE: We could speed this up slightly (at the expense of code size) by just adding a function that prefills the buffer */
1868	celt_encode_with_ec(celt_enc, pcm_buf+st->channels(frame_size-N2-N4), N4, dummy, 2, NULL((void)0));
1869
1870	err = celt_encode_with_ec(celt_enc, pcm_buf+st->channels(frame_size-N2), N2, data+nb_compr_bytes, redundancy_bytes, NULL((void)0));
1871	if (err < 0)
1872	{
1873	RESTORE_STACK;
1874	return OPUS_INTERNAL_ERROR-3;
1875	}
1876	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_GET_FINAL_RANGE(&redundant_rng)4031, ((&redundant_rng) + ((&redundant_rng) - (opus_uint32 *)(&redundant_rng))));
1877	}
1878
1879
1880
1881	/* Signalling the mode in the first byte */
1882	data--;
1883	data[0] = gen_toc(st->mode, st->Fs/frame_size, curr_bandwidth, st->stream_channels);
1884
1885	st->rangeFinal = enc.rng ^ redundant_rng;
1886
1887	if (to_celt)
1888	st->prev_mode = MODE_CELT_ONLY1002;
1889	else
1890	st->prev_mode = st->mode;
1891	st->prev_channels = st->stream_channels;
1892	st->prev_framesize = frame_size;
1893
1894	st->first = 0;
1895
1896	/* In the unlikely case that the SILK encoder busted its target, tell
1897	the decoder to call the PLC */
1898	if (ec_tell(&enc) > (max_data_bytes-1)*8)
1899	{
1900	if (max_data_bytes < 2)
1901	{
1902	RESTORE_STACK;
1903	return OPUS_BUFFER_TOO_SMALL-2;
1904	}
1905	data[1] = 0;
1906	ret = 1;
1907	st->rangeFinal = 0;
1908	} else if (st->mode==MODE_SILK_ONLY1000&&!redundancy)
1909	{
1910	/*When in LPC only mode it's perfectly
1911	reasonable to strip off trailing zero bytes as
1912	the required range decoder behavior is to
1913	fill these in. This can't be done when the MDCT
1914	modes are used because the decoder needs to know
1915	the actual length for allocation purposes.*/
1916	while(ret>2&&data[ret]==0)ret--;
1917	}
1918	/* Count ToC and redundancy */
1919	ret += 1+redundancy_bytes;
1920	if (!st->use_vbr)
1921	{
1922	if (opus_packet_pad(data, ret, max_data_bytes) != OPUS_OK0)
1923
1924	{
1925	RESTORE_STACK;
1926	return OPUS_INTERNAL_ERROR-3;
1927	}
1928	ret = max_data_bytes;
1929	}
1930	RESTORE_STACK;
1931	return ret;
1932	}
1933
1934	#ifdef FIXED_POINT
1935
1936	#ifndef DISABLE_FLOAT_API
1937	opus_int32 opus_encode_float(OpusEncoder st, const float pcm, int analysis_frame_size,
1938	unsigned char *data, opus_int32 max_data_bytes)
1939	{
1940	int i, ret;
1941	int frame_size;
1942	int delay_compensation;
1943	VARDECL(opus_int16, in);
1944	ALLOC_STACK;
1945
1946	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
1947	delay_compensation = 0;
1948	else
1949	delay_compensation = st->delay_compensation;
1950	frame_size = compute_frame_size(pcm, analysis_frame_size,
1951	st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
1952	delay_compensation, downmix_float, st->analysis.subframe_mem);
1953
1954	ALLOC(in, frame_sizest->channels, opus_int16)opus_int16 in[frame_sizest->channels];
1955
1956	for (i=0;i<frame_size*st->channels;i++)
1957	in[i] = FLOAT2INT16(pcm[i]);
1958	ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_float);
1959	RESTORE_STACK;
1960	return ret;
1961	}
1962	#endif
1963
1964	opus_int32 opus_encode(OpusEncoder st, const opus_int16 pcm, int analysis_frame_size,
1965	unsigned char *data, opus_int32 out_data_bytes)
1966	{
1967	int frame_size;
1968	int delay_compensation;
1969	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
1970	delay_compensation = 0;
1971	else
1972	delay_compensation = st->delay_compensation;
1973	frame_size = compute_frame_size(pcm, analysis_frame_size,
1974	st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
1975	delay_compensation, downmix_int
1976	#ifndef DISABLE_FLOAT_API
1977	, st->analysis.subframe_mem
1978	#endif
1979	);
1980	return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_int);
1981	}
1982
1983	#else
1984	opus_int32 opus_encode(OpusEncoder st, const opus_int16 pcm, int analysis_frame_size,
1985	unsigned char *data, opus_int32 max_data_bytes)
1986	{
1987	int i, ret;
1988	int frame_size;
1989	int delay_compensation;
1990	VARDECL(float, in);
1991	ALLOC_STACK;
1992
1993	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
1994	delay_compensation = 0;
1995	else
1996	delay_compensation = st->delay_compensation;
1997	frame_size = compute_frame_size(pcm, analysis_frame_size,
1998	st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
1999	delay_compensation, downmix_int, st->analysis.subframe_mem);
2000
2001	ALLOC(in, frame_sizest->channels, float)float in[frame_sizest->channels];
2002
2003	for (i=0;i<frame_size*st->channels;i++)
2004	in[i] = (1.0f/32768)*pcm[i];
2005	ret = opus_encode_native(st, in, frame_size, data, max_data_bytes, 16, pcm, analysis_frame_size, 0, -2, st->channels, downmix_int);
2006	RESTORE_STACK;
2007	return ret;
2008	}
2009	opus_int32 opus_encode_float(OpusEncoder st, const float pcm, int analysis_frame_size,
2010	unsigned char *data, opus_int32 out_data_bytes)
2011	{
2012	int frame_size;
2013	int delay_compensation;
2014	if (st->application == OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
2015	delay_compensation = 0;
2016	else
2017	delay_compensation = st->delay_compensation;
2018	frame_size = compute_frame_size(pcm, analysis_frame_size,
2019	st->variable_duration, st->channels, st->Fs, st->bitrate_bps,
2020	delay_compensation, downmix_float, st->analysis.subframe_mem);
2021	return opus_encode_native(st, pcm, frame_size, data, out_data_bytes, 24,
2022	pcm, analysis_frame_size, 0, -2, st->channels, downmix_float);
2023	}
2024	#endif
2025
2026
2027	int opus_encoder_ctl(OpusEncoder *st, int request, ...)
2028	{
2029	int ret;
2030	CELTEncoderOpusCustomEncoder *celt_enc;
2031	va_list ap;
2032
2033	ret = OPUS_OK0;
2034	va_start(ap, request)__builtin_va_start(ap, request);
2035
2036	celt_enc = (CELTEncoderOpusCustomEncoder)((char)st+st->celt_enc_offset);
2037
2038	switch (request)
2039	{
2040	case OPUS_SET_APPLICATION_REQUEST4000:
2041	{
2042	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2043	if ( (value != OPUS_APPLICATION_VOIP2048 && value != OPUS_APPLICATION_AUDIO2049
2044	&& value != OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
2045	\|\| (!st->first && st->application != value))
2046	{
2047	ret = OPUS_BAD_ARG-1;
2048	break;
2049	}
2050	st->application = value;
2051	}
2052	break;
2053	case OPUS_GET_APPLICATION_REQUEST4001:
2054	{
2055	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2056	if (!value)
2057	{
2058	goto bad_arg;
2059	}
2060	*value = st->application;
2061	}
2062	break;
2063	case OPUS_SET_BITRATE_REQUEST4002:
2064	{
2065	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2066	if (value != OPUS_AUTO-1000 && value != OPUS_BITRATE_MAX-1)
2067	{
2068	if (value <= 0)
2069	goto bad_arg;
2070	else if (value <= 500)
2071	value = 500;
2072	else if (value > (opus_int32)300000*st->channels)
2073	value = (opus_int32)300000*st->channels;
2074	}
2075	st->user_bitrate_bps = value;
2076	}
2077	break;
2078	case OPUS_GET_BITRATE_REQUEST4003:
2079	{
2080	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2081	if (!value)
2082	{
2083	goto bad_arg;
2084	}
2085	*value = user_bitrate_to_bitrate(st, st->prev_framesize, 1276);
2086	}
2087	break;
2088	case OPUS_SET_FORCE_CHANNELS_REQUEST4022:
2089	{
2090	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2091	if((value<1 \|\| value>st->channels) && value != OPUS_AUTO-1000)
2092	{
2093	goto bad_arg;
2094	}
2095	st->force_channels = value;
2096	}
2097	break;
2098	case OPUS_GET_FORCE_CHANNELS_REQUEST4023:
2099	{
2100	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2101	if (!value)
2102	{
2103	goto bad_arg;
2104	}
2105	*value = st->force_channels;
2106	}
2107	break;
2108	case OPUS_SET_MAX_BANDWIDTH_REQUEST4004:
2109	{
2110	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2111	if (value < OPUS_BANDWIDTH_NARROWBAND1101 \|\| value > OPUS_BANDWIDTH_FULLBAND1105)
2112	{
2113	goto bad_arg;
2114	}
2115	st->max_bandwidth = value;
2116	if (st->max_bandwidth == OPUS_BANDWIDTH_NARROWBAND1101) {
2117	st->silk_mode.maxInternalSampleRate = 8000;
2118	} else if (st->max_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND1102) {
2119	st->silk_mode.maxInternalSampleRate = 12000;
2120	} else {
2121	st->silk_mode.maxInternalSampleRate = 16000;
2122	}
2123	}
2124	break;
2125	case OPUS_GET_MAX_BANDWIDTH_REQUEST4005:
2126	{
2127	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2128	if (!value)
2129	{
2130	goto bad_arg;
2131	}
2132	*value = st->max_bandwidth;
2133	}
2134	break;
2135	case OPUS_SET_BANDWIDTH_REQUEST4008:
2136	{
2137	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2138	if ((value < OPUS_BANDWIDTH_NARROWBAND1101 \|\| value > OPUS_BANDWIDTH_FULLBAND1105) && value != OPUS_AUTO-1000)
2139	{
2140	goto bad_arg;
2141	}
2142	st->user_bandwidth = value;
2143	if (st->user_bandwidth == OPUS_BANDWIDTH_NARROWBAND1101) {
2144	st->silk_mode.maxInternalSampleRate = 8000;
2145	} else if (st->user_bandwidth == OPUS_BANDWIDTH_MEDIUMBAND1102) {
2146	st->silk_mode.maxInternalSampleRate = 12000;
2147	} else {
2148	st->silk_mode.maxInternalSampleRate = 16000;
2149	}
2150	}
2151	break;
2152	case OPUS_GET_BANDWIDTH_REQUEST4009:
2153	{
2154	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2155	if (!value)
2156	{
2157	goto bad_arg;
2158	}
2159	*value = st->bandwidth;
2160	}
2161	break;
2162	case OPUS_SET_DTX_REQUEST4016:
2163	{
2164	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2165	if(value<0 \|\| value>1)
2166	{
2167	goto bad_arg;
2168	}
2169	st->silk_mode.useDTX = value;
2170	}
2171	break;
2172	case OPUS_GET_DTX_REQUEST4017:
2173	{
2174	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2175	if (!value)
2176	{
2177	goto bad_arg;
2178	}
2179	*value = st->silk_mode.useDTX;
2180	}
2181	break;
2182	case OPUS_SET_COMPLEXITY_REQUEST4010:
2183	{
2184	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2185	if(value<0 \|\| value>10)
2186	{
2187	goto bad_arg;
2188	}
2189	st->silk_mode.complexity = value;
2190	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_COMPLEXITY(value)4010, (((void)((value) == (opus_int32)0)), (opus_int32)(value )));
2191	}
2192	break;
2193	case OPUS_GET_COMPLEXITY_REQUEST4011:
2194	{
2195	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2196	if (!value)
2197	{
2198	goto bad_arg;
2199	}
2200	*value = st->silk_mode.complexity;
2201	}
2202	break;
2203	case OPUS_SET_INBAND_FEC_REQUEST4012:
2204	{
2205	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2206	if(value<0 \|\| value>1)
2207	{
2208	goto bad_arg;
2209	}
2210	st->silk_mode.useInBandFEC = value;
2211	}
2212	break;
2213	case OPUS_GET_INBAND_FEC_REQUEST4013:
2214	{
2215	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2216	if (!value)
2217	{
2218	goto bad_arg;
2219	}
2220	*value = st->silk_mode.useInBandFEC;
2221	}
2222	break;
2223	case OPUS_SET_PACKET_LOSS_PERC_REQUEST4014:
2224	{
2225	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2226	if (value < 0 \|\| value > 100)
2227	{
2228	goto bad_arg;
2229	}
2230	st->silk_mode.packetLossPercentage = value;
2231	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_PACKET_LOSS_PERC(value)4014, (((void)((value) == (opus_int32)0)), (opus_int32)(value )));
2232	}
2233	break;
2234	case OPUS_GET_PACKET_LOSS_PERC_REQUEST4015:
2235	{
2236	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2237	if (!value)
2238	{
2239	goto bad_arg;
2240	}
2241	*value = st->silk_mode.packetLossPercentage;
2242	}
2243	break;
2244	case OPUS_SET_VBR_REQUEST4006:
2245	{
2246	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2247	if(value<0 \|\| value>1)
2248	{
2249	goto bad_arg;
2250	}
2251	st->use_vbr = value;
2252	st->silk_mode.useCBR = 1-value;
2253	}
2254	break;
2255	case OPUS_GET_VBR_REQUEST4007:
2256	{
2257	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2258	if (!value)
2259	{
2260	goto bad_arg;
2261	}
2262	*value = st->use_vbr;
2263	}
2264	break;
2265	case OPUS_SET_VOICE_RATIO_REQUEST11018:
2266	{
2267	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2268	if (value<-1 \|\| value>100)
2269	{
2270	goto bad_arg;
2271	}
2272	st->voice_ratio = value;
2273	}
2274	break;
2275	case OPUS_GET_VOICE_RATIO_REQUEST11019:
2276	{
2277	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2278	if (!value)
2279	{
2280	goto bad_arg;
2281	}
2282	*value = st->voice_ratio;
2283	}
2284	break;
2285	case OPUS_SET_VBR_CONSTRAINT_REQUEST4020:
2286	{
2287	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2288	if(value<0 \|\| value>1)
2289	{
2290	goto bad_arg;
2291	}
2292	st->vbr_constraint = value;
2293	}
2294	break;
2295	case OPUS_GET_VBR_CONSTRAINT_REQUEST4021:
2296	{
2297	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2298	if (!value)
2299	{
2300	goto bad_arg;
2301	}
2302	*value = st->vbr_constraint;
2303	}
2304	break;
2305	case OPUS_SET_SIGNAL_REQUEST4024:
2306	{
2307	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2308	if(value!=OPUS_AUTO-1000 && value!=OPUS_SIGNAL_VOICE3001 && value!=OPUS_SIGNAL_MUSIC3002)
2309	{
2310	goto bad_arg;
2311	}
2312	st->signal_type = value;
2313	}
2314	break;
2315	case OPUS_GET_SIGNAL_REQUEST4025:
2316	{
2317	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2318	if (!value)
2319	{
2320	goto bad_arg;
2321	}
2322	*value = st->signal_type;
2323	}
2324	break;
2325	case OPUS_GET_LOOKAHEAD_REQUEST4027:
2326	{
2327	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2328	if (!value)
2329	{
2330	goto bad_arg;
2331	}
2332	*value = st->Fs/400;
2333	if (st->application != OPUS_APPLICATION_RESTRICTED_LOWDELAY2051)
2334	*value += st->delay_compensation;
2335	}
2336	break;
2337	case OPUS_GET_SAMPLE_RATE_REQUEST4029:
2338	{
2339	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2340	if (!value)
2341	{
2342	goto bad_arg;
2343	}
2344	*value = st->Fs;
2345	}
2346	break;
2347	case OPUS_GET_FINAL_RANGE_REQUEST4031:
2348	{
2349	opus_uint32 value = va_arg(ap, opus_uint32)__builtin_va_arg(ap, opus_uint32*);
2350	if (!value)
2351	{
2352	goto bad_arg;
2353	}
2354	*value = st->rangeFinal;
2355	}
2356	break;
2357	case OPUS_SET_LSB_DEPTH_REQUEST4036:
2358	{
2359	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2360	if (value<8 \|\| value>24)
2361	{
2362	goto bad_arg;
2363	}
2364	st->lsb_depth=value;
2365	}
2366	break;
2367	case OPUS_GET_LSB_DEPTH_REQUEST4037:
2368	{
2369	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2370	if (!value)
2371	{
2372	goto bad_arg;
2373	}
2374	*value = st->lsb_depth;
2375	}
2376	break;
2377	case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST4040:
2378	{
2379	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2380	if (value != OPUS_FRAMESIZE_ARG5000 && value != OPUS_FRAMESIZE_2_5_MS5001 &&
2381	value != OPUS_FRAMESIZE_5_MS5002 && value != OPUS_FRAMESIZE_10_MS5003 &&
2382	value != OPUS_FRAMESIZE_20_MS5004 && value != OPUS_FRAMESIZE_40_MS5005 &&
2383	value != OPUS_FRAMESIZE_60_MS5006 && value != OPUS_FRAMESIZE_VARIABLE5010)
2384	{
2385	goto bad_arg;
2386	}
2387	st->variable_duration = value;
2388	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_EXPERT_FRAME_DURATION(value)4040, (((void)((value) == (opus_int32)0)), (opus_int32)(value )));
2389	}
2390	break;
2391	case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST4041:
2392	{
2393	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2394	if (!value)
2395	{
2396	goto bad_arg;
2397	}
2398	*value = st->variable_duration;
2399	}
2400	break;
2401	case OPUS_SET_PREDICTION_DISABLED_REQUEST4042:
2402	{
2403	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2404	if (value > 1 \|\| value < 0)
2405	goto bad_arg;
2406	st->silk_mode.reducedDependency = value;
2407	}
2408	break;
2409	case OPUS_GET_PREDICTION_DISABLED_REQUEST4043:
2410	{
2411	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32*);
2412	if (!value)
2413	goto bad_arg;
2414	*value = st->silk_mode.reducedDependency;
2415	}
2416	break;
2417	case OPUS_RESET_STATE4028:
2418	{
2419	void *silk_enc;
2420	silk_EncControlStruct dummy;
2421	silk_enc = (char*)st+st->silk_enc_offset;
2422
2423	OPUS_CLEAR((char)&st->OPUS_ENCODER_RESET_START,(memset(((char)&st->stream_channels), 0, (sizeof(OpusEncoder )- ((char)&st->stream_channels - (char)st))sizeof( ((char*)&st->stream_channels))))
2424	sizeof(OpusEncoder)-(memset(((char)&st->stream_channels), 0, (sizeof(OpusEncoder )- ((char)&st->stream_channels - (char)st))sizeof(* ((char*)&st->stream_channels))))
2425	((char)&st->OPUS_ENCODER_RESET_START - (char)st))(memset(((char)&st->stream_channels), 0, (sizeof(OpusEncoder )- ((char)&st->stream_channels - (char)st))sizeof(* ((char*)&st->stream_channels))));
2426
2427	celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_RESET_STATE4028);
2428	silk_InitEncoder( silk_enc, st->arch, &dummy );
2429	st->stream_channels = st->channels;
2430	st->hybrid_stereo_width_Q14 = 1 << 14;
2431	st->prev_HB_gain = Q15ONE1.0f;
2432	st->first = 1;
2433	st->mode = MODE_HYBRID1001;
2434	st->bandwidth = OPUS_BANDWIDTH_FULLBAND1105;
2435	st->variable_HP_smth2_Q15 = silk_LSHIFT( silk_lin2log( VARIABLE_HP_MIN_CUTOFF_HZ ), 8 )((opus_int32)((opus_uint32)(silk_lin2log( 60 ))<<(8)));
2436	}
2437	break;
2438	case OPUS_SET_FORCE_MODE_REQUEST11002:
2439	{
2440	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2441	if ((value < MODE_SILK_ONLY1000 \|\| value > MODE_CELT_ONLY1002) && value != OPUS_AUTO-1000)
2442	{
2443	goto bad_arg;
2444	}
2445	st->user_forced_mode = value;
2446	}
2447	break;
2448	case OPUS_SET_LFE_REQUEST10024:
2449	{
2450	opus_int32 value = va_arg(ap, opus_int32)__builtin_va_arg(ap, opus_int32);
2451	st->lfe = value;
2452	ret = celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_LFE(value)10024, (((void)((value) == (opus_int32)0)), (opus_int32)(value )));
2453	}
2454	break;
2455	case OPUS_SET_ENERGY_MASK_REQUEST10026:
2456	{
2457	opus_val16 value = va_arg(ap, opus_val16)__builtin_va_arg(ap, opus_val16*);
2458	st->energy_masking = value;
2459	ret = celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, OPUS_SET_ENERGY_MASK(value)10026, ((value) + ((value) - (opus_val16*)(value))));
2460	}
2461	break;
2462
2463	case CELT_GET_MODE_REQUEST10015:
2464	{
2465	const CELTModeOpusCustomMode value = va_arg(ap, const CELTMode)__builtin_va_arg(ap, const OpusCustomMode**);
2466	if (!value)
2467	{
2468	goto bad_arg;
2469	}
2470	ret = celt_encoder_ctlopus_custom_encoder_ctl(celt_enc, CELT_GET_MODE(value)10015, ((value) + ((value) - (const OpusCustomMode**)(value)) ));
2471	}
2472	break;
2473	default:
2474	/* fprintf(stderr, "unknown opus_encoder_ctl() request: %d", request);*/
2475	ret = OPUS_UNIMPLEMENTED-5;
2476	break;
2477	}
2478	va_end(ap)__builtin_va_end(ap);
2479	return ret;
2480	bad_arg:
2481	va_end(ap)__builtin_va_end(ap);
2482	return OPUS_BAD_ARG-1;
2483	}
2484
2485	void opus_encoder_destroy(OpusEncoder *st)
2486	{
2487	opus_free(st);
2488	}