Consider per-channel energy bits in surround_rate_allocation()
[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    int nb_lfe;
689    int nb_uncoupled;
690    int nb_coupled;
691    int nb_normal;
692    opus_int32 channel_offset;
693    opus_int32 bitrate;
694    int total;
695
696    nb_lfe = (st->lfe_stream!=-1);
697    nb_coupled = st->layout.nb_coupled_streams;
698    nb_uncoupled = st->layout.nb_streams-nb_coupled-nb_lfe;
699    nb_normal = 2*nb_coupled + nb_uncoupled;
700
701    /* Give each non-LFE channel enough bits per channel for coding band energy. */
702    channel_offset = 40*IMAX(50, Fs/frame_size);
703
704    if (st->bitrate_bps==OPUS_AUTO)
705    {
706       bitrate = nb_normal*(channel_offset + Fs + 10000) + 8000*nb_lfe;
707    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
708    {
709       bitrate = nb_normal*300000 + nb_lfe*128000;
710    } else {
711       bitrate = st->bitrate_bps;
712    }
713
714    /* Give LFE some basic stream_channel allocation but never exceed 1/20 of the
715       total rate for the non-energy part to avoid problems at really low rate. */
716    lfe_offset = IMIN(bitrate/20, 3000) + 15*IMAX(50, Fs/frame_size);
717
718    /* We give each stream (coupled or uncoupled) a starting bitrate.
719       This models the main saving of coupled channels over uncoupled. */
720    stream_offset = (bitrate - channel_offset*nb_normal - lfe_offset*nb_lfe)/nb_normal/2;
721    stream_offset = IMAX(0, IMIN(20000, stream_offset));
722
723    /* Coupled streams get twice the mono rate after the offset is allocated. */
724    coupled_ratio = 512;
725    /* Should depend on the bitrate, for now we assume LFE gets 1/8 the bits of mono */
726    lfe_ratio = 32;
727
728    total = (nb_uncoupled<<8)         /* mono */
729          + coupled_ratio*nb_coupled /* stereo */
730          + nb_lfe*lfe_ratio;
731    channel_rate = 256*(opus_int64)(bitrate - lfe_offset*nb_lfe - stream_offset*(nb_coupled+nb_uncoupled) - channel_offset*nb_normal)/total;
732 #ifndef FIXED_POINT
733    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
734    {
735       opus_int32 bonus;
736       bonus = 60*(Fs/frame_size-50);
737       channel_rate += bonus;
738    }
739 #endif
740
741    for (i=0;i<st->layout.nb_streams;i++)
742    {
743       if (i<st->layout.nb_coupled_streams)
744          rate[i] = 2*channel_offset + IMAX(0, stream_offset+(channel_rate*coupled_ratio>>8));
745       else if (i!=st->lfe_stream)
746          rate[i] = channel_offset + IMAX(0, stream_offset + channel_rate);
747       else
748          rate[i] = IMAX(0, lfe_offset+(channel_rate*lfe_ratio>>8));
749    }
750 }
751
752 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
753 static void ambisonics_rate_allocation(
754       OpusMSEncoder *st,
755       opus_int32 *rate,
756       int frame_size,
757       opus_int32 Fs
758       )
759 {
760    int i;
761    int non_mono_rate;
762    int total_rate;
763
764    /* The mono channel gets (rate_ratio_num / rate_ratio_den) times as many bits
765     * as all other channels */
766    const int rate_ratio_num = 4;
767    const int rate_ratio_den = 3;
768    const int num_channels = st->layout.nb_streams;
769
770    if (st->bitrate_bps==OPUS_AUTO)
771    {
772       total_rate = (st->layout.nb_coupled_streams + st->layout.nb_streams) *
773          (Fs+60*Fs/frame_size) + st->layout.nb_streams * 15000;
774    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
775    {
776       total_rate = num_channels * 320000;
777    } else {
778       total_rate = st->bitrate_bps;
779    }
780
781    /* Let y be the non-mono rate and let p, q be integers such that the mono
782     * channel rate is (p/q) * y.
783     * Also let T be the total bitrate to allocate. Then
784     *   (n - 1) y + (p/q) y = T
785     *   y = (T q) / (qn - q + p)
786     */
787    non_mono_rate =
788          total_rate * rate_ratio_den
789          / (rate_ratio_den*num_channels + rate_ratio_num - rate_ratio_den);
790
791 #ifndef FIXED_POINT
792    if (st->variable_duration==OPUS_FRAMESIZE_VARIABLE && frame_size != Fs/50)
793    {
794       opus_int32 bonus = 60*(Fs/frame_size-50);
795       non_mono_rate += bonus;
796    }
797 #endif
798
799    rate[0] = total_rate - (num_channels - 1) * non_mono_rate;
800    for (i=1;i<st->layout.nb_streams;i++)
801    {
802       rate[i] = non_mono_rate;
803    }
804 }
805 #endif /* ENABLE_EXPERIMENTAL_AMBISONICS */
806
807 static opus_int32 rate_allocation(
808       OpusMSEncoder *st,
809       opus_int32 *rate,
810       int frame_size
811       )
812 {
813    int i;
814    opus_int32 rate_sum=0;
815    opus_int32 Fs;
816    char *ptr;
817
818    ptr = (char*)st + align(sizeof(OpusMSEncoder));
819    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
820
821 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
822    if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
823      ambisonics_rate_allocation(st, rate, frame_size, Fs);
824    } else
825 #endif
826    {
827      surround_rate_allocation(st, rate, frame_size, Fs);
828    }
829
830    for (i=0;i<st->layout.nb_streams;i++)
831    {
832       rate[i] = IMAX(rate[i], 500);
833       rate_sum += rate[i];
834    }
835    return rate_sum;
836 }
837
838 /* Max size in case the encoder decides to return three frames */
839 #define MS_FRAME_TMP (3*1275+7)
840 static int opus_multistream_encode_native
841 (
842     OpusMSEncoder *st,
843     opus_copy_channel_in_func copy_channel_in,
844     const void *pcm,
845     int analysis_frame_size,
846     unsigned char *data,
847     opus_int32 max_data_bytes,
848     int lsb_depth,
849     downmix_func downmix,
850     int float_api
851 )
852 {
853    opus_int32 Fs;
854    int coupled_size;
855    int mono_size;
856    int s;
857    char *ptr;
858    int tot_size;
859    VARDECL(opus_val16, buf);
860    VARDECL(opus_val16, bandSMR);
861    unsigned char tmp_data[MS_FRAME_TMP];
862    OpusRepacketizer rp;
863    opus_int32 vbr;
864    const CELTMode *celt_mode;
865    opus_int32 bitrates[256];
866    opus_val16 bandLogE[42];
867    opus_val32 *mem = NULL;
868    opus_val32 *preemph_mem=NULL;
869    int frame_size;
870    opus_int32 rate_sum;
871    opus_int32 smallest_packet;
872    ALLOC_STACK;
873
874    if (st->mapping_type == MAPPING_TYPE_SURROUND)
875    {
876       preemph_mem = ms_get_preemph_mem(st);
877       mem = ms_get_window_mem(st);
878    }
879
880    ptr = (char*)st + align(sizeof(OpusMSEncoder));
881    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
882    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_VBR(&vbr));
883    opus_encoder_ctl((OpusEncoder*)ptr, CELT_GET_MODE(&celt_mode));
884
885    {
886       opus_int32 delay_compensation;
887
888       opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_LOOKAHEAD(&delay_compensation));
889       delay_compensation -= Fs/400;
890       frame_size = compute_frame_size(pcm, analysis_frame_size,
891             st->variable_duration, st->layout.nb_channels, Fs, st->bitrate_bps,
892             delay_compensation, downmix
893 #ifndef DISABLE_FLOAT_API
894             , st->subframe_mem
895 #endif
896             );
897    }
898
899    if (400*frame_size < Fs)
900    {
901       RESTORE_STACK;
902       return OPUS_BAD_ARG;
903    }
904    /* Validate frame_size before using it to allocate stack space.
905       This mirrors the checks in opus_encode[_float](). */
906    if (400*frame_size != Fs && 200*frame_size != Fs &&
907        100*frame_size != Fs &&  50*frame_size != Fs &&
908         25*frame_size != Fs &&  50*frame_size != 3*Fs)
909    {
910       RESTORE_STACK;
911       return OPUS_BAD_ARG;
912    }
913
914    /* Smallest packet the encoder can produce. */
915    smallest_packet = st->layout.nb_streams*2-1;
916    if (max_data_bytes < smallest_packet)
917    {
918       RESTORE_STACK;
919       return OPUS_BUFFER_TOO_SMALL;
920    }
921    ALLOC(buf, 2*frame_size, opus_val16);
922    coupled_size = opus_encoder_get_size(2);
923    mono_size = opus_encoder_get_size(1);
924
925    ALLOC(bandSMR, 21*st->layout.nb_channels, opus_val16);
926    if (st->mapping_type == MAPPING_TYPE_SURROUND)
927    {
928       surround_analysis(celt_mode, pcm, bandSMR, mem, preemph_mem, frame_size, 120, st->layout.nb_channels, Fs, copy_channel_in, st->arch);
929    }
930
931    /* Compute bitrate allocation between streams (this could be a lot better) */
932    rate_sum = rate_allocation(st, bitrates, frame_size);
933
934    if (!vbr)
935    {
936       if (st->bitrate_bps == OPUS_AUTO)
937       {
938          max_data_bytes = IMIN(max_data_bytes, 3*rate_sum/(3*8*Fs/frame_size));
939       } else if (st->bitrate_bps != OPUS_BITRATE_MAX)
940       {
941          max_data_bytes = IMIN(max_data_bytes, IMAX(smallest_packet,
942                           3*st->bitrate_bps/(3*8*Fs/frame_size)));
943       }
944    }
945    ptr = (char*)st + align(sizeof(OpusMSEncoder));
946    for (s=0;s<st->layout.nb_streams;s++)
947    {
948       OpusEncoder *enc;
949       enc = (OpusEncoder*)ptr;
950       if (s < st->layout.nb_coupled_streams)
951          ptr += align(coupled_size);
952       else
953          ptr += align(mono_size);
954       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrates[s]));
955       if (st->mapping_type == MAPPING_TYPE_SURROUND)
956       {
957          opus_int32 equiv_rate;
958          equiv_rate = st->bitrate_bps;
959          if (frame_size*50 < Fs)
960             equiv_rate -= 60*(Fs/frame_size - 50)*st->layout.nb_channels;
961          if (equiv_rate > 10000*st->layout.nb_channels)
962             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
963          else if (equiv_rate > 7000*st->layout.nb_channels)
964             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_SUPERWIDEBAND));
965          else if (equiv_rate > 5000*st->layout.nb_channels)
966             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_WIDEBAND));
967          else
968             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));
969          if (s < st->layout.nb_coupled_streams)
970          {
971             /* To preserve the spatial image, force stereo CELT on coupled streams */
972             opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
973             opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(2));
974          }
975       }
976 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
977       else if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
978         opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
979       }
980 #endif
981    }
982
983    ptr = (char*)st + align(sizeof(OpusMSEncoder));
984    /* Counting ToC */
985    tot_size = 0;
986    for (s=0;s<st->layout.nb_streams;s++)
987    {
988       OpusEncoder *enc;
989       int len;
990       int curr_max;
991       int c1, c2;
992       int ret;
993
994       opus_repacketizer_init(&rp);
995       enc = (OpusEncoder*)ptr;
996       if (s < st->layout.nb_coupled_streams)
997       {
998          int i;
999          int left, right;
1000          left = get_left_channel(&st->layout, s, -1);
1001          right = get_right_channel(&st->layout, s, -1);
1002          (*copy_channel_in)(buf, 2,
1003             pcm, st->layout.nb_channels, left, frame_size);
1004          (*copy_channel_in)(buf+1, 2,
1005             pcm, st->layout.nb_channels, right, frame_size);
1006          ptr += align(coupled_size);
1007          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1008          {
1009             for (i=0;i<21;i++)
1010             {
1011                bandLogE[i] = bandSMR[21*left+i];
1012                bandLogE[21+i] = bandSMR[21*right+i];
1013             }
1014          }
1015          c1 = left;
1016          c2 = right;
1017       } else {
1018          int i;
1019          int chan = get_mono_channel(&st->layout, s, -1);
1020          (*copy_channel_in)(buf, 1,
1021             pcm, st->layout.nb_channels, chan, frame_size);
1022          ptr += align(mono_size);
1023          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1024          {
1025             for (i=0;i<21;i++)
1026                bandLogE[i] = bandSMR[21*chan+i];
1027          }
1028          c1 = chan;
1029          c2 = -1;
1030       }
1031       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1032          opus_encoder_ctl(enc, OPUS_SET_ENERGY_MASK(bandLogE));
1033       /* number of bytes left (+Toc) */
1034       curr_max = max_data_bytes - tot_size;
1035       /* Reserve one byte for the last stream and two for the others */
1036       curr_max -= IMAX(0,2*(st->layout.nb_streams-s-1)-1);
1037       curr_max = IMIN(curr_max,MS_FRAME_TMP);
1038       /* Repacketizer will add one or two bytes for self-delimited frames */
1039       if (s != st->layout.nb_streams-1) curr_max -=  curr_max>253 ? 2 : 1;
1040       if (!vbr && s == st->layout.nb_streams-1)
1041          opus_encoder_ctl(enc, OPUS_SET_BITRATE(curr_max*(8*Fs/frame_size)));
1042       len = opus_encode_native(enc, buf, frame_size, tmp_data, curr_max, lsb_depth,
1043             pcm, analysis_frame_size, c1, c2, st->layout.nb_channels, downmix, float_api);
1044       if (len<0)
1045       {
1046          RESTORE_STACK;
1047          return len;
1048       }
1049       /* We need to use the repacketizer to add the self-delimiting lengths
1050          while taking into account the fact that the encoder can now return
1051          more than one frame at a time (e.g. 60 ms CELT-only) */
1052       ret = opus_repacketizer_cat(&rp, tmp_data, len);
1053       /* If the opus_repacketizer_cat() fails, then something's seriously wrong
1054          with the encoder. */
1055       if (ret != OPUS_OK)
1056       {
1057          RESTORE_STACK;
1058          return OPUS_INTERNAL_ERROR;
1059       }
1060       len = opus_repacketizer_out_range_impl(&rp, 0, opus_repacketizer_get_nb_frames(&rp),
1061             data, max_data_bytes-tot_size, s != st->layout.nb_streams-1, !vbr && s == st->layout.nb_streams-1);
1062       data += len;
1063       tot_size += len;
1064    }
1065    /*printf("\n");*/
1066    RESTORE_STACK;
1067    return tot_size;
1068 }
1069
1070 #if !defined(DISABLE_FLOAT_API)
1071 static void opus_copy_channel_in_float(
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 float *float_src;
1081    opus_int32 i;
1082    float_src = (const float *)src;
1083    for (i=0;i<frame_size;i++)
1084 #if defined(FIXED_POINT)
1085       dst[i*dst_stride] = FLOAT2INT16(float_src[i*src_stride+src_channel]);
1086 #else
1087       dst[i*dst_stride] = float_src[i*src_stride+src_channel];
1088 #endif
1089 }
1090 #endif
1091
1092 static void opus_copy_channel_in_short(
1093   opus_val16 *dst,
1094   int dst_stride,
1095   const void *src,
1096   int src_stride,
1097   int src_channel,
1098   int frame_size
1099 )
1100 {
1101    const opus_int16 *short_src;
1102    opus_int32 i;
1103    short_src = (const opus_int16 *)src;
1104    for (i=0;i<frame_size;i++)
1105 #if defined(FIXED_POINT)
1106       dst[i*dst_stride] = short_src[i*src_stride+src_channel];
1107 #else
1108       dst[i*dst_stride] = (1/32768.f)*short_src[i*src_stride+src_channel];
1109 #endif
1110 }
1111
1112
1113 #ifdef FIXED_POINT
1114 int opus_multistream_encode(
1115     OpusMSEncoder *st,
1116     const opus_val16 *pcm,
1117     int frame_size,
1118     unsigned char *data,
1119     opus_int32 max_data_bytes
1120 )
1121 {
1122    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1123       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1124 }
1125
1126 #ifndef DISABLE_FLOAT_API
1127 int opus_multistream_encode_float(
1128     OpusMSEncoder *st,
1129     const float *pcm,
1130     int frame_size,
1131     unsigned char *data,
1132     opus_int32 max_data_bytes
1133 )
1134 {
1135    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1136       pcm, frame_size, data, max_data_bytes, 16, downmix_float, 1);
1137 }
1138 #endif
1139
1140 #else
1141
1142 int opus_multistream_encode_float
1143 (
1144     OpusMSEncoder *st,
1145     const opus_val16 *pcm,
1146     int frame_size,
1147     unsigned char *data,
1148     opus_int32 max_data_bytes
1149 )
1150 {
1151    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1152       pcm, frame_size, data, max_data_bytes, 24, downmix_float, 1);
1153 }
1154
1155 int opus_multistream_encode(
1156     OpusMSEncoder *st,
1157     const opus_int16 *pcm,
1158     int frame_size,
1159     unsigned char *data,
1160     opus_int32 max_data_bytes
1161 )
1162 {
1163    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1164       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1165 }
1166 #endif
1167
1168 int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...)
1169 {
1170    va_list ap;
1171    int coupled_size, mono_size;
1172    char *ptr;
1173    int ret = OPUS_OK;
1174
1175    va_start(ap, request);
1176
1177    coupled_size = opus_encoder_get_size(2);
1178    mono_size = opus_encoder_get_size(1);
1179    ptr = (char*)st + align(sizeof(OpusMSEncoder));
1180    switch (request)
1181    {
1182    case OPUS_SET_BITRATE_REQUEST:
1183    {
1184       opus_int32 value = va_arg(ap, opus_int32);
1185       if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1186       {
1187          if (value <= 0)
1188             goto bad_arg;
1189          value = IMIN(300000*st->layout.nb_channels, IMAX(500*st->layout.nb_channels, value));
1190       }
1191       st->bitrate_bps = value;
1192    }
1193    break;
1194    case OPUS_GET_BITRATE_REQUEST:
1195    {
1196       int s;
1197       opus_int32 *value = va_arg(ap, opus_int32*);
1198       if (!value)
1199       {
1200          goto bad_arg;
1201       }
1202       *value = 0;
1203       for (s=0;s<st->layout.nb_streams;s++)
1204       {
1205          opus_int32 rate;
1206          OpusEncoder *enc;
1207          enc = (OpusEncoder*)ptr;
1208          if (s < st->layout.nb_coupled_streams)
1209             ptr += align(coupled_size);
1210          else
1211             ptr += align(mono_size);
1212          opus_encoder_ctl(enc, request, &rate);
1213          *value += rate;
1214       }
1215    }
1216    break;
1217    case OPUS_GET_LSB_DEPTH_REQUEST:
1218    case OPUS_GET_VBR_REQUEST:
1219    case OPUS_GET_APPLICATION_REQUEST:
1220    case OPUS_GET_BANDWIDTH_REQUEST:
1221    case OPUS_GET_COMPLEXITY_REQUEST:
1222    case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1223    case OPUS_GET_DTX_REQUEST:
1224    case OPUS_GET_VOICE_RATIO_REQUEST:
1225    case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1226    case OPUS_GET_SIGNAL_REQUEST:
1227    case OPUS_GET_LOOKAHEAD_REQUEST:
1228    case OPUS_GET_SAMPLE_RATE_REQUEST:
1229    case OPUS_GET_INBAND_FEC_REQUEST:
1230    case OPUS_GET_FORCE_CHANNELS_REQUEST:
1231    case OPUS_GET_PREDICTION_DISABLED_REQUEST:
1232    case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
1233    {
1234       OpusEncoder *enc;
1235       /* For int32* GET params, just query the first stream */
1236       opus_int32 *value = va_arg(ap, opus_int32*);
1237       enc = (OpusEncoder*)ptr;
1238       ret = opus_encoder_ctl(enc, request, value);
1239    }
1240    break;
1241    case OPUS_GET_FINAL_RANGE_REQUEST:
1242    {
1243       int s;
1244       opus_uint32 *value = va_arg(ap, opus_uint32*);
1245       opus_uint32 tmp;
1246       if (!value)
1247       {
1248          goto bad_arg;
1249       }
1250       *value=0;
1251       for (s=0;s<st->layout.nb_streams;s++)
1252       {
1253          OpusEncoder *enc;
1254          enc = (OpusEncoder*)ptr;
1255          if (s < st->layout.nb_coupled_streams)
1256             ptr += align(coupled_size);
1257          else
1258             ptr += align(mono_size);
1259          ret = opus_encoder_ctl(enc, request, &tmp);
1260          if (ret != OPUS_OK) break;
1261          *value ^= tmp;
1262       }
1263    }
1264    break;
1265    case OPUS_SET_LSB_DEPTH_REQUEST:
1266    case OPUS_SET_COMPLEXITY_REQUEST:
1267    case OPUS_SET_VBR_REQUEST:
1268    case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1269    case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1270    case OPUS_SET_BANDWIDTH_REQUEST:
1271    case OPUS_SET_SIGNAL_REQUEST:
1272    case OPUS_SET_APPLICATION_REQUEST:
1273    case OPUS_SET_INBAND_FEC_REQUEST:
1274    case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1275    case OPUS_SET_DTX_REQUEST:
1276    case OPUS_SET_FORCE_MODE_REQUEST:
1277    case OPUS_SET_FORCE_CHANNELS_REQUEST:
1278    case OPUS_SET_PREDICTION_DISABLED_REQUEST:
1279    case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
1280    {
1281       int s;
1282       /* This works for int32 params */
1283       opus_int32 value = va_arg(ap, opus_int32);
1284       for (s=0;s<st->layout.nb_streams;s++)
1285       {
1286          OpusEncoder *enc;
1287
1288          enc = (OpusEncoder*)ptr;
1289          if (s < st->layout.nb_coupled_streams)
1290             ptr += align(coupled_size);
1291          else
1292             ptr += align(mono_size);
1293          ret = opus_encoder_ctl(enc, request, value);
1294          if (ret != OPUS_OK)
1295             break;
1296       }
1297    }
1298    break;
1299    case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
1300    {
1301       int s;
1302       opus_int32 stream_id;
1303       OpusEncoder **value;
1304       stream_id = va_arg(ap, opus_int32);
1305       if (stream_id<0 || stream_id >= st->layout.nb_streams)
1306          ret = OPUS_BAD_ARG;
1307       value = va_arg(ap, OpusEncoder**);
1308       if (!value)
1309       {
1310          goto bad_arg;
1311       }
1312       for (s=0;s<stream_id;s++)
1313       {
1314          if (s < st->layout.nb_coupled_streams)
1315             ptr += align(coupled_size);
1316          else
1317             ptr += align(mono_size);
1318       }
1319       *value = (OpusEncoder*)ptr;
1320    }
1321    break;
1322    case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
1323    {
1324        opus_int32 value = va_arg(ap, opus_int32);
1325        st->variable_duration = value;
1326    }
1327    break;
1328    case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
1329    {
1330        opus_int32 *value = va_arg(ap, opus_int32*);
1331        if (!value)
1332        {
1333           goto bad_arg;
1334        }
1335        *value = st->variable_duration;
1336    }
1337    break;
1338    case OPUS_RESET_STATE:
1339    {
1340       int s;
1341       st->subframe_mem[0] = st->subframe_mem[1] = st->subframe_mem[2] = 0;
1342       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1343       {
1344          OPUS_CLEAR(ms_get_preemph_mem(st), st->layout.nb_channels);
1345          OPUS_CLEAR(ms_get_window_mem(st), st->layout.nb_channels*120);
1346       }
1347       for (s=0;s<st->layout.nb_streams;s++)
1348       {
1349          OpusEncoder *enc;
1350          enc = (OpusEncoder*)ptr;
1351          if (s < st->layout.nb_coupled_streams)
1352             ptr += align(coupled_size);
1353          else
1354             ptr += align(mono_size);
1355          ret = opus_encoder_ctl(enc, OPUS_RESET_STATE);
1356          if (ret != OPUS_OK)
1357             break;
1358       }
1359    }
1360    break;
1361    default:
1362       ret = OPUS_UNIMPLEMENTED;
1363       break;
1364    }
1365
1366    va_end(ap);
1367    return ret;
1368 bad_arg:
1369    va_end(ap);
1370    return OPUS_BAD_ARG;
1371 }
1372
1373 void opus_multistream_encoder_destroy(OpusMSEncoder *st)
1374 {
1375     opus_free(st);
1376 }