1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include <stdio.h> 18 #include <stdint.h> 19 #include <string.h> 20 #include <errno.h> 21 #include <fcntl.h> 22 #include <sys/epoll.h> 23 #include <sys/types.h> 24 #include <sys/socket.h> 25 #include <sys/stat.h> 26 #include <sys/time.h> 27 #include <time.h> 28 #include <arpa/inet.h> 29 #include <netinet/in.h> 30 31 // #define LOG_NDEBUG 0 32 #define LOG_TAG "AudioGroup" 33 #include <cutils/atomic.h> 34 #include <cutils/properties.h> 35 #include <utils/Log.h> 36 #include <utils/Errors.h> 37 #include <utils/RefBase.h> 38 #include <utils/threads.h> 39 #include <utils/SystemClock.h> 40 #include <media/AudioSystem.h> 41 #include <media/AudioRecord.h> 42 #include <media/AudioTrack.h> 43 #include <media/mediarecorder.h> 44 #include <media/AudioEffect.h> 45 #include <audio_effects/effect_aec.h> 46 #include <system/audio.h> 47 48 #include "jni.h" 49 #include "JNIHelp.h" 50 51 #include "AudioCodec.h" 52 #include "EchoSuppressor.h" 53 54 extern int parse(JNIEnv *env, jstring jAddress, int port, sockaddr_storage *ss); 55 56 namespace { 57 58 using namespace android; 59 60 int gRandom = -1; 61 62 // We use a circular array to implement jitter buffer. The simplest way is doing 63 // a modulo operation on the index while accessing the array. However modulo can 64 // be expensive on some platforms, such as ARM. Thus we round up the size of the 65 // array to the nearest power of 2 and then use bitwise-and instead of modulo. 66 // Currently we make it 2048ms long and assume packet interval is 50ms or less. 67 // The first 100ms is the place where samples get mixed. The rest is the real 68 // jitter buffer. For a stream at 8000Hz it takes 32 kilobytes. These numbers 69 // are chosen by experiments and each of them can be adjusted as needed. 70 71 // Originally a stream does not send packets when it is receive-only or there is 72 // nothing to mix. However, this causes some problems with certain firewalls and 73 // proxies. A firewall might remove a port mapping when there is no outgoing 74 // packet for a preiod of time, and a proxy might wait for incoming packets from 75 // both sides before start forwarding. To solve these problems, we send out a 76 // silence packet on the stream for every second. It should be good enough to 77 // keep the stream alive with relatively low resources. 78 79 // Other notes: 80 // + We use elapsedRealtime() to get the time. Since we use 32bit variables 81 // instead of 64bit ones, comparison must be done by subtraction. 82 // + Sampling rate must be multiple of 1000Hz, and packet length must be in 83 // milliseconds. No floating points. 84 // + If we cannot get enough CPU, we drop samples and simulate packet loss. 85 // + Resampling is not done yet, so streams in one group must use the same rate. 86 // For the first release only 8000Hz is supported. 87 88 #define BUFFER_SIZE 2048 89 #define HISTORY_SIZE 100 90 #define MEASURE_BASE 100 91 #define MEASURE_PERIOD 5000 92 #define DTMF_PERIOD 200 93 94 class AudioStream 95 { 96 public: 97 AudioStream(); 98 ~AudioStream(); 99 bool set(int mode, int socket, sockaddr_storage *remote, 100 AudioCodec *codec, int sampleRate, int sampleCount, 101 int codecType, int dtmfType); 102 103 void sendDtmf(int event); 104 bool mix(int32_t *output, int head, int tail, int sampleRate); 105 void encode(int tick, AudioStream *chain); 106 void decode(int tick); 107 108 private: 109 enum { 110 NORMAL = 0, 111 SEND_ONLY = 1, 112 RECEIVE_ONLY = 2, 113 LAST_MODE = 2, 114 }; 115 116 int mMode; 117 int mSocket; 118 sockaddr_storage mRemote; 119 AudioCodec *mCodec; 120 uint32_t mCodecMagic; 121 uint32_t mDtmfMagic; 122 bool mFixRemote; 123 124 int mTick; 125 int mSampleRate; 126 int mSampleCount; 127 int mInterval; 128 int mKeepAlive; 129 130 int16_t *mBuffer; 131 int mBufferMask; 132 int mBufferHead; 133 int mBufferTail; 134 int mLatencyTimer; 135 int mLatencyScore; 136 137 uint16_t mSequence; 138 uint32_t mTimestamp; 139 uint32_t mSsrc; 140 141 int mDtmfEvent; 142 int mDtmfStart; 143 144 AudioStream *mNext; 145 146 friend class AudioGroup; 147 }; 148 149 AudioStream::AudioStream() 150 { 151 mSocket = -1; 152 mCodec = NULL; 153 mBuffer = NULL; 154 mNext = NULL; 155 } 156 157 AudioStream::~AudioStream() 158 { 159 close(mSocket); 160 delete mCodec; 161 delete [] mBuffer; 162 ALOGD("stream[%d] is dead", mSocket); 163 } 164 165 bool AudioStream::set(int mode, int socket, sockaddr_storage *remote, 166 AudioCodec *codec, int sampleRate, int sampleCount, 167 int codecType, int dtmfType) 168 { 169 if (mode < 0 || mode > LAST_MODE) { 170 return false; 171 } 172 mMode = mode; 173 174 mCodecMagic = (0x8000 | codecType) << 16; 175 mDtmfMagic = (dtmfType == -1) ? 0 : (0x8000 | dtmfType) << 16; 176 177 mTick = elapsedRealtime(); 178 mSampleRate = sampleRate / 1000; 179 mSampleCount = sampleCount; 180 mInterval = mSampleCount / mSampleRate; 181 182 // Allocate jitter buffer. 183 for (mBufferMask = 8; mBufferMask < mSampleRate; mBufferMask <<= 1); 184 mBufferMask *= BUFFER_SIZE; 185 mBuffer = new int16_t[mBufferMask]; 186 --mBufferMask; 187 mBufferHead = 0; 188 mBufferTail = 0; 189 mLatencyTimer = 0; 190 mLatencyScore = 0; 191 192 // Initialize random bits. 193 read(gRandom, &mSequence, sizeof(mSequence)); 194 read(gRandom, &mTimestamp, sizeof(mTimestamp)); 195 read(gRandom, &mSsrc, sizeof(mSsrc)); 196 197 mDtmfEvent = -1; 198 mDtmfStart = 0; 199 200 // Only take over these things when succeeded. 201 mSocket = socket; 202 if (codec) { 203 mRemote = *remote; 204 mCodec = codec; 205 206 // Here we should never get an private address, but some buggy proxy 207 // servers do give us one. To solve this, we replace the address when 208 // the first time we successfully decode an incoming packet. 209 mFixRemote = false; 210 if (remote->ss_family == AF_INET) { 211 unsigned char *address = 212 (unsigned char *)&((sockaddr_in *)remote)->sin_addr; 213 if (address[0] == 10 || 214 (address[0] == 172 && (address[1] >> 4) == 1) || 215 (address[0] == 192 && address[1] == 168)) { 216 mFixRemote = true; 217 } 218 } 219 } 220 221 ALOGD("stream[%d] is configured as %s %dkHz %dms mode %d", mSocket, 222 (codec ? codec->name : "RAW"), mSampleRate, mInterval, mMode); 223 return true; 224 } 225 226 void AudioStream::sendDtmf(int event) 227 { 228 if (mDtmfMagic != 0) { 229 mDtmfEvent = event << 24; 230 mDtmfStart = mTimestamp + mSampleCount; 231 } 232 } 233 234 bool AudioStream::mix(int32_t *output, int head, int tail, int sampleRate) 235 { 236 if (mMode == SEND_ONLY) { 237 return false; 238 } 239 240 if (head - mBufferHead < 0) { 241 head = mBufferHead; 242 } 243 if (tail - mBufferTail > 0) { 244 tail = mBufferTail; 245 } 246 if (tail - head <= 0) { 247 return false; 248 } 249 250 head *= mSampleRate; 251 tail *= mSampleRate; 252 253 if (sampleRate == mSampleRate) { 254 for (int i = head; i - tail < 0; ++i) { 255 output[i - head] += mBuffer[i & mBufferMask]; 256 } 257 } else { 258 // TODO: implement resampling. 259 return false; 260 } 261 return true; 262 } 263 264 void AudioStream::encode(int tick, AudioStream *chain) 265 { 266 if (tick - mTick >= mInterval) { 267 // We just missed the train. Pretend that packets in between are lost. 268 int skipped = (tick - mTick) / mInterval; 269 mTick += skipped * mInterval; 270 mSequence += skipped; 271 mTimestamp += skipped * mSampleCount; 272 ALOGV("stream[%d] skips %d packets", mSocket, skipped); 273 } 274 275 tick = mTick; 276 mTick += mInterval; 277 ++mSequence; 278 mTimestamp += mSampleCount; 279 280 // If there is an ongoing DTMF event, send it now. 281 if (mMode != RECEIVE_ONLY && mDtmfEvent != -1) { 282 int duration = mTimestamp - mDtmfStart; 283 // Make sure duration is reasonable. 284 if (duration >= 0 && duration < mSampleRate * DTMF_PERIOD) { 285 duration += mSampleCount; 286 int32_t buffer[4] = { 287 htonl(mDtmfMagic | mSequence), 288 htonl(mDtmfStart), 289 mSsrc, 290 htonl(mDtmfEvent | duration), 291 }; 292 if (duration >= mSampleRate * DTMF_PERIOD) { 293 buffer[3] |= htonl(1 << 23); 294 mDtmfEvent = -1; 295 } 296 sendto(mSocket, buffer, sizeof(buffer), MSG_DONTWAIT, 297 (sockaddr *)&mRemote, sizeof(mRemote)); 298 return; 299 } 300 mDtmfEvent = -1; 301 } 302 303 int32_t buffer[mSampleCount + 3]; 304 bool data = false; 305 if (mMode != RECEIVE_ONLY) { 306 // Mix all other streams. 307 memset(buffer, 0, sizeof(buffer)); 308 while (chain) { 309 if (chain != this) { 310 data |= chain->mix(buffer, tick - mInterval, tick, mSampleRate); 311 } 312 chain = chain->mNext; 313 } 314 } 315 316 int16_t samples[mSampleCount]; 317 if (data) { 318 // Saturate into 16 bits. 319 for (int i = 0; i < mSampleCount; ++i) { 320 int32_t sample = buffer[i]; 321 if (sample < -32768) { 322 sample = -32768; 323 } 324 if (sample > 32767) { 325 sample = 32767; 326 } 327 samples[i] = sample; 328 } 329 } else { 330 if ((mTick ^ mKeepAlive) >> 10 == 0) { 331 return; 332 } 333 mKeepAlive = mTick; 334 memset(samples, 0, sizeof(samples)); 335 336 if (mMode != RECEIVE_ONLY) { 337 ALOGV("stream[%d] no data", mSocket); 338 } 339 } 340 341 if (!mCodec) { 342 // Special case for device stream. 343 send(mSocket, samples, sizeof(samples), MSG_DONTWAIT); 344 return; 345 } 346 347 // Cook the packet and send it out. 348 buffer[0] = htonl(mCodecMagic | mSequence); 349 buffer[1] = htonl(mTimestamp); 350 buffer[2] = mSsrc; 351 int length = mCodec->encode(&buffer[3], samples); 352 if (length <= 0) { 353 ALOGV("stream[%d] encoder error", mSocket); 354 return; 355 } 356 sendto(mSocket, buffer, length + 12, MSG_DONTWAIT, (sockaddr *)&mRemote, 357 sizeof(mRemote)); 358 } 359 360 void AudioStream::decode(int tick) 361 { 362 char c; 363 if (mMode == SEND_ONLY) { 364 recv(mSocket, &c, 1, MSG_DONTWAIT); 365 return; 366 } 367 368 // Make sure mBufferHead and mBufferTail are reasonable. 369 if ((unsigned int)(tick + BUFFER_SIZE - mBufferHead) > BUFFER_SIZE * 2) { 370 mBufferHead = tick - HISTORY_SIZE; 371 mBufferTail = mBufferHead; 372 } 373 374 if (tick - mBufferHead > HISTORY_SIZE) { 375 // Throw away outdated samples. 376 mBufferHead = tick - HISTORY_SIZE; 377 if (mBufferTail - mBufferHead < 0) { 378 mBufferTail = mBufferHead; 379 } 380 } 381 382 // Adjust the jitter buffer if the latency keeps larger than the threshold 383 // in the measurement period. 384 int score = mBufferTail - tick - MEASURE_BASE; 385 if (mLatencyScore > score || mLatencyScore <= 0) { 386 mLatencyScore = score; 387 mLatencyTimer = tick; 388 } else if (tick - mLatencyTimer >= MEASURE_PERIOD) { 389 ALOGV("stream[%d] reduces latency of %dms", mSocket, mLatencyScore); 390 mBufferTail -= mLatencyScore; 391 mLatencyScore = -1; 392 } 393 394 int count = (BUFFER_SIZE - (mBufferTail - mBufferHead)) * mSampleRate; 395 if (count < mSampleCount) { 396 // Buffer overflow. Drop the packet. 397 ALOGV("stream[%d] buffer overflow", mSocket); 398 recv(mSocket, &c, 1, MSG_DONTWAIT); 399 return; 400 } 401 402 // Receive the packet and decode it. 403 int16_t samples[count]; 404 if (!mCodec) { 405 // Special case for device stream. 406 count = recv(mSocket, samples, sizeof(samples), 407 MSG_TRUNC | MSG_DONTWAIT) >> 1; 408 } else { 409 __attribute__((aligned(4))) uint8_t buffer[2048]; 410 sockaddr_storage remote; 411 socklen_t addrlen = sizeof(remote); 412 413 int length = recvfrom(mSocket, buffer, sizeof(buffer), 414 MSG_TRUNC | MSG_DONTWAIT, (sockaddr *)&remote, &addrlen); 415 416 // Do we need to check SSRC, sequence, and timestamp? They are not 417 // reliable but at least they can be used to identify duplicates? 418 if (length < 12 || length > (int)sizeof(buffer) || 419 (ntohl(*(uint32_t *)buffer) & 0xC07F0000) != mCodecMagic) { 420 ALOGV("stream[%d] malformed packet", mSocket); 421 return; 422 } 423 int offset = 12 + ((buffer[0] & 0x0F) << 2); 424 if ((buffer[0] & 0x10) != 0) { 425 offset += 4 + (ntohs(*(uint16_t *)&buffer[offset + 2]) << 2); 426 } 427 if ((buffer[0] & 0x20) != 0) { 428 length -= buffer[length - 1]; 429 } 430 length -= offset; 431 if (length >= 0) { 432 length = mCodec->decode(samples, count, &buffer[offset], length); 433 } 434 if (length > 0 && mFixRemote) { 435 mRemote = remote; 436 mFixRemote = false; 437 } 438 count = length; 439 } 440 if (count <= 0) { 441 ALOGV("stream[%d] decoder error", mSocket); 442 return; 443 } 444 445 if (tick - mBufferTail > 0) { 446 // Buffer underrun. Reset the jitter buffer. 447 ALOGV("stream[%d] buffer underrun", mSocket); 448 if (mBufferTail - mBufferHead <= 0) { 449 mBufferHead = tick + mInterval; 450 mBufferTail = mBufferHead; 451 } else { 452 int tail = (tick + mInterval) * mSampleRate; 453 for (int i = mBufferTail * mSampleRate; i - tail < 0; ++i) { 454 mBuffer[i & mBufferMask] = 0; 455 } 456 mBufferTail = tick + mInterval; 457 } 458 } 459 460 // Append to the jitter buffer. 461 int tail = mBufferTail * mSampleRate; 462 for (int i = 0; i < count; ++i) { 463 mBuffer[tail & mBufferMask] = samples[i]; 464 ++tail; 465 } 466 mBufferTail += mInterval; 467 } 468 469 //------------------------------------------------------------------------------ 470 471 class AudioGroup 472 { 473 public: 474 AudioGroup(); 475 ~AudioGroup(); 476 bool set(int sampleRate, int sampleCount); 477 478 bool setMode(int mode); 479 bool sendDtmf(int event); 480 bool add(AudioStream *stream); 481 bool remove(AudioStream *stream); 482 bool platformHasAec() { return mPlatformHasAec; } 483 484 private: 485 enum { 486 ON_HOLD = 0, 487 MUTED = 1, 488 NORMAL = 2, 489 ECHO_SUPPRESSION = 3, 490 LAST_MODE = 3, 491 }; 492 493 bool checkPlatformAec(); 494 495 AudioStream *mChain; 496 int mEventQueue; 497 volatile int mDtmfEvent; 498 499 int mMode; 500 int mSampleRate; 501 int mSampleCount; 502 int mDeviceSocket; 503 bool mPlatformHasAec; 504 505 class NetworkThread : public Thread 506 { 507 public: 508 NetworkThread(AudioGroup *group) : Thread(false), mGroup(group) {} 509 510 bool start() 511 { 512 if (run("Network", ANDROID_PRIORITY_AUDIO) != NO_ERROR) { 513 ALOGE("cannot start network thread"); 514 return false; 515 } 516 return true; 517 } 518 519 private: 520 AudioGroup *mGroup; 521 bool threadLoop(); 522 }; 523 sp<NetworkThread> mNetworkThread; 524 525 class DeviceThread : public Thread 526 { 527 public: 528 DeviceThread(AudioGroup *group) : Thread(false), mGroup(group) {} 529 530 bool start() 531 { 532 if (run("Device", ANDROID_PRIORITY_AUDIO) != NO_ERROR) { 533 ALOGE("cannot start device thread"); 534 return false; 535 } 536 return true; 537 } 538 539 private: 540 AudioGroup *mGroup; 541 bool threadLoop(); 542 }; 543 sp<DeviceThread> mDeviceThread; 544 }; 545 546 AudioGroup::AudioGroup() 547 { 548 mMode = ON_HOLD; 549 mChain = NULL; 550 mEventQueue = -1; 551 mDtmfEvent = -1; 552 mDeviceSocket = -1; 553 mNetworkThread = new NetworkThread(this); 554 mDeviceThread = new DeviceThread(this); 555 mPlatformHasAec = checkPlatformAec(); 556 } 557 558 AudioGroup::~AudioGroup() 559 { 560 mNetworkThread->requestExitAndWait(); 561 mDeviceThread->requestExitAndWait(); 562 close(mEventQueue); 563 close(mDeviceSocket); 564 while (mChain) { 565 AudioStream *next = mChain->mNext; 566 delete mChain; 567 mChain = next; 568 } 569 ALOGD("group[%d] is dead", mDeviceSocket); 570 } 571 572 bool AudioGroup::set(int sampleRate, int sampleCount) 573 { 574 mEventQueue = epoll_create(2); 575 if (mEventQueue == -1) { 576 ALOGE("epoll_create: %s", strerror(errno)); 577 return false; 578 } 579 580 mSampleRate = sampleRate; 581 mSampleCount = sampleCount; 582 583 // Create device socket. 584 int pair[2]; 585 if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair)) { 586 ALOGE("socketpair: %s", strerror(errno)); 587 return false; 588 } 589 mDeviceSocket = pair[0]; 590 591 // Create device stream. 592 mChain = new AudioStream; 593 if (!mChain->set(AudioStream::NORMAL, pair[1], NULL, NULL, 594 sampleRate, sampleCount, -1, -1)) { 595 close(pair[1]); 596 ALOGE("cannot initialize device stream"); 597 return false; 598 } 599 600 // Give device socket a reasonable timeout. 601 timeval tv; 602 tv.tv_sec = 0; 603 tv.tv_usec = 1000 * sampleCount / sampleRate * 500; 604 if (setsockopt(pair[0], SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv))) { 605 ALOGE("setsockopt: %s", strerror(errno)); 606 return false; 607 } 608 609 // Add device stream into event queue. 610 epoll_event event; 611 event.events = EPOLLIN; 612 event.data.ptr = mChain; 613 if (epoll_ctl(mEventQueue, EPOLL_CTL_ADD, pair[1], &event)) { 614 ALOGE("epoll_ctl: %s", strerror(errno)); 615 return false; 616 } 617 618 // Anything else? 619 ALOGD("stream[%d] joins group[%d]", pair[1], pair[0]); 620 return true; 621 } 622 623 bool AudioGroup::setMode(int mode) 624 { 625 if (mode < 0 || mode > LAST_MODE) { 626 return false; 627 } 628 // FIXME: temporary code to overcome echo and mic gain issues on herring and tuna boards. 629 // Must be modified/removed when the root cause of the issue is fixed in the hardware or 630 // driver 631 char value[PROPERTY_VALUE_MAX]; 632 property_get("ro.product.board", value, ""); 633 if (mode == NORMAL && 634 (!strcmp(value, "herring") || !strcmp(value, "tuna"))) { 635 mode = ECHO_SUPPRESSION; 636 } 637 if (mMode == mode) { 638 return true; 639 } 640 641 mDeviceThread->requestExitAndWait(); 642 ALOGD("group[%d] switches from mode %d to %d", mDeviceSocket, mMode, mode); 643 mMode = mode; 644 return (mode == ON_HOLD) || mDeviceThread->start(); 645 } 646 647 bool AudioGroup::sendDtmf(int event) 648 { 649 if (event < 0 || event > 15) { 650 return false; 651 } 652 653 // DTMF is rarely used, so we try to make it as lightweight as possible. 654 // Using volatile might be dodgy, but using a pipe or pthread primitives 655 // or stop-set-restart threads seems too heavy. Will investigate later. 656 timespec ts; 657 ts.tv_sec = 0; 658 ts.tv_nsec = 100000000; 659 for (int i = 0; mDtmfEvent != -1 && i < 20; ++i) { 660 nanosleep(&ts, NULL); 661 } 662 if (mDtmfEvent != -1) { 663 return false; 664 } 665 mDtmfEvent = event; 666 nanosleep(&ts, NULL); 667 return true; 668 } 669 670 bool AudioGroup::add(AudioStream *stream) 671 { 672 mNetworkThread->requestExitAndWait(); 673 674 epoll_event event; 675 event.events = EPOLLIN; 676 event.data.ptr = stream; 677 if (epoll_ctl(mEventQueue, EPOLL_CTL_ADD, stream->mSocket, &event)) { 678 ALOGE("epoll_ctl: %s", strerror(errno)); 679 return false; 680 } 681 682 stream->mNext = mChain->mNext; 683 mChain->mNext = stream; 684 if (!mNetworkThread->start()) { 685 // Only take over the stream when succeeded. 686 mChain->mNext = stream->mNext; 687 return false; 688 } 689 690 ALOGD("stream[%d] joins group[%d]", stream->mSocket, mDeviceSocket); 691 return true; 692 } 693 694 bool AudioGroup::remove(AudioStream *stream) 695 { 696 mNetworkThread->requestExitAndWait(); 697 698 for (AudioStream *chain = mChain; chain->mNext; chain = chain->mNext) { 699 if (chain->mNext == stream) { 700 if (epoll_ctl(mEventQueue, EPOLL_CTL_DEL, stream->mSocket, NULL)) { 701 ALOGE("epoll_ctl: %s", strerror(errno)); 702 return false; 703 } 704 chain->mNext = stream->mNext; 705 ALOGD("stream[%d] leaves group[%d]", stream->mSocket, mDeviceSocket); 706 delete stream; 707 break; 708 } 709 } 710 711 // Do not start network thread if there is only one stream. 712 if (!mChain->mNext || !mNetworkThread->start()) { 713 return false; 714 } 715 return true; 716 } 717 718 bool AudioGroup::NetworkThread::threadLoop() 719 { 720 AudioStream *chain = mGroup->mChain; 721 int tick = elapsedRealtime(); 722 int deadline = tick + 10; 723 int count = 0; 724 725 for (AudioStream *stream = chain; stream; stream = stream->mNext) { 726 if (tick - stream->mTick >= 0) { 727 stream->encode(tick, chain); 728 } 729 if (deadline - stream->mTick > 0) { 730 deadline = stream->mTick; 731 } 732 ++count; 733 } 734 735 int event = mGroup->mDtmfEvent; 736 if (event != -1) { 737 for (AudioStream *stream = chain; stream; stream = stream->mNext) { 738 stream->sendDtmf(event); 739 } 740 mGroup->mDtmfEvent = -1; 741 } 742 743 deadline -= tick; 744 if (deadline < 1) { 745 deadline = 1; 746 } 747 748 epoll_event events[count]; 749 count = epoll_wait(mGroup->mEventQueue, events, count, deadline); 750 if (count == -1) { 751 ALOGE("epoll_wait: %s", strerror(errno)); 752 return false; 753 } 754 for (int i = 0; i < count; ++i) { 755 ((AudioStream *)events[i].data.ptr)->decode(tick); 756 } 757 758 return true; 759 } 760 761 bool AudioGroup::checkPlatformAec() 762 { 763 effect_descriptor_t fxDesc; 764 uint32_t numFx; 765 766 if (AudioEffect::queryNumberEffects(&numFx) != NO_ERROR) { 767 return false; 768 } 769 for (uint32_t i = 0; i < numFx; i++) { 770 if (AudioEffect::queryEffect(i, &fxDesc) != NO_ERROR) { 771 continue; 772 } 773 if (memcmp(&fxDesc.type, FX_IID_AEC, sizeof(effect_uuid_t)) == 0) { 774 return true; 775 } 776 } 777 return false; 778 } 779 780 bool AudioGroup::DeviceThread::threadLoop() 781 { 782 int mode = mGroup->mMode; 783 int sampleRate = mGroup->mSampleRate; 784 int sampleCount = mGroup->mSampleCount; 785 int deviceSocket = mGroup->mDeviceSocket; 786 787 // Find out the frame count for AudioTrack and AudioRecord. 788 size_t output = 0; 789 size_t input = 0; 790 if (AudioTrack::getMinFrameCount(&output, AUDIO_STREAM_VOICE_CALL, 791 sampleRate) != NO_ERROR || output <= 0 || 792 AudioRecord::getMinFrameCount(&input, sampleRate, 793 AUDIO_FORMAT_PCM_16_BIT, AUDIO_CHANNEL_IN_MONO) != NO_ERROR || input <= 0) { 794 ALOGE("cannot compute frame count"); 795 return false; 796 } 797 ALOGD("reported frame count: output %d, input %d", output, input); 798 799 if (output < sampleCount * 2) { 800 output = sampleCount * 2; 801 } 802 if (input < sampleCount * 2) { 803 input = sampleCount * 2; 804 } 805 ALOGD("adjusted frame count: output %d, input %d", output, input); 806 807 // Initialize AudioTrack and AudioRecord. 808 AudioTrack track; 809 AudioRecord record; 810 if (track.set(AUDIO_STREAM_VOICE_CALL, sampleRate, AUDIO_FORMAT_PCM_16_BIT, 811 AUDIO_CHANNEL_OUT_MONO, output) != NO_ERROR || 812 record.set(AUDIO_SOURCE_VOICE_COMMUNICATION, sampleRate, AUDIO_FORMAT_PCM_16_BIT, 813 AUDIO_CHANNEL_IN_MONO, input) != NO_ERROR) { 814 ALOGE("cannot initialize audio device"); 815 return false; 816 } 817 ALOGD("latency: output %d, input %d", track.latency(), record.latency()); 818 819 // Give device socket a reasonable buffer size. 820 setsockopt(deviceSocket, SOL_SOCKET, SO_RCVBUF, &output, sizeof(output)); 821 setsockopt(deviceSocket, SOL_SOCKET, SO_SNDBUF, &output, sizeof(output)); 822 823 // Drain device socket. 824 char c; 825 while (recv(deviceSocket, &c, 1, MSG_DONTWAIT) == 1); 826 827 // check if platform supports echo cancellation and do not active local echo suppression in 828 // this case 829 EchoSuppressor *echo = NULL; 830 AudioEffect *aec = NULL; 831 if (mode == ECHO_SUPPRESSION) { 832 if (mGroup->platformHasAec()) { 833 aec = new AudioEffect(FX_IID_AEC, 834 NULL, 835 0, 836 0, 837 0, 838 record.getSessionId(), 839 record.getInput()); 840 status_t status = aec->initCheck(); 841 if (status == NO_ERROR || status == ALREADY_EXISTS) { 842 aec->setEnabled(true); 843 } else { 844 delete aec; 845 aec = NULL; 846 } 847 } 848 // Create local echo suppressor if platform AEC cannot be used. 849 if (aec == NULL) { 850 echo = new EchoSuppressor(sampleCount, 851 (track.latency() + record.latency()) * sampleRate / 1000); 852 } 853 } 854 // Start AudioRecord before AudioTrack. This prevents AudioTrack from being 855 // disabled due to buffer underrun while waiting for AudioRecord. 856 if (mode != MUTED) { 857 record.start(); 858 int16_t one; 859 record.read(&one, sizeof(one)); 860 } 861 track.start(); 862 863 while (!exitPending()) { 864 int16_t output[sampleCount]; 865 if (recv(deviceSocket, output, sizeof(output), 0) <= 0) { 866 memset(output, 0, sizeof(output)); 867 } 868 869 int16_t input[sampleCount]; 870 int toWrite = sampleCount; 871 int toRead = (mode == MUTED) ? 0 : sampleCount; 872 int chances = 100; 873 874 while (--chances > 0 && (toWrite > 0 || toRead > 0)) { 875 if (toWrite > 0) { 876 AudioTrack::Buffer buffer; 877 buffer.frameCount = toWrite; 878 879 status_t status = track.obtainBuffer(&buffer, 1); 880 if (status == NO_ERROR) { 881 int offset = sampleCount - toWrite; 882 memcpy(buffer.i8, &output[offset], buffer.size); 883 toWrite -= buffer.frameCount; 884 track.releaseBuffer(&buffer); 885 } else if (status != TIMED_OUT && status != WOULD_BLOCK) { 886 ALOGE("cannot write to AudioTrack"); 887 goto exit; 888 } 889 } 890 891 if (toRead > 0) { 892 AudioRecord::Buffer buffer; 893 buffer.frameCount = toRead; 894 895 status_t status = record.obtainBuffer(&buffer, 1); 896 if (status == NO_ERROR) { 897 int offset = sampleCount - toRead; 898 memcpy(&input[offset], buffer.i8, buffer.size); 899 toRead -= buffer.frameCount; 900 record.releaseBuffer(&buffer); 901 } else if (status != TIMED_OUT && status != WOULD_BLOCK) { 902 ALOGE("cannot read from AudioRecord"); 903 goto exit; 904 } 905 } 906 } 907 908 if (chances <= 0) { 909 ALOGW("device loop timeout"); 910 while (recv(deviceSocket, &c, 1, MSG_DONTWAIT) == 1); 911 } 912 913 if (mode != MUTED) { 914 if (echo != NULL) { 915 ALOGV("echo->run()"); 916 echo->run(output, input); 917 } 918 send(deviceSocket, input, sizeof(input), MSG_DONTWAIT); 919 } 920 } 921 922 exit: 923 delete echo; 924 delete aec; 925 return true; 926 } 927 928 //------------------------------------------------------------------------------ 929 930 static jfieldID gNative; 931 static jfieldID gMode; 932 933 int add(JNIEnv *env, jobject thiz, jint mode, 934 jint socket, jstring jRemoteAddress, jint remotePort, 935 jstring jCodecSpec, jint dtmfType) 936 { 937 AudioCodec *codec = NULL; 938 AudioStream *stream = NULL; 939 AudioGroup *group = NULL; 940 941 // Sanity check. 942 sockaddr_storage remote; 943 if (parse(env, jRemoteAddress, remotePort, &remote) < 0) { 944 // Exception already thrown. 945 return 0; 946 } 947 if (!jCodecSpec) { 948 jniThrowNullPointerException(env, "codecSpec"); 949 return 0; 950 } 951 const char *codecSpec = env->GetStringUTFChars(jCodecSpec, NULL); 952 if (!codecSpec) { 953 // Exception already thrown. 954 return 0; 955 } 956 socket = dup(socket); 957 if (socket == -1) { 958 jniThrowException(env, "java/lang/IllegalStateException", 959 "cannot get stream socket"); 960 return 0; 961 } 962 963 // Create audio codec. 964 int codecType = -1; 965 char codecName[16]; 966 int sampleRate = -1; 967 sscanf(codecSpec, "%d %15[^/]%*c%d", &codecType, codecName, &sampleRate); 968 codec = newAudioCodec(codecName); 969 int sampleCount = (codec ? codec->set(sampleRate, codecSpec) : -1); 970 env->ReleaseStringUTFChars(jCodecSpec, codecSpec); 971 if (sampleCount <= 0) { 972 jniThrowException(env, "java/lang/IllegalStateException", 973 "cannot initialize audio codec"); 974 goto error; 975 } 976 977 // Create audio stream. 978 stream = new AudioStream; 979 if (!stream->set(mode, socket, &remote, codec, sampleRate, sampleCount, 980 codecType, dtmfType)) { 981 jniThrowException(env, "java/lang/IllegalStateException", 982 "cannot initialize audio stream"); 983 goto error; 984 } 985 socket = -1; 986 codec = NULL; 987 988 // Create audio group. 989 group = (AudioGroup *)env->GetIntField(thiz, gNative); 990 if (!group) { 991 int mode = env->GetIntField(thiz, gMode); 992 group = new AudioGroup; 993 if (!group->set(8000, 256) || !group->setMode(mode)) { 994 jniThrowException(env, "java/lang/IllegalStateException", 995 "cannot initialize audio group"); 996 goto error; 997 } 998 } 999 1000 // Add audio stream into audio group. 1001 if (!group->add(stream)) { 1002 jniThrowException(env, "java/lang/IllegalStateException", 1003 "cannot add audio stream"); 1004 goto error; 1005 } 1006 1007 // Succeed. 1008 env->SetIntField(thiz, gNative, (int)group); 1009 return (int)stream; 1010 1011 error: 1012 delete group; 1013 delete stream; 1014 delete codec; 1015 close(socket); 1016 env->SetIntField(thiz, gNative, 0); 1017 return 0; 1018 } 1019 1020 void remove(JNIEnv *env, jobject thiz, jint stream) 1021 { 1022 AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative); 1023 if (group) { 1024 if (!stream || !group->remove((AudioStream *)stream)) { 1025 delete group; 1026 env->SetIntField(thiz, gNative, 0); 1027 } 1028 } 1029 } 1030 1031 void setMode(JNIEnv *env, jobject thiz, jint mode) 1032 { 1033 AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative); 1034 if (group && !group->setMode(mode)) { 1035 jniThrowException(env, "java/lang/IllegalArgumentException", NULL); 1036 } 1037 } 1038 1039 void sendDtmf(JNIEnv *env, jobject thiz, jint event) 1040 { 1041 AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative); 1042 if (group && !group->sendDtmf(event)) { 1043 jniThrowException(env, "java/lang/IllegalArgumentException", NULL); 1044 } 1045 } 1046 1047 JNINativeMethod gMethods[] = { 1048 {"nativeAdd", "(IILjava/lang/String;ILjava/lang/String;I)I", (void *)add}, 1049 {"nativeRemove", "(I)V", (void *)remove}, 1050 {"nativeSetMode", "(I)V", (void *)setMode}, 1051 {"nativeSendDtmf", "(I)V", (void *)sendDtmf}, 1052 }; 1053 1054 } // namespace 1055 1056 int registerAudioGroup(JNIEnv *env) 1057 { 1058 gRandom = open("/dev/urandom", O_RDONLY); 1059 if (gRandom == -1) { 1060 ALOGE("urandom: %s", strerror(errno)); 1061 return -1; 1062 } 1063 1064 jclass clazz; 1065 if ((clazz = env->FindClass("android/net/rtp/AudioGroup")) == NULL || 1066 (gNative = env->GetFieldID(clazz, "mNative", "I")) == NULL || 1067 (gMode = env->GetFieldID(clazz, "mMode", "I")) == NULL || 1068 env->RegisterNatives(clazz, gMethods, NELEM(gMethods)) < 0) { 1069 ALOGE("JNI registration failed"); 1070 return -1; 1071 } 1072 return 0; 1073 } 1074