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