NLSF VQ now uses absolute error, and prediction
[opus.git] / src / opus_multistream_encoder.c
1 /* Copyright (c) 2011 Xiph.Org Foundation
2    Written by Jean-Marc Valin */
3 /*
4    Redistribution and use in source and binary forms, with or without
5    modification, are permitted provided that the following conditions
6    are met:
7
8    - Redistributions of source code must retain the above copyright
9    notice, this list of conditions and the following disclaimer.
10
11    - Redistributions in binary form must reproduce the above copyright
12    notice, this list of conditions and the following disclaimer in the
13    documentation and/or other materials provided with the distribution.
14
15    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
16    ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
17    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
18    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
19    OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
20    EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21    PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
22    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
23    LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
24    NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25    SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 #ifdef HAVE_CONFIG_H
29 #include "config.h"
30 #endif
31
32 #include "opus_multistream.h"
33 #include "opus.h"
34 #include "opus_private.h"
35 #include "stack_alloc.h"
36 #include <stdarg.h>
37 #include "float_cast.h"
38 #include "os_support.h"
39 #include "mathops.h"
40 #include "mdct.h"
41 #include "modes.h"
42 #include "bands.h"
43 #include "quant_bands.h"
44 #include "pitch.h"
45
46 typedef struct {
47    int nb_streams;
48    int nb_coupled_streams;
49    unsigned char mapping[8];
50 } VorbisLayout;
51
52 /* Index is nb_channel-1*/
53 static const VorbisLayout vorbis_mappings[8] = {
54       {1, 0, {0}},                      /* 1: mono */
55       {1, 1, {0, 1}},                   /* 2: stereo */
56       {2, 1, {0, 2, 1}},                /* 3: 1-d surround */
57       {2, 2, {0, 1, 2, 3}},             /* 4: quadraphonic surround */
58       {3, 2, {0, 4, 1, 2, 3}},          /* 5: 5-channel surround */
59       {4, 2, {0, 4, 1, 2, 3, 5}},       /* 6: 5.1 surround */
60       {4, 3, {0, 4, 1, 2, 3, 5, 6}},    /* 7: 6.1 surround */
61       {5, 3, {0, 6, 1, 2, 3, 4, 5, 7}}, /* 8: 7.1 surround */
62 };
63
64 typedef void (*opus_copy_channel_in_func)(
65   opus_val16 *dst,
66   int dst_stride,
67   const void *src,
68   int src_stride,
69   int src_channel,
70   int frame_size
71 );
72
73 typedef enum {
74   MAPPING_TYPE_NONE,
75   MAPPING_TYPE_SURROUND
76 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
77   ,  /* Do not include comma at end of enumerator list */
78   MAPPING_TYPE_AMBISONICS
79 #endif
80 } MappingType;
81
82 struct OpusMSEncoder {
83    ChannelLayout layout;
84    int arch;
85    int lfe_stream;
86    int application;
87    int variable_duration;
88    MappingType mapping_type;
89    opus_int32 bitrate_bps;
90    float subframe_mem[3];
91    /* Encoder states go here */
92    /* then opus_val32 window_mem[channels*120]; */
93    /* then opus_val32 preemph_mem[channels]; */
94 };
95
96 static opus_val32 *ms_get_preemph_mem(OpusMSEncoder *st)
97 {
98    int s;
99    char *ptr;
100    int coupled_size, mono_size;
101
102    coupled_size = opus_encoder_get_size(2);
103    mono_size = opus_encoder_get_size(1);
104    ptr = (char*)st + align(sizeof(OpusMSEncoder));
105    for (s=0;s<st->layout.nb_streams;s++)
106    {
107       if (s < st->layout.nb_coupled_streams)
108          ptr += align(coupled_size);
109       else
110          ptr += align(mono_size);
111    }
112    /* void* cast avoids clang -Wcast-align warning */
113    return (opus_val32*)(void*)(ptr+st->layout.nb_channels*120*sizeof(opus_val32));
114 }
115
116 static opus_val32 *ms_get_window_mem(OpusMSEncoder *st)
117 {
118    int s;
119    char *ptr;
120    int coupled_size, mono_size;
121
122    coupled_size = opus_encoder_get_size(2);
123    mono_size = opus_encoder_get_size(1);
124    ptr = (char*)st + align(sizeof(OpusMSEncoder));
125    for (s=0;s<st->layout.nb_streams;s++)
126    {
127       if (s < st->layout.nb_coupled_streams)
128          ptr += align(coupled_size);
129       else
130          ptr += align(mono_size);
131    }
132    /* void* cast avoids clang -Wcast-align warning */
133    return (opus_val32*)(void*)ptr;
134 }
135
136 static int validate_encoder_layout(const ChannelLayout *layout)
137 {
138    int s;
139    for (s=0;s<layout->nb_streams;s++)
140    {
141       if (s < layout->nb_coupled_streams)
142       {
143          if (get_left_channel(layout, s, -1)==-1)
144             return 0;
145          if (get_right_channel(layout, s, -1)==-1)
146             return 0;
147       } else {
148          if (get_mono_channel(layout, s, -1)==-1)
149             return 0;
150       }
151    }
152    return 1;
153 }
154
155 static void channel_pos(int channels, int pos[8])
156 {
157    /* Position in the mix: 0 don't mix, 1: left, 2: center, 3:right */
158    if (channels==4)
159    {
160       pos[0]=1;
161       pos[1]=3;
162       pos[2]=1;
163       pos[3]=3;
164    } else if (channels==3||channels==5||channels==6)
165    {
166       pos[0]=1;
167       pos[1]=2;
168       pos[2]=3;
169       pos[3]=1;
170       pos[4]=3;
171       pos[5]=0;
172    } else if (channels==7)
173    {
174       pos[0]=1;
175       pos[1]=2;
176       pos[2]=3;
177       pos[3]=1;
178       pos[4]=3;
179       pos[5]=2;
180       pos[6]=0;
181    } else if (channels==8)
182    {
183       pos[0]=1;
184       pos[1]=2;
185       pos[2]=3;
186       pos[3]=1;
187       pos[4]=3;
188       pos[5]=1;
189       pos[6]=3;
190       pos[7]=0;
191    }
192 }
193
194 #if 1
195 /* Computes a rough approximation of log2(2^a + 2^b) */
196 static opus_val16 logSum(opus_val16 a, opus_val16 b)
197 {
198    opus_val16 max;
199    opus_val32 diff;
200    opus_val16 frac;
201    static const opus_val16 diff_table[17] = {
202          QCONST16(0.5000000f, DB_SHIFT), QCONST16(0.2924813f, DB_SHIFT), QCONST16(0.1609640f, DB_SHIFT), QCONST16(0.0849625f, DB_SHIFT),
203          QCONST16(0.0437314f, DB_SHIFT), QCONST16(0.0221971f, DB_SHIFT), QCONST16(0.0111839f, DB_SHIFT), QCONST16(0.0056136f, DB_SHIFT),
204          QCONST16(0.0028123f, DB_SHIFT)
205    };
206    int low;
207    if (a>b)
208    {
209       max = a;
210       diff = SUB32(EXTEND32(a),EXTEND32(b));
211    } else {
212       max = b;
213       diff = SUB32(EXTEND32(b),EXTEND32(a));
214    }
215    if (!(diff < QCONST16(8.f, DB_SHIFT)))  /* inverted to catch NaNs */
216       return max;
217 #ifdef FIXED_POINT
218    low = SHR32(diff, DB_SHIFT-1);
219    frac = SHL16(diff - SHL16(low, DB_SHIFT-1), 16-DB_SHIFT);
220 #else
221    low = (int)floor(2*diff);
222    frac = 2*diff - low;
223 #endif
224    return max + diff_table[low] + MULT16_16_Q15(frac, SUB16(diff_table[low+1], diff_table[low]));
225 }
226 #else
227 opus_val16 logSum(opus_val16 a, opus_val16 b)
228 {
229    return log2(pow(4, a)+ pow(4, b))/2;
230 }
231 #endif
232
233 void surround_analysis(const CELTMode *celt_mode, const void *pcm, opus_val16 *bandLogE, opus_val32 *mem, opus_val32 *preemph_mem,
234       int len, int overlap, int channels, int rate, opus_copy_channel_in_func copy_channel_in, int arch
235 )
236 {
237    int c;
238    int i;
239    int LM;
240    int pos[8] = {0};
241    int upsample;
242    int frame_size;
243    opus_val16 channel_offset;
244    opus_val32 bandE[21];
245    opus_val16 maskLogE[3][21];
246    VARDECL(opus_val32, in);
247    VARDECL(opus_val16, x);
248    VARDECL(opus_val32, freq);
249    SAVE_STACK;
250
251    upsample = resampling_factor(rate);
252    frame_size = len*upsample;
253
254    /* LM = log2(frame_size / 120) */
255    for (LM=0;LM<celt_mode->maxLM;LM++)
256       if (celt_mode->shortMdctSize<<LM==frame_size)
257          break;
258
259    ALLOC(in, frame_size+overlap, opus_val32);
260    ALLOC(x, len, opus_val16);
261    ALLOC(freq, frame_size, opus_val32);
262
263    channel_pos(channels, pos);
264
265    for (c=0;c<3;c++)
266       for (i=0;i<21;i++)
267          maskLogE[c][i] = -QCONST16(28.f, DB_SHIFT);
268
269    for (c=0;c<channels;c++)
270    {
271       OPUS_COPY(in, mem+c*overlap, overlap);
272       (*copy_channel_in)(x, 1, pcm, channels, c, len);
273       celt_preemphasis(x, in+overlap, frame_size, 1, upsample, celt_mode->preemph, preemph_mem+c, 0);
274 #ifndef FIXED_POINT
275       {
276          opus_val32 sum;
277          sum = celt_inner_prod(in, in, frame_size+overlap, 0);
278          /* This should filter out both NaNs and ridiculous signals that could
279             cause NaNs further down. */
280          if (!(sum < 1e9f) || celt_isnan(sum))
281          {
282             OPUS_CLEAR(in, frame_size+overlap);
283             preemph_mem[c] = 0;
284          }
285       }
286 #endif
287       clt_mdct_forward(&celt_mode->mdct, in, freq, celt_mode->window,
288             overlap, celt_mode->maxLM-LM, 1, arch);
289       if (upsample != 1)
290       {
291          int bound = len;
292          for (i=0;i<bound;i++)
293             freq[i] *= upsample;
294          for (;i<frame_size;i++)
295             freq[i] = 0;
296       }
297
298       compute_band_energies(celt_mode, freq, bandE, 21, 1, LM);
299       amp2Log2(celt_mode, 21, 21, bandE, bandLogE+21*c, 1);
300       /* Apply spreading function with -6 dB/band going up and -12 dB/band going down. */
301       for (i=1;i<21;i++)
302          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i-1]-QCONST16(1.f, DB_SHIFT));
303       for (i=19;i>=0;i--)
304          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i+1]-QCONST16(2.f, DB_SHIFT));
305       if (pos[c]==1)
306       {
307          for (i=0;i<21;i++)
308             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]);
309       } else if (pos[c]==3)
310       {
311          for (i=0;i<21;i++)
312             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]);
313       } else if (pos[c]==2)
314       {
315          for (i=0;i<21;i++)
316          {
317             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
318             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
319          }
320       }
321 #if 0
322       for (i=0;i<21;i++)
323          printf("%f ", bandLogE[21*c+i]);
324       float sum=0;
325       for (i=0;i<21;i++)
326          sum += bandLogE[21*c+i];
327       printf("%f ", sum/21);
328 #endif
329       OPUS_COPY(mem+c*overlap, in+frame_size, overlap);
330    }
331    for (i=0;i<21;i++)
332       maskLogE[1][i] = MIN32(maskLogE[0][i],maskLogE[2][i]);
333    channel_offset = HALF16(celt_log2(QCONST32(2.f,14)/(channels-1)));
334    for (c=0;c<3;c++)
335       for (i=0;i<21;i++)
336          maskLogE[c][i] += channel_offset;
337 #if 0
338    for (c=0;c<3;c++)
339    {
340       for (i=0;i<21;i++)
341          printf("%f ", maskLogE[c][i]);
342    }
343 #endif
344    for (c=0;c<channels;c++)
345    {
346       opus_val16 *mask;
347       if (pos[c]!=0)
348       {
349          mask = &maskLogE[pos[c]-1][0];
350          for (i=0;i<21;i++)
351             bandLogE[21*c+i] = bandLogE[21*c+i] - mask[i];
352       } else {
353          for (i=0;i<21;i++)
354             bandLogE[21*c+i] = 0;
355       }
356 #if 0
357       for (i=0;i<21;i++)
358          printf("%f ", bandLogE[21*c+i]);
359       printf("\n");
360 #endif
361 #if 0
362       float sum=0;
363       for (i=0;i<21;i++)
364          sum += bandLogE[21*c+i];
365       printf("%f ", sum/(float)QCONST32(21.f, DB_SHIFT));
366       printf("\n");
367 #endif
368    }
369    RESTORE_STACK;
370 }
371
372 opus_int32 opus_multistream_encoder_get_size(int nb_streams, int nb_coupled_streams)
373 {
374    int coupled_size;
375    int mono_size;
376
377    if(nb_streams<1||nb_coupled_streams>nb_streams||nb_coupled_streams<0)return 0;
378    coupled_size = opus_encoder_get_size(2);
379    mono_size = opus_encoder_get_size(1);
380    return align(sizeof(OpusMSEncoder))
381         + nb_coupled_streams * align(coupled_size)
382         + (nb_streams-nb_coupled_streams) * align(mono_size);
383 }
384
385 opus_int32 opus_multistream_surround_encoder_get_size(int channels, int mapping_family)
386 {
387    int nb_streams;
388    int nb_coupled_streams;
389    opus_int32 size;
390
391    if (mapping_family==0)
392    {
393       if (channels==1)
394       {
395          nb_streams=1;
396          nb_coupled_streams=0;
397       } else if (channels==2)
398       {
399          nb_streams=1;
400          nb_coupled_streams=1;
401       } else
402          return 0;
403    } else if (mapping_family==1 && channels<=8 && channels>=1)
404    {
405       nb_streams=vorbis_mappings[channels-1].nb_streams;
406       nb_coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
407    } else if (mapping_family==255)
408    {
409       nb_streams=channels;
410       nb_coupled_streams=0;
411 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
412    } else if (mapping_family==254)
413    {
414       nb_streams=channels;
415       nb_coupled_streams=0;
416 #endif
417    } else
418       return 0;
419    size = opus_multistream_encoder_get_size(nb_streams, nb_coupled_streams);
420    if (channels>2)
421    {
422       size += channels*(120*sizeof(opus_val32) + sizeof(opus_val32));
423    }
424    return size;
425 }
426
427 static int opus_multistream_encoder_init_impl(
428       OpusMSEncoder *st,
429       opus_int32 Fs,
430       int channels,
431       int streams,
432       int coupled_streams,
433       const unsigned char *mapping,
434       int application,
435       MappingType mapping_type
436 )
437 {
438    int coupled_size;
439    int mono_size;
440    int i, ret;
441    char *ptr;
442
443    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
444        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
445       return OPUS_BAD_ARG;
446
447    st->arch = opus_select_arch();
448    st->layout.nb_channels = channels;
449    st->layout.nb_streams = streams;
450    st->layout.nb_coupled_streams = coupled_streams;
451    st->subframe_mem[0]=st->subframe_mem[1]=st->subframe_mem[2]=0;
452    if (mapping_type != MAPPING_TYPE_SURROUND)
453       st->lfe_stream = -1;
454    st->bitrate_bps = OPUS_AUTO;
455    st->application = application;
456    st->variable_duration = OPUS_FRAMESIZE_ARG;
457    for (i=0;i<st->layout.nb_channels;i++)
458       st->layout.mapping[i] = mapping[i];
459    if (!validate_layout(&st->layout) || !validate_encoder_layout(&st->layout))
460       return OPUS_BAD_ARG;
461    ptr = (char*)st + align(sizeof(OpusMSEncoder));
462    coupled_size = opus_encoder_get_size(2);
463    mono_size = opus_encoder_get_size(1);
464
465    for (i=0;i<st->layout.nb_coupled_streams;i++)
466    {
467       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 2, application);
468       if(ret!=OPUS_OK)return ret;
469       if (i==st->lfe_stream)
470          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
471       ptr += align(coupled_size);
472    }
473    for (;i<st->layout.nb_streams;i++)
474    {
475       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 1, application);
476       if (i==st->lfe_stream)
477          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
478       if(ret!=OPUS_OK)return ret;
479       ptr += align(mono_size);
480    }
481    if (mapping_type == MAPPING_TYPE_SURROUND)
482    {
483       OPUS_CLEAR(ms_get_preemph_mem(st), channels);
484       OPUS_CLEAR(ms_get_window_mem(st), channels*120);
485    }
486    st->mapping_type = mapping_type;
487    return OPUS_OK;
488 }
489
490 int opus_multistream_encoder_init(
491       OpusMSEncoder *st,
492       opus_int32 Fs,
493       int channels,
494       int streams,
495       int coupled_streams,
496       const unsigned char *mapping,
497       int application
498 )
499 {
500    return opus_multistream_encoder_init_impl(st, Fs, channels, streams,
501                                              coupled_streams, mapping,
502                                              application, MAPPING_TYPE_NONE);
503 }
504
505 int opus_multistream_surround_encoder_init(
506       OpusMSEncoder *st,
507       opus_int32 Fs,
508       int channels,
509       int mapping_family,
510       int *streams,
511       int *coupled_streams,
512       unsigned char *mapping,
513       int application
514 )
515 {
516    MappingType mapping_type;
517
518    if ((channels>255) || (channels<1))
519       return OPUS_BAD_ARG;
520    st->lfe_stream = -1;
521    if (mapping_family==0)
522    {
523       if (channels==1)
524       {
525          *streams=1;
526          *coupled_streams=0;
527          mapping[0]=0;
528       } else if (channels==2)
529       {
530          *streams=1;
531          *coupled_streams=1;
532          mapping[0]=0;
533          mapping[1]=1;
534       } else
535          return OPUS_UNIMPLEMENTED;
536    } else if (mapping_family==1 && channels<=8 && channels>=1)
537    {
538       int i;
539       *streams=vorbis_mappings[channels-1].nb_streams;
540       *coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
541       for (i=0;i<channels;i++)
542          mapping[i] = vorbis_mappings[channels-1].mapping[i];
543       if (channels>=6)
544          st->lfe_stream = *streams-1;
545    } else if (mapping_family==255)
546    {
547       int i;
548       *streams=channels;
549       *coupled_streams=0;
550       for(i=0;i<channels;i++)
551          mapping[i] = i;
552 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
553    } else if (mapping_family==254)
554    {
555       int i;
556       *streams=channels;
557       *coupled_streams=0;
558       for(i=0;i<channels;i++)
559          mapping[i] = i;
560 #endif
561    } else
562       return OPUS_UNIMPLEMENTED;
563
564    if (channels>2 && mapping_family==1) {
565       mapping_type = MAPPING_TYPE_SURROUND;
566 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
567    } else if (mapping_family==254)
568    {
569       mapping_type = MAPPING_TYPE_AMBISONICS;
570 #endif
571    } else
572    {
573       mapping_type = MAPPING_TYPE_NONE;
574    }
575    return opus_multistream_encoder_init_impl(st, Fs, channels, *streams,
576                                              *coupled_streams, mapping,
577                                              application, mapping_type);
578 }
579
580 OpusMSEncoder *opus_multistream_encoder_create(
581       opus_int32 Fs,
582       int channels,
583       int streams,
584       int coupled_streams,
585       const unsigned char *mapping,
586       int application,
587       int *error
588 )
589 {
590    int ret;
591    OpusMSEncoder *st;
592    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
593        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
594    {
595       if (error)
596          *error = OPUS_BAD_ARG;
597       return NULL;
598    }
599    st = (OpusMSEncoder *)opus_alloc(opus_multistream_encoder_get_size(streams, coupled_streams));
600    if (st==NULL)
601    {
602       if (error)
603          *error = OPUS_ALLOC_FAIL;
604       return NULL;
605    }
606    ret = opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application);
607    if (ret != OPUS_OK)
608    {
609       opus_free(st);
610       st = NULL;
611    }
612    if (error)
613       *error = ret;
614    return st;
615 }
616
617 OpusMSEncoder *opus_multistream_surround_encoder_create(
618       opus_int32 Fs,
619       int channels,
620       int mapping_family,
621       int *streams,
622       int *coupled_streams,
623       unsigned char *mapping,
624       int application,
625       int *error
626 )
627 {
628    int ret;
629    opus_int32 size;
630    OpusMSEncoder *st;
631    if ((channels>255) || (channels<1))
632    {
633       if (error)
634          *error = OPUS_BAD_ARG;
635       return NULL;
636    }
637    size = opus_multistream_surround_encoder_get_size(channels, mapping_family);
638    if (!size)
639    {
640       if (error)
641          *error = OPUS_UNIMPLEMENTED;
642       return NULL;
643    }
644    st = (OpusMSEncoder *)opus_alloc(size);
645    if (st==NULL)
646    {
647       if (error)
648          *error = OPUS_ALLOC_FAIL;
649       return NULL;
650    }
651    ret = opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application);
652    if (ret != OPUS_OK)
653    {
654       opus_free(st);
655       st = NULL;
656    }
657    if (error)
658       *error = ret;
659    return st;
660 }
661
662 static void surround_rate_allocation(
663       OpusMSEncoder *st,
664       opus_int32 *rate,
665       int frame_size,
666       opus_int32 Fs
667       )
668 {
669    int i;
670    opus_int32 channel_rate;
671    int stream_offset;
672    int lfe_offset;
673    int coupled_ratio; /* Q8 */
674    int lfe_ratio;     /* Q8 */
675
676    if (st->bitrate_bps > st->layout.nb_channels*40000)
677       stream_offset = 20000;
678    else
679       stream_offset = st->bitrate_bps/st->layout.nb_channels/2;
680    stream_offset += 60*(Fs/frame_size-50);
681    /* We start by giving each stream (coupled or uncoupled) the same bitrate.
682       This models the main saving of coupled channels over uncoupled. */
683    /* The LFE stream is an exception to the above and gets fewer bits. */
684    lfe_offset = 3500 + 60*(Fs/frame_size-50);
685    /* Coupled streams get twice the mono rate after the first 20 kb/s. */
686    coupled_ratio = 512;
687    /* Should depend on the bitrate, for now we assume LFE gets 1/8 the bits of mono */
688    lfe_ratio = 32;
689
690    /* Compute bitrate allocation between streams */
691    if (st->bitrate_bps==OPUS_AUTO)
692    {
693       channel_rate = Fs+60*Fs/frame_size;
694    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
695    {
696       channel_rate = 300000;
697    } else {
698       int nb_lfe;
699       int nb_uncoupled;
700       int nb_coupled;
701       int total;
702       nb_lfe = (st->lfe_stream!=-1);
703       nb_coupled = st->layout.nb_coupled_streams;
704       nb_uncoupled = st->layout.nb_streams-nb_coupled-nb_lfe;
705       total = (nb_uncoupled<<8)         /* mono */
706             + coupled_ratio*nb_coupled /* stereo */
707             + nb_lfe*lfe_ratio;
708       channel_rate = 256*(st->bitrate_bps-lfe_offset*nb_lfe-stream_offset*(nb_coupled+nb_uncoupled))/total;
709    }
710 #ifndef FIXED_POINT
711    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
712    {
713       opus_int32 bonus;
714       bonus = 60*(Fs/frame_size-50);
715       channel_rate += bonus;
716    }
717 #endif
718
719    for (i=0;i<st->layout.nb_streams;i++)
720    {
721       if (i<st->layout.nb_coupled_streams)
722          rate[i] = stream_offset+(channel_rate*coupled_ratio>>8);
723       else if (i!=st->lfe_stream)
724          rate[i] = stream_offset+channel_rate;
725       else
726          rate[i] = lfe_offset+(channel_rate*lfe_ratio>>8);
727    }
728 }
729
730 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
731 static void ambisonics_rate_allocation(
732       OpusMSEncoder *st,
733       opus_int32 *rate,
734       int frame_size,
735       opus_int32 Fs
736       )
737 {
738    int i;
739    int non_mono_rate;
740    int total_rate;
741
742    /* The mono channel gets (rate_ratio_num / rate_ratio_den) times as many bits
743     * as all other channels */
744    const int rate_ratio_num = 4;
745    const int rate_ratio_den = 3;
746    const int num_channels = st->layout.nb_streams;
747
748    if (st->bitrate_bps==OPUS_AUTO)
749    {
750       total_rate = num_channels * (20000 + st->layout.nb_streams*(Fs+60*Fs/frame_size));
751    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
752    {
753       total_rate = num_channels * 320000;
754    } else {
755       total_rate = st->bitrate_bps;
756    }
757
758    /* Let y be the non-mono rate and let p, q be integers such that the mono
759     * channel rate is (p/q) * y.
760     * Also let T be the total bitrate to allocate. Then
761     *   (n - 1) y + (p/q) y = T
762     *   y = (T q) / (qn - q + p)
763     */
764    non_mono_rate =
765          total_rate * rate_ratio_den
766          / (rate_ratio_den*num_channels + rate_ratio_num - rate_ratio_den);
767
768 #ifndef FIXED_POINT
769    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
770    {
771       opus_int32 bonus = 60*(Fs/frame_size-50);
772       non_mono_rate += bonus;
773    }
774 #endif
775
776    rate[0] = total_rate - (num_channels - 1) * non_mono_rate;
777    for (i=1;i<st->layout.nb_streams;i++)
778    {
779       rate[i] = non_mono_rate;
780    }
781 }
782 #endif /* ENABLE_EXPERIMENTAL_AMBISONICS */
783
784 static opus_int32 rate_allocation(
785       OpusMSEncoder *st,
786       opus_int32 *rate,
787       int frame_size
788       )
789 {
790    int i;
791    opus_int32 rate_sum=0;
792    opus_int32 Fs;
793    char *ptr;
794
795    ptr = (char*)st + align(sizeof(OpusMSEncoder));
796    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
797
798 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
799    if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
800      ambisonics_rate_allocation(st, rate, frame_size, Fs);
801    } else
802 #endif
803    {
804      surround_rate_allocation(st, rate, frame_size, Fs);
805    }
806
807    for (i=0;i<st->layout.nb_streams;i++)
808    {
809       rate[i] = IMAX(rate[i], 500);
810       rate_sum += rate[i];
811    }
812    return rate_sum;
813 }
814
815 /* Max size in case the encoder decides to return three frames */
816 #define MS_FRAME_TMP (3*1275+7)
817 static int opus_multistream_encode_native
818 (
819     OpusMSEncoder *st,
820     opus_copy_channel_in_func copy_channel_in,
821     const void *pcm,
822     int analysis_frame_size,
823     unsigned char *data,
824     opus_int32 max_data_bytes,
825     int lsb_depth,
826     downmix_func downmix,
827     int float_api
828 )
829 {
830    opus_int32 Fs;
831    int coupled_size;
832    int mono_size;
833    int s;
834    char *ptr;
835    int tot_size;
836    VARDECL(opus_val16, buf);
837    VARDECL(opus_val16, bandSMR);
838    unsigned char tmp_data[MS_FRAME_TMP];
839    OpusRepacketizer rp;
840    opus_int32 vbr;
841    const CELTMode *celt_mode;
842    opus_int32 bitrates[256];
843    opus_val16 bandLogE[42];
844    opus_val32 *mem = NULL;
845    opus_val32 *preemph_mem=NULL;
846    int frame_size;
847    opus_int32 rate_sum;
848    opus_int32 smallest_packet;
849    ALLOC_STACK;
850
851    if (st->mapping_type == MAPPING_TYPE_SURROUND)
852    {
853       preemph_mem = ms_get_preemph_mem(st);
854       mem = ms_get_window_mem(st);
855    }
856
857    ptr = (char*)st + align(sizeof(OpusMSEncoder));
858    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
859    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_VBR(&vbr));
860    opus_encoder_ctl((OpusEncoder*)ptr, CELT_GET_MODE(&celt_mode));
861
862    {
863       opus_int32 delay_compensation;
864       int channels;
865
866       channels = st->layout.nb_streams + st->layout.nb_coupled_streams;
867       opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_LOOKAHEAD(&delay_compensation));
868       delay_compensation -= Fs/400;
869       frame_size = compute_frame_size(pcm, analysis_frame_size,
870             st->variable_duration, channels, Fs, st->bitrate_bps,
871             delay_compensation, downmix
872 #ifndef DISABLE_FLOAT_API
873             , st->subframe_mem
874 #endif
875             );
876    }
877
878    if (400*frame_size < Fs)
879    {
880       RESTORE_STACK;
881       return OPUS_BAD_ARG;
882    }
883    /* Validate frame_size before using it to allocate stack space.
884       This mirrors the checks in opus_encode[_float](). */
885    if (400*frame_size != Fs && 200*frame_size != Fs &&
886        100*frame_size != Fs &&  50*frame_size != Fs &&
887         25*frame_size != Fs &&  50*frame_size != 3*Fs)
888    {
889       RESTORE_STACK;
890       return OPUS_BAD_ARG;
891    }
892
893    /* Smallest packet the encoder can produce. */
894    smallest_packet = st->layout.nb_streams*2-1;
895    if (max_data_bytes < smallest_packet)
896    {
897       RESTORE_STACK;
898       return OPUS_BUFFER_TOO_SMALL;
899    }
900    ALLOC(buf, 2*frame_size, opus_val16);
901    coupled_size = opus_encoder_get_size(2);
902    mono_size = opus_encoder_get_size(1);
903
904    ALLOC(bandSMR, 21*st->layout.nb_channels, opus_val16);
905    if (st->mapping_type == MAPPING_TYPE_SURROUND)
906    {
907       surround_analysis(celt_mode, pcm, bandSMR, mem, preemph_mem, frame_size, 120, st->layout.nb_channels, Fs, copy_channel_in, st->arch);
908    }
909
910    /* Compute bitrate allocation between streams (this could be a lot better) */
911    rate_sum = rate_allocation(st, bitrates, frame_size);
912
913    if (!vbr)
914    {
915       if (st->bitrate_bps == OPUS_AUTO)
916       {
917          max_data_bytes = IMIN(max_data_bytes, 3*rate_sum/(3*8*Fs/frame_size));
918       } else if (st->bitrate_bps != OPUS_BITRATE_MAX)
919       {
920          max_data_bytes = IMIN(max_data_bytes, IMAX(smallest_packet,
921                           3*st->bitrate_bps/(3*8*Fs/frame_size)));
922       }
923    }
924    ptr = (char*)st + align(sizeof(OpusMSEncoder));
925    for (s=0;s<st->layout.nb_streams;s++)
926    {
927       OpusEncoder *enc;
928       enc = (OpusEncoder*)ptr;
929       if (s < st->layout.nb_coupled_streams)
930          ptr += align(coupled_size);
931       else
932          ptr += align(mono_size);
933       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrates[s]));
934       if (st->mapping_type == MAPPING_TYPE_SURROUND)
935       {
936          opus_int32 equiv_rate;
937          equiv_rate = st->bitrate_bps;
938          if (frame_size*50 < Fs)
939             equiv_rate -= 60*(Fs/frame_size - 50)*st->layout.nb_channels;
940          if (equiv_rate > 10000*st->layout.nb_channels)
941             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
942          else if (equiv_rate > 7000*st->layout.nb_channels)
943             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_SUPERWIDEBAND));
944          else if (equiv_rate > 5000*st->layout.nb_channels)
945             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_WIDEBAND));
946          else
947             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));
948          if (s < st->layout.nb_coupled_streams)
949          {
950             /* To preserve the spatial image, force stereo CELT on coupled streams */
951             opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
952             opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(2));
953          }
954       }
955 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
956       else if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
957         opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
958       }
959 #endif
960    }
961
962    ptr = (char*)st + align(sizeof(OpusMSEncoder));
963    /* Counting ToC */
964    tot_size = 0;
965    for (s=0;s<st->layout.nb_streams;s++)
966    {
967       OpusEncoder *enc;
968       int len;
969       int curr_max;
970       int c1, c2;
971       int ret;
972
973       opus_repacketizer_init(&rp);
974       enc = (OpusEncoder*)ptr;
975       if (s < st->layout.nb_coupled_streams)
976       {
977          int i;
978          int left, right;
979          left = get_left_channel(&st->layout, s, -1);
980          right = get_right_channel(&st->layout, s, -1);
981          (*copy_channel_in)(buf, 2,
982             pcm, st->layout.nb_channels, left, frame_size);
983          (*copy_channel_in)(buf+1, 2,
984             pcm, st->layout.nb_channels, right, frame_size);
985          ptr += align(coupled_size);
986          if (st->mapping_type == MAPPING_TYPE_SURROUND)
987          {
988             for (i=0;i<21;i++)
989             {
990                bandLogE[i] = bandSMR[21*left+i];
991                bandLogE[21+i] = bandSMR[21*right+i];
992             }
993          }
994          c1 = left;
995          c2 = right;
996       } else {
997          int i;
998          int chan = get_mono_channel(&st->layout, s, -1);
999          (*copy_channel_in)(buf, 1,
1000             pcm, st->layout.nb_channels, chan, frame_size);
1001          ptr += align(mono_size);
1002          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1003          {
1004             for (i=0;i<21;i++)
1005                bandLogE[i] = bandSMR[21*chan+i];
1006          }
1007          c1 = chan;
1008          c2 = -1;
1009       }
1010       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1011          opus_encoder_ctl(enc, OPUS_SET_ENERGY_MASK(bandLogE));
1012       /* number of bytes left (+Toc) */
1013       curr_max = max_data_bytes - tot_size;
1014       /* Reserve one byte for the last stream and two for the others */
1015       curr_max -= IMAX(0,2*(st->layout.nb_streams-s-1)-1);
1016       curr_max = IMIN(curr_max,MS_FRAME_TMP);
1017       /* Repacketizer will add one or two bytes for self-delimited frames */
1018       if (s != st->layout.nb_streams-1) curr_max -=  curr_max>253 ? 2 : 1;
1019       if (!vbr && s == st->layout.nb_streams-1)
1020          opus_encoder_ctl(enc, OPUS_SET_BITRATE(curr_max*(8*Fs/frame_size)));
1021       len = opus_encode_native(enc, buf, frame_size, tmp_data, curr_max, lsb_depth,
1022             pcm, analysis_frame_size, c1, c2, st->layout.nb_channels, downmix, float_api);
1023       if (len<0)
1024       {
1025          RESTORE_STACK;
1026          return len;
1027       }
1028       /* We need to use the repacketizer to add the self-delimiting lengths
1029          while taking into account the fact that the encoder can now return
1030          more than one frame at a time (e.g. 60 ms CELT-only) */
1031       ret = opus_repacketizer_cat(&rp, tmp_data, len);
1032       /* If the opus_repacketizer_cat() fails, then something's seriously wrong
1033          with the encoder. */
1034       if (ret != OPUS_OK)
1035       {
1036          RESTORE_STACK;
1037          return OPUS_INTERNAL_ERROR;
1038       }
1039       len = opus_repacketizer_out_range_impl(&rp, 0, opus_repacketizer_get_nb_frames(&rp),
1040             data, max_data_bytes-tot_size, s != st->layout.nb_streams-1, !vbr && s == st->layout.nb_streams-1);
1041       data += len;
1042       tot_size += len;
1043    }
1044    /*printf("\n");*/
1045    RESTORE_STACK;
1046    return tot_size;
1047 }
1048
1049 #if !defined(DISABLE_FLOAT_API)
1050 static void opus_copy_channel_in_float(
1051   opus_val16 *dst,
1052   int dst_stride,
1053   const void *src,
1054   int src_stride,
1055   int src_channel,
1056   int frame_size
1057 )
1058 {
1059    const float *float_src;
1060    opus_int32 i;
1061    float_src = (const float *)src;
1062    for (i=0;i<frame_size;i++)
1063 #if defined(FIXED_POINT)
1064       dst[i*dst_stride] = FLOAT2INT16(float_src[i*src_stride+src_channel]);
1065 #else
1066       dst[i*dst_stride] = float_src[i*src_stride+src_channel];
1067 #endif
1068 }
1069 #endif
1070
1071 static void opus_copy_channel_in_short(
1072   opus_val16 *dst,
1073   int dst_stride,
1074   const void *src,
1075   int src_stride,
1076   int src_channel,
1077   int frame_size
1078 )
1079 {
1080    const opus_int16 *short_src;
1081    opus_int32 i;
1082    short_src = (const opus_int16 *)src;
1083    for (i=0;i<frame_size;i++)
1084 #if defined(FIXED_POINT)
1085       dst[i*dst_stride] = short_src[i*src_stride+src_channel];
1086 #else
1087       dst[i*dst_stride] = (1/32768.f)*short_src[i*src_stride+src_channel];
1088 #endif
1089 }
1090
1091
1092 #ifdef FIXED_POINT
1093 int opus_multistream_encode(
1094     OpusMSEncoder *st,
1095     const opus_val16 *pcm,
1096     int frame_size,
1097     unsigned char *data,
1098     opus_int32 max_data_bytes
1099 )
1100 {
1101    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1102       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1103 }
1104
1105 #ifndef DISABLE_FLOAT_API
1106 int opus_multistream_encode_float(
1107     OpusMSEncoder *st,
1108     const float *pcm,
1109     int frame_size,
1110     unsigned char *data,
1111     opus_int32 max_data_bytes
1112 )
1113 {
1114    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1115       pcm, frame_size, data, max_data_bytes, 16, downmix_float, 1);
1116 }
1117 #endif
1118
1119 #else
1120
1121 int opus_multistream_encode_float
1122 (
1123     OpusMSEncoder *st,
1124     const opus_val16 *pcm,
1125     int frame_size,
1126     unsigned char *data,
1127     opus_int32 max_data_bytes
1128 )
1129 {
1130    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1131       pcm, frame_size, data, max_data_bytes, 24, downmix_float, 1);
1132 }
1133
1134 int opus_multistream_encode(
1135     OpusMSEncoder *st,
1136     const opus_int16 *pcm,
1137     int frame_size,
1138     unsigned char *data,
1139     opus_int32 max_data_bytes
1140 )
1141 {
1142    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1143       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1144 }
1145 #endif
1146
1147 int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...)
1148 {
1149    va_list ap;
1150    int coupled_size, mono_size;
1151    char *ptr;
1152    int ret = OPUS_OK;
1153
1154    va_start(ap, request);
1155
1156    coupled_size = opus_encoder_get_size(2);
1157    mono_size = opus_encoder_get_size(1);
1158    ptr = (char*)st + align(sizeof(OpusMSEncoder));
1159    switch (request)
1160    {
1161    case OPUS_SET_BITRATE_REQUEST:
1162    {
1163       opus_int32 value = va_arg(ap, opus_int32);
1164       if (value<0 && value!=OPUS_AUTO && value!=OPUS_BITRATE_MAX)
1165       {
1166          goto bad_arg;
1167       }
1168       st->bitrate_bps = value;
1169    }
1170    break;
1171    case OPUS_GET_BITRATE_REQUEST:
1172    {
1173       int s;
1174       opus_int32 *value = va_arg(ap, opus_int32*);
1175       if (!value)
1176       {
1177          goto bad_arg;
1178       }
1179       *value = 0;
1180       for (s=0;s<st->layout.nb_streams;s++)
1181       {
1182          opus_int32 rate;
1183          OpusEncoder *enc;
1184          enc = (OpusEncoder*)ptr;
1185          if (s < st->layout.nb_coupled_streams)
1186             ptr += align(coupled_size);
1187          else
1188             ptr += align(mono_size);
1189          opus_encoder_ctl(enc, request, &rate);
1190          *value += rate;
1191       }
1192    }
1193    break;
1194    case OPUS_GET_LSB_DEPTH_REQUEST:
1195    case OPUS_GET_VBR_REQUEST:
1196    case OPUS_GET_APPLICATION_REQUEST:
1197    case OPUS_GET_BANDWIDTH_REQUEST:
1198    case OPUS_GET_COMPLEXITY_REQUEST:
1199    case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1200    case OPUS_GET_DTX_REQUEST:
1201    case OPUS_GET_VOICE_RATIO_REQUEST:
1202    case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1203    case OPUS_GET_SIGNAL_REQUEST:
1204    case OPUS_GET_LOOKAHEAD_REQUEST:
1205    case OPUS_GET_SAMPLE_RATE_REQUEST:
1206    case OPUS_GET_INBAND_FEC_REQUEST:
1207    case OPUS_GET_FORCE_CHANNELS_REQUEST:
1208    case OPUS_GET_PREDICTION_DISABLED_REQUEST:
1209    {
1210       OpusEncoder *enc;
1211       /* For int32* GET params, just query the first stream */
1212       opus_int32 *value = va_arg(ap, opus_int32*);
1213       enc = (OpusEncoder*)ptr;
1214       ret = opus_encoder_ctl(enc, request, value);
1215    }
1216    break;
1217    case OPUS_GET_FINAL_RANGE_REQUEST:
1218    {
1219       int s;
1220       opus_uint32 *value = va_arg(ap, opus_uint32*);
1221       opus_uint32 tmp;
1222       if (!value)
1223       {
1224          goto bad_arg;
1225       }
1226       *value=0;
1227       for (s=0;s<st->layout.nb_streams;s++)
1228       {
1229          OpusEncoder *enc;
1230          enc = (OpusEncoder*)ptr;
1231          if (s < st->layout.nb_coupled_streams)
1232             ptr += align(coupled_size);
1233          else
1234             ptr += align(mono_size);
1235          ret = opus_encoder_ctl(enc, request, &tmp);
1236          if (ret != OPUS_OK) break;
1237          *value ^= tmp;
1238       }
1239    }
1240    break;
1241    case OPUS_SET_LSB_DEPTH_REQUEST:
1242    case OPUS_SET_COMPLEXITY_REQUEST:
1243    case OPUS_SET_VBR_REQUEST:
1244    case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1245    case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1246    case OPUS_SET_BANDWIDTH_REQUEST:
1247    case OPUS_SET_SIGNAL_REQUEST:
1248    case OPUS_SET_APPLICATION_REQUEST:
1249    case OPUS_SET_INBAND_FEC_REQUEST:
1250    case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1251    case OPUS_SET_DTX_REQUEST:
1252    case OPUS_SET_FORCE_MODE_REQUEST:
1253    case OPUS_SET_FORCE_CHANNELS_REQUEST:
1254    case OPUS_SET_PREDICTION_DISABLED_REQUEST:
1255    {
1256       int s;
1257       /* This works for int32 params */
1258       opus_int32 value = va_arg(ap, opus_int32);
1259       for (s=0;s<st->layout.nb_streams;s++)
1260       {
1261          OpusEncoder *enc;
1262
1263          enc = (OpusEncoder*)ptr;
1264          if (s < st->layout.nb_coupled_streams)
1265             ptr += align(coupled_size);
1266          else
1267             ptr += align(mono_size);
1268          ret = opus_encoder_ctl(enc, request, value);
1269          if (ret != OPUS_OK)
1270             break;
1271       }
1272    }
1273    break;
1274    case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
1275    {
1276       int s;
1277       opus_int32 stream_id;
1278       OpusEncoder **value;
1279       stream_id = va_arg(ap, opus_int32);
1280       if (stream_id<0 || stream_id >= st->layout.nb_streams)
1281          ret = OPUS_BAD_ARG;
1282       value = va_arg(ap, OpusEncoder**);
1283       if (!value)
1284       {
1285          goto bad_arg;
1286       }
1287       for (s=0;s<stream_id;s++)
1288       {
1289          if (s < st->layout.nb_coupled_streams)
1290             ptr += align(coupled_size);
1291          else
1292             ptr += align(mono_size);
1293       }
1294       *value = (OpusEncoder*)ptr;
1295    }
1296    break;
1297    case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
1298    {
1299        opus_int32 value = va_arg(ap, opus_int32);
1300        st->variable_duration = value;
1301    }
1302    break;
1303    case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
1304    {
1305        opus_int32 *value = va_arg(ap, opus_int32*);
1306        if (!value)
1307        {
1308           goto bad_arg;
1309        }
1310        *value = st->variable_duration;
1311    }
1312    break;
1313    case OPUS_RESET_STATE:
1314    {
1315       int s;
1316       st->subframe_mem[0] = st->subframe_mem[1] = st->subframe_mem[2] = 0;
1317       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1318       {
1319          OPUS_CLEAR(ms_get_preemph_mem(st), st->layout.nb_channels);
1320          OPUS_CLEAR(ms_get_window_mem(st), st->layout.nb_channels*120);
1321       }
1322       for (s=0;s<st->layout.nb_streams;s++)
1323       {
1324          OpusEncoder *enc;
1325          enc = (OpusEncoder*)ptr;
1326          if (s < st->layout.nb_coupled_streams)
1327             ptr += align(coupled_size);
1328          else
1329             ptr += align(mono_size);
1330          ret = opus_encoder_ctl(enc, OPUS_RESET_STATE);
1331          if (ret != OPUS_OK)
1332             break;
1333       }
1334    }
1335    break;
1336    default:
1337       ret = OPUS_UNIMPLEMENTED;
1338       break;
1339    }
1340
1341    va_end(ap);
1342    return ret;
1343 bad_arg:
1344    va_end(ap);
1345    return OPUS_BAD_ARG;
1346 }
1347
1348 void opus_multistream_encoder_destroy(OpusMSEncoder *st)
1349 {
1350     opus_free(st);
1351 }