int stream_udp(STREAM_XMIT_NODE_T *pList, double durationSec) {
STREAM_XMIT_NODE_T *pStream;
COLLECT_STREAM_PKTDATA_T collectPkt;
int triedXmit;
unsigned int idxDest;
TIME_VAL tmstart, tm1, tmnow;
TIME_VAL tmprevbwdescr;
int rc;
int sz;
int szPkt;
unsigned int szData;
const unsigned char *pData;
unsigned int szDataPayload;
const unsigned char *pDataPayload;
uint64_t totBytes = 0;
unsigned int totPkts = 0;
unsigned int bytes = 0;
unsigned int pkts = 0;
unsigned int bytes2 = 0;
unsigned int pkts2 = 0;
//char dstStr[64];
#ifndef WIN32
unsigned int countIterations = 0;
#endif // WIN32
if(!pList
#if defined(VSX_HAVE_LICENSE)
|| !pList->pLic
#endif // VSX_HAVE_LICENSE
) {
return -1;
}
//snprintf(dstStr, sizeof(dstStr), "%s:%d", inet_ntoa(pList->pRtpMulti->pdests[0].saDsts.sin_addr),
// ntohs(pList->pRtpMulti->pdests[0].saDsts.sin_port));
tmstart = tmnow = timer_GetTime();
tm1 = tmstart;
tmprevbwdescr = tmstart;
while(*pList->prunning == STREAMER_STATE_RUNNING && !g_proc_exit) {
pStream = pList;
triedXmit = 0;
while(pStream) {
if((rc = pStream->cbCanSend(pStream->pCbData)) > 0) {
pData = stream_rtp_data(pStream->pRtpMulti);
szData = stream_rtp_datalen(pStream->pRtpMulti);
if(szData >= RTP_HEADER_LEN) {
pDataPayload = pData + RTP_HEADER_LEN;
szDataPayload = szData - RTP_HEADER_LEN;
} else {
pDataPayload = NULL;
szDataPayload = 0;
}
if(pStream->pXmitAction->do_stream) {
triedXmit = 1;
totPkts++;
pkts++;
pkts2++;
if(pStream->pXmitAction->do_output) {
szPkt = 0;
for(idxDest = 0; idxDest < pStream->pRtpMulti->numDests; idxDest++) {
if(pStream->pXmitDestRc[idxDest] != 0) {
continue;
}
if(pStream->rawSend) {
if(pktgen_Queue(pData, szData) != 0) {
pStream->pXmitDestRc[idxDest] = -1;
sz = -1;
} else {
sz = szData;
}
} else {
//
// Check and send an rtcp sender report
//
if(*pStream->pfrtcp_sr_intervalsec > 0 &&
(tmnow - pStream->pRtpMulti->pdests[idxDest].tmLastRtcpSr) / TIME_VAL_MS >
*pStream->pfrtcp_sr_intervalsec * 1000) {
sendRtcpSr(pStream, idxDest);
pStream->pRtpMulti->pdests[idxDest].tmLastRtcpSr = tmnow;
}
if((sz = sendPktUdpRtp(pStream, idxDest, pData, szData)) < 0) {
pStream->pXmitDestRc[idxDest] = sz;
}
}
if(szPkt == 0 && sz > 0) {
szPkt = sz;
}
} // end of for
// Exit if there are no good transmitters in the list
if(pStream->pXmitAction->do_output && szPkt == 0) {
return -1;
}
} else { // if do_output
szPkt = szData;
}
if(!pStream->pXmitAction->do_output_rtphdr && szPkt > RTP_HEADER_LEN) {
szPkt -= RTP_HEADER_LEN;
}
totBytes += szPkt;
bytes += szPkt;
//
// Add the packet data to any outbound avclive subscribers
//
// TODO: do not hardcode szData > RTP_HEADER_LEN rtp hdr len
if(pStream->pLiveQ && pStream->pLiveQ->numActive > 0 && szDataPayload > 0) {
pthread_mutex_lock(&pStream->pLiveQ->mtx);
for(sz = 0; (unsigned int) sz < pStream->pLiveQ->max; sz++) {
if(pStream->pLiveQ->pQs[sz]) {
pktqueue_addpkt(pStream->pLiveQ->pQs[sz], pDataPayload, szDataPayload, NULL, 0);
}
}
pthread_mutex_unlock(&pStream->pLiveQ->mtx);
}
bytes2 += szPkt;
} else {
// preserve rtp sequence number during 'live pause'
//pStream->pRtp->m_pRtp->sequence_num =
// htons(htons(pStream->pRtp->m_pRtp->sequence_num) - 1);
//During 'live pause', update the last seq #
//if(pStream->pXmitAction->prior_do_stream && pStream->prtp_sequence_at_end) {
// *pStream->prtp_sequence_at_end = pStream->pRtp->m_pRtp->sequence_num;
//}
//fprintf(stderr, "not streaming\n");
}
//
// Record output stream
//
if(pStream->pXmitAction->do_record_post && pStream->pXmitCbs->cbRecord &&
pStream->pXmitCbs->pCbRecordData) {
memset(&collectPkt, 0, sizeof(collectPkt));
collectPkt.payload.pData = (unsigned char *) pDataPayload;
PKTCAPLEN(collectPkt.payload) = szDataPayload;
if((sz = pStream->pXmitCbs->cbRecord(pStream->pXmitCbs->pCbRecordData, &collectPkt)) < 0) {
return -1;
}
if(triedXmit == 0) {
triedXmit = 1;
}
}
//
// Call post processing function, such as http live streaming
// callback to segment and package output ts files
//
if(pStream->pXmitAction->do_httplive && pStream->pXmitCbs->cbPostProc &&
pStream->pXmitCbs->pCbPostProcData && pStream->pXmitAction->do_stream) {
if((sz = pStream->pXmitCbs->cbPostProc(pStream->pXmitCbs->pCbPostProcData,
pDataPayload, szDataPayload)) < 0) {
return -1;
}
if(triedXmit == 0) {
triedXmit = 1;
}
}
//if(pStream->pXmitAction->do_stream != pStream->pXmitAction->prior_do_stream) {
// pStream->pXmitAction->prior_do_stream = pStream->pXmitAction->do_stream;
//}
pStream->pRtpMulti->payloadLen = 0;
if((rc = pStream->cbPreparePkt(pStream->pCbData)) < 0) {
return -1;
}
//fprintf(stderr, "streamer prepare pkt returned %d\n", rc);
} else if(rc < 0) {
LOG(X_DEBUG("Stream ending, sent: %"LL64"u bytes %u pkts"), totBytes, totPkts);
return -1;
} else {
//fprintf(stderr, "streamer cansend rc:%d\n", rc);
}
pStream = pStream->pNext;
} // while(pStream)
pktgen_SendQueued();
if(triedXmit == 0) {
#ifdef WIN32
//sl1 = timer_GetTime();
//Sleep(1) may sleep past its short bedtime on win32, even from a thread w/ SCHED_RR
//However, sleep(0) uses alot more cpu slices
//TODO: make this a WaitForSingleObject for any registered pktqueue writers
if(pList->pSleepQ) {
//TODO: this does not return if a pkt has been queued and no subsequent pkt arrives
pktqueue_waitforunreaddata(pList->pSleepQ);
//pthread_cond_wait(pList->pCond, pList->pMtxCond);
} else {
Sleep(1);
}
} else {
// On windows Sleep 0 relinquishes execution for any waiting threads
Sleep(0);
#else // WIN32
VSX_DEBUG2(tmnow = timer_GetTime())
usleep(1000);
countIterations = 0;
VSX_DEBUGLOG3("stream_udp slept for %lld ns\n", timer_GetTime() - tmnow);
} else {
if(countIterations++ > 10000) {
// During continuous xmit, sleep to prevent unresponsive system
usleep(1);
countIterations = 0;
}
#endif // WIN32
}
tmnow = timer_GetTime();
if(pList->pBwDescr && (tmnow / TIME_VAL_US) > (tmprevbwdescr / TIME_VAL_US) + 1) {
pList->pBwDescr->intervalMs = (float)(tmnow - tmprevbwdescr)/ TIME_VAL_MS;
pList->pBwDescr->pkts = pkts2;
pList->pBwDescr->bytes = bytes2;
TV_FROM_TIMEVAL(pList->pBwDescr->updateTv, tmnow);
//pList->pBwDescr->updateTv.tv_sec = tmnow / TIME_VAL_US;
//pList->pBwDescr->updateTv.tv_usec = tmnow % TIME_VAL_US;
bytes2 = 0;
pkts2 = 0;
tmprevbwdescr = tmnow;
}
if(durationSec > 0 && tmnow > tmstart + (durationSec * TIME_VAL_US)) {
LOG(X_DEBUG("Stream duration %.1f sec limit reached"), durationSec);
*pList->prunning = STREAMER_STATE_FINISHED;
}
#if defined (VSX_HAVE_LICENSE)
// Check if stream time is limited
if(!(pList->pLic->capabilities & LIC_CAP_STREAM_TIME_UNLIMITED)) {
if(tmnow > tmstart + (STREAM_LIMIT_SEC * TIME_VAL_US)) {
LOG(X_INFO("Stream time limited. Stopping stream transmission after %d sec"),
(int) (tmnow - tmstart) / TIME_VAL_US);
*pList->prunning = STREAMER_STATE_FINISHED;
if(!(g_proc_exit_flags & PROC_EXIT_FLAG_NO_EXIT_ON_STREAM_TIME_LIMITED)) {
g_proc_exit = 1;
}
}
}
#endif // VSX_HAVE_LICENSE
#if defined(LITE_VERSION)
if(tmnow > tmstart + (STREAM_LIMIT_LITE_SEC * TIME_VAL_US)) {
LOG(X_INFO("Stream time limited. Stopping stream transmission after %d sec"),
(int) (tmnow - tmstart) / TIME_VAL_US);
*pList->prunning = STREAMER_STATE_FINISHED;
if(!(g_proc_exit_flags & PROC_EXIT_FLAG_NO_EXIT_ON_STREAM_TIME_LIMITED)) {
g_proc_exit = 1;
}
}
#endif // (LITE_VERSION)
/*
if(0 && pList->verbosity > 1 && tv2.tv_sec > tv1.tv_sec+3) {
elapsedMs0 = ((tv2.tv_sec - tv0.tv_sec) * 1000) +
((tv2.tv_usec - tv0.tv_usec) /1000);
elapsedMs1 = ((tv2.tv_sec - tv1.tv_sec) * 1000) +
((tv2.tv_usec - tv1.tv_usec) /1000);
fprintf(stdout, "%u", elapsedMs0/1000);
if(durationSec != 0) {
fprintf(stdout, "/%.1f", durationSec);
}
fprintf(stdout, " sec, %s %.1fKb/s %.1fpkts/s (total: %u pkts, %.1fKB, %.1fKb/s)",
dstStr,
(double)(bytes / 128.0f / ((double)elapsedMs1/1000.0f)),
(double)(pkts/ ((double)elapsedMs1/1000.0f)),
totPkts, (double)totBytes/1024.0f,
(double)(totBytes / 128.0f / ((double)elapsedMs0/1000.0f)));
fprintf(stdout, "\n");
bytes = 0;
pkts = 0;
tv1.tv_sec = tv2.tv_sec;
tv1.tv_usec = tv2.tv_usec;
}
*/
}
static int streamxmit_retransmitRtp(STREAM_RTP_DEST_T *pDest) {
STREAMXMIT_PKT_HDR_T *pktHdr;
unsigned int idxRd;
unsigned int count = 0;
int lastWasExpired = 0;
int rc;
int haveRequestedRetransmission = 0;
const PKTQUEUE_PKT_T *pQPkt = NULL;
STREAM_XMIT_QUEUE_T *pAsyncQ = &pDest->asyncQ;
TIME_VAL tvNow;
struct timeval tv;
float kbps;
char tmp[128];
tvNow = timer_GetTime();
TV_FROM_TIMEVAL(tv, tvNow);
pthread_mutex_lock(&pAsyncQ->mtx);
idxRd = pAsyncQ->pQ->idxRd;
//LOG(X_DEBUG("NACK streamxmit_iterate ... idxRd:%d, idxWr:%d / %d"), pAsyncQ->pQ->idxRd, pAsyncQ->pQ->idxWr, pAsyncQ->pQ->cfg.maxPkts);
while(count++ < pAsyncQ->pQ->cfg.maxPkts) {
pQPkt = &pAsyncQ->pQ->pkts[idxRd];
if(!(pQPkt->flags & PKTQUEUE_FLAG_HAVEPKTDATA)) {
//LOG(X_DEBUG("NACK streamxmit_iterate break at qid[%d]"), idxRd);
break;
}
//LOG(X_DEBUG("NACK streamxmit_iterate check qid[%d] seqno:%d, %lld ms ago"), idxRd, ((STREAMXMIT_PKT_HDR_T *) pQPkt->xtra.pQUserData)->seqNum, (tvNow - ((STREAMXMIT_PKT_HDR_T *) pQPkt->xtra.pQUserData)->tvxmit)/1000);
lastWasExpired = 0;
if(!(pktHdr = (STREAMXMIT_PKT_HDR_T *) pQPkt->xtra.pQUserData)) {
pAsyncQ->pQ->idxRd = idxRd;
fprintf(stderr, "streamxmit_itertate should never get here... idxRd:%d\n", idxRd);
} else if(pktHdr->tvXmit + (pAsyncQ->nackHistoryMs * TIME_VAL_MS) < tvNow) {
//
// The queue slot RTP sequence number came before the NACK starting sequence number
// so the current queue content is before the scope of the NACK
//
if(pktHdr->doRetransmit > 0) {
pktHdr->doRetransmit = -1;
if(pDest->pstreamStats) {
stream_abr_notifyBitrate(pDest->pstreamStats, &pDest->streamStatsMtx,
STREAM_ABR_UPDATE_REASON_NACK_AGED, .5f);
}
}
pAsyncQ->pQ->idxRd = idxRd;
pAsyncQ->pQ->pkts[idxRd].flags = 0;
lastWasExpired = 1;
//LOG(X_DEBUG("NACK streamxmit_iterate old here marked to -1 ... idxRd:%d, seqNum:%d"), idxRd, pktHdr->seqNum);
} else if(pktHdr->doRetransmit > 0 && !pktHdr->rtcp) {
if(pktHdr->tvLastRetransmit == 0 ||
pktHdr->tvLastRetransmit + (RTP_RETRANSMIT_INTERVAL_MS * TIME_VAL_MS) < tvNow) {
//
// Ensure that the retransmission will not exceed our retransmission bitrate limit
//
if(pAsyncQ->retransmissionKbpsMax > 0 &&
burstmeter_updateCounters(&pAsyncQ->retransmissionMeter, &tv) == 0 &&
(kbps = (burstmeter_getBitrateBps(&pAsyncQ->retransmissionMeter)/THROUGHPUT_BYTES_IN_KILO_F)) >= pAsyncQ->retransmissionKbpsMax) {
LOG(X_WARNING("RTP NACK retransmission bitrate %.3f >= %.3f throttled pt:%d sequence:%d to %s:%d, for original %d ms ago."),
kbps, pAsyncQ->retransmissionKbpsMax, pDest->pRtpMulti->init.pt, pktHdr->seqNum,
FORMAT_NETADDR(pDest->saDstsRtcp, tmp, sizeof(tmp)), ntohs(INET_PORT(pDest->saDstsRtcp)),
(tvNow - pktHdr->tvXmit) / TIME_VAL_MS);
if(pDest->pstreamStats) {
stream_abr_notifyBitrate(pDest->pstreamStats, &pDest->streamStatsMtx,
STREAM_ABR_UPDATE_REASON_NACK_THROTTLED, .5f);
}
pktHdr->doRetransmit = 0;
pktHdr->tvLastRetransmit = tvNow;
} else {
burstmeter_AddSample(&pAsyncQ->retransmissionMeter, pQPkt->len, &tv);
//LOG(X_DEBUG("RTP NACK Retransmission bitrate: %.3f %s (%.3f bps)"), (float) pAsyncQ->retransmissionMeter.meter.rangeMs/1000, burstmeter_printThroughputStr(buf, sizeof(buf), &pAsyncQ->retransmissionMeter), (float) burstmeter_getBitrateBps(&pAsyncQ->retransmissionMeter));
//
// Retransmit the RTP packet
//
LOG(X_DEBUG("RTP NACK retransmitting pt:%d sequence:%d, len:%d to %s:%d, original sent %d ms ago. "
"Rate: %.3f pkts/s, %.3f b/s"),
pDest->pRtpMulti->init.pt, pktHdr->seqNum, pQPkt->len,
FORMAT_NETADDR(pDest->saDstsRtcp, tmp, sizeof(tmp)), ntohs(INET_PORT(pDest->saDstsRtcp)),
(tvNow - pktHdr->tvXmit) / TIME_VAL_MS,
(float) burstmeter_getPacketratePs(&pAsyncQ->retransmissionMeter),
(float) burstmeter_getBitrateBps(&pAsyncQ->retransmissionMeter));
if((rc = srtp_sendto(STREAM_RTP_PNETIOSOCK(*pDest), (void *) pQPkt->pData, pQPkt->len, 0,
(const struct sockaddr *) &pDest->saDsts, NULL, SENDTO_PKT_TYPE_RTP, 1)) < 0) {
pktHdr->doRetransmit = -1;
} else {
pktHdr->doRetransmit = 0;
}
pktHdr->tvLastRetransmit = tvNow;
if(pDest->pstreamStats) {
stream_abr_notifyBitrate(pDest->pstreamStats, &pDest->streamStatsMtx,
STREAM_ABR_UPDATE_REASON_NACK_RETRANSMITTED, .5f);
}
}
} else {
haveRequestedRetransmission = 1;
}
}
if(++idxRd >= pAsyncQ->pQ->cfg.maxPkts) {
idxRd = 0;
}
if(lastWasExpired) {
pAsyncQ->pQ->idxRd = idxRd;
}
} // end of while...
pAsyncQ->haveRequestedRetransmission = haveRequestedRetransmission;
pthread_mutex_unlock(&pAsyncQ->mtx);
return haveRequestedRetransmission;
}
