blob: e91f146de17dcd101ce16676719abdabeb407df2 [file] [log] [blame]
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <time.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#define LOG_TAG "AudioGroup"
#include <cutils/atomic.h>
#include <utils/Log.h>
#include <utils/Errors.h>
#include <utils/RefBase.h>
#include <utils/threads.h>
#include <utils/SystemClock.h>
#include <media/AudioRecord.h>
#include <media/AudioTrack.h>
#include <media/mediarecorder.h>
#include "jni.h"
#include "JNIHelp.h"
#include "AudioCodec.h"
extern int parse(JNIEnv *env, jstring jAddress, int port, sockaddr_storage *ss);
namespace {
using namespace android;
int gRandom = -1;
// We use a circular array to implement jitter buffer. The simplest way is doing
// a modulo operation on the index while accessing the array. However modulo can
// be expensive on some platforms, such as ARM. Thus we round up the size of the
// array to the nearest power of 2 and then use bitwise-and instead of modulo.
// Currently we make it 256ms long and assume packet interval is 32ms or less.
// The first 64ms is the place where samples get mixed. The rest 192ms is the
// real jitter buffer. For a stream at 8000Hz it takes 4096 bytes. These numbers
// are chosen by experiments and each of them can be adjusted as needed.
// Other notes:
// + We use elapsedRealtime() to get the time. Since we use 32bit variables
// instead of 64bit ones, comparison must be done by subtraction.
// + Sampling rate must be multiple of 1000Hz, and packet length must be in
// milliseconds. No floating points.
// + If we cannot get enough CPU, we drop samples and simulate packet loss.
// + Resampling is not done yet, so streams in one group must use the same rate.
// For the first release we might only support 8kHz and 16kHz.
class AudioStream
{
public:
AudioStream();
~AudioStream();
bool set(int mode, int socket, sockaddr_storage *remote,
const char *codecName, int sampleRate, int sampleCount,
int codecType, int dtmfType);
void sendDtmf(int event);
bool mix(int32_t *output, int head, int tail, int sampleRate);
void encode(int tick, AudioStream *chain);
void decode(int tick);
private:
enum {
NORMAL = 0,
SEND_ONLY = 1,
RECEIVE_ONLY = 2,
LAST_MODE = 2,
};
int mMode;
int mSocket;
sockaddr_storage mRemote;
AudioCodec *mCodec;
uint32_t mCodecMagic;
uint32_t mDtmfMagic;
int mTick;
int mSampleRate;
int mSampleCount;
int mInterval;
int16_t *mBuffer;
int mBufferMask;
int mBufferHead;
int mBufferTail;
int mLatencyScore;
uint16_t mSequence;
uint32_t mTimestamp;
uint32_t mSsrc;
int mDtmfEvent;
int mDtmfStart;
AudioStream *mNext;
friend class AudioGroup;
};
AudioStream::AudioStream()
{
mSocket = -1;
mCodec = NULL;
mBuffer = NULL;
mNext = NULL;
}
AudioStream::~AudioStream()
{
close(mSocket);
delete mCodec;
delete [] mBuffer;
LOGD("stream[%d] is dead", mSocket);
}
bool AudioStream::set(int mode, int socket, sockaddr_storage *remote,
const char *codecName, int sampleRate, int sampleCount,
int codecType, int dtmfType)
{
if (mode < 0 || mode > LAST_MODE) {
return false;
}
mMode = mode;
if (codecName) {
mRemote = *remote;
mCodec = newAudioCodec(codecName);
if (!mCodec || !mCodec->set(sampleRate, sampleCount)) {
return false;
}
}
mCodecMagic = (0x8000 | codecType) << 16;
mDtmfMagic = (dtmfType == -1) ? 0 : (0x8000 | dtmfType) << 16;
mTick = elapsedRealtime();
mSampleRate = sampleRate / 1000;
mSampleCount = sampleCount;
mInterval = mSampleCount / mSampleRate;
// Allocate jitter buffer.
for (mBufferMask = 8192; mBufferMask < sampleRate; mBufferMask <<= 1);
mBufferMask >>= 2;
mBuffer = new int16_t[mBufferMask];
--mBufferMask;
mBufferHead = 0;
mBufferTail = 0;
mLatencyScore = 0;
// Initialize random bits.
read(gRandom, &mSequence, sizeof(mSequence));
read(gRandom, &mTimestamp, sizeof(mTimestamp));
read(gRandom, &mSsrc, sizeof(mSsrc));
mDtmfEvent = -1;
mDtmfStart = 0;
// Only take over the socket when succeeded.
mSocket = socket;
LOGD("stream[%d] is configured as %s %dkHz %dms", mSocket,
(codecName ? codecName : "RAW"), mSampleRate, mInterval);
return true;
}
void AudioStream::sendDtmf(int event)
{
if (mDtmfMagic != 0) {
mDtmfEvent = event << 24;
mDtmfStart = mTimestamp + mSampleCount;
}
}
bool AudioStream::mix(int32_t *output, int head, int tail, int sampleRate)
{
if (mMode == SEND_ONLY) {
return false;
}
if (head - mBufferHead < 0) {
head = mBufferHead;
}
if (tail - mBufferTail > 0) {
tail = mBufferTail;
}
if (tail - head <= 0) {
return false;
}
head *= mSampleRate;
tail *= mSampleRate;
if (sampleRate == mSampleRate) {
for (int i = head; i - tail < 0; ++i) {
output[i - head] += mBuffer[i & mBufferMask];
}
} else {
// TODO: implement resampling.
return false;
}
return true;
}
void AudioStream::encode(int tick, AudioStream *chain)
{
if (tick - mTick >= mInterval) {
// We just missed the train. Pretend that packets in between are lost.
int skipped = (tick - mTick) / mInterval;
mTick += skipped * mInterval;
mSequence += skipped;
mTimestamp += skipped * mSampleCount;
LOGD("stream[%d] skips %d packets", mSocket, skipped);
}
tick = mTick;
mTick += mInterval;
++mSequence;
mTimestamp += mSampleCount;
if (mMode == RECEIVE_ONLY) {
return;
}
// If there is an ongoing DTMF event, send it now.
if (mDtmfEvent != -1) {
int duration = mTimestamp - mDtmfStart;
// Make sure duration is reasonable.
if (duration >= 0 && duration < mSampleRate * 100) {
duration += mSampleCount;
int32_t buffer[4] = {
htonl(mDtmfMagic | mSequence),
htonl(mDtmfStart),
mSsrc,
htonl(mDtmfEvent | duration),
};
if (duration >= mSampleRate * 100) {
buffer[3] |= htonl(1 << 23);
mDtmfEvent = -1;
}
sendto(mSocket, buffer, sizeof(buffer), MSG_DONTWAIT,
(sockaddr *)&mRemote, sizeof(mRemote));
return;
}
mDtmfEvent = -1;
}
// It is time to mix streams.
bool mixed = false;
int32_t buffer[mSampleCount + 3];
memset(buffer, 0, sizeof(buffer));
while (chain) {
if (chain != this &&
chain->mix(buffer, tick - mInterval, tick, mSampleRate)) {
mixed = true;
}
chain = chain->mNext;
}
if (!mixed) {
LOGD("stream[%d] no data", mSocket);
return;
}
// Cook the packet and send it out.
int16_t samples[mSampleCount];
for (int i = 0; i < mSampleCount; ++i) {
int32_t sample = buffer[i];
if (sample < -32768) {
sample = -32768;
}
if (sample > 32767) {
sample = 32767;
}
samples[i] = sample;
}
if (!mCodec) {
// Special case for device stream.
send(mSocket, samples, sizeof(samples), MSG_DONTWAIT);
return;
}
buffer[0] = htonl(mCodecMagic | mSequence);
buffer[1] = htonl(mTimestamp);
buffer[2] = mSsrc;
int length = mCodec->encode(&buffer[3], samples);
if (length <= 0) {
LOGD("stream[%d] encoder error", mSocket);
return;
}
sendto(mSocket, buffer, length + 12, MSG_DONTWAIT, (sockaddr *)&mRemote,
sizeof(mRemote));
}
void AudioStream::decode(int tick)
{
char c;
if (mMode == SEND_ONLY) {
recv(mSocket, &c, 1, MSG_DONTWAIT);
return;
}
// Make sure mBufferHead and mBufferTail are reasonable.
if ((unsigned int)(tick + 256 - mBufferHead) > 1024) {
mBufferHead = tick - 64;
mBufferTail = mBufferHead;
}
if (tick - mBufferHead > 64) {
// Throw away outdated samples.
mBufferHead = tick - 64;
if (mBufferTail - mBufferHead < 0) {
mBufferTail = mBufferHead;
}
}
if (mBufferTail - tick <= 80) {
mLatencyScore = tick;
} else if (tick - mLatencyScore >= 5000) {
// Reset the jitter buffer to 40ms if the latency keeps larger than 80ms
// in the past 5s. This rarely happens, so let us just keep it simple.
LOGD("stream[%d] latency control", mSocket);
mBufferTail = tick + 40;
}
if (mBufferTail - mBufferHead > 256 - mInterval) {
// Buffer overflow. Drop the packet.
LOGD("stream[%d] buffer overflow", mSocket);
recv(mSocket, &c, 1, MSG_DONTWAIT);
return;
}
// Receive the packet and decode it.
int16_t samples[mSampleCount];
int length = 0;
if (!mCodec) {
// Special case for device stream.
length = recv(mSocket, samples, sizeof(samples),
MSG_TRUNC | MSG_DONTWAIT) >> 1;
} else {
__attribute__((aligned(4))) uint8_t buffer[2048];
length = recv(mSocket, buffer, sizeof(buffer),
MSG_TRUNC | MSG_DONTWAIT);
// Do we need to check SSRC, sequence, and timestamp? They are not
// reliable but at least they can be used to identity duplicates?
if (length < 12 || length > (int)sizeof(buffer) ||
(ntohl(*(uint32_t *)buffer) & 0xC07F0000) != mCodecMagic) {
LOGD("stream[%d] malformed packet", mSocket);
return;
}
int offset = 12 + ((buffer[0] & 0x0F) << 2);
if ((buffer[0] & 0x10) != 0) {
offset += 4 + (ntohs(*(uint16_t *)&buffer[offset + 2]) << 2);
}
if ((buffer[0] & 0x20) != 0) {
length -= buffer[length - 1];
}
length -= offset;
if (length >= 0) {
length = mCodec->decode(samples, &buffer[offset], length);
}
}
if (length != mSampleCount) {
LOGD("stream[%d] decoder error", mSocket);
return;
}
if (tick - mBufferTail > 0) {
// Buffer underrun. Reset the jitter buffer to 40ms.
LOGD("stream[%d] buffer underrun", mSocket);
if (mBufferTail - mBufferHead <= 0) {
mBufferHead = tick + 40;
mBufferTail = mBufferHead;
} else {
int tail = (tick + 40) * mSampleRate;
for (int i = mBufferTail * mSampleRate; i - tail < 0; ++i) {
mBuffer[i & mBufferMask] = 0;
}
mBufferTail = tick + 40;
}
}
// Append to the jitter buffer.
int tail = mBufferTail * mSampleRate;
for (int i = 0; i < mSampleCount; ++i) {
mBuffer[tail & mBufferMask] = samples[i];
++tail;
}
mBufferTail += mInterval;
}
//------------------------------------------------------------------------------
class AudioGroup
{
public:
AudioGroup();
~AudioGroup();
bool set(int sampleRate, int sampleCount);
bool setMode(int mode);
bool sendDtmf(int event);
bool add(AudioStream *stream);
bool remove(int socket);
private:
enum {
ON_HOLD = 0,
MUTED = 1,
NORMAL = 2,
EC_ENABLED = 3,
LAST_MODE = 3,
};
int mMode;
AudioStream *mChain;
int mEventQueue;
volatile int mDtmfEvent;
int mSampleCount;
int mDeviceSocket;
AudioTrack mTrack;
AudioRecord mRecord;
bool networkLoop();
bool deviceLoop();
class NetworkThread : public Thread
{
public:
NetworkThread(AudioGroup *group) : Thread(false), mGroup(group) {}
bool start()
{
if (run("Network", ANDROID_PRIORITY_AUDIO) != NO_ERROR) {
LOGE("cannot start network thread");
return false;
}
return true;
}
private:
AudioGroup *mGroup;
bool threadLoop()
{
return mGroup->networkLoop();
}
};
sp<NetworkThread> mNetworkThread;
class DeviceThread : public Thread
{
public:
DeviceThread(AudioGroup *group) : Thread(false), mGroup(group) {}
bool start()
{
if (run("Device", ANDROID_PRIORITY_AUDIO) != NO_ERROR) {
LOGE("cannot start device thread");
return false;
}
return true;
}
private:
AudioGroup *mGroup;
bool threadLoop()
{
return mGroup->deviceLoop();
}
};
sp<DeviceThread> mDeviceThread;
};
AudioGroup::AudioGroup()
{
mMode = ON_HOLD;
mChain = NULL;
mEventQueue = -1;
mDtmfEvent = -1;
mDeviceSocket = -1;
mNetworkThread = new NetworkThread(this);
mDeviceThread = new DeviceThread(this);
}
AudioGroup::~AudioGroup()
{
mNetworkThread->requestExitAndWait();
mDeviceThread->requestExitAndWait();
mTrack.stop();
mRecord.stop();
close(mEventQueue);
close(mDeviceSocket);
while (mChain) {
AudioStream *next = mChain->mNext;
delete mChain;
mChain = next;
}
LOGD("group[%d] is dead", mDeviceSocket);
}
bool AudioGroup::set(int sampleRate, int sampleCount)
{
mEventQueue = epoll_create(2);
if (mEventQueue == -1) {
LOGE("epoll_create: %s", strerror(errno));
return false;
}
mSampleCount = sampleCount;
// Find out the frame count for AudioTrack and AudioRecord.
int output = 0;
int input = 0;
if (AudioTrack::getMinFrameCount(&output, AudioSystem::VOICE_CALL,
sampleRate) != NO_ERROR || output <= 0 ||
AudioRecord::getMinFrameCount(&input, sampleRate,
AudioSystem::PCM_16_BIT, 1) != NO_ERROR || input <= 0) {
LOGE("cannot compute frame count");
return false;
}
LOGD("reported frame count: output %d, input %d", output, input);
output = (output + sampleCount - 1) / sampleCount * sampleCount;
if (output < sampleCount * 3) {
output = sampleCount * 3;
}
input = (input + sampleCount - 1) / sampleCount * sampleCount;
if (input < sampleCount * 3) {
input = sampleCount * 3;
}
LOGD("adjusted frame count: output %d, input %d", output, input);
// Initialize AudioTrack and AudioRecord.
if (mTrack.set(AudioSystem::VOICE_CALL, sampleRate, AudioSystem::PCM_16_BIT,
AudioSystem::CHANNEL_OUT_MONO, output) != NO_ERROR ||
mRecord.set(AUDIO_SOURCE_MIC, sampleRate, AudioSystem::PCM_16_BIT,
AudioSystem::CHANNEL_IN_MONO, input) != NO_ERROR) {
LOGE("cannot initialize audio device");
return false;
}
LOGD("latency: output %d, input %d", mTrack.latency(), mRecord.latency());
// TODO: initialize echo canceler here.
// Create device socket.
int pair[2];
if (socketpair(AF_UNIX, SOCK_DGRAM, 0, pair)) {
LOGE("socketpair: %s", strerror(errno));
return false;
}
mDeviceSocket = pair[0];
// Create device stream.
mChain = new AudioStream;
if (!mChain->set(AudioStream::NORMAL, pair[1], NULL, NULL,
sampleRate, sampleCount, -1, -1)) {
close(pair[1]);
LOGE("cannot initialize device stream");
return false;
}
// Give device socket a reasonable timeout and buffer size.
timeval tv;
tv.tv_sec = 0;
tv.tv_usec = 1000 * sampleCount / sampleRate * 500;
if (setsockopt(pair[0], SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) ||
setsockopt(pair[0], SOL_SOCKET, SO_RCVBUF, &output, sizeof(output))) {
LOGE("setsockopt: %s", strerror(errno));
return false;
}
// Add device stream into event queue.
epoll_event event;
event.events = EPOLLIN;
event.data.ptr = mChain;
if (epoll_ctl(mEventQueue, EPOLL_CTL_ADD, pair[1], &event)) {
LOGE("epoll_ctl: %s", strerror(errno));
return false;
}
// Anything else?
LOGD("stream[%d] joins group[%d]", pair[1], pair[0]);
return true;
}
bool AudioGroup::setMode(int mode)
{
if (mode < 0 || mode > LAST_MODE) {
return false;
}
if (mMode == mode) {
return true;
}
LOGD("group[%d] switches from mode %d to %d", mDeviceSocket, mMode, mode);
mMode = mode;
mDeviceThread->requestExitAndWait();
if (mode == ON_HOLD) {
mTrack.stop();
mRecord.stop();
return true;
}
mTrack.start();
if (mode == MUTED) {
mRecord.stop();
} else {
mRecord.start();
}
if (!mDeviceThread->start()) {
mTrack.stop();
mRecord.stop();
return false;
}
return true;
}
bool AudioGroup::sendDtmf(int event)
{
if (event < 0 || event > 15) {
return false;
}
// DTMF is rarely used, so we try to make it as lightweight as possible.
// Using volatile might be dodgy, but using a pipe or pthread primitives
// or stop-set-restart threads seems too heavy. Will investigate later.
timespec ts;
ts.tv_sec = 0;
ts.tv_nsec = 100000000;
for (int i = 0; mDtmfEvent != -1 && i < 20; ++i) {
nanosleep(&ts, NULL);
}
if (mDtmfEvent != -1) {
return false;
}
mDtmfEvent = event;
nanosleep(&ts, NULL);
return true;
}
bool AudioGroup::add(AudioStream *stream)
{
mNetworkThread->requestExitAndWait();
epoll_event event;
event.events = EPOLLIN;
event.data.ptr = stream;
if (epoll_ctl(mEventQueue, EPOLL_CTL_ADD, stream->mSocket, &event)) {
LOGE("epoll_ctl: %s", strerror(errno));
return false;
}
stream->mNext = mChain->mNext;
mChain->mNext = stream;
if (!mNetworkThread->start()) {
// Only take over the stream when succeeded.
mChain->mNext = stream->mNext;
return false;
}
LOGD("stream[%d] joins group[%d]", stream->mSocket, mDeviceSocket);
return true;
}
bool AudioGroup::remove(int socket)
{
mNetworkThread->requestExitAndWait();
for (AudioStream *stream = mChain; stream->mNext; stream = stream->mNext) {
AudioStream *target = stream->mNext;
if (target->mSocket == socket) {
stream->mNext = target->mNext;
LOGD("stream[%d] leaves group[%d]", socket, mDeviceSocket);
delete target;
break;
}
}
// Do not start network thread if there is only one stream.
if (!mChain->mNext || !mNetworkThread->start()) {
return false;
}
return true;
}
bool AudioGroup::networkLoop()
{
int tick = elapsedRealtime();
int deadline = tick + 10;
int count = 0;
for (AudioStream *stream = mChain; stream; stream = stream->mNext) {
if (!stream->mTick || tick - stream->mTick >= 0) {
stream->encode(tick, mChain);
}
if (deadline - stream->mTick > 0) {
deadline = stream->mTick;
}
++count;
}
if (mDtmfEvent != -1) {
int event = mDtmfEvent;
for (AudioStream *stream = mChain; stream; stream = stream->mNext) {
stream->sendDtmf(event);
}
mDtmfEvent = -1;
}
deadline -= tick;
if (deadline < 1) {
deadline = 1;
}
epoll_event events[count];
count = epoll_wait(mEventQueue, events, count, deadline);
if (count == -1) {
LOGE("epoll_wait: %s", strerror(errno));
return false;
}
for (int i = 0; i < count; ++i) {
((AudioStream *)events[i].data.ptr)->decode(tick);
}
return true;
}
bool AudioGroup::deviceLoop()
{
int16_t output[mSampleCount];
if (recv(mDeviceSocket, output, sizeof(output), 0) <= 0) {
memset(output, 0, sizeof(output));
}
if (mTrack.write(output, sizeof(output)) != (int)sizeof(output)) {
LOGE("cannot write to AudioTrack");
return false;
}
if (mMode != MUTED) {
uint32_t frameCount = mRecord.frameCount();
AudioRecord::Buffer input;
input.frameCount = frameCount;
if (mRecord.obtainBuffer(&input, -1) != NO_ERROR) {
LOGE("cannot read from AudioRecord");
return false;
}
if (input.frameCount < (uint32_t)mSampleCount) {
input.frameCount = 0;
} else {
if (mMode == NORMAL) {
send(mDeviceSocket, input.i8, sizeof(output), MSG_DONTWAIT);
} else {
// TODO: Echo canceller runs here.
send(mDeviceSocket, input.i8, sizeof(output), MSG_DONTWAIT);
}
if (input.frameCount < frameCount) {
input.frameCount = mSampleCount;
}
}
mRecord.releaseBuffer(&input);
}
return true;
}
//------------------------------------------------------------------------------
static jfieldID gNative;
static jfieldID gMode;
jint add(JNIEnv *env, jobject thiz, jint mode,
jint socket, jstring jRemoteAddress, jint remotePort,
jstring jCodecName, jint sampleRate, jint sampleCount,
jint codecType, jint dtmfType)
{
const char *codecName = NULL;
AudioStream *stream = NULL;
AudioGroup *group = NULL;
// Sanity check.
sockaddr_storage remote;
if (parse(env, jRemoteAddress, remotePort, &remote) < 0) {
// Exception already thrown.
return -1;
}
if (sampleRate < 0 || sampleCount < 0 || codecType < 0 || codecType > 127) {
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
goto error;
}
if (!jCodecName) {
jniThrowNullPointerException(env, "codecName");
return -1;
}
codecName = env->GetStringUTFChars(jCodecName, NULL);
if (!codecName) {
// Exception already thrown.
return -1;
}
// Create audio stream.
stream = new AudioStream;
if (!stream->set(mode, socket, &remote, codecName, sampleRate, sampleCount,
codecType, dtmfType)) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot initialize audio stream");
goto error;
}
socket = -1;
// Create audio group.
group = (AudioGroup *)env->GetIntField(thiz, gNative);
if (!group) {
int mode = env->GetIntField(thiz, gMode);
group = new AudioGroup;
if (!group->set(8000, 256) || !group->setMode(mode)) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot initialize audio group");
goto error;
}
}
// Add audio stream into audio group.
if (!group->add(stream)) {
jniThrowException(env, "java/lang/IllegalStateException",
"cannot add audio stream");
goto error;
}
// Succeed.
env->SetIntField(thiz, gNative, (int)group);
env->ReleaseStringUTFChars(jCodecName, codecName);
return socket;
error:
delete group;
delete stream;
close(socket);
env->SetIntField(thiz, gNative, NULL);
env->ReleaseStringUTFChars(jCodecName, codecName);
return -1;
}
void remove(JNIEnv *env, jobject thiz, jint socket)
{
AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative);
if (group) {
if (socket == -1 || !group->remove(socket)) {
delete group;
env->SetIntField(thiz, gNative, NULL);
}
}
}
void setMode(JNIEnv *env, jobject thiz, jint mode)
{
AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative);
if (group && !group->setMode(mode)) {
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
return;
}
env->SetIntField(thiz, gMode, mode);
}
void sendDtmf(JNIEnv *env, jobject thiz, jint event)
{
AudioGroup *group = (AudioGroup *)env->GetIntField(thiz, gNative);
if (group && !group->sendDtmf(event)) {
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
}
}
JNINativeMethod gMethods[] = {
{"add", "(IILjava/lang/String;ILjava/lang/String;IIII)I", (void *)add},
{"remove", "(I)V", (void *)remove},
{"setMode", "(I)V", (void *)setMode},
{"sendDtmf", "(I)V", (void *)sendDtmf},
};
} // namespace
int registerAudioGroup(JNIEnv *env)
{
gRandom = open("/dev/urandom", O_RDONLY);
if (gRandom == -1) {
LOGE("urandom: %s", strerror(errno));
return -1;
}
jclass clazz;
if ((clazz = env->FindClass("android/net/rtp/AudioGroup")) == NULL ||
(gNative = env->GetFieldID(clazz, "mNative", "I")) == NULL ||
(gMode = env->GetFieldID(clazz, "mMode", "I")) == NULL ||
env->RegisterNatives(clazz, gMethods, NELEM(gMethods)) < 0) {
LOGE("JNI registration failed");
return -1;
}
return 0;
}