Support for Channel Mapping 253
[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 static opus_val32 *ms_get_preemph_mem(OpusMSEncoder *st)
74 {
75    int s;
76    char *ptr;
77    int coupled_size, mono_size;
78
79    coupled_size = opus_encoder_get_size(2);
80    mono_size = opus_encoder_get_size(1);
81    ptr = (char*)st + align(sizeof(OpusMSEncoder));
82    for (s=0;s<st->layout.nb_streams;s++)
83    {
84       if (s < st->layout.nb_coupled_streams)
85          ptr += align(coupled_size);
86       else
87          ptr += align(mono_size);
88    }
89    /* void* cast avoids clang -Wcast-align warning */
90    return (opus_val32*)(void*)(ptr+st->layout.nb_channels*120*sizeof(opus_val32));
91 }
92
93 static opus_val32 *ms_get_window_mem(OpusMSEncoder *st)
94 {
95    int s;
96    char *ptr;
97    int coupled_size, mono_size;
98
99    coupled_size = opus_encoder_get_size(2);
100    mono_size = opus_encoder_get_size(1);
101    ptr = (char*)st + align(sizeof(OpusMSEncoder));
102    for (s=0;s<st->layout.nb_streams;s++)
103    {
104       if (s < st->layout.nb_coupled_streams)
105          ptr += align(coupled_size);
106       else
107          ptr += align(mono_size);
108    }
109    /* void* cast avoids clang -Wcast-align warning */
110    return (opus_val32*)(void*)ptr;
111 }
112
113 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
114 static int validate_ambisonics(int nb_channels, int *nb_streams, int *nb_coupled_streams)
115 {
116    int order_plus_one;
117    int acn_channels;
118    int nondiegetic_channels;
119
120    order_plus_one = isqrt32(nb_channels);
121    acn_channels = order_plus_one * order_plus_one;
122    nondiegetic_channels = nb_channels - acn_channels;
123
124    if (order_plus_one < 1 || order_plus_one > 15 ||
125        (nondiegetic_channels != 0 && nondiegetic_channels != 2))
126       return 0;
127
128    if (nb_streams)
129       *nb_streams = acn_channels + (nondiegetic_channels != 0);
130    if (nb_coupled_streams)
131       *nb_coupled_streams = nondiegetic_channels != 0;
132    return 1;
133 }
134 #endif
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 < 1e18f) || 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, arch);
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       if (!validate_ambisonics(channels, &nb_streams, &nb_coupled_streams))
428          return 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    if (mapping_type != MAPPING_TYPE_SURROUND)
465       st->lfe_stream = -1;
466    st->bitrate_bps = OPUS_AUTO;
467    st->application = application;
468    st->variable_duration = OPUS_FRAMESIZE_ARG;
469    for (i=0;i<st->layout.nb_channels;i++)
470       st->layout.mapping[i] = mapping[i];
471    if (!validate_layout(&st->layout))
472       return OPUS_BAD_ARG;
473    if (mapping_type == MAPPING_TYPE_SURROUND &&
474        !validate_encoder_layout(&st->layout))
475       return OPUS_BAD_ARG;
476 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
477    if (mapping_type == MAPPING_TYPE_AMBISONICS &&
478        !validate_ambisonics(st->layout.nb_channels, NULL, NULL))
479       return OPUS_BAD_ARG;
480 #endif
481    ptr = (char*)st + align(sizeof(OpusMSEncoder));
482    coupled_size = opus_encoder_get_size(2);
483    mono_size = opus_encoder_get_size(1);
484
485    for (i=0;i<st->layout.nb_coupled_streams;i++)
486    {
487       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 2, application);
488       if(ret!=OPUS_OK)return ret;
489       if (i==st->lfe_stream)
490          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
491       ptr += align(coupled_size);
492    }
493    for (;i<st->layout.nb_streams;i++)
494    {
495       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 1, application);
496       if (i==st->lfe_stream)
497          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
498       if(ret!=OPUS_OK)return ret;
499       ptr += align(mono_size);
500    }
501    if (mapping_type == MAPPING_TYPE_SURROUND)
502    {
503       OPUS_CLEAR(ms_get_preemph_mem(st), channels);
504       OPUS_CLEAR(ms_get_window_mem(st), channels*120);
505    }
506    st->mapping_type = mapping_type;
507    return OPUS_OK;
508 }
509
510 int opus_multistream_encoder_init(
511       OpusMSEncoder *st,
512       opus_int32 Fs,
513       int channels,
514       int streams,
515       int coupled_streams,
516       const unsigned char *mapping,
517       int application
518 )
519 {
520    return opus_multistream_encoder_init_impl(st, Fs, channels, streams,
521                                              coupled_streams, mapping,
522                                              application, MAPPING_TYPE_NONE);
523 }
524
525 int opus_multistream_surround_encoder_init(
526       OpusMSEncoder *st,
527       opus_int32 Fs,
528       int channels,
529       int mapping_family,
530       int *streams,
531       int *coupled_streams,
532       unsigned char *mapping,
533       int application
534 )
535 {
536    MappingType mapping_type;
537
538    if ((channels>255) || (channels<1))
539       return OPUS_BAD_ARG;
540    st->lfe_stream = -1;
541    if (mapping_family==0)
542    {
543       if (channels==1)
544       {
545          *streams=1;
546          *coupled_streams=0;
547          mapping[0]=0;
548       } else if (channels==2)
549       {
550          *streams=1;
551          *coupled_streams=1;
552          mapping[0]=0;
553          mapping[1]=1;
554       } else
555          return OPUS_UNIMPLEMENTED;
556    } else if (mapping_family==1 && channels<=8 && channels>=1)
557    {
558       int i;
559       *streams=vorbis_mappings[channels-1].nb_streams;
560       *coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
561       for (i=0;i<channels;i++)
562          mapping[i] = vorbis_mappings[channels-1].mapping[i];
563       if (channels>=6)
564          st->lfe_stream = *streams-1;
565    } else if (mapping_family==255)
566    {
567       int i;
568       *streams=channels;
569       *coupled_streams=0;
570       for(i=0;i<channels;i++)
571          mapping[i] = i;
572 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
573    } else if (mapping_family==254)
574    {
575       int i;
576       if (!validate_ambisonics(channels, streams, coupled_streams))
577          return OPUS_BAD_ARG;
578       for(i = 0; i < (*streams - *coupled_streams); i++)
579          mapping[i] = i + (*coupled_streams * 2);
580       for(i = 0; i < *coupled_streams * 2; i++)
581          mapping[i + (*streams - *coupled_streams)] = i;
582 #endif
583    } else
584       return OPUS_UNIMPLEMENTED;
585
586    if (channels>2 && mapping_family==1) {
587       mapping_type = MAPPING_TYPE_SURROUND;
588 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
589    } else if (mapping_family==254)
590    {
591       mapping_type = MAPPING_TYPE_AMBISONICS;
592 #endif
593    } else
594    {
595       mapping_type = MAPPING_TYPE_NONE;
596    }
597    return opus_multistream_encoder_init_impl(st, Fs, channels, *streams,
598                                              *coupled_streams, mapping,
599                                              application, mapping_type);
600 }
601
602 OpusMSEncoder *opus_multistream_encoder_create(
603       opus_int32 Fs,
604       int channels,
605       int streams,
606       int coupled_streams,
607       const unsigned char *mapping,
608       int application,
609       int *error
610 )
611 {
612    int ret;
613    OpusMSEncoder *st;
614    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
615        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
616    {
617       if (error)
618          *error = OPUS_BAD_ARG;
619       return NULL;
620    }
621    st = (OpusMSEncoder *)opus_alloc(opus_multistream_encoder_get_size(streams, coupled_streams));
622    if (st==NULL)
623    {
624       if (error)
625          *error = OPUS_ALLOC_FAIL;
626       return NULL;
627    }
628    ret = opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application);
629    if (ret != OPUS_OK)
630    {
631       opus_free(st);
632       st = NULL;
633    }
634    if (error)
635       *error = ret;
636    return st;
637 }
638
639 OpusMSEncoder *opus_multistream_surround_encoder_create(
640       opus_int32 Fs,
641       int channels,
642       int mapping_family,
643       int *streams,
644       int *coupled_streams,
645       unsigned char *mapping,
646       int application,
647       int *error
648 )
649 {
650    int ret;
651    opus_int32 size;
652    OpusMSEncoder *st;
653    if ((channels>255) || (channels<1))
654    {
655       if (error)
656          *error = OPUS_BAD_ARG;
657       return NULL;
658    }
659    size = opus_multistream_surround_encoder_get_size(channels, mapping_family);
660    if (!size)
661    {
662       if (error)
663          *error = OPUS_UNIMPLEMENTED;
664       return NULL;
665    }
666    st = (OpusMSEncoder *)opus_alloc(size);
667    if (st==NULL)
668    {
669       if (error)
670          *error = OPUS_ALLOC_FAIL;
671       return NULL;
672    }
673    ret = opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application);
674    if (ret != OPUS_OK)
675    {
676       opus_free(st);
677       st = NULL;
678    }
679    if (error)
680       *error = ret;
681    return st;
682 }
683
684 static void surround_rate_allocation(
685       OpusMSEncoder *st,
686       opus_int32 *rate,
687       int frame_size,
688       opus_int32 Fs
689       )
690 {
691    int i;
692    opus_int32 channel_rate;
693    int stream_offset;
694    int lfe_offset;
695    int coupled_ratio; /* Q8 */
696    int lfe_ratio;     /* Q8 */
697    int nb_lfe;
698    int nb_uncoupled;
699    int nb_coupled;
700    int nb_normal;
701    opus_int32 channel_offset;
702    opus_int32 bitrate;
703    int total;
704
705    nb_lfe = (st->lfe_stream!=-1);
706    nb_coupled = st->layout.nb_coupled_streams;
707    nb_uncoupled = st->layout.nb_streams-nb_coupled-nb_lfe;
708    nb_normal = 2*nb_coupled + nb_uncoupled;
709
710    /* Give each non-LFE channel enough bits per channel for coding band energy. */
711    channel_offset = 40*IMAX(50, Fs/frame_size);
712
713    if (st->bitrate_bps==OPUS_AUTO)
714    {
715       bitrate = nb_normal*(channel_offset + Fs + 10000) + 8000*nb_lfe;
716    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
717    {
718       bitrate = nb_normal*300000 + nb_lfe*128000;
719    } else {
720       bitrate = st->bitrate_bps;
721    }
722
723    /* Give LFE some basic stream_channel allocation but never exceed 1/20 of the
724       total rate for the non-energy part to avoid problems at really low rate. */
725    lfe_offset = IMIN(bitrate/20, 3000) + 15*IMAX(50, Fs/frame_size);
726
727    /* We give each stream (coupled or uncoupled) a starting bitrate.
728       This models the main saving of coupled channels over uncoupled. */
729    stream_offset = (bitrate - channel_offset*nb_normal - lfe_offset*nb_lfe)/nb_normal/2;
730    stream_offset = IMAX(0, IMIN(20000, stream_offset));
731
732    /* Coupled streams get twice the mono rate after the offset is allocated. */
733    coupled_ratio = 512;
734    /* Should depend on the bitrate, for now we assume LFE gets 1/8 the bits of mono */
735    lfe_ratio = 32;
736
737    total = (nb_uncoupled<<8)         /* mono */
738          + coupled_ratio*nb_coupled /* stereo */
739          + nb_lfe*lfe_ratio;
740    channel_rate = 256*(opus_int64)(bitrate - lfe_offset*nb_lfe - stream_offset*(nb_coupled+nb_uncoupled) - channel_offset*nb_normal)/total;
741
742    for (i=0;i<st->layout.nb_streams;i++)
743    {
744       if (i<st->layout.nb_coupled_streams)
745          rate[i] = 2*channel_offset + IMAX(0, stream_offset+(channel_rate*coupled_ratio>>8));
746       else if (i!=st->lfe_stream)
747          rate[i] = channel_offset + IMAX(0, stream_offset + channel_rate);
748       else
749          rate[i] = IMAX(0, lfe_offset+(channel_rate*lfe_ratio>>8));
750    }
751 }
752
753 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
754 static void ambisonics_rate_allocation(
755       OpusMSEncoder *st,
756       opus_int32 *rate,
757       int frame_size,
758       opus_int32 Fs
759       )
760 {
761    int i;
762    int total_rate;
763    int directional_rate;
764    int nondirectional_rate;
765    int leftover_bits;
766
767    /* Each nondirectional channel gets (rate_ratio_num / rate_ratio_den) times
768     * as many bits as all other ambisonics channels.
769     */
770    const int rate_ratio_num = 4;
771    const int rate_ratio_den = 3;
772    const int nb_channels = st->layout.nb_streams + st->layout.nb_coupled_streams;
773    const int nb_nondirectional_channels = st->layout.nb_coupled_streams * 2 + 1;
774    const int nb_directional_channels = st->layout.nb_streams - 1;
775
776    if (st->bitrate_bps==OPUS_AUTO)
777    {
778       total_rate = (st->layout.nb_coupled_streams + st->layout.nb_streams) *
779          (Fs+60*Fs/frame_size) + st->layout.nb_streams * 15000;
780    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
781    {
782       total_rate = nb_channels * 320000;
783    } else
784    {
785       total_rate = st->bitrate_bps;
786    }
787
788    /* Let y be the directional rate, m be the num of nondirectional channels
789     *   m = (s + 1)
790     * and let p, q be integers such that the nondirectional rate is
791     *   m_rate = (p / q) * y
792     * Also let T be the total bitrate to allocate. Then
793     *   T = (n - m) * y + m * m_rate
794     * Solving for y,
795     *   y = (q * T) / (m * (p - q) + n * q)
796     */
797    directional_rate =
798       total_rate * rate_ratio_den
799       / (nb_nondirectional_channels * (rate_ratio_num - rate_ratio_den)
800        + nb_channels * rate_ratio_den);
801
802    /* Calculate the nondirectional rate.
803     *   m_rate = y * (p / q)
804     */
805    nondirectional_rate = directional_rate * rate_ratio_num / rate_ratio_den;
806
807    /* Calculate the leftover from truncation error.
808     *   leftover = T - y * (n - m) - m_rate * m
809     * Place leftover bits in omnidirectional channel.
810     */
811    leftover_bits = total_rate
812       - directional_rate * nb_directional_channels
813       - nondirectional_rate * nb_nondirectional_channels;
814
815    /* Calculate rates for each channel */
816    for (i = 0; i < st->layout.nb_streams; i++)
817    {
818       if (i < st->layout.nb_coupled_streams)
819       {
820          rate[i] = nondirectional_rate * 2;
821       } else if (i == st->layout.nb_coupled_streams)
822       {
823          rate[i] = nondirectional_rate + leftover_bits;
824       } else
825       {
826          rate[i] = directional_rate;
827       }
828    }
829 }
830 #endif /* ENABLE_EXPERIMENTAL_AMBISONICS */
831
832 static opus_int32 rate_allocation(
833       OpusMSEncoder *st,
834       opus_int32 *rate,
835       int frame_size
836       )
837 {
838    int i;
839    opus_int32 rate_sum=0;
840    opus_int32 Fs;
841    char *ptr;
842
843    ptr = (char*)st + align(sizeof(OpusMSEncoder));
844    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
845
846 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
847    if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
848      ambisonics_rate_allocation(st, rate, frame_size, Fs);
849    } else
850 #endif
851    {
852      surround_rate_allocation(st, rate, frame_size, Fs);
853    }
854
855    for (i=0;i<st->layout.nb_streams;i++)
856    {
857       rate[i] = IMAX(rate[i], 500);
858       rate_sum += rate[i];
859    }
860    return rate_sum;
861 }
862
863 /* Max size in case the encoder decides to return six frames (6 x 20 ms = 120 ms) */
864 #define MS_FRAME_TMP (6*1275+12)
865 static int opus_multistream_encode_native
866 (
867     OpusMSEncoder *st,
868     opus_copy_channel_in_func copy_channel_in,
869     const void *pcm,
870     int analysis_frame_size,
871     unsigned char *data,
872     opus_int32 max_data_bytes,
873     int lsb_depth,
874     downmix_func downmix,
875     int float_api
876 )
877 {
878    opus_int32 Fs;
879    int coupled_size;
880    int mono_size;
881    int s;
882    char *ptr;
883    int tot_size;
884    VARDECL(opus_val16, buf);
885    VARDECL(opus_val16, bandSMR);
886    unsigned char tmp_data[MS_FRAME_TMP];
887    OpusRepacketizer rp;
888    opus_int32 vbr;
889    const CELTMode *celt_mode;
890    opus_int32 bitrates[256];
891    opus_val16 bandLogE[42];
892    opus_val32 *mem = NULL;
893    opus_val32 *preemph_mem=NULL;
894    int frame_size;
895    opus_int32 rate_sum;
896    opus_int32 smallest_packet;
897    ALLOC_STACK;
898
899    if (st->mapping_type == MAPPING_TYPE_SURROUND)
900    {
901       preemph_mem = ms_get_preemph_mem(st);
902       mem = ms_get_window_mem(st);
903    }
904
905    ptr = (char*)st + align(sizeof(OpusMSEncoder));
906    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
907    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_VBR(&vbr));
908    opus_encoder_ctl((OpusEncoder*)ptr, CELT_GET_MODE(&celt_mode));
909
910    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, Fs);
911    if (frame_size <= 0)
912    {
913       RESTORE_STACK;
914       return OPUS_BAD_ARG;
915    }
916
917    /* Smallest packet the encoder can produce. */
918    smallest_packet = st->layout.nb_streams*2-1;
919    /* 100 ms needs an extra byte per stream for the ToC. */
920    if (Fs/frame_size == 10)
921      smallest_packet += st->layout.nb_streams;
922    if (max_data_bytes < smallest_packet)
923    {
924       RESTORE_STACK;
925       return OPUS_BUFFER_TOO_SMALL;
926    }
927    ALLOC(buf, 2*frame_size, opus_val16);
928    coupled_size = opus_encoder_get_size(2);
929    mono_size = opus_encoder_get_size(1);
930
931    ALLOC(bandSMR, 21*st->layout.nb_channels, opus_val16);
932    if (st->mapping_type == MAPPING_TYPE_SURROUND)
933    {
934       surround_analysis(celt_mode, pcm, bandSMR, mem, preemph_mem, frame_size, 120, st->layout.nb_channels, Fs, copy_channel_in, st->arch);
935    }
936
937    /* Compute bitrate allocation between streams (this could be a lot better) */
938    rate_sum = rate_allocation(st, bitrates, frame_size);
939
940    if (!vbr)
941    {
942       if (st->bitrate_bps == OPUS_AUTO)
943       {
944          max_data_bytes = IMIN(max_data_bytes, 3*rate_sum/(3*8*Fs/frame_size));
945       } else if (st->bitrate_bps != OPUS_BITRATE_MAX)
946       {
947          max_data_bytes = IMIN(max_data_bytes, IMAX(smallest_packet,
948                           3*st->bitrate_bps/(3*8*Fs/frame_size)));
949       }
950    }
951    ptr = (char*)st + align(sizeof(OpusMSEncoder));
952    for (s=0;s<st->layout.nb_streams;s++)
953    {
954       OpusEncoder *enc;
955       enc = (OpusEncoder*)ptr;
956       if (s < st->layout.nb_coupled_streams)
957          ptr += align(coupled_size);
958       else
959          ptr += align(mono_size);
960       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrates[s]));
961       if (st->mapping_type == MAPPING_TYPE_SURROUND)
962       {
963          opus_int32 equiv_rate;
964          equiv_rate = st->bitrate_bps;
965          if (frame_size*50 < Fs)
966             equiv_rate -= 60*(Fs/frame_size - 50)*st->layout.nb_channels;
967          if (equiv_rate > 10000*st->layout.nb_channels)
968             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
969          else if (equiv_rate > 7000*st->layout.nb_channels)
970             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_SUPERWIDEBAND));
971          else if (equiv_rate > 5000*st->layout.nb_channels)
972             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_WIDEBAND));
973          else
974             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));
975          if (s < st->layout.nb_coupled_streams)
976          {
977             /* To preserve the spatial image, force stereo CELT on coupled streams */
978             opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
979             opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(2));
980          }
981       }
982 #ifdef ENABLE_EXPERIMENTAL_AMBISONICS
983       else if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
984         opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
985       }
986 #endif
987    }
988
989    ptr = (char*)st + align(sizeof(OpusMSEncoder));
990    /* Counting ToC */
991    tot_size = 0;
992    for (s=0;s<st->layout.nb_streams;s++)
993    {
994       OpusEncoder *enc;
995       int len;
996       int curr_max;
997       int c1, c2;
998       int ret;
999
1000       opus_repacketizer_init(&rp);
1001       enc = (OpusEncoder*)ptr;
1002       if (s < st->layout.nb_coupled_streams)
1003       {
1004          int i;
1005          int left, right;
1006          left = get_left_channel(&st->layout, s, -1);
1007          right = get_right_channel(&st->layout, s, -1);
1008          (*copy_channel_in)(buf, 2,
1009             pcm, st->layout.nb_channels, left, frame_size);
1010          (*copy_channel_in)(buf+1, 2,
1011             pcm, st->layout.nb_channels, right, frame_size);
1012          ptr += align(coupled_size);
1013          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1014          {
1015             for (i=0;i<21;i++)
1016             {
1017                bandLogE[i] = bandSMR[21*left+i];
1018                bandLogE[21+i] = bandSMR[21*right+i];
1019             }
1020          }
1021          c1 = left;
1022          c2 = right;
1023       } else {
1024          int i;
1025          int chan = get_mono_channel(&st->layout, s, -1);
1026          (*copy_channel_in)(buf, 1,
1027             pcm, st->layout.nb_channels, chan, frame_size);
1028          ptr += align(mono_size);
1029          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1030          {
1031             for (i=0;i<21;i++)
1032                bandLogE[i] = bandSMR[21*chan+i];
1033          }
1034          c1 = chan;
1035          c2 = -1;
1036       }
1037       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1038          opus_encoder_ctl(enc, OPUS_SET_ENERGY_MASK(bandLogE));
1039       /* number of bytes left (+Toc) */
1040       curr_max = max_data_bytes - tot_size;
1041       /* Reserve one byte for the last stream and two for the others */
1042       curr_max -= IMAX(0,2*(st->layout.nb_streams-s-1)-1);
1043       /* For 100 ms, reserve an extra byte per stream for the ToC */
1044       if (Fs/frame_size == 10)
1045         curr_max -= st->layout.nb_streams-s-1;
1046       curr_max = IMIN(curr_max,MS_FRAME_TMP);
1047       /* Repacketizer will add one or two bytes for self-delimited frames */
1048       if (s != st->layout.nb_streams-1) curr_max -=  curr_max>253 ? 2 : 1;
1049       if (!vbr && s == st->layout.nb_streams-1)
1050          opus_encoder_ctl(enc, OPUS_SET_BITRATE(curr_max*(8*Fs/frame_size)));
1051       len = opus_encode_native(enc, buf, frame_size, tmp_data, curr_max, lsb_depth,
1052             pcm, analysis_frame_size, c1, c2, st->layout.nb_channels, downmix, float_api);
1053       if (len<0)
1054       {
1055          RESTORE_STACK;
1056          return len;
1057       }
1058       /* We need to use the repacketizer to add the self-delimiting lengths
1059          while taking into account the fact that the encoder can now return
1060          more than one frame at a time (e.g. 60 ms CELT-only) */
1061       ret = opus_repacketizer_cat(&rp, tmp_data, len);
1062       /* If the opus_repacketizer_cat() fails, then something's seriously wrong
1063          with the encoder. */
1064       if (ret != OPUS_OK)
1065       {
1066          RESTORE_STACK;
1067          return OPUS_INTERNAL_ERROR;
1068       }
1069       len = opus_repacketizer_out_range_impl(&rp, 0, opus_repacketizer_get_nb_frames(&rp),
1070             data, max_data_bytes-tot_size, s != st->layout.nb_streams-1, !vbr && s == st->layout.nb_streams-1);
1071       data += len;
1072       tot_size += len;
1073    }
1074    /*printf("\n");*/
1075    RESTORE_STACK;
1076    return tot_size;
1077 }
1078
1079 #if !defined(DISABLE_FLOAT_API)
1080 static void opus_copy_channel_in_float(
1081   opus_val16 *dst,
1082   int dst_stride,
1083   const void *src,
1084   int src_stride,
1085   int src_channel,
1086   int frame_size
1087 )
1088 {
1089    const float *float_src;
1090    opus_int32 i;
1091    float_src = (const float *)src;
1092    for (i=0;i<frame_size;i++)
1093 #if defined(FIXED_POINT)
1094       dst[i*dst_stride] = FLOAT2INT16(float_src[i*src_stride+src_channel]);
1095 #else
1096       dst[i*dst_stride] = float_src[i*src_stride+src_channel];
1097 #endif
1098 }
1099 #endif
1100
1101 static void opus_copy_channel_in_short(
1102   opus_val16 *dst,
1103   int dst_stride,
1104   const void *src,
1105   int src_stride,
1106   int src_channel,
1107   int frame_size
1108 )
1109 {
1110    const opus_int16 *short_src;
1111    opus_int32 i;
1112    short_src = (const opus_int16 *)src;
1113    for (i=0;i<frame_size;i++)
1114 #if defined(FIXED_POINT)
1115       dst[i*dst_stride] = short_src[i*src_stride+src_channel];
1116 #else
1117       dst[i*dst_stride] = (1/32768.f)*short_src[i*src_stride+src_channel];
1118 #endif
1119 }
1120
1121
1122 #ifdef FIXED_POINT
1123 int opus_multistream_encode(
1124     OpusMSEncoder *st,
1125     const opus_val16 *pcm,
1126     int frame_size,
1127     unsigned char *data,
1128     opus_int32 max_data_bytes
1129 )
1130 {
1131    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1132       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1133 }
1134
1135 #ifndef DISABLE_FLOAT_API
1136 int opus_multistream_encode_float(
1137     OpusMSEncoder *st,
1138     const float *pcm,
1139     int frame_size,
1140     unsigned char *data,
1141     opus_int32 max_data_bytes
1142 )
1143 {
1144    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1145       pcm, frame_size, data, max_data_bytes, 16, downmix_float, 1);
1146 }
1147 #endif
1148
1149 #else
1150
1151 int opus_multistream_encode_float
1152 (
1153     OpusMSEncoder *st,
1154     const opus_val16 *pcm,
1155     int frame_size,
1156     unsigned char *data,
1157     opus_int32 max_data_bytes
1158 )
1159 {
1160    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1161       pcm, frame_size, data, max_data_bytes, 24, downmix_float, 1);
1162 }
1163
1164 int opus_multistream_encode(
1165     OpusMSEncoder *st,
1166     const opus_int16 *pcm,
1167     int frame_size,
1168     unsigned char *data,
1169     opus_int32 max_data_bytes
1170 )
1171 {
1172    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1173       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0);
1174 }
1175 #endif
1176
1177 int opus_multistream_encoder_ctl_va_list(OpusMSEncoder *st, int request,
1178                                          va_list ap)
1179 {
1180    int coupled_size, mono_size;
1181    char *ptr;
1182    int ret = OPUS_OK;
1183
1184    coupled_size = opus_encoder_get_size(2);
1185    mono_size = opus_encoder_get_size(1);
1186    ptr = (char*)st + align(sizeof(OpusMSEncoder));
1187    switch (request)
1188    {
1189    case OPUS_SET_BITRATE_REQUEST:
1190    {
1191       opus_int32 value = va_arg(ap, opus_int32);
1192       if (value != OPUS_AUTO && value != OPUS_BITRATE_MAX)
1193       {
1194          if (value <= 0)
1195             goto bad_arg;
1196          value = IMIN(300000*st->layout.nb_channels, IMAX(500*st->layout.nb_channels, value));
1197       }
1198       st->bitrate_bps = value;
1199    }
1200    break;
1201    case OPUS_GET_BITRATE_REQUEST:
1202    {
1203       int s;
1204       opus_int32 *value = va_arg(ap, opus_int32*);
1205       if (!value)
1206       {
1207          goto bad_arg;
1208       }
1209       *value = 0;
1210       for (s=0;s<st->layout.nb_streams;s++)
1211       {
1212          opus_int32 rate;
1213          OpusEncoder *enc;
1214          enc = (OpusEncoder*)ptr;
1215          if (s < st->layout.nb_coupled_streams)
1216             ptr += align(coupled_size);
1217          else
1218             ptr += align(mono_size);
1219          opus_encoder_ctl(enc, request, &rate);
1220          *value += rate;
1221       }
1222    }
1223    break;
1224    case OPUS_GET_LSB_DEPTH_REQUEST:
1225    case OPUS_GET_VBR_REQUEST:
1226    case OPUS_GET_APPLICATION_REQUEST:
1227    case OPUS_GET_BANDWIDTH_REQUEST:
1228    case OPUS_GET_COMPLEXITY_REQUEST:
1229    case OPUS_GET_PACKET_LOSS_PERC_REQUEST:
1230    case OPUS_GET_DTX_REQUEST:
1231    case OPUS_GET_VOICE_RATIO_REQUEST:
1232    case OPUS_GET_VBR_CONSTRAINT_REQUEST:
1233    case OPUS_GET_SIGNAL_REQUEST:
1234    case OPUS_GET_LOOKAHEAD_REQUEST:
1235    case OPUS_GET_SAMPLE_RATE_REQUEST:
1236    case OPUS_GET_INBAND_FEC_REQUEST:
1237    case OPUS_GET_FORCE_CHANNELS_REQUEST:
1238    case OPUS_GET_PREDICTION_DISABLED_REQUEST:
1239    case OPUS_GET_PHASE_INVERSION_DISABLED_REQUEST:
1240    {
1241       OpusEncoder *enc;
1242       /* For int32* GET params, just query the first stream */
1243       opus_int32 *value = va_arg(ap, opus_int32*);
1244       enc = (OpusEncoder*)ptr;
1245       ret = opus_encoder_ctl(enc, request, value);
1246    }
1247    break;
1248    case OPUS_GET_FINAL_RANGE_REQUEST:
1249    {
1250       int s;
1251       opus_uint32 *value = va_arg(ap, opus_uint32*);
1252       opus_uint32 tmp;
1253       if (!value)
1254       {
1255          goto bad_arg;
1256       }
1257       *value=0;
1258       for (s=0;s<st->layout.nb_streams;s++)
1259       {
1260          OpusEncoder *enc;
1261          enc = (OpusEncoder*)ptr;
1262          if (s < st->layout.nb_coupled_streams)
1263             ptr += align(coupled_size);
1264          else
1265             ptr += align(mono_size);
1266          ret = opus_encoder_ctl(enc, request, &tmp);
1267          if (ret != OPUS_OK) break;
1268          *value ^= tmp;
1269       }
1270    }
1271    break;
1272    case OPUS_SET_LSB_DEPTH_REQUEST:
1273    case OPUS_SET_COMPLEXITY_REQUEST:
1274    case OPUS_SET_VBR_REQUEST:
1275    case OPUS_SET_VBR_CONSTRAINT_REQUEST:
1276    case OPUS_SET_MAX_BANDWIDTH_REQUEST:
1277    case OPUS_SET_BANDWIDTH_REQUEST:
1278    case OPUS_SET_SIGNAL_REQUEST:
1279    case OPUS_SET_APPLICATION_REQUEST:
1280    case OPUS_SET_INBAND_FEC_REQUEST:
1281    case OPUS_SET_PACKET_LOSS_PERC_REQUEST:
1282    case OPUS_SET_DTX_REQUEST:
1283    case OPUS_SET_FORCE_MODE_REQUEST:
1284    case OPUS_SET_FORCE_CHANNELS_REQUEST:
1285    case OPUS_SET_PREDICTION_DISABLED_REQUEST:
1286    case OPUS_SET_PHASE_INVERSION_DISABLED_REQUEST:
1287    {
1288       int s;
1289       /* This works for int32 params */
1290       opus_int32 value = va_arg(ap, opus_int32);
1291       for (s=0;s<st->layout.nb_streams;s++)
1292       {
1293          OpusEncoder *enc;
1294
1295          enc = (OpusEncoder*)ptr;
1296          if (s < st->layout.nb_coupled_streams)
1297             ptr += align(coupled_size);
1298          else
1299             ptr += align(mono_size);
1300          ret = opus_encoder_ctl(enc, request, value);
1301          if (ret != OPUS_OK)
1302             break;
1303       }
1304    }
1305    break;
1306    case OPUS_MULTISTREAM_GET_ENCODER_STATE_REQUEST:
1307    {
1308       int s;
1309       opus_int32 stream_id;
1310       OpusEncoder **value;
1311       stream_id = va_arg(ap, opus_int32);
1312       if (stream_id<0 || stream_id >= st->layout.nb_streams)
1313          ret = OPUS_BAD_ARG;
1314       value = va_arg(ap, OpusEncoder**);
1315       if (!value)
1316       {
1317          goto bad_arg;
1318       }
1319       for (s=0;s<stream_id;s++)
1320       {
1321          if (s < st->layout.nb_coupled_streams)
1322             ptr += align(coupled_size);
1323          else
1324             ptr += align(mono_size);
1325       }
1326       *value = (OpusEncoder*)ptr;
1327    }
1328    break;
1329    case OPUS_SET_EXPERT_FRAME_DURATION_REQUEST:
1330    {
1331        opus_int32 value = va_arg(ap, opus_int32);
1332        st->variable_duration = value;
1333    }
1334    break;
1335    case OPUS_GET_EXPERT_FRAME_DURATION_REQUEST:
1336    {
1337        opus_int32 *value = va_arg(ap, opus_int32*);
1338        if (!value)
1339        {
1340           goto bad_arg;
1341        }
1342        *value = st->variable_duration;
1343    }
1344    break;
1345    case OPUS_RESET_STATE:
1346    {
1347       int s;
1348       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1349       {
1350          OPUS_CLEAR(ms_get_preemph_mem(st), st->layout.nb_channels);
1351          OPUS_CLEAR(ms_get_window_mem(st), st->layout.nb_channels*120);
1352       }
1353       for (s=0;s<st->layout.nb_streams;s++)
1354       {
1355          OpusEncoder *enc;
1356          enc = (OpusEncoder*)ptr;
1357          if (s < st->layout.nb_coupled_streams)
1358             ptr += align(coupled_size);
1359          else
1360             ptr += align(mono_size);
1361          ret = opus_encoder_ctl(enc, OPUS_RESET_STATE);
1362          if (ret != OPUS_OK)
1363             break;
1364       }
1365    }
1366    break;
1367    default:
1368       ret = OPUS_UNIMPLEMENTED;
1369       break;
1370    }
1371    return ret;
1372 bad_arg:
1373    return OPUS_BAD_ARG;
1374 }
1375
1376 int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...)
1377 {
1378    int ret;
1379    va_list ap;
1380    va_start(ap, request);
1381    ret = opus_multistream_encoder_ctl_va_list(st, request, ap);
1382    va_end(ap);
1383    return ret;
1384 }
1385
1386 void opus_multistream_encoder_destroy(OpusMSEncoder *st)
1387 {
1388     opus_free(st);
1389 }