void t_audio_tx::run(void) {
const AppDataUnit* adu;
struct timespec sleeptimer;
//struct timeval debug_timer, debug_timer_prev;
int last_seqnum = -1; // seqnum of last received RTP packet
// RTP packets with multiple SSRCs may be received. Each SSRC
// represents an audio stream. Twinkle will only play 1 audio stream.
// On a reception of a new SSRC, Twinkle will switch over to play the
// new stream. This supports devices that change SSRC during a call.
uint32 ssrc_current = 0;
bool recvd_dtmf = false; // indicates if last RTP packets is a DTMF event
// The running flag is set already in t_audio_session::run to prevent
// a crash when the thread gets destroyed before it starts running.
// is_running = true;
uint32 rtp_timestamp = 0;
// This thread may not take the lock on the transaction layer to
// prevent dead locks
phone->add_prohibited_thread();
ui->add_prohibited_thread();
while (true) {
do {
adu = NULL;
if (stop_running) break;
rtp_timestamp = rtp_session->getFirstTimestamp();
adu = rtp_session->getData(
rtp_session->getFirstTimestamp());
if (adu == NULL || adu->getSize() <= 0) {
// There is no packet available. This may have
// several reasons:
// - the thread scheduling granularity does
// not match ptime
// - packet lost
// - packet delayed
// Wait another cycle for a packet. The
// jitter buffer will cope with this variation.
if (adu) {
delete adu;
adu = NULL;
}
// If we are the mixer in a 3-way call and there
// is enough media from the other far-end then
// this must be sent to the dsp.
if (is_3way && is_3way_mixer &&
media_3way_peer_tx->size_content() >=
ptime * (audio_sample_rate(codec) / 1000) * 2)
{
// Fill the sample buffer with silence
int len = ptime * (audio_sample_rate(codec) / 1000) * 2;
memset(sample_buf, 0, len);
play_pcm(sample_buf, len, true);
}
// Sleep ptime ms
sleeptimer.tv_sec = 0;
if (ptime >= 20) {
sleeptimer.tv_nsec =
ptime * 1000000 - 10000000;
} else {
// With a thread schedule of 10ms
// granularity, this will schedule the
// thread every 10ms.
sleeptimer.tv_nsec = 5000000;
}
nanosleep(&sleeptimer, NULL);
}
} while (adu == NULL || (adu->getSize() <= 0));
if (stop_running) {
if (adu) delete adu;
break;
}
if (adu) {
// adu is created by ccRTP, but we have to delete it,
// so report it to MEMMAN
MEMMAN_NEW(const_cast<ost::AppDataUnit*>(adu));
}
// Check for a codec change
map<unsigned short, t_audio_codec>::const_iterator it_codec;
it_codec = payload2codec.find(adu->getType());
t_audio_codec recvd_codec = CODEC_NULL;
if (it_codec != payload2codec.end()) {
recvd_codec = it_codec->second;
}
// Switch over to new SSRC
if (last_seqnum == -1 || ssrc_current != adu->getSource().getID()) {
if (recvd_codec != CODEC_NULL) {
ssrc_current = adu->getSource().getID();
// An SSRC defines a sequence number space. So a new
// SSRC starts with a new random sequence number
last_seqnum = -1;
log_file->write_header("t_audio_tx::run",
LOG_NORMAL);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": play SSRC ");
log_file->write_raw(ssrc_current);
log_file->write_endl();
log_file->write_footer();
} else {
// SSRC received had an unsupported codec
// Discard.
// KLUDGE: for now this supports a scenario where a
// far-end starts ZRTP negotiation by sending CN
// packets with a separate SSRC while ZRTP is disabled
// in Twinkle. Twinkle will then receive the CN packets
// and discard them here as CN is an unsupported codec.
log_file->write_header("t_audio_tx::run",
LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": SSRC received (");
log_file->write_raw(adu->getSource().getID());
log_file->write_raw(") has unsupported codec ");
log_file->write_raw(adu->getType());
log_file->write_endl();
log_file->write_footer();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
}
map<t_audio_codec, t_audio_decoder *>::const_iterator it_decoder;
it_decoder = map_audio_decoder.find(recvd_codec);
if (it_decoder != map_audio_decoder.end()) {
if (codec != recvd_codec) {
codec = recvd_codec;
get_line()->ci_set_recv_codec(codec);
ui->cb_async_recv_codec_changed(get_line()->get_line_number(),
codec);
log_file->write_header("t_audio_tx::run",
LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": codec change to ");
log_file->write_raw(ui->format_codec(codec));
log_file->write_endl();
log_file->write_footer();
}
} else {
if (adu->getType() == pt_telephone_event ||
adu->getType() == pt_telephone_event_alt)
{
recvd_dtmf = true;
} else {
if (codec != CODEC_UNSUPPORTED) {
codec = CODEC_UNSUPPORTED;
get_line()->ci_set_recv_codec(codec);
ui->cb_async_recv_codec_changed(
get_line()->get_line_number(), codec);
log_file->write_header("t_audio_tx::run",
LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": payload type ");
log_file->write_raw(adu->getType());
log_file->write_raw(" not supported\n");
log_file->write_footer();
}
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
}
// DTMF event
if (recvd_dtmf) {
// NOTE: the DTMF tone will be detected here
// while there might still be data in the jitter
// buffer. If the jitter buffer was already sent
// to the DSP, then the DSP will continue to play
// out the buffer sound samples.
if (dtmf_previous_timestamp != rtp_timestamp) {
// A new DTMF tone has been received.
dtmf_previous_timestamp = rtp_timestamp;
t_rtp_telephone_event *e =
(t_rtp_telephone_event *)adu->getData();
ui->cb_async_dtmf_detected(get_line()->get_line_number(),
e->get_event());
// Log DTMF event
log_file->write_header("t_audio_tx::run");
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": detected DTMF event - ");
log_file->write_raw(e->get_event());
log_file->write_endl();
log_file->write_footer();
}
recvd_dtmf = false;
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
// Discard invalide payload sizes
if (!map_audio_decoder[codec]->valid_payload_size(
adu->getSize(), SAMPLE_BUF_SIZE / 2))
{
log_file->write_header("t_audio_tx::run", LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": RTP payload size (");
log_file->write_raw((unsigned long)(adu->getSize()));
log_file->write_raw(" bytes) invalid for \n");
log_file->write_raw(ui->format_codec(codec));
log_file->write_footer();
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
unsigned short recvd_ptime;
recvd_ptime = map_audio_decoder[codec]->get_ptime(adu->getSize());
// Log a change of ptime
if (ptime != recvd_ptime) {
log_file->write_header("t_audio_tx::run", LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": ptime changed from ");
log_file->write_raw(ptime);
log_file->write_raw(" ms to ");
log_file->write_raw(recvd_ptime);
log_file->write_raw(" ms\n");
log_file->write_footer();
ptime = recvd_ptime;
}
// Check for lost packets
// This must be done before decoding the received samples as the
// speex decoder has its own PLC algorithm for which it needs the decoding
// state before decoding the new samples.
seq16_t seq_recvd(adu->getSeqNum());
seq16_t seq_last(static_cast<uint16>(last_seqnum));
if (last_seqnum != -1 && seq_recvd - seq_last > 1) {
// Packets have been lost
uint16 num_lost = (seq_recvd - seq_last) - 1;
log_file->write_header("t_audio_tx::run", LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": ");
log_file->write_raw(num_lost);
log_file->write_raw(" RTP packets lost.\n");
log_file->write_footer();
if (num_lost <= conceal_num) {
// Conceal packet loss
conceal(num_lost);
}
clear_conceal_buf();
}
// Determine if resampling is needed due to dynamic change to
// codec with other sample rate.
short downsample_factor = 1;
short upsample_factor = 1;
if (audio_sample_rate(codec) > sc_sample_rate) {
downsample_factor = audio_sample_rate(codec) / sc_sample_rate;
} else if (audio_sample_rate(codec) < sc_sample_rate) {
upsample_factor = sc_sample_rate / audio_sample_rate(codec);
}
// Create sample buffer. If no resampling is needed, the sample
// buffer from the audio_tx object can be used directly.
// Otherwise a temporary sample buffers is created that will
// be resampled to the object's sample buffer later.
short *sb;
int sb_size;
if (downsample_factor > 1) {
sb_size = SAMPLE_BUF_SIZE / 2 * downsample_factor;
sb = new short[sb_size];
MEMMAN_NEW_ARRAY(sb);
} else if (upsample_factor > 1) {
sb_size = SAMPLE_BUF_SIZE / 2;
sb = new short[SAMPLE_BUF_SIZE / 2];
MEMMAN_NEW_ARRAY(sb);
} else {
sb_size = SAMPLE_BUF_SIZE / 2;
sb = (short *)sample_buf;
}
// Decode the audio
unsigned char *payload = const_cast<uint8 *>(adu->getData());
short sample_size; // size in bytes
sample_size = 2 * map_audio_decoder[codec]->decode(payload, adu->getSize(), sb, sb_size);
// Resample if needed
if (downsample_factor > 1) {
short *p = sb;
sb = (short *)sample_buf;
for (int i = 0; i < sample_size / 2; i += downsample_factor) {
sb[i / downsample_factor] = p[i];
}
MEMMAN_DELETE_ARRAY(p);
delete [] p;
sample_size /= downsample_factor;
} else if (upsample_factor > 1) {
short *p = sb;
sb = (short *)sample_buf;
for (int i = 0; i < sample_size / 2; i++) {
for (int j = 0; j < upsample_factor; j++) {
sb[i * upsample_factor + j] = p[i];
}
}
MEMMAN_DELETE_ARRAY(p);
delete [] p;
sample_size *= upsample_factor;
}
// If the decoder deliverd 0 bytes, then it failed
if (sample_size == 0) {
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
// Discard packet if we are lacking behind. This happens if the
// soundcard plays at a rate less than the requested sample rate.
if (rtp_session->isWaiting(&(adu->getSource()))) {
uint32 last_ts = rtp_session->getLastTimestamp(&(adu->getSource()));
uint32 diff;
diff = last_ts - rtp_timestamp;
if (diff > (uint32_t)(JITTER_BUF_SIZE(sc_sample_rate) / AUDIO_SAMPLE_SIZE) * 8)
{
log_file->write_header("t_audio_tx::run", LOG_NORMAL, LOG_DEBUG);
log_file->write_raw("Audio tx line ");
log_file->write_raw(get_line()->get_line_number()+1);
log_file->write_raw(": discard delayed packet.\n");
log_file->write_raw("Timestamp: ");
log_file->write_raw(rtp_timestamp);
log_file->write_raw(", Last timestamp: ");
log_file->write_raw((long unsigned int)last_ts);
log_file->write_endl();
log_file->write_footer();
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
continue;
}
}
play_pcm(sample_buf, sample_size);
retain_for_concealment(sample_buf, sample_size);
last_seqnum = adu->getSeqNum();
MEMMAN_DELETE(const_cast<ost::AppDataUnit*>(adu));
delete adu;
// No sleep is done here but in the loop waiting
// for a new packet. If a packet is already available
// it can be send to the sound card immediately so
// the play-out buffer keeps filled.
// If the play-out buffer gets empty you hear a
// crack in the sound.
#ifdef HAVE_SPEEX
// store decoded output for (optional) echo cancellation
if (audio_session->get_do_echo_cancellation()) {
if (audio_session->get_echo_captured_last()) {
speex_echo_playback(audio_session->get_speex_echo_state(), (spx_int16_t *) sb);
audio_session->set_echo_captured_last(false);;
}
}
#endif
}
phone->remove_prohibited_thread();
ui->remove_prohibited_thread();
is_running = false;
}
static WAVEHDR* outPrePrep(int n, DWORD bufLen)
{
WAVEHDR* pWH;
int doAlloc = (hOutHdr[n] == NULL);
MpBufferMsg* msg;
MpBufferMsg* pFlush;
MpBufPtr ob;
static int oPP = 0;
static MpBufPtr prev = NULL; // prev is for future concealment use
static int concealed = 0;
static int flushes = 0;
static int skip = 0;
assert((n > -1) && (n < N_OUT_BUFFERS));
#ifdef DEBUG_WINDOZE /* [ */
if (1) {
static int spkQLen[1024];
int in = oPP % 1024;
int i, j;
spkQLen[in] = MpMisc.pSpkQ->numMsgs();
if (in == 1023) {
osPrintf("\n\n Speaker Queue lengths [%d,%d]:\n ", oPP, frameCount);
for (i=0; i<1024; i+=32) {
for (j=i; j<(i+32); j++) {
osPrintf("%3d", spkQLen[j]);
}
osPrintf("\n ");
}
osPrintf("\n\n");
}
}
#endif /* DEBUG_WINDOZE ] */
oPP++;
#ifdef DEBUG_WINDOZE /* [ */
if (0 && (0 == (oPP % 1000))) {
osPrintf("outPrePrep(): %d playbacks, %d flushes\n", oPP, flushes);
}
#endif /* DEBUG_WINDOZE ] */
while (MpMisc.pSpkQ && MprToSpkr::MAX_SPKR_BUFFERS < MpMisc.pSpkQ->numMsgs()) {
OsStatus res;
flushes++;
res = MpMisc.pSpkQ->receive((OsMsg*&) pFlush, OsTime::NO_WAIT);
if (OS_SUCCESS == res) {
MpBuf_delRef(pFlush->getTag());
pFlush->releaseMsg();
} else {
osPrintf("DmaTask: queue was full, now empty (4)!"
" (res=%d)\n", res);
}
if (flushes > 100) {
osPrintf("outPrePrep(): %d playbacks, %d flushes\n", oPP, flushes);
flushes = 0;
}
}
if (MpMisc.pSpkQ && (skip == 0) && (MprToSpkr::MIN_SPKR_BUFFERS > MpMisc.pSpkQ->numMsgs())) {
skip = MprToSpkr::SKIP_SPKR_BUFFERS;
assert(MprToSpkr::MAX_SPKR_BUFFERS >= skip);
#ifdef DEBUG_WINDOZE /* [ */
osPrintf("Skip(%d,%d)\n", skip, oPP);
#endif /* DEBUG_WINDOZE ] */
}
ob = NULL;
if (0 == skip) {
if (MpMisc.pSpkQ && OS_SUCCESS == MpMisc.pSpkQ->receive((OsMsg*&)msg, OsTime::NO_WAIT)) {
ob = msg->getTag();
msg->releaseMsg();
}
} else {
if (MpMisc.pSpkQ && MpMisc.pSpkQ->numMsgs() >= skip) skip = 0;
}
if (NULL == ob) {
ob = conceal(prev, concealed);
concealed++;
} else {
concealed = 0;
}
if (doAlloc) {
hOutHdr[n] = GlobalAlloc(GPTR, sizeof(WAVEHDR));
assert(NULL != hOutHdr[n]);
hOutBuf[n] = GlobalAlloc(GPTR, bufLen);
assert(NULL != hOutBuf[n]);
}
pOutHdr[n] = pWH = (WAVEHDR*) GlobalLock(hOutHdr[n]);
assert(NULL != pOutHdr[n]);
pWH->lpData = (char*) GlobalLock(hOutBuf[n]);
pWH->dwBufferLength = bufLen;
pWH->dwUser = n;
pWH->dwBytesRecorded = 0;
pWH->dwFlags = 0;
pWH->dwLoops = 0;
pWH->lpNext = 0;
pWH->reserved = 0;
memcpy(pWH->lpData, MpBuf_getSamples(ob), bufLen);
MpBuf_delRef(prev);
prev = ob;
return pWH;
}
