Fix bitrate allocation for channel mapping 2
[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 static opus_val32 *ms_get_preemph_mem(OpusMSEncoder *st)
65 {
66    int s;
67    char *ptr;
68    int coupled_size, mono_size;
69
70    coupled_size = opus_encoder_get_size(2);
71    mono_size = opus_encoder_get_size(1);
72    ptr = (char*)st + align(sizeof(OpusMSEncoder));
73    for (s=0;s<st->layout.nb_streams;s++)
74    {
75       if (s < st->layout.nb_coupled_streams)
76          ptr += align(coupled_size);
77       else
78          ptr += align(mono_size);
79    }
80    /* void* cast avoids clang -Wcast-align warning */
81    return (opus_val32*)(void*)(ptr+st->layout.nb_channels*120*sizeof(opus_val32));
82 }
83
84 static opus_val32 *ms_get_window_mem(OpusMSEncoder *st)
85 {
86    int s;
87    char *ptr;
88    int coupled_size, mono_size;
89
90    coupled_size = opus_encoder_get_size(2);
91    mono_size = opus_encoder_get_size(1);
92    ptr = (char*)st + align(sizeof(OpusMSEncoder));
93    for (s=0;s<st->layout.nb_streams;s++)
94    {
95       if (s < st->layout.nb_coupled_streams)
96          ptr += align(coupled_size);
97       else
98          ptr += align(mono_size);
99    }
100    /* void* cast avoids clang -Wcast-align warning */
101    return (opus_val32*)(void*)ptr;
102 }
103
104 static int validate_ambisonics(int nb_channels, int *nb_streams, int *nb_coupled_streams)
105 {
106    int order_plus_one;
107    int acn_channels;
108    int nondiegetic_channels;
109
110    if (nb_channels < 1 || nb_channels > 227)
111       return 0;
112
113    order_plus_one = isqrt32(nb_channels);
114    acn_channels = order_plus_one * order_plus_one;
115    nondiegetic_channels = nb_channels - acn_channels;
116
117    if (nondiegetic_channels != 0 && nondiegetic_channels != 2)
118       return 0;
119
120    if (nb_streams)
121       *nb_streams = acn_channels + (nondiegetic_channels != 0);
122    if (nb_coupled_streams)
123       *nb_coupled_streams = nondiegetic_channels != 0;
124    return 1;
125 }
126
127 static int validate_encoder_layout(const ChannelLayout *layout)
128 {
129    int s;
130    for (s=0;s<layout->nb_streams;s++)
131    {
132       if (s < layout->nb_coupled_streams)
133       {
134          if (get_left_channel(layout, s, -1)==-1)
135             return 0;
136          if (get_right_channel(layout, s, -1)==-1)
137             return 0;
138       } else {
139          if (get_mono_channel(layout, s, -1)==-1)
140             return 0;
141       }
142    }
143    return 1;
144 }
145
146 static void channel_pos(int channels, int pos[8])
147 {
148    /* Position in the mix: 0 don't mix, 1: left, 2: center, 3:right */
149    if (channels==4)
150    {
151       pos[0]=1;
152       pos[1]=3;
153       pos[2]=1;
154       pos[3]=3;
155    } else if (channels==3||channels==5||channels==6)
156    {
157       pos[0]=1;
158       pos[1]=2;
159       pos[2]=3;
160       pos[3]=1;
161       pos[4]=3;
162       pos[5]=0;
163    } else if (channels==7)
164    {
165       pos[0]=1;
166       pos[1]=2;
167       pos[2]=3;
168       pos[3]=1;
169       pos[4]=3;
170       pos[5]=2;
171       pos[6]=0;
172    } else if (channels==8)
173    {
174       pos[0]=1;
175       pos[1]=2;
176       pos[2]=3;
177       pos[3]=1;
178       pos[4]=3;
179       pos[5]=1;
180       pos[6]=3;
181       pos[7]=0;
182    }
183 }
184
185 #if 1
186 /* Computes a rough approximation of log2(2^a + 2^b) */
187 static opus_val16 logSum(opus_val16 a, opus_val16 b)
188 {
189    opus_val16 max;
190    opus_val32 diff;
191    opus_val16 frac;
192    static const opus_val16 diff_table[17] = {
193          QCONST16(0.5000000f, DB_SHIFT), QCONST16(0.2924813f, DB_SHIFT), QCONST16(0.1609640f, DB_SHIFT), QCONST16(0.0849625f, DB_SHIFT),
194          QCONST16(0.0437314f, DB_SHIFT), QCONST16(0.0221971f, DB_SHIFT), QCONST16(0.0111839f, DB_SHIFT), QCONST16(0.0056136f, DB_SHIFT),
195          QCONST16(0.0028123f, DB_SHIFT)
196    };
197    int low;
198    if (a>b)
199    {
200       max = a;
201       diff = SUB32(EXTEND32(a),EXTEND32(b));
202    } else {
203       max = b;
204       diff = SUB32(EXTEND32(b),EXTEND32(a));
205    }
206    if (!(diff < QCONST16(8.f, DB_SHIFT)))  /* inverted to catch NaNs */
207       return max;
208 #ifdef FIXED_POINT
209    low = SHR32(diff, DB_SHIFT-1);
210    frac = SHL16(diff - SHL16(low, DB_SHIFT-1), 16-DB_SHIFT);
211 #else
212    low = (int)floor(2*diff);
213    frac = 2*diff - low;
214 #endif
215    return max + diff_table[low] + MULT16_16_Q15(frac, SUB16(diff_table[low+1], diff_table[low]));
216 }
217 #else
218 opus_val16 logSum(opus_val16 a, opus_val16 b)
219 {
220    return log2(pow(4, a)+ pow(4, b))/2;
221 }
222 #endif
223
224 void surround_analysis(const CELTMode *celt_mode, const void *pcm, opus_val16 *bandLogE, opus_val32 *mem, opus_val32 *preemph_mem,
225       int len, int overlap, int channels, int rate, opus_copy_channel_in_func copy_channel_in, int arch
226 )
227 {
228    int c;
229    int i;
230    int LM;
231    int pos[8] = {0};
232    int upsample;
233    int frame_size;
234    int freq_size;
235    opus_val16 channel_offset;
236    opus_val32 bandE[21];
237    opus_val16 maskLogE[3][21];
238    VARDECL(opus_val32, in);
239    VARDECL(opus_val16, x);
240    VARDECL(opus_val32, freq);
241    SAVE_STACK;
242
243    upsample = resampling_factor(rate);
244    frame_size = len*upsample;
245    freq_size = IMIN(960, frame_size);
246
247    /* LM = log2(frame_size / 120) */
248    for (LM=0;LM<celt_mode->maxLM;LM++)
249       if (celt_mode->shortMdctSize<<LM==frame_size)
250          break;
251
252    ALLOC(in, frame_size+overlap, opus_val32);
253    ALLOC(x, len, opus_val16);
254    ALLOC(freq, freq_size, opus_val32);
255
256    channel_pos(channels, pos);
257
258    for (c=0;c<3;c++)
259       for (i=0;i<21;i++)
260          maskLogE[c][i] = -QCONST16(28.f, DB_SHIFT);
261
262    for (c=0;c<channels;c++)
263    {
264       int frame;
265       int nb_frames = frame_size/freq_size;
266       celt_assert(nb_frames*freq_size == frame_size);
267       OPUS_COPY(in, mem+c*overlap, overlap);
268       (*copy_channel_in)(x, 1, pcm, channels, c, len, NULL);
269       celt_preemphasis(x, in+overlap, frame_size, 1, upsample, celt_mode->preemph, preemph_mem+c, 0);
270 #ifndef FIXED_POINT
271       {
272          opus_val32 sum;
273          sum = celt_inner_prod(in, in, frame_size+overlap, 0);
274          /* This should filter out both NaNs and ridiculous signals that could
275             cause NaNs further down. */
276          if (!(sum < 1e18f) || celt_isnan(sum))
277          {
278             OPUS_CLEAR(in, frame_size+overlap);
279             preemph_mem[c] = 0;
280          }
281       }
282 #endif
283       OPUS_CLEAR(bandE, 21);
284       for (frame=0;frame<nb_frames;frame++)
285       {
286          opus_val32 tmpE[21];
287          clt_mdct_forward(&celt_mode->mdct, in+960*frame, freq, celt_mode->window,
288                overlap, celt_mode->maxLM-LM, 1, arch);
289          if (upsample != 1)
290          {
291             int bound = freq_size/upsample;
292             for (i=0;i<bound;i++)
293                freq[i] *= upsample;
294             for (;i<freq_size;i++)
295                freq[i] = 0;
296          }
297
298          compute_band_energies(celt_mode, freq, tmpE, 21, 1, LM, arch);
299          /* If we have multiple frames, take the max energy. */
300          for (i=0;i<21;i++)
301             bandE[i] = MAX32(bandE[i], tmpE[i]);
302       }
303       amp2Log2(celt_mode, 21, 21, bandE, bandLogE+21*c, 1);
304       /* Apply spreading function with -6 dB/band going up and -12 dB/band going down. */
305       for (i=1;i<21;i++)
306          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i-1]-QCONST16(1.f, DB_SHIFT));
307       for (i=19;i>=0;i--)
308          bandLogE[21*c+i] = MAX16(bandLogE[21*c+i], bandLogE[21*c+i+1]-QCONST16(2.f, DB_SHIFT));
309       if (pos[c]==1)
310       {
311          for (i=0;i<21;i++)
312             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]);
313       } else if (pos[c]==3)
314       {
315          for (i=0;i<21;i++)
316             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]);
317       } else if (pos[c]==2)
318       {
319          for (i=0;i<21;i++)
320          {
321             maskLogE[0][i] = logSum(maskLogE[0][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
322             maskLogE[2][i] = logSum(maskLogE[2][i], bandLogE[21*c+i]-QCONST16(.5f, DB_SHIFT));
323          }
324       }
325 #if 0
326       for (i=0;i<21;i++)
327          printf("%f ", bandLogE[21*c+i]);
328       float sum=0;
329       for (i=0;i<21;i++)
330          sum += bandLogE[21*c+i];
331       printf("%f ", sum/21);
332 #endif
333       OPUS_COPY(mem+c*overlap, in+frame_size, overlap);
334    }
335    for (i=0;i<21;i++)
336       maskLogE[1][i] = MIN32(maskLogE[0][i],maskLogE[2][i]);
337    channel_offset = HALF16(celt_log2(QCONST32(2.f,14)/(channels-1)));
338    for (c=0;c<3;c++)
339       for (i=0;i<21;i++)
340          maskLogE[c][i] += channel_offset;
341 #if 0
342    for (c=0;c<3;c++)
343    {
344       for (i=0;i<21;i++)
345          printf("%f ", maskLogE[c][i]);
346    }
347 #endif
348    for (c=0;c<channels;c++)
349    {
350       opus_val16 *mask;
351       if (pos[c]!=0)
352       {
353          mask = &maskLogE[pos[c]-1][0];
354          for (i=0;i<21;i++)
355             bandLogE[21*c+i] = bandLogE[21*c+i] - mask[i];
356       } else {
357          for (i=0;i<21;i++)
358             bandLogE[21*c+i] = 0;
359       }
360 #if 0
361       for (i=0;i<21;i++)
362          printf("%f ", bandLogE[21*c+i]);
363       printf("\n");
364 #endif
365 #if 0
366       float sum=0;
367       for (i=0;i<21;i++)
368          sum += bandLogE[21*c+i];
369       printf("%f ", sum/(float)QCONST32(21.f, DB_SHIFT));
370       printf("\n");
371 #endif
372    }
373    RESTORE_STACK;
374 }
375
376 opus_int32 opus_multistream_encoder_get_size(int nb_streams, int nb_coupled_streams)
377 {
378    int coupled_size;
379    int mono_size;
380
381    if(nb_streams<1||nb_coupled_streams>nb_streams||nb_coupled_streams<0)return 0;
382    coupled_size = opus_encoder_get_size(2);
383    mono_size = opus_encoder_get_size(1);
384    return align(sizeof(OpusMSEncoder))
385         + nb_coupled_streams * align(coupled_size)
386         + (nb_streams-nb_coupled_streams) * align(mono_size);
387 }
388
389 opus_int32 opus_multistream_surround_encoder_get_size(int channels, int mapping_family)
390 {
391    int nb_streams;
392    int nb_coupled_streams;
393    opus_int32 size;
394
395    if (mapping_family==0)
396    {
397       if (channels==1)
398       {
399          nb_streams=1;
400          nb_coupled_streams=0;
401       } else if (channels==2)
402       {
403          nb_streams=1;
404          nb_coupled_streams=1;
405       } else
406          return 0;
407    } else if (mapping_family==1 && channels<=8 && channels>=1)
408    {
409       nb_streams=vorbis_mappings[channels-1].nb_streams;
410       nb_coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
411    } else if (mapping_family==255)
412    {
413       nb_streams=channels;
414       nb_coupled_streams=0;
415    } else if (mapping_family==2)
416    {
417       if (!validate_ambisonics(channels, &nb_streams, &nb_coupled_streams))
418          return 0;
419    } else
420       return 0;
421    size = opus_multistream_encoder_get_size(nb_streams, nb_coupled_streams);
422    if (channels>2)
423    {
424       size += channels*(120*sizeof(opus_val32) + sizeof(opus_val32));
425    }
426    return size;
427 }
428
429 static int opus_multistream_encoder_init_impl(
430       OpusMSEncoder *st,
431       opus_int32 Fs,
432       int channels,
433       int streams,
434       int coupled_streams,
435       const unsigned char *mapping,
436       int application,
437       MappingType mapping_type
438 )
439 {
440    int coupled_size;
441    int mono_size;
442    int i, ret;
443    char *ptr;
444
445    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
446        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
447       return OPUS_BAD_ARG;
448
449    st->arch = opus_select_arch();
450    st->layout.nb_channels = channels;
451    st->layout.nb_streams = streams;
452    st->layout.nb_coupled_streams = coupled_streams;
453    if (mapping_type != MAPPING_TYPE_SURROUND)
454       st->lfe_stream = -1;
455    st->bitrate_bps = OPUS_AUTO;
456    st->application = application;
457    st->variable_duration = OPUS_FRAMESIZE_ARG;
458    for (i=0;i<st->layout.nb_channels;i++)
459       st->layout.mapping[i] = mapping[i];
460    if (!validate_layout(&st->layout))
461       return OPUS_BAD_ARG;
462    if (mapping_type == MAPPING_TYPE_SURROUND &&
463        !validate_encoder_layout(&st->layout))
464       return OPUS_BAD_ARG;
465    if (mapping_type == MAPPING_TYPE_AMBISONICS &&
466        !validate_ambisonics(st->layout.nb_channels, NULL, NULL))
467       return OPUS_BAD_ARG;
468    ptr = (char*)st + align(sizeof(OpusMSEncoder));
469    coupled_size = opus_encoder_get_size(2);
470    mono_size = opus_encoder_get_size(1);
471
472    for (i=0;i<st->layout.nb_coupled_streams;i++)
473    {
474       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 2, application);
475       if(ret!=OPUS_OK)return ret;
476       if (i==st->lfe_stream)
477          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
478       ptr += align(coupled_size);
479    }
480    for (;i<st->layout.nb_streams;i++)
481    {
482       ret = opus_encoder_init((OpusEncoder*)ptr, Fs, 1, application);
483       if (i==st->lfe_stream)
484          opus_encoder_ctl((OpusEncoder*)ptr, OPUS_SET_LFE(1));
485       if(ret!=OPUS_OK)return ret;
486       ptr += align(mono_size);
487    }
488    if (mapping_type == MAPPING_TYPE_SURROUND)
489    {
490       OPUS_CLEAR(ms_get_preemph_mem(st), channels);
491       OPUS_CLEAR(ms_get_window_mem(st), channels*120);
492    }
493    st->mapping_type = mapping_type;
494    return OPUS_OK;
495 }
496
497 int opus_multistream_encoder_init(
498       OpusMSEncoder *st,
499       opus_int32 Fs,
500       int channels,
501       int streams,
502       int coupled_streams,
503       const unsigned char *mapping,
504       int application
505 )
506 {
507    return opus_multistream_encoder_init_impl(st, Fs, channels, streams,
508                                              coupled_streams, mapping,
509                                              application, MAPPING_TYPE_NONE);
510 }
511
512 int opus_multistream_surround_encoder_init(
513       OpusMSEncoder *st,
514       opus_int32 Fs,
515       int channels,
516       int mapping_family,
517       int *streams,
518       int *coupled_streams,
519       unsigned char *mapping,
520       int application
521 )
522 {
523    MappingType mapping_type;
524
525    if ((channels>255) || (channels<1))
526       return OPUS_BAD_ARG;
527    st->lfe_stream = -1;
528    if (mapping_family==0)
529    {
530       if (channels==1)
531       {
532          *streams=1;
533          *coupled_streams=0;
534          mapping[0]=0;
535       } else if (channels==2)
536       {
537          *streams=1;
538          *coupled_streams=1;
539          mapping[0]=0;
540          mapping[1]=1;
541       } else
542          return OPUS_UNIMPLEMENTED;
543    } else if (mapping_family==1 && channels<=8 && channels>=1)
544    {
545       int i;
546       *streams=vorbis_mappings[channels-1].nb_streams;
547       *coupled_streams=vorbis_mappings[channels-1].nb_coupled_streams;
548       for (i=0;i<channels;i++)
549          mapping[i] = vorbis_mappings[channels-1].mapping[i];
550       if (channels>=6)
551          st->lfe_stream = *streams-1;
552    } else if (mapping_family==255)
553    {
554       int i;
555       *streams=channels;
556       *coupled_streams=0;
557       for(i=0;i<channels;i++)
558          mapping[i] = i;
559    } else if (mapping_family==2)
560    {
561       int i;
562       if (!validate_ambisonics(channels, streams, coupled_streams))
563          return OPUS_BAD_ARG;
564       for(i = 0; i < (*streams - *coupled_streams); i++)
565          mapping[i] = i + (*coupled_streams * 2);
566       for(i = 0; i < *coupled_streams * 2; i++)
567          mapping[i + (*streams - *coupled_streams)] = i;
568    } else
569       return OPUS_UNIMPLEMENTED;
570
571    if (channels>2 && mapping_family==1) {
572       mapping_type = MAPPING_TYPE_SURROUND;
573    } else if (mapping_family==2)
574    {
575       mapping_type = MAPPING_TYPE_AMBISONICS;
576    } else
577    {
578       mapping_type = MAPPING_TYPE_NONE;
579    }
580    return opus_multistream_encoder_init_impl(st, Fs, channels, *streams,
581                                              *coupled_streams, mapping,
582                                              application, mapping_type);
583 }
584
585 OpusMSEncoder *opus_multistream_encoder_create(
586       opus_int32 Fs,
587       int channels,
588       int streams,
589       int coupled_streams,
590       const unsigned char *mapping,
591       int application,
592       int *error
593 )
594 {
595    int ret;
596    OpusMSEncoder *st;
597    if ((channels>255) || (channels<1) || (coupled_streams>streams) ||
598        (streams<1) || (coupled_streams<0) || (streams>255-coupled_streams))
599    {
600       if (error)
601          *error = OPUS_BAD_ARG;
602       return NULL;
603    }
604    st = (OpusMSEncoder *)opus_alloc(opus_multistream_encoder_get_size(streams, coupled_streams));
605    if (st==NULL)
606    {
607       if (error)
608          *error = OPUS_ALLOC_FAIL;
609       return NULL;
610    }
611    ret = opus_multistream_encoder_init(st, Fs, channels, streams, coupled_streams, mapping, application);
612    if (ret != OPUS_OK)
613    {
614       opus_free(st);
615       st = NULL;
616    }
617    if (error)
618       *error = ret;
619    return st;
620 }
621
622 OpusMSEncoder *opus_multistream_surround_encoder_create(
623       opus_int32 Fs,
624       int channels,
625       int mapping_family,
626       int *streams,
627       int *coupled_streams,
628       unsigned char *mapping,
629       int application,
630       int *error
631 )
632 {
633    int ret;
634    opus_int32 size;
635    OpusMSEncoder *st;
636    if ((channels>255) || (channels<1))
637    {
638       if (error)
639          *error = OPUS_BAD_ARG;
640       return NULL;
641    }
642    size = opus_multistream_surround_encoder_get_size(channels, mapping_family);
643    if (!size)
644    {
645       if (error)
646          *error = OPUS_UNIMPLEMENTED;
647       return NULL;
648    }
649    st = (OpusMSEncoder *)opus_alloc(size);
650    if (st==NULL)
651    {
652       if (error)
653          *error = OPUS_ALLOC_FAIL;
654       return NULL;
655    }
656    ret = opus_multistream_surround_encoder_init(st, Fs, channels, mapping_family, streams, coupled_streams, mapping, application);
657    if (ret != OPUS_OK)
658    {
659       opus_free(st);
660       st = NULL;
661    }
662    if (error)
663       *error = ret;
664    return st;
665 }
666
667 static void surround_rate_allocation(
668       OpusMSEncoder *st,
669       opus_int32 *rate,
670       int frame_size,
671       opus_int32 Fs
672       )
673 {
674    int i;
675    opus_int32 channel_rate;
676    int stream_offset;
677    int lfe_offset;
678    int coupled_ratio; /* Q8 */
679    int lfe_ratio;     /* Q8 */
680    int nb_lfe;
681    int nb_uncoupled;
682    int nb_coupled;
683    int nb_normal;
684    opus_int32 channel_offset;
685    opus_int32 bitrate;
686    int total;
687
688    nb_lfe = (st->lfe_stream!=-1);
689    nb_coupled = st->layout.nb_coupled_streams;
690    nb_uncoupled = st->layout.nb_streams-nb_coupled-nb_lfe;
691    nb_normal = 2*nb_coupled + nb_uncoupled;
692
693    /* Give each non-LFE channel enough bits per channel for coding band energy. */
694    channel_offset = 40*IMAX(50, Fs/frame_size);
695
696    if (st->bitrate_bps==OPUS_AUTO)
697    {
698       bitrate = nb_normal*(channel_offset + Fs + 10000) + 8000*nb_lfe;
699    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
700    {
701       bitrate = nb_normal*300000 + nb_lfe*128000;
702    } else {
703       bitrate = st->bitrate_bps;
704    }
705
706    /* Give LFE some basic stream_channel allocation but never exceed 1/20 of the
707       total rate for the non-energy part to avoid problems at really low rate. */
708    lfe_offset = IMIN(bitrate/20, 3000) + 15*IMAX(50, Fs/frame_size);
709
710    /* We give each stream (coupled or uncoupled) a starting bitrate.
711       This models the main saving of coupled channels over uncoupled. */
712    stream_offset = (bitrate - channel_offset*nb_normal - lfe_offset*nb_lfe)/nb_normal/2;
713    stream_offset = IMAX(0, IMIN(20000, stream_offset));
714
715    /* Coupled streams get twice the mono rate after the offset is allocated. */
716    coupled_ratio = 512;
717    /* Should depend on the bitrate, for now we assume LFE gets 1/8 the bits of mono */
718    lfe_ratio = 32;
719
720    total = (nb_uncoupled<<8)         /* mono */
721          + coupled_ratio*nb_coupled /* stereo */
722          + nb_lfe*lfe_ratio;
723    channel_rate = 256*(opus_int64)(bitrate - lfe_offset*nb_lfe - stream_offset*(nb_coupled+nb_uncoupled) - channel_offset*nb_normal)/total;
724
725    for (i=0;i<st->layout.nb_streams;i++)
726    {
727       if (i<st->layout.nb_coupled_streams)
728          rate[i] = 2*channel_offset + IMAX(0, stream_offset+(channel_rate*coupled_ratio>>8));
729       else if (i!=st->lfe_stream)
730          rate[i] = channel_offset + IMAX(0, stream_offset + channel_rate);
731       else
732          rate[i] = IMAX(0, lfe_offset+(channel_rate*lfe_ratio>>8));
733    }
734 }
735
736 static void ambisonics_rate_allocation(
737       OpusMSEncoder *st,
738       opus_int32 *rate,
739       int frame_size,
740       opus_int32 Fs
741       )
742 {
743    int i;
744    int total_rate;
745    int directional_rate;
746    int nondirectional_rate;
747    int leftover_bits;
748
749    /* Each nondirectional channel gets (rate_ratio_num / rate_ratio_den) times
750     * as many bits as all other ambisonics channels.
751     */
752    const int rate_ratio_num = 4;
753    const int rate_ratio_den = 3;
754    const int nb_channels = st->layout.nb_streams + st->layout.nb_coupled_streams;
755    /* The omnidirectional ambisonics and non-diegetic stereo channels */
756    const int nb_nondirectional_channels = st->layout.nb_coupled_streams * 2 + 1;
757    /* The remaining ambisonics channels */
758    const int nb_directional_channels = nb_channels - nb_nondirectional_channels;
759
760    if (st->bitrate_bps==OPUS_AUTO)
761    {
762       total_rate = (st->layout.nb_coupled_streams + st->layout.nb_streams) *
763          (Fs+60*Fs/frame_size) + st->layout.nb_streams * 15000;
764    } else if (st->bitrate_bps==OPUS_BITRATE_MAX)
765    {
766       total_rate = nb_channels * 320000;
767    } else
768    {
769       total_rate = st->bitrate_bps;
770    }
771
772    /* Let y be the directional rate, m be the num of nondirectional channels
773     *   m = (s + 1)
774     * and let p, q be integers such that the nondirectional rate is
775     *   m_rate = (p / q) * y
776     * Also let T be the total bitrate to allocate. Then
777     *   T = (n - m) * y + m * m_rate
778     * Solving for y,
779     *   y = (q * T) / (m * (p - q) + n * q)
780     */
781    directional_rate =
782       total_rate * rate_ratio_den
783       / (nb_nondirectional_channels * (rate_ratio_num - rate_ratio_den)
784        + nb_channels * rate_ratio_den);
785
786    /* Calculate the nondirectional rate.
787     *   m_rate = y * (p / q)
788     */
789    nondirectional_rate = directional_rate * rate_ratio_num / rate_ratio_den;
790
791    /* Calculate the leftover from truncation error.
792     *   leftover = T - y * (n - m) - m_rate * m
793     * Place leftover bits in omnidirectional channel.
794     */
795    leftover_bits = total_rate
796       - directional_rate * nb_directional_channels
797       - nondirectional_rate * nb_nondirectional_channels;
798
799    /* Calculate rates for each channel */
800    for (i = 0; i < st->layout.nb_streams; i++)
801    {
802       if (i < st->layout.nb_coupled_streams)
803       {
804          rate[i] = nondirectional_rate * 2;
805       } else if (i == st->layout.nb_coupled_streams)
806       {
807          rate[i] = nondirectional_rate + leftover_bits;
808       } else
809       {
810          rate[i] = directional_rate;
811       }
812    }
813 }
814
815 static opus_int32 rate_allocation(
816       OpusMSEncoder *st,
817       opus_int32 *rate,
818       int frame_size
819       )
820 {
821    int i;
822    opus_int32 rate_sum=0;
823    opus_int32 Fs;
824    char *ptr;
825
826    ptr = (char*)st + align(sizeof(OpusMSEncoder));
827    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
828
829    if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
830      ambisonics_rate_allocation(st, rate, frame_size, Fs);
831    } else
832    {
833      surround_rate_allocation(st, rate, frame_size, Fs);
834    }
835
836    for (i=0;i<st->layout.nb_streams;i++)
837    {
838       rate[i] = IMAX(rate[i], 500);
839       rate_sum += rate[i];
840    }
841    return rate_sum;
842 }
843
844 /* Max size in case the encoder decides to return six frames (6 x 20 ms = 120 ms) */
845 #define MS_FRAME_TMP (6*1275+12)
846 int opus_multistream_encode_native
847 (
848     OpusMSEncoder *st,
849     opus_copy_channel_in_func copy_channel_in,
850     const void *pcm,
851     int analysis_frame_size,
852     unsigned char *data,
853     opus_int32 max_data_bytes,
854     int lsb_depth,
855     downmix_func downmix,
856     int float_api,
857     void *user_data
858 )
859 {
860    opus_int32 Fs;
861    int coupled_size;
862    int mono_size;
863    int s;
864    char *ptr;
865    int tot_size;
866    VARDECL(opus_val16, buf);
867    VARDECL(opus_val16, bandSMR);
868    unsigned char tmp_data[MS_FRAME_TMP];
869    OpusRepacketizer rp;
870    opus_int32 vbr;
871    const CELTMode *celt_mode;
872    opus_int32 bitrates[256];
873    opus_val16 bandLogE[42];
874    opus_val32 *mem = NULL;
875    opus_val32 *preemph_mem=NULL;
876    int frame_size;
877    opus_int32 rate_sum;
878    opus_int32 smallest_packet;
879    ALLOC_STACK;
880
881    if (st->mapping_type == MAPPING_TYPE_SURROUND)
882    {
883       preemph_mem = ms_get_preemph_mem(st);
884       mem = ms_get_window_mem(st);
885    }
886
887    ptr = (char*)st + align(sizeof(OpusMSEncoder));
888    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_SAMPLE_RATE(&Fs));
889    opus_encoder_ctl((OpusEncoder*)ptr, OPUS_GET_VBR(&vbr));
890    opus_encoder_ctl((OpusEncoder*)ptr, CELT_GET_MODE(&celt_mode));
891
892    frame_size = frame_size_select(analysis_frame_size, st->variable_duration, Fs);
893    if (frame_size <= 0)
894    {
895       RESTORE_STACK;
896       return OPUS_BAD_ARG;
897    }
898
899    /* Smallest packet the encoder can produce. */
900    smallest_packet = st->layout.nb_streams*2-1;
901    /* 100 ms needs an extra byte per stream for the ToC. */
902    if (Fs/frame_size == 10)
903      smallest_packet += st->layout.nb_streams;
904    if (max_data_bytes < smallest_packet)
905    {
906       RESTORE_STACK;
907       return OPUS_BUFFER_TOO_SMALL;
908    }
909    ALLOC(buf, 2*frame_size, opus_val16);
910    coupled_size = opus_encoder_get_size(2);
911    mono_size = opus_encoder_get_size(1);
912
913    ALLOC(bandSMR, 21*st->layout.nb_channels, opus_val16);
914    if (st->mapping_type == MAPPING_TYPE_SURROUND)
915    {
916       surround_analysis(celt_mode, pcm, bandSMR, mem, preemph_mem, frame_size, 120, st->layout.nb_channels, Fs, copy_channel_in, st->arch);
917    }
918
919    /* Compute bitrate allocation between streams (this could be a lot better) */
920    rate_sum = rate_allocation(st, bitrates, frame_size);
921
922    if (!vbr)
923    {
924       if (st->bitrate_bps == OPUS_AUTO)
925       {
926          max_data_bytes = IMIN(max_data_bytes, 3*rate_sum/(3*8*Fs/frame_size));
927       } else if (st->bitrate_bps != OPUS_BITRATE_MAX)
928       {
929          max_data_bytes = IMIN(max_data_bytes, IMAX(smallest_packet,
930                           3*st->bitrate_bps/(3*8*Fs/frame_size)));
931       }
932    }
933    ptr = (char*)st + align(sizeof(OpusMSEncoder));
934    for (s=0;s<st->layout.nb_streams;s++)
935    {
936       OpusEncoder *enc;
937       enc = (OpusEncoder*)ptr;
938       if (s < st->layout.nb_coupled_streams)
939          ptr += align(coupled_size);
940       else
941          ptr += align(mono_size);
942       opus_encoder_ctl(enc, OPUS_SET_BITRATE(bitrates[s]));
943       if (st->mapping_type == MAPPING_TYPE_SURROUND)
944       {
945          opus_int32 equiv_rate;
946          equiv_rate = st->bitrate_bps;
947          if (frame_size*50 < Fs)
948             equiv_rate -= 60*(Fs/frame_size - 50)*st->layout.nb_channels;
949          if (equiv_rate > 10000*st->layout.nb_channels)
950             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_FULLBAND));
951          else if (equiv_rate > 7000*st->layout.nb_channels)
952             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_SUPERWIDEBAND));
953          else if (equiv_rate > 5000*st->layout.nb_channels)
954             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_WIDEBAND));
955          else
956             opus_encoder_ctl(enc, OPUS_SET_BANDWIDTH(OPUS_BANDWIDTH_NARROWBAND));
957          if (s < st->layout.nb_coupled_streams)
958          {
959             /* To preserve the spatial image, force stereo CELT on coupled streams */
960             opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
961             opus_encoder_ctl(enc, OPUS_SET_FORCE_CHANNELS(2));
962          }
963       }
964       else if (st->mapping_type == MAPPING_TYPE_AMBISONICS) {
965         opus_encoder_ctl(enc, OPUS_SET_FORCE_MODE(MODE_CELT_ONLY));
966       }
967    }
968
969    ptr = (char*)st + align(sizeof(OpusMSEncoder));
970    /* Counting ToC */
971    tot_size = 0;
972    for (s=0;s<st->layout.nb_streams;s++)
973    {
974       OpusEncoder *enc;
975       int len;
976       int curr_max;
977       int c1, c2;
978       int ret;
979
980       opus_repacketizer_init(&rp);
981       enc = (OpusEncoder*)ptr;
982       if (s < st->layout.nb_coupled_streams)
983       {
984          int i;
985          int left, right;
986          left = get_left_channel(&st->layout, s, -1);
987          right = get_right_channel(&st->layout, s, -1);
988          (*copy_channel_in)(buf, 2,
989             pcm, st->layout.nb_channels, left, frame_size, user_data);
990          (*copy_channel_in)(buf+1, 2,
991             pcm, st->layout.nb_channels, right, frame_size, user_data);
992          ptr += align(coupled_size);
993          if (st->mapping_type == MAPPING_TYPE_SURROUND)
994          {
995             for (i=0;i<21;i++)
996             {
997                bandLogE[i] = bandSMR[21*left+i];
998                bandLogE[21+i] = bandSMR[21*right+i];
999             }
1000          }
1001          c1 = left;
1002          c2 = right;
1003       } else {
1004          int i;
1005          int chan = get_mono_channel(&st->layout, s, -1);
1006          (*copy_channel_in)(buf, 1,
1007             pcm, st->layout.nb_channels, chan, frame_size, user_data);
1008          ptr += align(mono_size);
1009          if (st->mapping_type == MAPPING_TYPE_SURROUND)
1010          {
1011             for (i=0;i<21;i++)
1012                bandLogE[i] = bandSMR[21*chan+i];
1013          }
1014          c1 = chan;
1015          c2 = -1;
1016       }
1017       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1018          opus_encoder_ctl(enc, OPUS_SET_ENERGY_MASK(bandLogE));
1019       /* number of bytes left (+Toc) */
1020       curr_max = max_data_bytes - tot_size;
1021       /* Reserve one byte for the last stream and two for the others */
1022       curr_max -= IMAX(0,2*(st->layout.nb_streams-s-1)-1);
1023       /* For 100 ms, reserve an extra byte per stream for the ToC */
1024       if (Fs/frame_size == 10)
1025         curr_max -= st->layout.nb_streams-s-1;
1026       curr_max = IMIN(curr_max,MS_FRAME_TMP);
1027       /* Repacketizer will add one or two bytes for self-delimited frames */
1028       if (s != st->layout.nb_streams-1) curr_max -=  curr_max>253 ? 2 : 1;
1029       if (!vbr && s == st->layout.nb_streams-1)
1030          opus_encoder_ctl(enc, OPUS_SET_BITRATE(curr_max*(8*Fs/frame_size)));
1031       len = opus_encode_native(enc, buf, frame_size, tmp_data, curr_max, lsb_depth,
1032             pcm, analysis_frame_size, c1, c2, st->layout.nb_channels, downmix, float_api);
1033       if (len<0)
1034       {
1035          RESTORE_STACK;
1036          return len;
1037       }
1038       /* We need to use the repacketizer to add the self-delimiting lengths
1039          while taking into account the fact that the encoder can now return
1040          more than one frame at a time (e.g. 60 ms CELT-only) */
1041       ret = opus_repacketizer_cat(&rp, tmp_data, len);
1042       /* If the opus_repacketizer_cat() fails, then something's seriously wrong
1043          with the encoder. */
1044       if (ret != OPUS_OK)
1045       {
1046          RESTORE_STACK;
1047          return OPUS_INTERNAL_ERROR;
1048       }
1049       len = opus_repacketizer_out_range_impl(&rp, 0, opus_repacketizer_get_nb_frames(&rp),
1050             data, max_data_bytes-tot_size, s != st->layout.nb_streams-1, !vbr && s == st->layout.nb_streams-1);
1051       data += len;
1052       tot_size += len;
1053    }
1054    /*printf("\n");*/
1055    RESTORE_STACK;
1056    return tot_size;
1057 }
1058
1059 #if !defined(DISABLE_FLOAT_API)
1060 static void opus_copy_channel_in_float(
1061   opus_val16 *dst,
1062   int dst_stride,
1063   const void *src,
1064   int src_stride,
1065   int src_channel,
1066   int frame_size,
1067   void *user_data
1068 )
1069 {
1070    const float *float_src;
1071    opus_int32 i;
1072    (void)user_data;
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   void *user_data
1091 )
1092 {
1093    const opus_int16 *short_src;
1094    opus_int32 i;
1095    (void)user_data;
1096    short_src = (const opus_int16 *)src;
1097    for (i=0;i<frame_size;i++)
1098 #if defined(FIXED_POINT)
1099       dst[i*dst_stride] = short_src[i*src_stride+src_channel];
1100 #else
1101       dst[i*dst_stride] = (1/32768.f)*short_src[i*src_stride+src_channel];
1102 #endif
1103 }
1104
1105
1106 #ifdef FIXED_POINT
1107 int opus_multistream_encode(
1108     OpusMSEncoder *st,
1109     const opus_val16 *pcm,
1110     int frame_size,
1111     unsigned char *data,
1112     opus_int32 max_data_bytes
1113 )
1114 {
1115    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1116       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0, NULL);
1117 }
1118
1119 #ifndef DISABLE_FLOAT_API
1120 int opus_multistream_encode_float(
1121     OpusMSEncoder *st,
1122     const float *pcm,
1123     int frame_size,
1124     unsigned char *data,
1125     opus_int32 max_data_bytes
1126 )
1127 {
1128    return opus_multistream_encode_native(st, opus_copy_channel_in_float,
1129       pcm, frame_size, data, max_data_bytes, 16, downmix_float, 1, NULL);
1130 }
1131 #endif
1132
1133 #else
1134
1135 int opus_multistream_encode_float
1136 (
1137     OpusMSEncoder *st,
1138     const opus_val16 *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, 24, downmix_float, 1, NULL);
1146 }
1147
1148 int opus_multistream_encode(
1149     OpusMSEncoder *st,
1150     const opus_int16 *pcm,
1151     int frame_size,
1152     unsigned char *data,
1153     opus_int32 max_data_bytes
1154 )
1155 {
1156    return opus_multistream_encode_native(st, opus_copy_channel_in_short,
1157       pcm, frame_size, data, max_data_bytes, 16, downmix_int, 0, NULL);
1158 }
1159 #endif
1160
1161 int opus_multistream_encoder_ctl_va_list(OpusMSEncoder *st, int request,
1162                                          va_list ap)
1163 {
1164    int coupled_size, mono_size;
1165    char *ptr;
1166    int ret = OPUS_OK;
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       if (st->mapping_type == MAPPING_TYPE_SURROUND)
1333       {
1334          OPUS_CLEAR(ms_get_preemph_mem(st), st->layout.nb_channels);
1335          OPUS_CLEAR(ms_get_window_mem(st), st->layout.nb_channels*120);
1336       }
1337       for (s=0;s<st->layout.nb_streams;s++)
1338       {
1339          OpusEncoder *enc;
1340          enc = (OpusEncoder*)ptr;
1341          if (s < st->layout.nb_coupled_streams)
1342             ptr += align(coupled_size);
1343          else
1344             ptr += align(mono_size);
1345          ret = opus_encoder_ctl(enc, OPUS_RESET_STATE);
1346          if (ret != OPUS_OK)
1347             break;
1348       }
1349    }
1350    break;
1351    default:
1352       ret = OPUS_UNIMPLEMENTED;
1353       break;
1354    }
1355    return ret;
1356 bad_arg:
1357    return OPUS_BAD_ARG;
1358 }
1359
1360 int opus_multistream_encoder_ctl(OpusMSEncoder *st, int request, ...)
1361 {
1362    int ret;
1363    va_list ap;
1364    va_start(ap, request);
1365    ret = opus_multistream_encoder_ctl_va_list(st, request, ap);
1366    va_end(ap);
1367    return ret;
1368 }
1369
1370 void opus_multistream_encoder_destroy(OpusMSEncoder *st)
1371 {
1372     opus_free(st);
1373 }