Fixes surround_analysis() for frame size > 20 ms
[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    int freq_size;
244    opus_val16 channel_offset;
245    opus_val32 bandE[21];
246    opus_val16 maskLogE[3][21];
247    VARDECL(opus_val32, in);
248    VARDECL(opus_val16, x);
249    VARDECL(opus_val32, freq);
250    SAVE_STACK;
251
252    upsample = resampling_factor(rate);
253    frame_size = len*upsample;
254    freq_size = IMIN(960, frame_size);
255
256    /* LM = log2(frame_size / 120) */
257    for (LM=0;LM<celt_mode->maxLM;LM++)
258       if (celt_mode->shortMdctSize<<LM==frame_size)
259          break;
260
261    ALLOC(in, frame_size+overlap, opus_val32);
262    ALLOC(x, len, opus_val16);
263    ALLOC(freq, freq_size, opus_val32);
264
265    channel_pos(channels, pos);
266
267    for (c=0;c<3;c++)
268       for (i=0;i<21;i++)
269          maskLogE[c][i] = -QCONST16(28.f, DB_SHIFT);
270
271    for (c=0;c<channels;c++)
272    {
273       int frame;
274       int nb_frames = frame_size/freq_size;
275       celt_assert(nb_frames*freq_size == frame_size);
276       OPUS_COPY(in, mem+c*overlap, overlap);
277       (*copy_channel_in)(x, 1, pcm, channels, c, len);
278       celt_preemphasis(x, in+overlap, frame_size, 1, upsample, celt_mode->preemph, preemph_mem+c, 0);
279 #ifndef FIXED_POINT
280       {
281          opus_val32 sum;
282          sum = celt_inner_prod(in, in, frame_size+overlap, 0);
283          /* This should filter out both NaNs and ridiculous signals that could
284             cause NaNs further down. */
285          if (!(sum < 1e9f) || celt_isnan(sum))
286          {
287             OPUS_CLEAR(in, frame_size+overlap);
288             preemph_mem[c] = 0;
289          }
290       }
291 #endif
292       OPUS_CLEAR(bandE, 21);
293       for (frame=0;frame<nb_frames;frame++)
294       {
295          opus_val32 tmpE[21];
296          clt_mdct_forward(&celt_mode->mdct, in+960*frame, freq, celt_mode->window,
297                overlap, celt_mode->maxLM-LM, 1, arch);
298          if (upsample != 1)
299          {
300             int bound = freq_size/upsample;
301             for (i=0;i<bound;i++)
302                freq[i] *= upsample;
303             for (;i<freq_size;i++)
304                freq[i] = 0;
305          }
306
307          compute_band_energies(celt_mode, freq, tmpE, 21, 1, LM);
308          /* If we have multiple frames, take the max energy. */
309          for (i=0;i<21;i++)
310             bandE[i] = MAX32(bandE[i], tmpE[i]);
311       }
312       amp2Log2(celt_mode, 21, 21, bandE, bandLogE+21*c, 1);
313       /* Apply spreading function with -6 dB/band going up and -12 dB/band going down. */
314       for (i=1;i<21;i++)
315          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i-1]-QCONST16(1.f, DB_SHIFT));
316       for (i=19;i>=0;i--)
317          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i+1]-QCONST16(2.f, DB_SHIFT));
318       if (pos[c]==1)
319       {
320          for (i=0;i<21;i++)
321             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]);
322       } else if (pos[c]==3)
323       {
324          for (i=0;i<21;i++)
325             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]);
326       } else if (pos[c]==2)
327       {
328          for (i=0;i<21;i++)
329          {
330             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
331             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
332          }
333       }
334 #if 0
335       for (i=0;i<21;i++)
336          printf("%f ", bandLogE[21*c+i]);
337       float sum=0;
338       for (i=0;i<21;i++)
339          sum += bandLogE[21*c+i];
340       printf("%f ", sum/21);
341 #endif
342       OPUS_COPY(mem+c*overlap, in+frame_size, overlap);
343    }
344    for (i=0;i<21;i++)
345       maskLogE[1][i] = MIN32(maskLogE[0][i],maskLogE[2][i]);
346    channel_offset = HALF16(celt_log2(QCONST32(2.f,14)/(channels-1)));
347    for (c=0;c<3;c++)
348       for (i=0;i<21;i++)
349          maskLogE[c][i] += channel_offset;
350 #if 0
351    for (c=0;c<3;c++)
352    {
353       for (i=0;i<21;i++)
354          printf("%f ", maskLogE[c][i]);
355    }
356 #endif
357    for (c=0;c<channels;c++)
358    {
359       opus_val16 *mask;
360       if (pos[c]!=0)
361       {
362          mask = &maskLogE[pos[c]-1][0];
363          for (i=0;i<21;i++)
364             bandLogE[21*c+i] = bandLogE[21*c+i] - mask[i];
365       } else {
366          for (i=0;i<21;i++)
367             bandLogE[21*c+i] = 0;
368       }
369 #if 0
370       for (i=0;i<21;i++)
371          printf("%f ", bandLogE[21*c+i]);
372       printf("\n");
373 #endif
374 #if 0
375       float sum=0;
376       for (i=0;i<21;i++)
377          sum += bandLogE[21*c+i];
378       printf("%f ", sum/(float)QCONST32(21.f, DB_SHIFT));
379       printf("\n");
380 #endif
381    }
382    RESTORE_STACK;
383 }
384
385 opus_int32 opus_multistream_encoder_get_size(int nb_streams, int nb_coupled_streams)
386 {
387    int coupled_size;
388    int mono_size;
389
390    if(nb_streams<1||nb_coupled_streams>nb_streams||nb_coupled_streams<0)return 0;
391    coupled_size = opus_encoder_get_size(2);
392    mono_size = opus_encoder_get_size(1);
393    return align(sizeof(OpusMSEncoder))
394         + nb_coupled_streams * align(coupled_size)
395         + (nb_streams-nb_coupled_streams) * align(mono_size);
396 }
397
398 opus_int32 opus_multistream_surround_encoder_get_size(int channels, int mapping_family)
399 {
400    int nb_streams;
401    int nb_coupled_streams;
402    opus_int32 size;
403
404    if (mapping_family==0)
405    {
406       if (channels==1)
407       {
408          nb_streams=1;
409          nb_coupled_streams=0;
410       } else if (channels==2)
411       {
412          nb_streams=1;
413          nb_coupled_streams=1;
414       } else
415          return 0;
416    } else if (mapping_family==1 && channels<=8 && channels>=1)
417    {
418       nb_streams=vorbis_mappings[channels-1].nb_streams;
419       nb_coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
420    } else if (mapping_family==255)
421    {
422       nb_streams=channels;
423       nb_coupled_streams=0;
424 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
425    } else if (mapping_family==254)
426    {
427       nb_streams=channels;
428       nb_coupled_streams=0;
429 #endif
430    } else
431       return 0;
432    size = opus_multistream_encoder_get_size(nb_streams, nb_coupled_streams);
433    if (channels>2)
434    {
435       size += channels*(120*sizeof(opus_val32) + sizeof(opus_val32));
436    }
437    return size;
438 }
439
440 static int opus_multistream_encoder_init_impl(
441       OpusMSEncoder *st,
442       opus_int32 Fs,
443       int channels,
444       int streams,
445       int coupled_streams,
446       const unsigned char *mapping,
447       int application,
448       MappingType mapping_type
449 )
450 {
451    int coupled_size;
452    int mono_size;
453    int i, ret;
454    char *ptr;
455
456    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
457        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
458       return OPUS_BAD_ARG;
459
460    st->arch = opus_select_arch();
461    st->layout.nb_channels = channels;
462    st->layout.nb_streams = streams;
463    st->layout.nb_coupled_streams = coupled_streams;
464    st->subframe_mem[0]=st->subframe_mem[1]=st->subframe_mem[2]=0;
465    if (mapping_type != MAPPING_TYPE_SURROUND)
466       st->lfe_stream = -1;
467    st->bitrate_bps = OPUS_AUTO;
468    st->application = application;
469    st->variable_duration = OPUS_FRAMESIZE_ARG;
470    for (i=0;i<st->layout.nb_channels;i++)
471       st->layout.mapping[i] = mapping[i];
472    if (!validate_layout(&st->layout) || !validate_encoder_layout(&st->layout))
473       return OPUS_BAD_ARG;
474    ptr = (char*)st + align(sizeof(OpusMSEncoder));
475    coupled_size = opus_encoder_get_size(2);
476    mono_size = opus_encoder_get_size(1);
477
478    for (i=0;i<st->layout.nb_coupled_streams;i++)
479    {
480       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 2, application);
481       if(ret!=OPUS_OK)return ret;
482       if (i==st->lfe_stream)
483          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
484       ptr += align(coupled_size);
485    }
486    for (;i<st->layout.nb_streams;i++)
487    {
488       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 1, application);
489       if (i==st->lfe_stream)
490          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
491       if(ret!=OPUS_OK)return ret;
492       ptr += align(mono_size);
493    }
494    if (mapping_type == MAPPING_TYPE_SURROUND)
495    {
496       OPUS_CLEAR(ms_get_preemph_mem(st), channels);
497       OPUS_CLEAR(ms_get_window_mem(st), channels*120);
498    }
499    st->mapping_type = mapping_type;
500    return OPUS_OK;
501 }
502
503 int opus_multistream_encoder_init(
504       OpusMSEncoder *st,
505       opus_int32 Fs,
506       int channels,
507       int streams,
508       int coupled_streams,
509       const unsigned char *mapping,
510       int application
511 )
512 {
513    return opus_multistream_encoder_init_impl(st, Fs, channels, streams,
514                                              coupled_streams, mapping,
515                                              application, MAPPING_TYPE_NONE);
516 }
517
518 int opus_multistream_surround_encoder_init(
519       OpusMSEncoder *st,
520       opus_int32 Fs,
521       int channels,
522       int mapping_family,
523       int *streams,
524       int *coupled_streams,
525       unsigned char *mapping,
526       int application
527 )
528 {
529    MappingType mapping_type;
530
531    if ((channels>255) || (channels<1))
532       return OPUS_BAD_ARG;
533    st->lfe_stream = -1;
534    if (mapping_family==0)
535    {
536       if (channels==1)
537       {
538          *streams=1;
539          *coupled_streams=0;
540          mapping[0]=0;
541       } else if (channels==2)
542       {
543          *streams=1;
544          *coupled_streams=1;
545          mapping[0]=0;
546          mapping[1]=1;
547       } else
548          return OPUS_UNIMPLEMENTED;
549    } else if (mapping_family==1 && channels<=8 && channels>=1)
550    {
551       int i;
552       *streams=vorbis_mappings[channels-1].nb_streams;
553       *coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
554       for (i=0;i<channels;i++)
555          mapping[i] = vorbis_mappings[channels-1].mapping[i];
556       if (channels>=6)
557          st->lfe_stream = *streams-1;
558    } else if (mapping_family==255)
559    {
560       int i;
561       *streams=channels;
562       *coupled_streams=0;
563       for(i=0;i<channels;i++)
564          mapping[i] = i;
565 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
566    } else if (mapping_family==254)
567    {
568       int i;
569       *streams=channels;
570       *coupled_streams=0;
571       for(i=0;i<channels;i++)
572          mapping[i] = i;
573 #endif
574    } else
575       return OPUS_UNIMPLEMENTED;
576
577    if (channels>2 && mapping_family==1) {
578       mapping_type = MAPPING_TYPE_SURROUND;
579 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
580    } else if (mapping_family==254)
581    {
582       mapping_type = MAPPING_TYPE_AMBISONICS;
583 #endif
584    } else
585    {
586       mapping_type = MAPPING_TYPE_NONE;
587    }
588    return opus_multistream_encoder_init_impl(st, Fs, channels, *streams,
589                                              *coupled_streams, mapping,
590                                              application, mapping_type);
591 }
592
593 OpusMSEncoder *opus_multistream_encoder_create(
594       opus_int32 Fs,
595       int channels,
596       int streams,
597       int coupled_streams,
598       const unsigned char *mapping,
599       int application,
600       int *error
601 )
602 {
603    int ret;
604    OpusMSEncoder *st;
605    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
606        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
607    {
608       if (error)
609          *error = OPUS_BAD_ARG;
610       return NULL;
611    }
612    st = (OpusMSEncoder *)opus_alloc(opus_multistream_encoder_get_size(streams, coupled_streams));
613    if (st==NULL)
614    {
615       if (error)
616          *error = OPUS_ALLOC_FAIL;
617       return NULL;
618    }
619    ret = opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application);
620    if (ret != OPUS_OK)
621    {
622       opus_free(st);
623       st = NULL;
624    }
625    if (error)
626       *error = ret;
627    return st;
628 }
629
630 OpusMSEncoder *opus_multistream_surround_encoder_create(
631       opus_int32 Fs,
632       int channels,
633       int mapping_family,
634       int *streams,
635       int *coupled_streams,
636       unsigned char *mapping,
637       int application,
638       int *error
639 )
640 {
641    int ret;
642    opus_int32 size;
643    OpusMSEncoder *st;
644    if ((channels>255) || (channels<1))
645    {
646       if (error)
647          *error = OPUS_BAD_ARG;
648       return NULL;
649    }
650    size = opus_multistream_surround_encoder_get_size(channels, mapping_family);
651    if (!size)
652    {
653       if (error)
654          *error = OPUS_UNIMPLEMENTED;
655       return NULL;
656    }
657    st = (OpusMSEncoder *)opus_alloc(size);
658    if (st==NULL)
659    {
660       if (error)
661          *error = OPUS_ALLOC_FAIL;
662       return NULL;
663    }
664    ret = opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application);
665    if (ret != OPUS_OK)
666    {
667       opus_free(st);
668       st = NULL;
669    }
670    if (error)
671       *error = ret;
672    return st;
673 }
674
675 static void surround_rate_allocation(
676       OpusMSEncoder *st,
677       opus_int32 *rate,
678       int frame_size,
679       opus_int32 Fs
680       )
681 {
682    int i;
683    opus_int32 channel_rate;
684    int stream_offset;
685    int lfe_offset;
686    int coupled_ratio; /* Q8 */
687    int lfe_ratio;     /* Q8 */
688
689    if (st->bitrate_bps > st->layout.nb_channels*40000)
690       stream_offset = 20000;
691    else
692       stream_offset = st->bitrate_bps/st->layout.nb_channels/2;
693    stream_offset += 60*(Fs/frame_size-50);
694    /* We start by giving each stream (coupled or uncoupled) the same bitrate.
695       This models the main saving of coupled channels over uncoupled. */
696    /* The LFE stream is an exception to the above and gets fewer bits. */
697    lfe_offset = 3500 + 60*(Fs/frame_size-50);
698    /* Coupled streams get twice the mono rate after the first 20 kb/s. */
699    coupled_ratio = 512;
700    /* Should depend on the bitrate, for now we assume LFE gets 1/8 the bits of mono */
701    lfe_ratio = 32;
702
703    /* Compute bitrate allocation between streams */
704    if (st->bitrate_bps==OPUS_AUTO)
705    {
706       channel_rate = Fs+60*Fs/frame_size;
707    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
708    {
709       channel_rate = 300000;
710    } else {
711       int nb_lfe;
712       int nb_uncoupled;
713       int nb_coupled;
714       int total;
715       nb_lfe = (st->lfe_stream!=-1);
716       nb_coupled = st->layout.nb_coupled_streams;
717       nb_uncoupled = st->layout.nb_streams-nb_coupled-nb_lfe;
718       total = (nb_uncoupled<<8)         /* mono */
719             + coupled_ratio*nb_coupled /* stereo */
720             + nb_lfe*lfe_ratio;
721       channel_rate = 256*(opus_int64)(st->bitrate_bps-lfe_offset*nb_lfe-stream_offset*(nb_coupled+nb_uncoupled))/total;
722    }
723 #ifndef FIXED_POINT
724    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
725    {
726       opus_int32 bonus;
727       bonus = 60*(Fs/frame_size-50);
728       channel_rate += bonus;
729    }
730 #endif
731
732    for (i=0;i<st->layout.nb_streams;i++)
733    {
734       if (i<st->layout.nb_coupled_streams)
735          rate[i] = stream_offset+(channel_rate*coupled_ratio>>8);
736       else if (i!=st->lfe_stream)
737          rate[i] = stream_offset+channel_rate;
738       else
739          rate[i] = lfe_offset+(channel_rate*lfe_ratio>>8);
740    }
741 }
742
743 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
744 static void ambisonics_rate_allocation(
745       OpusMSEncoder *st,
746       opus_int32 *rate,
747       int frame_size,
748       opus_int32 Fs
749       )
750 {
751    int i;
752    int non_mono_rate;
753    int total_rate;
754
755    /* The mono channel gets (rate_ratio_num / rate_ratio_den) times as many bits
756     * as all other channels */
757    const int rate_ratio_num = 4;
758    const int rate_ratio_den = 3;
759    const int num_channels = st->layout.nb_streams;
760
761    if (st->bitrate_bps==OPUS_AUTO)
762    {
763       total_rate = (st->layout.nb_coupled_streams + st->layout.nb_streams) *
764          (Fs+60*Fs/frame_size) + st->layout.nb_streams * 15000;
765    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
766    {
767       total_rate = num_channels * 320000;
768    } else {
769       total_rate = st->bitrate_bps;
770    }
771
772    /* Let y be the non-mono rate and let p, q be integers such that the mono
773     * channel rate is (p/q) * y.
774     * Also let T be the total bitrate to allocate. Then
775     *   (n - 1) y + (p/q) y = T
776     *   y = (T q) / (qn - q + p)
777     */
778    non_mono_rate =
779          total_rate * rate_ratio_den
780          / (rate_ratio_den*num_channels + rate_ratio_num - rate_ratio_den);
781
782 #ifndef FIXED_POINT
783    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
784    {
785       opus_int32 bonus = 60*(Fs/frame_size-50);
786       non_mono_rate += bonus;
787    }
788 #endif
789
790    rate[0] = total_rate - (num_channels - 1) * non_mono_rate;
791    for (i=1;i<st->layout.nb_streams;i++)
792    {
793       rate[i] = non_mono_rate;
794    }
795 }
796 #endif /* ENABLE_EXPERIMENTAL_AMBISONICS */
797
798 static opus_int32 rate_allocation(
799       OpusMSEncoder *st,
800       opus_int32 *rate,
801       int frame_size
802       )
803 {
804    int i;
805    opus_int32 rate_sum=0;
806    opus_int32 Fs;
807    char *ptr;
808
809    ptr = (char*)st + align(sizeof(OpusMSEncoder));
810    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
811
812 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
813    if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
814      ambisonics_rate_allocation(st, rate, frame_size, Fs);
815    } else
816 #endif
817    {
818      surround_rate_allocation(st, rate, frame_size, Fs);
819    }
820
821    for (i=0;i<st->layout.nb_streams;i++)
822    {
823       rate[i] = IMAX(rate[i], 500);
824       rate_sum += rate[i];
825    }
826    return rate_sum;
827 }
828
829 /* Max size in case the encoder decides to return three frames */
830 #define MS_FRAME_TMP (3*1275+7)
831 static int opus_multistream_encode_native
832 (
833     OpusMSEncoder *st,
834     opus_copy_channel_in_func copy_channel_in,
835     const void *pcm,
836     int analysis_frame_size,
837     unsigned char *data,
838     opus_int32 max_data_bytes,
839     int lsb_depth,
840     downmix_func downmix,
841     int float_api
842 )
843 {
844    opus_int32 Fs;
845    int coupled_size;
846    int mono_size;
847    int s;
848    char *ptr;
849    int tot_size;
850    VARDECL(opus_val16, buf);
851    VARDECL(opus_val16, bandSMR);
852    unsigned char tmp_data[MS_FRAME_TMP];
853    OpusRepacketizer rp;
854    opus_int32 vbr;
855    const CELTMode *celt_mode;
856    opus_int32 bitrates[256];
857    opus_val16 bandLogE[42];
858    opus_val32 *mem = NULL;
859    opus_val32 *preemph_mem=NULL;
860    int frame_size;
861    opus_int32 rate_sum;
862    opus_int32 smallest_packet;
863    ALLOC_STACK;
864
865    if (st->mapping_type == MAPPING_TYPE_SURROUND)
866    {
867       preemph_mem = ms_get_preemph_mem(st);
868       mem = ms_get_window_mem(st);
869    }
870
871    ptr = (char*)st + align(sizeof(OpusMSEncoder));
872    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
873    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_VBR(&vbr));
874    opus_encoder_ctl((OpusEncoder*)ptr, CELT_GET_MODE(&celt_mode));
875
876    {
877       opus_int32 delay_compensation;
878
879       opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_LOOKAHEAD(&delay_compensation));
880       delay_compensation -= Fs/400;
881       frame_size = compute_frame_size(pcm, analysis_frame_size,
882             st->variable_duration, st->layout.nb_channels, Fs, st->bitrate_bps,
883             delay_compensation, downmix
884 #ifndef DISABLE_FLOAT_API
885             , st->subframe_mem
886 #endif
887             );
888    }
889
890    if (400*frame_size < Fs)
891    {
892       RESTORE_STACK;
893       return OPUS_BAD_ARG;
894    }
895    /* Validate frame_size before using it to allocate stack space.
896       This mirrors the checks in opus_encode[_float](). */
897    if (400*frame_size != Fs && 200*frame_size != Fs &&
898        100*frame_size != Fs &&  50*frame_size != Fs &&
899         25*frame_size != Fs &&  50*frame_size != 3*Fs)
900    {
901       RESTORE_STACK;
902       return OPUS_BAD_ARG;
903    }
904
905    /* Smallest packet the encoder can produce. */
906    smallest_packet = st->layout.nb_streams*2-1;
907    if (max_data_bytes < smallest_packet)
908    {
909       RESTORE_STACK;
910       return OPUS_BUFFER_TOO_SMALL;
911    }
912    ALLOC(buf, 2*frame_size, opus_val16);
913    coupled_size = opus_encoder_get_size(2);
914    mono_size = opus_encoder_get_size(1);
915
916    ALLOC(bandSMR, 21*st->layout.nb_channels, opus_val16);
917    if (st->mapping_type == MAPPING_TYPE_SURROUND)
918    {
919       surround_analysis(celt_mode, pcm, bandSMR, mem, preemph_mem, frame_size, 120, st->layout.nb_channels, Fs, copy_channel_in, st->arch);
920    }
921
922    /* Compute bitrate allocation between streams (this could be a lot better) */
923    rate_sum = rate_allocation(st, bitrates, frame_size);
924
925    if (!vbr)
926    {
927       if (st->bitrate_bps == OPUS_AUTO)
928       {
929          max_data_bytes = IMIN(max_data_bytes, 3*rate_sum/(3*8*Fs/frame_size));
930       } else if (st->bitrate_bps != OPUS_BITRATE_MAX)
931       {
932          max_data_bytes = IMIN(max_data_bytes, IMAX(smallest_packet,
933                           3*st->bitrate_bps/(3*8*Fs/frame_size)));
934       }
935    }
936    ptr = (char*)st + align(sizeof(OpusMSEncoder));
937    for (s=0;s<st->layout.nb_streams;s++)
938    {
939       OpusEncoder *enc;
940       enc = (OpusEncoder*)ptr;
941       if (s < st->layout.nb_coupled_streams)
942          ptr += align(coupled_size);
943       else
944          ptr += align(mono_size);
945       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrates[s]));
946       if (st->mapping_type == MAPPING_TYPE_SURROUND)
947       {
948          opus_int32 equiv_rate;
949          equiv_rate = st->bitrate_bps;
950          if (frame_size*50 < Fs)
951             equiv_rate -= 60*(Fs/frame_size - 50)*st->layout.nb_channels;
952          if (equiv_rate > 10000*st->layout.nb_channels)
953             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
954          else if (equiv_rate > 7000*st->layout.nb_channels)
955             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_SUPERWIDEBAND));
956          else if (equiv_rate > 5000*st->layout.nb_channels)
957             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_WIDEBAND));
958          else
959             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));
960          if (s < st->layout.nb_coupled_streams)
961          {
962             /* To preserve the spatial image, force stereo CELT on coupled streams */
963             opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
964             opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(2));
965          }
966       }
967 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
968       else if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
969         opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
970       }
971 #endif
972    }
973
974    ptr = (char*)st + align(sizeof(OpusMSEncoder));
975    /* Counting ToC */
976    tot_size = 0;
977    for (s=0;s<st->layout.nb_streams;s++)
978    {
979       OpusEncoder *enc;
980       int len;
981       int curr_max;
982       int c1, c2;
983       int ret;
984
985       opus_repacketizer_init(&rp);
986       enc = (OpusEncoder*)ptr;
987       if (s < st->layout.nb_coupled_streams)
988       {
989          int i;
990          int left, right;
991          left = get_left_channel(&st->layout, s, -1);
992          right = get_right_channel(&st->layout, s, -1);
993          (*copy_channel_in)(buf, 2,
994             pcm, st->layout.nb_channels, left, frame_size);
995          (*copy_channel_in)(buf+1, 2,
996             pcm, st->layout.nb_channels, right, frame_size);
997          ptr += align(coupled_size);
998          if (st->mapping_type == MAPPING_TYPE_SURROUND)
999          {
1000             for (i=0;i<21;i++)
1001             {
1002                bandLogE[i] = bandSMR[21*left+i];
1003                bandLogE[21+i] = bandSMR[21*right+i];
1004             }
1005          }
1006          c1 = left;
1007          c2 = right;
1008       } else {
1009          int i;
1010          int chan = get_mono_channel(&st->layout, s, -1);
1011          (*copy_channel_in)(buf, 1,
1012             pcm, st->layout.nb_channels, chan, frame_size);
1013          ptr += align(mono_size);
1014          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1015          {
1016             for (i=0;i<21;i++)
1017                bandLogE[i] = bandSMR[21*chan+i];
1018          }
1019          c1 = chan;
1020          c2 = -1;
1021       }
1022       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1023          opus_encoder_ctl(enc, OPUS_SET_ENERGY_MASK(bandLogE));
1024       /* number of bytes left (+Toc) */
1025       curr_max = max_data_bytes - tot_size;
1026       /* Reserve one byte for the last stream and two for the others */
1027       curr_max -= IMAX(0,2*(st->layout.nb_streams-s-1)-1);
1028       curr_max = IMIN(curr_max,MS_FRAME_TMP);
1029       /* Repacketizer will add one or two bytes for self-delimited frames */
1030       if (s != st->layout.nb_streams-1) curr_max -=  curr_max>253 ? 2 : 1;
1031       if (!vbr && s == st->layout.nb_streams-1)
1032          opus_encoder_ctl(enc, OPUS_SET_BITRATE(curr_max*(8*Fs/frame_size)));
1033       len = opus_encode_native(enc, buf, frame_size, tmp_data, curr_max, lsb_depth,
1034             pcm, analysis_frame_size, c1, c2, st->layout.nb_channels, downmix, float_api);
1035       if (len<0)
1036       {
1037          RESTORE_STACK;
1038          return len;
1039       }
1040       /* We need to use the repacketizer to add the self-delimiting lengths
1041          while taking into account the fact that the encoder can now return
1042          more than one frame at a time (e.g. 60 ms CELT-only) */
1043       ret = opus_repacketizer_cat(&rp, tmp_data, len);
1044       /* If the opus_repacketizer_cat() fails, then something's seriously wrong
1045          with the encoder. */
1046       if (ret != OPUS_OK)
1047       {
1048          RESTORE_STACK;
1049          return OPUS_INTERNAL_ERROR;
1050       }
1051       len = opus_repacketizer_out_range_impl(&rp, 0, opus_repacketizer_get_nb_frames(&rp),
1052             data, max_data_bytes-tot_size, s != st->layout.nb_streams-1, !vbr && s == st->layout.nb_streams-1);
1053       data += len;
1054       tot_size += len;
1055    }
1056    /*printf("\n");*/
1057    RESTORE_STACK;
1058    return tot_size;
1059 }
1060
1061 #if !defined(DISABLE_FLOAT_API)
1062 static void opus_copy_channel_in_float(
1063   opus_val16 *dst,
1064   int dst_stride,
1065   const void *src,
1066   int src_stride,
1067   int src_channel,
1068   int frame_size
1069 )
1070 {
1071    const float *float_src;
1072    opus_int32 i;
1073    float_src = (const float *)src;
1074    for (i=0;i<frame_size;i++)
1075 #if defined(FIXED_POINT)
1076       dst[i*dst_stride] = FLOAT2INT16(float_src[i*src_stride+src_channel]);
1077 #else
1078       dst[i*dst_stride] = float_src[i*src_stride+src_channel];
1079 #endif
1080 }
1081 #endif
1082
1083 static void opus_copy_channel_in_short(
1084   opus_val16 *dst,
1085   int dst_stride,
1086   const void *src,
1087   int src_stride,
1088   int src_channel,
1089   int frame_size
1090 )
1091 {
1092    const opus_int16 *short_src;
1093    opus_int32 i;
1094    short_src = (const opus_int16 *)src;
1095    for (i=0;i<frame_size;i++)
1096 #if defined(FIXED_POINT)
1097       dst[i*dst_stride] = short_src[i*src_stride+src_channel];
1098 #else
1099       dst[i*dst_stride] = (1/32768.f)*short_src[i*src_stride+src_channel];
1100 #endif
1101 }
1102
1103
1104 #ifdef FIXED_POINT
1105 int opus_multistream_encode(
1106     OpusMSEncoder *st,
1107     const opus_val16 *pcm,
1108     int frame_size,
1109     unsigned char *data,
1110     opus_int32 max_data_bytes
1111 )
1112 {
1113    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1114       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1115 }
1116
1117 #ifndef DISABLE_FLOAT_API
1118 int opus_multistream_encode_float(
1119     OpusMSEncoder *st,
1120     const float *pcm,
1121     int frame_size,
1122     unsigned char *data,
1123     opus_int32 max_data_bytes
1124 )
1125 {
1126    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1127       pcm, frame_size, data, max_data_bytes, 16, downmix_float, 1);
1128 }
1129 #endif
1130
1131 #else
1132
1133 int opus_multistream_encode_float
1134 (
1135     OpusMSEncoder *st,
1136     const opus_val16 *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_float,
1143       pcm, frame_size, data, max_data_bytes, 24, downmix_float, 1);
1144 }
1145
1146 int opus_multistream_encode(
1147     OpusMSEncoder *st,
1148     const opus_int16 *pcm,
1149     int frame_size,
1150     unsigned char *data,
1151     opus_int32 max_data_bytes
1152 )
1153 {
1154    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1155       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1156 }
1157 #endif
1158
1159 int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...)
1160 {
1161    va_list ap;
1162    int coupled_size, mono_size;
1163    char *ptr;
1164    int ret = OPUS_OK;
1165
1166    va_start(ap, request);
1167
1168    coupled_size = opus_encoder_get_size(2);
1169    mono_size = opus_encoder_get_size(1);
1170    ptr = (char*)st + align(sizeof(OpusMSEncoder));
1171    switch (request)
1172    {
1173    case OPUS_SET_BITRATE_REQUEST:
1174    {
1175       opus_int32 value = va_arg(ap, opus_int32);
1176       if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1177       {
1178          if (value <= 0)
1179             goto bad_arg;
1180          value = IMIN(300000*st->layout.nb_channels, IMAX(500*st->layout.nb_channels, value));
1181       }
1182       st->bitrate_bps = value;
1183    }
1184    break;
1185    case OPUS_GET_BITRATE_REQUEST:
1186    {
1187       int s;
1188       opus_int32 *value = va_arg(ap, opus_int32*);
1189       if (!value)
1190       {
1191          goto bad_arg;
1192       }
1193       *value = 0;
1194       for (s=0;s<st->layout.nb_streams;s++)
1195       {
1196          opus_int32 rate;
1197          OpusEncoder *enc;
1198          enc = (OpusEncoder*)ptr;
1199          if (s < st->layout.nb_coupled_streams)
1200             ptr += align(coupled_size);
1201          else
1202             ptr += align(mono_size);
1203          opus_encoder_ctl(enc, request, &rate);
1204          *value += rate;
1205       }
1206    }
1207    break;
1208    case OPUS_GET_LSB_DEPTH_REQUEST:
1209    case OPUS_GET_VBR_REQUEST:
1210    case OPUS_GET_APPLICATION_REQUEST:
1211    case OPUS_GET_BANDWIDTH_REQUEST:
1212    case OPUS_GET_COMPLEXITY_REQUEST:
1213    case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1214    case OPUS_GET_DTX_REQUEST:
1215    case OPUS_GET_VOICE_RATIO_REQUEST:
1216    case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1217    case OPUS_GET_SIGNAL_REQUEST:
1218    case OPUS_GET_LOOKAHEAD_REQUEST:
1219    case OPUS_GET_SAMPLE_RATE_REQUEST:
1220    case OPUS_GET_INBAND_FEC_REQUEST:
1221    case OPUS_GET_FORCE_CHANNELS_REQUEST:
1222    case OPUS_GET_PREDICTION_DISABLED_REQUEST:
1223    case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
1224    {
1225       OpusEncoder *enc;
1226       /* For int32* GET params, just query the first stream */
1227       opus_int32 *value = va_arg(ap, opus_int32*);
1228       enc = (OpusEncoder*)ptr;
1229       ret = opus_encoder_ctl(enc, request, value);
1230    }
1231    break;
1232    case OPUS_GET_FINAL_RANGE_REQUEST:
1233    {
1234       int s;
1235       opus_uint32 *value = va_arg(ap, opus_uint32*);
1236       opus_uint32 tmp;
1237       if (!value)
1238       {
1239          goto bad_arg;
1240       }
1241       *value=0;
1242       for (s=0;s<st->layout.nb_streams;s++)
1243       {
1244          OpusEncoder *enc;
1245          enc = (OpusEncoder*)ptr;
1246          if (s < st->layout.nb_coupled_streams)
1247             ptr += align(coupled_size);
1248          else
1249             ptr += align(mono_size);
1250          ret = opus_encoder_ctl(enc, request, &tmp);
1251          if (ret != OPUS_OK) break;
1252          *value ^= tmp;
1253       }
1254    }
1255    break;
1256    case OPUS_SET_LSB_DEPTH_REQUEST:
1257    case OPUS_SET_COMPLEXITY_REQUEST:
1258    case OPUS_SET_VBR_REQUEST:
1259    case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1260    case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1261    case OPUS_SET_BANDWIDTH_REQUEST:
1262    case OPUS_SET_SIGNAL_REQUEST:
1263    case OPUS_SET_APPLICATION_REQUEST:
1264    case OPUS_SET_INBAND_FEC_REQUEST:
1265    case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1266    case OPUS_SET_DTX_REQUEST:
1267    case OPUS_SET_FORCE_MODE_REQUEST:
1268    case OPUS_SET_FORCE_CHANNELS_REQUEST:
1269    case OPUS_SET_PREDICTION_DISABLED_REQUEST:
1270    case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
1271    {
1272       int s;
1273       /* This works for int32 params */
1274       opus_int32 value = va_arg(ap, opus_int32);
1275       for (s=0;s<st->layout.nb_streams;s++)
1276       {
1277          OpusEncoder *enc;
1278
1279          enc = (OpusEncoder*)ptr;
1280          if (s < st->layout.nb_coupled_streams)
1281             ptr += align(coupled_size);
1282          else
1283             ptr += align(mono_size);
1284          ret = opus_encoder_ctl(enc, request, value);
1285          if (ret != OPUS_OK)
1286             break;
1287       }
1288    }
1289    break;
1290    case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
1291    {
1292       int s;
1293       opus_int32 stream_id;
1294       OpusEncoder **value;
1295       stream_id = va_arg(ap, opus_int32);
1296       if (stream_id<0 || stream_id >= st->layout.nb_streams)
1297          ret = OPUS_BAD_ARG;
1298       value = va_arg(ap, OpusEncoder**);
1299       if (!value)
1300       {
1301          goto bad_arg;
1302       }
1303       for (s=0;s<stream_id;s++)
1304       {
1305          if (s < st->layout.nb_coupled_streams)
1306             ptr += align(coupled_size);
1307          else
1308             ptr += align(mono_size);
1309       }
1310       *value = (OpusEncoder*)ptr;
1311    }
1312    break;
1313    case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
1314    {
1315        opus_int32 value = va_arg(ap, opus_int32);
1316        st->variable_duration = value;
1317    }
1318    break;
1319    case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
1320    {
1321        opus_int32 *value = va_arg(ap, opus_int32*);
1322        if (!value)
1323        {
1324           goto bad_arg;
1325        }
1326        *value = st->variable_duration;
1327    }
1328    break;
1329    case OPUS_RESET_STATE:
1330    {
1331       int s;
1332       st->subframe_mem[0] = st->subframe_mem[1] = st->subframe_mem[2] = 0;
1333       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1334       {
1335          OPUS_CLEAR(ms_get_preemph_mem(st), st->layout.nb_channels);
1336          OPUS_CLEAR(ms_get_window_mem(st), st->layout.nb_channels*120);
1337       }
1338       for (s=0;s<st->layout.nb_streams;s++)
1339       {
1340          OpusEncoder *enc;
1341          enc = (OpusEncoder*)ptr;
1342          if (s < st->layout.nb_coupled_streams)
1343             ptr += align(coupled_size);
1344          else
1345             ptr += align(mono_size);
1346          ret = opus_encoder_ctl(enc, OPUS_RESET_STATE);
1347          if (ret != OPUS_OK)
1348             break;
1349       }
1350    }
1351    break;
1352    default:
1353       ret = OPUS_UNIMPLEMENTED;
1354       break;
1355    }
1356
1357    va_end(ap);
1358    return ret;
1359 bad_arg:
1360    va_end(ap);
1361    return OPUS_BAD_ARG;
1362 }
1363
1364 void opus_multistream_encoder_destroy(OpusMSEncoder *st)
1365 {
1366     opus_free(st);
1367 }