int maintestjitter()
{
char buffer[65536];
JitterBufferPacket in, out;
int i;
JitterBuffer *jb = jitter_buffer_init(10);
out.data = buffer;
/* Frozen sender case */
jitterFill(jb);
for(i=0;i<100;++i) {
out.len = 65536;
jitter_buffer_get(jb, &out, 10, NULL);
jitter_buffer_tick(jb);
}
synthIn(&in, 100, 1);
jitter_buffer_put(jb, &in);
out.len = 65536;
if (jitter_buffer_get(jb, &out, 10, NULL) != JITTER_BUFFER_OK) {
printf("Failed frozen sender resynchronize\n");
} else {
printf("Frozen sender: Jitter %d\n", out.timestamp - 100*10);
}
return 0;
}
int speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *current_timestamp, void** userData)
{
int i;
int jbRet; /* results returned by the JB */
int ourRet; /* result that we will return */
spx_int32_t activity;
char data[2048];
JitterBufferPacket packet;
packet.data = data;
packet.len = 2048; /* AAAAARGH: it took a week to find and add this missing line */
if (jitter->valid_bits)
{
/* Try decoding last received packet */
jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (jbRet == 0)
{
jitter_buffer_tick(jitter->packets);
return 1;
} else {
jitter->valid_bits = 0;
}
}
jbRet = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, NULL);
if (jbRet != JITTER_BUFFER_OK)
{
/* no packet found, so no corresponding user-data */
*userData = NULL;
/* No packet found... extrapolate one */
/*fprintf (stderr, "lost/late frame\n");*/
/*Packet is late or lost*/
speex_decode_int(jitter->dec, NULL, out);
ourRet = 2;
} else {
/* found a packet, so there is corresponding user-data */
*userData = (void*)(packet.user_data);
speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
/* Decode packet */
jbRet = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (jbRet == 0) {
ourRet = 0;
jitter->valid_bits = 1;
} else {
/* Error while decoding */
ourRet = 3;
for (i=0;i<jitter->frame_size;i++) out[i]=0;
}
}
speex_decoder_ctl(jitter->dec, SPEEX_GET_ACTIVITY, &activity);
if (activity < jitter->activity_threshold)
jitter_buffer_update_delay(jitter->packets, &packet, NULL);
jitter_buffer_tick(jitter->packets);
return ourRet;
}
static tsk_size_t tdav_speex_jitterbuffer_get(tmedia_jitterbuffer_t* self, void* out_data, tsk_size_t out_size)
{
tdav_speex_jitterbuffer_t *jb = (tdav_speex_jitterbuffer_t *)self;
JitterBufferPacket jb_packet;
int ret;
if(!out_data || !out_size){
TSK_DEBUG_ERROR("Invalid parameter");
return 0;
}
if(!jb->state){
TSK_DEBUG_ERROR("Invalid state");
return 0;
}
if(jb->x_data_size != out_size){ // consumer must request PTIME data
TSK_DEBUG_WARN("%d not expected as frame size. %u<>%u", out_size, jb->frame_duration, (out_size * 500)/jb->rate);
return 0;
}
jb_packet.data = out_data;
jb_packet.len = out_size;
if ((ret = jitter_buffer_get(jb->state, &jb_packet, jb->frame_duration/*(out_size * 500)/jb->rate*/, tsk_null)) != JITTER_BUFFER_OK) {
switch(ret){
case JITTER_BUFFER_MISSING: /*TSK_DEBUG_INFO("JITTER_BUFFER_MISSING - %d", ret);*/ break;
case JITTER_BUFFER_INSERTION: /*TSK_DEBUG_INFO("JITTER_BUFFER_INSERTION - %d", ret);*/ break;
default: TSK_DEBUG_INFO("jitter_buffer_get() failed - %d", ret); break;
}
jitter_buffer_update_delay(jb->state, &jb_packet, NULL);
return 0;
}
// jitter_buffer_update_delay(jitterbuffer->state, &jb_packet, NULL);
return out_size;
}
static tsk_size_t tdav_speex_jitterbuffer_get(tmedia_jitterbuffer_t* self, void* out_data, tsk_size_t out_size)
{
tdav_speex_jitterbuffer_t *jb = (tdav_speex_jitterbuffer_t *)self;
JitterBufferPacket jb_packet;
int ret, miss = 0;
tsk_size_t ret_size = 0;
if (!out_data || !out_size) {
TSK_DEBUG_ERROR("Invalid parameter");
return 0;
}
if (!jb->state) {
TSK_DEBUG_ERROR("Invalid state");
return 0;
}
if (jb->x_data_size != out_size) { // consumer must request PTIME data
TSK_DEBUG_WARN("%d not expected as frame size. %u<>%u", out_size, jb->frame_duration, (out_size * 500) / jb->rate);
return 0;
}
jb_packet.data = out_data;
jb_packet.len = (spx_uint32_t)out_size;
if ((ret = jitter_buffer_get(jb->state, &jb_packet, jb->frame_duration/*(out_size * 500)/jb->rate*/, tsk_null)) != JITTER_BUFFER_OK) {
++jb->num_pkt_miss;
switch (ret) {
case JITTER_BUFFER_MISSING:
/*TSK_DEBUG_INFO("JITTER_BUFFER_MISSING - %d", ret);*/
if (jb->num_pkt_miss > jb->num_pkt_miss_max /*too much missing pkts*/ && jb->num_pkt_in > jb->num_pkt_miss_max/*we're really receiving pkts*/) {
jb->num_pkt_miss = 0;
self->plugin->reset(self);
TSK_DEBUG_WARN("Too much missing audio pkts");
}
break;
case JITTER_BUFFER_INSERTION:
/*TSK_DEBUG_INFO("JITTER_BUFFER_INSERTION - %d", ret);*/
break;
default:
TSK_DEBUG_INFO("jitter_buffer_get() failed - %d", ret);
break;
}
// jitter_buffer_update_delay(jb->state, &jb_packet, NULL);
//return 0;
}
else {
jb->num_pkt_miss = 0; // reset
ret_size = jb_packet.len;
}
//jitter_buffer_update_delay(jb->state, &jb_packet, NULL);
return ret_size;
}
JNIEXPORT jint JNICALL Native_NATIVE(jitter_1buffer_1get)
(JNIEnv *env, jclass that, jlong arg0, jobject arg1, jint arg2, jintArray arg3)
{
JitterBufferPacket _arg1, *lparg1=NULL;
jint *lparg3=NULL;
jint rc = 0;
Native_NATIVE_ENTER(env, that, Native_jitter_1buffer_1get_FUNC);
if (arg1) if ((lparg1 = getJitterBufferPacketFields(env, arg1, &_arg1)) == NULL) goto fail;
if (arg3) if ((lparg3 = (*env)->GetIntArrayElements(env, arg3, NULL)) == NULL) goto fail;
rc = jitter_buffer_get((JitterBuffer *)(intptr_t)arg0, lparg1, arg2, lparg3);
fail:
if (arg3 && lparg3) (*env)->ReleaseIntArrayElements(env, arg3, lparg3, 0);
if (arg1 && lparg1) setJitterBufferPacketFields(env, arg1, lparg1);
Native_NATIVE_EXIT(env, that, Native_jitter_1buffer_1get_FUNC);
return rc;
}
void AudioInput::addMic(const void *data, unsigned int nsamp) {
while (nsamp > 0) {
unsigned int left = qMin(nsamp, iMicLength - iMicFilled);
imfMic(pfMicInput + iMicFilled, data, left, iMicChannels);
iMicFilled += left;
nsamp -= left;
if (nsamp > 0) {
if (eMicFormat == SampleFloat)
data = reinterpret_cast<const float *>(data) + left * iMicChannels;
else
data = reinterpret_cast<const short *>(data) + left * iMicChannels;
}
if (iMicFilled == iMicLength) {
iMicFilled = 0;
float *ptr = srsMic ? pfOutput : pfMicInput;
if (srsMic) {
spx_uint32_t inlen = iMicLength;
spx_uint32_t outlen = iFrameSize;
speex_resampler_process_float(srsMic, 0, pfMicInput, &inlen, pfOutput, &outlen);
}
const float mul = 32768.f;
for (int j=0;j<iFrameSize;++j)
psMic[j] = static_cast<short>(ptr[j] * mul);
if (iEchoChannels > 0) {
JitterBufferPacket jbp;
jbp.data = reinterpret_cast<char *>(psSpeaker);
jbp.len = iFrameSize * sizeof(short);
jbp.timestamp = 0;
jbp.span = 0;
jbp.sequence = 0;
jbp.user_data = 0;
spx_int32_t offs;
jitter_buffer_get(jb, &jbp, 10, &offs);
jitter_buffer_tick(jb);
}
encodeAudioFrame();
}
}
}
void speex_jitter_get(SpeexJitter *jitter, short *out, int *current_timestamp)
{
int i;
int ret;
char data[2048];
JitterBufferPacket packet;
packet.data = data;
if (jitter->valid_bits)
{
/* Try decoding last received packet */
ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (ret == 0)
{
jitter_buffer_tick(jitter->packets);
return;
} else {
jitter->valid_bits = 0;
}
}
ret = jitter_buffer_get(jitter->packets, &packet, NULL);
if (ret != JITTER_BUFFER_OK)
{
/* No packet found */
/*fprintf (stderr, "lost/late frame\n");*/
/*Packet is late or lost*/
speex_decode_int(jitter->dec, NULL, out);
} else {
speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
/* Decode packet */
ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
if (ret == 0)
{
jitter->valid_bits = 1;
} else {
/* Error while decoding */
for (i=0;i<jitter->frame_size;i++)
out[i]=0;
}
}
jitter_buffer_tick(jitter->packets);
}
void jitterFill(JitterBuffer *jb) {
char buffer[65536];
JitterBufferPacket in, out;
int i;
out.data = buffer;
jitter_buffer_reset(jb);
for(i=0;i<100;++i) {
synthIn(&in, i, 1);
jitter_buffer_put(jb, &in);
out.len = 65536;
if (jitter_buffer_get(jb, &out, 10, NULL) != JITTER_BUFFER_OK) {
printf("Fill test failed iteration %d\n", i);
}
if (out.timestamp != i * 10) {
printf("Fill test expected %d got %d\n", i*10, out.timestamp);
}
jitter_buffer_tick(jb);
}
}
bool AudioOutputSpeech::needSamples(unsigned int snum) {
for (unsigned int i=iLastConsume;i<iBufferFilled;++i)
pfBuffer[i-iLastConsume]=pfBuffer[i];
iBufferFilled -= iLastConsume;
iLastConsume = snum;
if (iBufferFilled >= snum)
return bLastAlive;
float *pOut;
STACKVAR(float, fOut, iFrameSize + 4096);
bool nextalive = bLastAlive;
while (iBufferFilled < snum) {
resizeBuffer(iBufferFilled + iOutputSize);
pOut = (srs) ? fOut : (pfBuffer + iBufferFilled);
if (! bLastAlive) {
memset(pOut, 0, iFrameSize * sizeof(float));
} else {
if (p == LoopUser::lpLoopy) {
LoopUser::lpLoopy->fetchFrames();
}
int avail = 0;
int ts = jitter_buffer_get_pointer_timestamp(jbJitter);
jitter_buffer_ctl(jbJitter, JITTER_BUFFER_GET_AVAILABLE_COUNT, &avail);
if (p && (ts == 0)) {
int want = iroundf(p->fAverageAvailable);
if (avail < want) {
++iMissCount;
if (iMissCount < 20) {
memset(pOut, 0, iFrameSize * sizeof(float));
goto nextframe;
}
}
}
if (qlFrames.isEmpty()) {
QMutexLocker lock(&qmJitter);
char data[4096];
JitterBufferPacket jbp;
jbp.data = data;
jbp.len = 4096;
spx_int32_t startofs = 0;
if (jitter_buffer_get(jbJitter, &jbp, iFrameSize, &startofs) == JITTER_BUFFER_OK) {
PacketDataStream pds(jbp.data, jbp.len);
iMissCount = 0;
ucFlags = static_cast<unsigned char>(pds.next());
bHasTerminator = false;
unsigned int header = 0;
do {
header = static_cast<unsigned int>(pds.next());
if (header)
qlFrames << pds.dataBlock(header & 0x7f);
else
bHasTerminator = true;
} while ((header & 0x80) && pds.isValid());
if (pds.left()) {
pds >> fPos[0];
pds >> fPos[1];
pds >> fPos[2];
} else {
fPos[0] = fPos[1] = fPos[2] = 0.0f;
}
if (p) {
float a = static_cast<float>(avail);
if (avail >= p->fAverageAvailable)
p->fAverageAvailable = a;
else
p->fAverageAvailable *= 0.99f;
}
} else {
int main(int argc, char **argv)
{
int sd, rc, n, tmp;
char msg[MAX_MSG];
int nfds;
int send_timestamp = 0;
int recv_started = 0;
struct pollfd *pfds;
struct alsa_dev *dev;
CELTEncoder *enc_state;
CELTDecoder *dec_state;
CELTMode *mode;
struct sched_param param;
JitterBuffer *jitter;
SpeexEchoState *echo_state;
char mac_own[6], mac_remote[6];
if (argc != 4)
panic("Usage %s plughw:0,0 <lmac in xx:xx:xx:xx:xx:xx> <rmac>\n", argv[0]);
register_signal(SIGINT, sighandler);
hack_mac(mac_own, argv[2], strlen(argv[2]));
hack_mac(mac_remote, argv[3], strlen(argv[3]));
sd = socket(AF_LANA, SOCK_RAW, 0);
if (sd < 0)
panic("%s: cannot open socket \n", argv[0]);
printf("If ready hit key!\n"); //user must do binding
getchar();
dev = alsa_open(argv[1], SAMPLING_RATE, CHANNELS, FRAME_SIZE);
mode = celt_mode_create(SAMPLING_RATE, FRAME_SIZE, NULL);
enc_state = celt_encoder_create(mode, CHANNELS, NULL);
dec_state = celt_decoder_create(mode, CHANNELS, NULL);
param.sched_priority = sched_get_priority_min(SCHED_FIFO);
if (sched_setscheduler(0, SCHED_FIFO, ¶m))
whine("sched_setscheduler error!\n");
/* Setup all file descriptors for poll()ing */
nfds = alsa_nfds(dev);
pfds = xmalloc(sizeof(*pfds) * (nfds + 1));
alsa_getfds(dev, pfds, nfds);
pfds[nfds].fd = sd;
pfds[nfds].events = POLLIN;
/* Setup jitter buffer using decoder */
jitter = jitter_buffer_init(FRAME_SIZE);
tmp = FRAME_SIZE;
jitter_buffer_ctl(jitter, JITTER_BUFFER_SET_MARGIN, &tmp);
/* Echo canceller with 200 ms tail length */
echo_state = speex_echo_state_init(FRAME_SIZE, 10 * FRAME_SIZE);
tmp = SAMPLING_RATE;
speex_echo_ctl(echo_state, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);
register_signal_f(SIGALRM, timer_elapsed, SA_SIGINFO);
alsa_start(dev);
printf("ALSA started!\n");
itimer.it_interval.tv_sec = 0;
itimer.it_interval.tv_usec = interval;
itimer.it_value.tv_sec = 0;
itimer.it_value.tv_usec = interval;
setitimer(ITIMER_REAL, &itimer, NULL);
while (!sigint) {
poll(pfds, nfds + 1, -1);
/* Received packets */
if (pfds[nfds].revents & POLLIN) {
memset(msg, 0, MAX_MSG);
n = recv(sd, msg, MAX_MSG, 0);
if (n <= 0)
goto do_alsa;
pkts_in++;
int recv_timestamp;
memcpy(&recv_timestamp, msg, sizeof(recv_timestamp));
JitterBufferPacket packet;
packet.data = msg+4/*+6+6+2*/;
packet.len = n-4/*-6-6-2*/;
packet.timestamp = recv_timestamp;
packet.span = FRAME_SIZE;
packet.sequence = 0;
/* Put content of the packet into the jitter buffer,
except for the pseudo-header */
jitter_buffer_put(jitter, &packet);
recv_started = 1;
}
do_alsa:
/* Ready to play a frame (playback) */
if (alsa_play_ready(dev, pfds, nfds)) {
short pcm[FRAME_SIZE * CHANNELS] = {0};
if (recv_started) {
JitterBufferPacket packet;
/* Get audio from the jitter buffer */
packet.data = msg;
packet.len = MAX_MSG;
jitter_buffer_tick(jitter);
jitter_buffer_get(jitter, &packet, FRAME_SIZE,
NULL);
if (packet.len == 0)
packet.data=NULL;
celt_decode(dec_state, (const unsigned char *)
packet.data, packet.len, pcm);
}
/* Playback the audio and reset the echo canceller
if we got an underrun */
alsa_write(dev, pcm, FRAME_SIZE);
// if (alsa_write(dev, pcm, FRAME_SIZE))
// speex_echo_state_reset(echo_state);
/* Put frame into playback buffer */
// speex_echo_playback(echo_state, pcm);
}
/* Audio available from the soundcard (capture) */
if (alsa_cap_ready(dev, pfds, nfds)) {
short pcm[FRAME_SIZE * CHANNELS];
//pcm2[FRAME_SIZE * CHANNELS];
char outpacket[MAX_MSG];
alsa_read(dev, pcm, FRAME_SIZE);
/* Perform echo cancellation */
// speex_echo_capture(echo_state, pcm, pcm2);
// for (i = 0; i < FRAME_SIZE * CHANNELS; ++i)
// pcm[i] = pcm2[i];
celt_encode(enc_state, pcm, NULL, (unsigned char *)
(outpacket+4+6+6+2), PACKETSIZE);
/* Pseudo header: four null bytes and a 32-bit
timestamp; XXX hack */
memcpy(outpacket,mac_remote,6);
memcpy(outpacket+6,mac_own,6);
outpacket[6+6] = (uint8_t) 0xac;
outpacket[6+6+1] = (uint8_t) 0xdc;
memcpy(outpacket+6+6+2, &send_timestamp, sizeof(send_timestamp));
send_timestamp += FRAME_SIZE;
rc = sendto(sd, outpacket, PACKETSIZE+4+6+6+2, 0, NULL, 0);
if (rc < 0)
panic("cannot send to socket");
pkts_out++;
}
}
itimer.it_interval.tv_sec = 0;
itimer.it_interval.tv_usec = 0;
itimer.it_value.tv_sec = 0;
itimer.it_value.tv_usec = 0;
setitimer(ITIMER_REAL, &itimer, NULL);
close(sd);
return 0;
}
