void pool_close(POOL_T *pPool, int wait_for_ret) {
TIME_VAL tv0 = timer_GetTime();
if(!pPool) {
return;
}
if(pPool->pInUse) {
pPool->destroy_onempty = 1;
if(wait_for_ret) {
LOG(X_DEBUG("pool_close %s waiting for resources to be returned"), (pPool->descr ? pPool->descr : ""));
while(pPool->pInUse) {
if(wait_for_ret > 0 && (timer_GetTime() - tv0) / TIME_VAL_MS > wait_for_ret) {
LOG(X_WARNING("pool_close %s aborting wait for resources to be returned"), (pPool->descr ? pPool->descr : ""));
break;
}
usleep(50000);
}
LOG(X_DEBUG("pool_close %s done waiting for resources to be returned"), (pPool->descr ? pPool->descr : ""));
} else {
LOG(X_DEBUG("pool_close %s delaying deallocation until resources returned"),
(pPool->descr ? pPool->descr : ""));
return;
}
}
pool_free(pPool);
}
int mediadb_mkdirfull(const char *root, const char *path) {
size_t idxprev;
struct stat st;
size_t sz = 0;
size_t len;
char buf[VSX_MAX_PATH_LEN];
// fprintf(stdout, "mkdirfull '%s' '%s'\n", root, path);
if(!path) {
return -1;
}
if(root) {
sz = strlen(root);
}
buf[sizeof(buf) - 1] = '\0';
idxprev = sz;
len = strlen(path);
for(; sz < len && sz < sizeof(buf); sz++) {
if(path[sz] == DIR_DELIMETER) {
memset(buf, 0, sizeof(buf));
strncpy(buf, path, sz);
//fprintf(stdout, "stat '%s'\n", buf);
if(strlen(buf) > 0 && fileops_stat(buf, &st) != 0) {
LOG(X_DEBUG("Creating dir '%s'"), buf);
if(fileops_MkDir(buf, S_IRWXU | S_IRWXG | S_IRWXO ) < 0) {
LOG(X_ERROR("Unable to create dir '%s'"), buf);
return -1;
}
}
while(path[sz] == DIR_DELIMETER) {
sz++;
}
idxprev = sz;
//fprintf(stdout, "after'%s'\n", &path[sz]);
}
}
if(sz > idxprev && fileops_stat(path, &st) != 0) {
LOG(X_DEBUG("Creating dir '%s'"), path);
if(fileops_MkDir(path, S_IRWXU | S_IRWXG | S_IRWXO ) < 0) {
LOG(X_ERROR("Unable to create dir '%s'"), path);
return -1;
}
}
return 0;
}
static H264_NAL_T *getNextVclSlice(STREAM_H264_T *pStreamH264) {
if(pStreamH264->loop && pStreamH264->idxNal >= pStreamH264->pH264->lastFrameId) {
LOG(X_DEBUG("Looping H.264 stream"));
pStreamH264->idxNal = 0;
}
//fprintf(stderr, "GETNEXTVCLSLICE loop:%d, idxNal [%d/%d], pSlice: 0x%x 0x%x\n", pStreamH264->loop, pStreamH264->idxNal, pStreamH264->pH264->lastFrameId, pStreamH264->frame.pSlice, pStreamH264->frame.pSlice ? pStreamH264->frame.pSlice->hdr : 0);
if(pStreamH264->frame.pSlice &&
((H264_USE_DIRECT_READ(pStreamH264->pH264) && pStreamH264->frame.pSlice->content.pnext) ||
//(((pStreamH264->pH264->pMkvCtxt || pStreamH264->pH264->pMp4Ctxt) && pStreamH264->frame.pSlice->content.pnext) ||
(
//pStreamH264->frame.pSlice == &pStreamH264->audSlice ||
pStreamH264->frame.pSlice == &pStreamH264->spsSlice ||
pStreamH264->frame.pSlice == &pStreamH264->ppsSlice)
)) {
pStreamH264->frame.pSlice = (H264_NAL_T *) pStreamH264->frame.pSlice->content.pnext;
if(pStreamH264->idxNal == 0) {
pStreamH264->idxNal++;
}
//fprintf(stderr, "RETURNING NEXT SLICE IN FR 0x%x\n", pStreamH264->frame.pSlice->hdr);
return pStreamH264->frame.pSlice;
}
return (H264_NAL_T *) h264_cbGetNextAnnexBSample(pStreamH264->pH264,
pStreamH264->idxNal++, 0);
}
int cbOnPkt_silk(void *pUserData, const COLLECT_STREAM_PKTDATA_T *pPkt) {
CAPTURE_CBDATA_SP_T *pSp = (CAPTURE_CBDATA_SP_T *) pUserData;
const unsigned char *pData = pPkt ? pPkt->payload.pData : NULL;
unsigned int len = pPkt ? PKTCAPLEN(pPkt->payload) : 0;
CAPTURE_STORE_CBDATA_T cbData;
int queueFr = 0;
int rc = 0;
if(pSp == NULL) {
return -1;
} else if(!pPkt || !pPkt->payload.pData) {
// Packet was lost
LOG(X_WARNING("RTP SILK lost packet, last seq:%u, last ts:%u"), pSp->lastPktSeq, pSp->lastPktTs);
pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_PREVLOST);
return 0;
}
VSX_DEBUG_RTP(
LOG(X_DEBUG("RTP - rtp-recv-silk len:%d seq:%u ts:%u(%.3f) ts0:%u(%.3f, dlta:%.3f), mrk:%d ssrc:0x%x "
"flags:0x%x pQ:0x%x"),
PKTCAPLEN(pPkt->payload), pPkt->u.rtp.seq, pPkt->u.rtp.ts, PTSF(pPkt->u.rtp.ts),
pSp->pStream->ts0,
(pSp->pStream->clockHz > 0 ? ((double)pSp->pStream->ts0/pSp->pStream->clockHz) : 0),
(pSp->pStream->clockHz > 0 ? ((double)(pPkt->u.rtp.ts - pSp->pStream->ts0)/pSp->pStream->clockHz) : 0),
(pPkt->u.rtp.marksz & PKTDATA_RTP_MASK_MARKER)?1:0,
pSp->pStream->hdr.key.ssrc, pSp->spFlags, pSp->pCapAction && pSp->pCapAction->pQueue ? 1 : 0);
if(pPkt && PKTCAPLEN(pPkt->payload) > 0) {
LOGHEX_DEBUG(pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)));
}
);
int cbOnPkt_vp8(void *pUserData, const COLLECT_STREAM_PKTDATA_T *pPkt) {
int rc = 0;
CAPTURE_CBDATA_SP_T *pSp = (CAPTURE_CBDATA_SP_T *) pUserData;
CAPTURE_STORE_CBDATA_T cbData;
int queueFr = 0;
if(pSp == NULL) {
return -1;
} else if(!pPkt || !pPkt->payload.pData) {
// Packet was lost
LOG(X_WARNING("RTP VP8 lost packet, last seq:%u, last ts:%u"), pSp->lastPktSeq, pSp->lastPktTs);
pSp->spFlags |= (CAPTURE_SP_FLAG_DAMAGEDFRAME | CAPTURE_SP_FLAG_PREVLOST);
return 0;
}
VSX_DEBUG(
//VSX_DEBUGLOG_TIME
LOG(X_DEBUG("rtp-recv-vp8 len:%d seq:%u ts:%u(%.3f) ts0:%u(%.3f, dlta:%.3f), mrk:%d ssrc:0x%x "
"flags:0x%x pQ:0x%x"),
PKTCAPLEN(pPkt->payload), pPkt->u.rtp.seq, pPkt->u.rtp.ts, PTSF(pPkt->u.rtp.ts),
pSp->pStream->ts0,
(pSp->pStream->clockHz > 0 ? ((double)pSp->pStream->ts0/pSp->pStream->clockHz) : 0),
(pSp->pStream->clockHz > 0 ? ((double)(pPkt->u.rtp.ts - pSp->pStream->ts0)/pSp->pStream->clockHz) : 0),
(pPkt->u.rtp.marksz & PKTDATA_RTP_MASK_MARKER)?1:0,
pSp->pStream->hdr.key.ssrc, pSp->spFlags, pSp->pCapAction && pSp->pCapAction->pQueue ? 1 : 0);
if(pPkt && PKTCAPLEN(pPkt->payload) > 0) {
LOGHEX_DEBUG(pPkt->payload.pData, MIN(16, PKTCAPLEN(pPkt->payload)));
}
//fprintf(stderr, "tmpFrame.buf.idx:%d\n", pSp->pCapAction->tmpFrameBuf.idx);
);
static int stream_net_av_reset(STREAM_PES_T *pPes) {
STREAM_AV_DATA_T *pData = NULL;
unsigned int idx;
LOG(X_DEBUG("A/V input stream reset"));
for(idx = 0; idx < 2; idx++) {
if(idx == 0) {
pData = &pPes->vid;
} else {
pData = &pPes->aud;
}
if(pData->pDataSrc) {
pktqueue_reset((PKTQUEUE_T *) pData->pDataSrc->pCbData, 1);
}
xcode_resetdata(pData->pXcodeData);
pData->numFrames = 0;
memset(&pData->curPesTm, 0, sizeof(pData->curPesTm));
memset(&pData->prevPesTm, 0, sizeof(pData->prevPesTm));
pData->lastQWrIdx = 0;
if(pData->pHaveSeqStart) {
*pData->pHaveSeqStart = 0;
}
}
return 0;
}
static int extractGenericTrak(const MP4_CONTAINER_T *pMp4,
const MP4_TRAK_T *pMp4BoxSet,
const char *path,
float fStart,
float fDuration) {
FILE_STREAM_T fStreamOut;
CBDATA_WRITE_GENERIC_SAMPLE_T genericDescr;
uint64_t startHz = 0;
uint64_t durationHz = 0;
int rc = 0;
durationHz = (uint64_t) (fDuration * pMp4BoxSet->pMdhd->timescale);
startHz = (uint64_t) (fStart * pMp4BoxSet->pMdhd->timescale);
if((fStreamOut.fp = fileops_Open(path, O_RDWR | O_CREAT)) == FILEOPS_INVALID_FP) {
LOG(X_CRITICAL("Unable to open file for writing: %s"), path);
return -1;
}
fStreamOut.offset = 0;
LOG(X_DEBUG("Extracting raw media from %s"), pMp4->pStream->cbGetName(pMp4->pStream));
genericDescr.pStreamOut = &fStreamOut;
rc = mp4_readSamplesFromTrack(pMp4BoxSet, pMp4->pStream, writeGenericSample_mp4wrap, &genericDescr,
startHz, durationHz);
fileops_Close(fStreamOut.fp);
return rc;
}
int metafile_close(META_FILE_T *pMetaFile) {
int rc = 0;
ENTRY_IGNORE_T *pIgnore, *pIgnoreNext;
ENTRY_META_DESCRIPTION_T *pDesc, *pDescNext;
if(pMetaFile) {
VSX_DEBUG_METAFILE( LOG(X_DEBUG("META - metafile_close for file: '%s'"), pMetaFile->filestr) );
pIgnore = pMetaFile->pignoreList;
while(pIgnore) {
pIgnoreNext = pIgnore->pnext;
free(pIgnore);
pIgnore = pIgnoreNext;
}
pDesc = pMetaFile->pDescriptionList;
while(pDesc) {
pDescNext = pDesc->pnext;
free(pDesc);
pDesc = pDescNext;
}
pMetaFile->pignoreList = NULL;
pMetaFile->pDescriptionList = NULL;
}
return rc;
}
int dtls_netsock_setmtu(NETIO_SOCK_T *pnetsock, int mtu) {
if(!pnetsock || !pnetsock->ssl.pCtxt) {
return -1;
} else if(mtu <= 0) {
return 0;
} else {
#if defined(__linux__)
if(mtu < 228) {
LOG(X_ERROR("Cannot set DTLS MTU %d below minimum %d"), 228);
return -1;
}
pthread_mutex_lock(&((STREAM_DTLS_CTXT_T *) pnetsock->ssl.pDtlsCtxt)->mtx);
LOG(X_DEBUG("Setting DTLS MTU %d (netsock: 0x%x)"), mtu, pnetsock);
// openSSL MTU may be broken on Mac, but may work on Linux
//SSL_set_options(pnetsock->ssl.pCtxt, SSL_OP_NO_QUERY_MTU); //TODO: setting this makes the socket mtu 0, and the ssl/d1_both.c:268 assert crashes the app
SSL_set_mtu(pnetsock->ssl.pCtxt, mtu);
//SSL_set_mtu(pnetsock->ssl.pCtxt, mtu - 28);
pthread_mutex_unlock(&((STREAM_DTLS_CTXT_T *) pnetsock->ssl.pDtlsCtxt)->mtx);
#endif // (__linux__)
return 0;
}
}
int procdb_delete(SYS_PROCLIST_T *pProcs, const char *name, const char *id, int lock) {
int rc = -1;
SYS_PROC_T *pProc = NULL;
SYS_PROC_T *pProcPrev = NULL;
if(!pProcs || !name) {
return -1;
}
if(!id) {
id = "";
}
if(lock) {
pthread_mutex_lock(&pProcs->mtx);
}
pProc = pProcs->procs;
while(pProc) {
if(!strcasecmp(pProc->name, name) && !strcasecmp(pProc->id, id)) {
if(pProcPrev) {
pProcPrev->pnext = pProc->pnext;
}
if(pProcs->procs == pProc) {
pProcs->procs = pProc->pnext;
}
LOG(X_DEBUG("Removing process '%s' pid:%d flags:0x%x"),
pProc->name, pProc->pid, pProc->flags);
if(pProcs->activeInstances > 0) {
pProcs->activeInstances--;
}
if(pProc->isXcoded && pProcs->activeXcodeInstances > 0) {
pProcs->activeXcodeInstances--;
}
free(pProc);
rc = 0;
break;
} else {
pProcPrev = pProc;
pProc = pProc->pnext;
}
}
if(lock) {
pthread_mutex_unlock(&pProcs->mtx);
}
if(rc != 0) {
LOG(X_ERROR("Failed to remove process '%s'"), pProc->name);
}
return rc;
}
float stream_net_h264_jump(STREAM_H264_T *pStreamH264, float fStartSec, int syncframe) {
uint64_t desiredOffset = 0;
H264_NAL_T *pNal = NULL;
float fOffsetActual;
if(!pStreamH264 || fStartSec < 0) {
return -1;
}
desiredOffset = (uint64_t) (fStartSec * pStreamH264->pH264->clockHzOverride);
pStreamH264->idxNal = 0;
pNal = (H264_NAL_T *) h264_cbGetNextAnnexBSample(
pStreamH264->pH264, pStreamH264->idxNal++, -1);
while(pNal && pNal->content.playOffsetHz + pNal->content.playDurationHz <
desiredOffset) {
pNal = (H264_NAL_T *) h264_cbGetNextAnnexBSample(
pStreamH264->pH264, pStreamH264->idxNal++, -1);
}
if(pNal) {
if(syncframe) {
h264_moveToPriorSync(pStreamH264->pH264);
}
pNal = (H264_NAL_T *) h264_cbGetNextAnnexBSample(
pStreamH264->pH264, pStreamH264->idxNal++, 1);
}
if(!pNal) {
LOG(X_WARNING("h.264 stream jump to %.2f out of range %.2f (%u)"),
fStartSec, (double)pStreamH264->pH264->lastPlayOffsetHz /
pStreamH264->pH264->clockHzOverride,
pStreamH264->pH264->pNalsLastVcl->content.frameId);
return -1;
}
fOffsetActual = (float) ((double)pNal->content.playOffsetHz /
pStreamH264->pH264->clockHzOverride);
pStreamH264->frame.numSlices = 1;
pStreamH264->frame.szTot = pNal->content.sizeRd;
pStreamH264->frame.frameId = pNal->content.frameId;
pStreamH264->frame.pFileStream = pNal->content.pStreamIn;
pStreamH264->frame.idxInSlice = pStreamH264->frame.szTot;
pStreamH264->frame.idxSlice = 1;
pStreamH264->frame.pSlice = pNal;
if(pStreamH264->includeAnnexBHdr) {
pStreamH264->frame.idxInSlice += 4;
}
LOG(X_DEBUG("h.264 stream playout moved to frame %d actual:%.1fs (%.1fs) file:0x%llx"),
pNal->content.frameId, fOffsetActual, fStartSec, pNal->content.fileOffset);
return fOffsetActual;
}
RTSP_SESSION_T *rtspsrv_newSession(STREAM_RTSP_SESSIONS_T *pRtsp, int rtpmux, int rtcpmux) {
RTSP_SESSION_T *pSes = NULL;
unsigned int idx;
if(!pRtsp) {
return NULL;
}
pthread_mutex_lock(&pRtsp->mtx);
for(idx = 0; idx < pRtsp->max; idx++) {
if(!pRtsp->psessions[idx].inuse) {
pSes = &pRtsp->psessions[idx];
rtspsrv_initSession(pRtsp, pSes);
if(rtsp_alloc_listener_ports(pSes, pRtsp->staticLocalPort, rtpmux, rtcpmux, 1, 1) < 0) {
memset(pSes, 0, sizeof(RTSP_SESSION_T));
return NULL;
}
/*
if(pRtsp->staticLocalPort) {
//
// Some RTSP firewalls / SBCs require source port to always be in a range 6970 - 9999
// or even 6970-6971 only
//
pSes->vid.localports[0] = pRtsp->staticLocalPort;
pSes->vid.localports[1] = pSes->vid.localports[0] + 1;
pSes->aud.localports[0] = pSes->vid.localports[0] + 0;
pSes->aud.localports[1] = pSes->aud.localports[0] + 1;
} else {
//
// Create contiguous series of ports
// Some media clients/servers may not work properly with different
// video / audio port ranges,
//
pSes->vid.localports[0] = net_getlocalmediaport(2);
pSes->vid.localports[1] = pSes->vid.localports[0] + 1;
pSes->aud.localports[0] = pSes->vid.localports[0] + 2;
pSes->aud.localports[1] = pSes->aud.localports[0] + 1;
}
*/
pRtsp->numActive++;
pSes->inuse = 1;
LOG(X_DEBUG("Created RTSP %ssession %s Active: %d / %d"),
((pSes->sessionType & RTSP_SESSION_TYPE_INTERLEAVED) ? "(interleaved) " : ""),
pSes->sessionid, pRtsp->numActive, pRtsp->max);
break;
}
}
pthread_mutex_unlock(&pRtsp->mtx);
return pSes;
}
void *avc_calloc(size_t count, size_t size) {
void *p;
if((p = calloc(count, size)) == NULL) {
LOG(X_CRITICAL("Failed to calloc %d x %d"), count, size);
}
VSX_DEBUG_MEM( LOG(X_DEBUG("MEM - avc_calloc %d x %d = %d at 0x%x"), count, size, count * size, p); );
int net_connect_tmt(SOCKET sock, const struct sockaddr *psa, unsigned int mstmt) {
int rc = 0;
struct timeval tv;
fd_set fdsetRd, fdsetWr;
char tmp[128];
int try = 0;
if(sock == INVALID_SOCKET || !psa) {
return -1;
} else if(mstmt == 0) {
return net_connect(sock, psa);
}
VSX_DEBUG_NET( LOG(X_DEBUG("NET - net_connect family: %d, fd: %d, trying to %s:%d with timeout %d ms"),
psa->sa_family, sock, FORMAT_NETADDR(*psa, tmp, sizeof(tmp)), ntohs(PINET_PORT(psa)), mstmt) );
if((rc = net_setsocknonblock(sock, 1)) < 0) {
return rc;
}
do {
if((rc = connect(sock, psa, (socklen_t) INET_SIZE(*psa))) != 0) {
if(errno == EINPROGRESS) {
tv.tv_sec = (mstmt / 1000);
tv.tv_usec = (mstmt % 1000) * 1000;
FD_ZERO(&fdsetRd);
FD_SET(sock, &fdsetRd);
FD_ZERO(&fdsetWr);
FD_SET(sock, &fdsetWr);
if((rc = select(sock + 1, &fdsetRd, &fdsetWr, NULL, &tv)) > 0) {
// call connect again to see if it was succesful
try++;
rc = -1;
} else if(rc == 0) {
// timeout expired
rc = -1;
errno = ETIMEDOUT;
break;
} else {
// select error
break;
}
} else if(errno == EISCONN && try > 0) {
// already connected
rc = 0;
break;
} else {
// connect failure
rc = -1;
break;
}
} // end of if((rc = connect...
STREAM_STATS_T *stream_monitor_createattach(STREAM_STATS_MONITOR_T *pMonitor,
const struct sockaddr_in *psaRemote,
STREAM_METHOD_T method,
STREAM_MONITOR_ABR_TYPE_T abrEnabled) {
unsigned int numWr = 1;
unsigned int numRd = 1;
STREAM_STATS_T *pStats;
if(!pMonitor || !pMonitor->active || !psaRemote) {
return NULL;
}
//
// If this monitor is for use with Adaptive Bitrate control then we don't care about stream
// data sources which do not account for the bitrate we intend to control.
//
if(pMonitor->pAbr && abrEnabled == STREAM_MONITOR_ABR_NONE) {
return NULL;
}
if(abrEnabled == STREAM_MONITOR_ABR_ENABLED) {
LOG(X_DEBUG("ABR is enabled for output -> %s://%s:%d"),
devtype_methodstr(method), inet_ntoa(psaRemote->sin_addr), htons(psaRemote->sin_port));
}
if(method == STREAM_METHOD_UDP) {
//
// payload over UDP w/o RTP header (MPEG-2 ts)
//
numRd = 0;
} else if(method == STREAM_METHOD_UDP_RTP) {
//
// We try to account RTP and RTCP output independently
//
numWr = 2;
//
// For RTP output there is no TCP flow based in/out queing disparity
//
numRd = 0;
}
if(!(pStats = stream_stats_create(psaRemote, numWr, numRd, pMonitor->rangeMs1, pMonitor->rangeMs2))) {
return NULL;
}
pStats->method = method;
pStats->abrEnabled = abrEnabled;
if(stream_monitor_attach(pMonitor, pStats) < 0) {
stream_stats_destroy(&pStats, NULL);
}
return pStats;
}
void sig_handler(int sig) {
LOG(X_DEBUG("Deleting shared memory"));
xcode_ipc_close(g_pXcodeIpc);
signal(sig, SIG_DFL);
exit(0);
}
static int mp4_extractAvcVid(const MP4_CONTAINER_T *pMp4, const char *path,
float fStart, float fDuration) {
FILE_STREAM_T fStreamOut;
MP4_TRAK_AVCC_T mp4BoxSet;
AVCC_CBDATA_WRITE_SAMPLE_T avcDescr;
uint64_t startHz = 0;
uint64_t durationHz = 0;
uint32_t sampledelta = 0;
int rc = 0;
if(!pMp4|| !pMp4->pStream || pMp4->pStream == FILEOPS_INVALID_FP) {
return -1;
}
LOG(X_DEBUG("Extracting h.264 video from %s"), pMp4->pStream->cbGetName(pMp4->pStream));
if(mp4_initAvcCTrack(pMp4, &mp4BoxSet) < 0) {
return -1;
}
durationHz = (uint64_t) (fDuration * mp4BoxSet.tk.pMdhd->timescale);
startHz = (uint64_t) (fStart * mp4BoxSet.tk.pMdhd->timescale);
if((fStreamOut.fp = fileops_Open(path, O_RDWR | O_CREAT)) == FILEOPS_INVALID_FP) {
LOG(X_CRITICAL("Unable to open file for writing: %s"), path);
return -1;
}
fStreamOut.offset = 0;
if((sampledelta = mp4_getSttsSampleDelta(&mp4BoxSet.tk.pStts->list)) == 0) {
LOG(X_WARNING("Unable to get video sample timing from stts w/ %d entries"),
mp4BoxSet.tk.pStts->list.entrycnt);
}
rc = avcc_writeSPSPPS(&fStreamOut, &mp4BoxSet.pAvcC->avcc,
sampledelta, mp4BoxSet.tk.pMdhd->timescale);
if(rc >= 0) {
avcDescr.lenNalSzField = mp4BoxSet.pAvcC->avcc.lenminusone + 1;
avcDescr.pStreamOut = &fStreamOut;
if(avcDescr.lenNalSzField <= 0 || avcDescr.lenNalSzField > 4) {
LOG(X_ERROR("Invalid avcC start frame length field: %u"), avcDescr.lenNalSzField);
fileops_Close(fStreamOut.fp);
return -1;
}
rc = mp4_readSamplesFromTrack(&mp4BoxSet.tk, pMp4->pStream,
avcc_cbWriteSample_mp4wrap, &avcDescr, startHz, durationHz);
}
fileops_Close(fStreamOut.fp);
return rc;
}
static int flvsrv_init_aud_aac(CODEC_AUD_CTXT_T *pCtxtA, const uint8_t *pAdtsHdr) {
CODEC_AUD_CTXT_AAC_T *pCtxtAac = &pCtxtA->codecCtxt.aac;
int rc;
memset(pCtxtAac, 0, sizeof(CODEC_AUD_CTXT_AAC_T));
if(pCtxtA->pStreamerCfg && !pCtxtA->pStreamerCfg->xcode.aud.common.cfgDo_xcode &&
XCODE_AUD_UDATA_PTR(&pCtxtA->pStreamerCfg->xcode)->u.aac.descr.sp.init) {
LOG(X_DEBUG("Loading aac sequence start from source media"));
memcpy(&pCtxtAac->adtsFrame.sp, &XCODE_AUD_UDATA_PTR(&pCtxtA->pStreamerCfg->xcode)->u.aac.descr.sp,
sizeof(pCtxtAac->adtsFrame.sp));
aac_encodeADTSHdr(pCtxtAac->adtsHdr, sizeof(pCtxtAac->adtsHdr), &pCtxtAac->adtsFrame.sp, 0);
} else {
LOG(X_DEBUG("Loading aac sequence start from stream ADTS header"));
if(aac_decodeAdtsHdr(pAdtsHdr, 7, &pCtxtAac->adtsFrame) < 0) {
return -1;
}
memcpy(pCtxtAac->adtsHdr, pAdtsHdr, 7);
}
if((rc = esds_encodeDecoderSp((uint8_t *) pCtxtAac->spbuf, sizeof(pCtxtAac->spbuf),
&pCtxtAac->adtsFrame.sp)) <= 0) {
return -1;
}
pCtxtA->ctxt.clockHz = esds_getFrequencyVal(ESDS_FREQ_IDX(pCtxtAac->adtsFrame.sp));
pCtxtA->ctxt.channels = pCtxtAac->adtsFrame.sp.channelIdx;
pCtxtA->ctxt.pstartHdrs = pCtxtAac->spbuf;
pCtxtA->ctxt.startHdrsLen = rc;
//fprintf(stderr, "init_aud_aac haveExtFreqIdx:%d, %dHz\n", pCtxtAac->adtsFrame.sp.haveExtFreqIdx, esds_getFrequencyVal(ESDS_FREQ_IDX(pCtxtAac->adtsFrame.sp))); avc_dumpHex(stderr, pCtxtA->ctxt.pstartHdrs, pCtxtA->ctxt.startHdrsLen, 1);
return 0;
}
int net_recvnb(SOCKET sock, unsigned char *buf, unsigned int len,
unsigned int mstmt, int peek, int *pclosed) {
struct timeval tv;
fd_set fdsetRd;
int rc;
int sockflags = 0;
#if !defined(__APPLE__) && !defined(WIN32)
sockflags = MSG_NOSIGNAL;
#endif // __APPLE__
if(sock == INVALID_SOCKET) {
return -1;
}
if(peek) {
sockflags |= MSG_PEEK;
}
if(pclosed) {
*pclosed = 0;
}
tv.tv_sec = (mstmt / 1000);
tv.tv_usec = (mstmt % 1000) * 1000;
FD_ZERO(&fdsetRd);
FD_SET(sock, &fdsetRd);
if((rc = select(sock + 1, &fdsetRd, NULL, NULL, &tv)) > 0) {
if((rc = recv(sock, (void *) buf, len, sockflags)) < 0) {
LOG(X_ERROR("recv nonblock %d, sockflags: 0x%x returned %d "ERRNO_FMT_STR),
len, sockflags, rc, ERRNO_FMT_ARGS);
} else if(rc == 0) {
LOG(X_WARNING("recv nonblock %d - connection has been closed."), len);
if(pclosed) {
*pclosed = 1;
}
// Do not return 0, since that is what select will return if timeout has expired
return -1;
} else {
VSX_DEBUG_NET( LOG(X_DEBUG("NET - net_recvnb %s %d/%d bytes, fd: %d"), peek ? "peeked" : "got", rc, len, sock) );
}
} else if(rc == 0) {
//fprintf(stderr, "TMT EXPIRED sock:%d tv:%d,%d, mstmt:%d\n", sock, tv.tv_sec, tv.tv_usec, mstmt);
// timeout expired
} else {
LOG(X_ERROR("select socket:%d returned: %d"), sock, rc);
}
return rc;
}
static int mp4_extractAacAud(const MP4_CONTAINER_T *pMp4, const char *path,
float fStart, float fDuration) {
FILE_STREAM_T fStreamOut;
MP4_TRAK_MP4A_T mp4BoxSet;
ESDS_CBDATA_WRITE_SAMPLE_T esdsDescr;
unsigned char buf[4096];
uint64_t startHz = 0;
uint64_t durationHz = 0;
int rc = 0;
if(!pMp4|| !pMp4->pStream || pMp4->pStream == FILEOPS_INVALID_FP) {
return -1;
}
LOG(X_DEBUG("Extracting aac audio from %s"), pMp4->pStream->cbGetName(pMp4->pStream));
esdsDescr.bs.buf = buf;
esdsDescr.bs.sz = sizeof(buf);
esdsDescr.bs.idx = 0;
if(mp4_initMp4aTrack(pMp4, &mp4BoxSet) < 0) {
return -1;
}
if(mp4BoxSet.pEsds->config.objtypeid != ESDS_OBJTYPE_MP4A) {
LOG(X_ERROR("Unsupported mp4a esds object type descriptor: %u"),
mp4BoxSet.pEsds->config.objtypeid);
return -1;
} else if(esds_decodeDecoderSp(mp4BoxSet.pEsds->specific.startcodes,
(mp4BoxSet.pEsds->specific.type.length > sizeof(mp4BoxSet.pEsds->specific.startcodes) ?
sizeof(mp4BoxSet.pEsds->specific.startcodes) : mp4BoxSet.pEsds->specific.type.length),
&esdsDescr.decoderCfg) != 0) {
LOG(X_ERROR("Failed to decode mp4a esds decoder specific data for type descriptor: %u"),
mp4BoxSet.pEsds->config.type.descriptor);
return -1;
}
durationHz = (uint64_t) (fDuration * mp4BoxSet.tk.pMdhd->timescale);
startHz = (uint64_t) (fStart * mp4BoxSet.tk.pMdhd->timescale);
if((fStreamOut.fp = fileops_Open(path, O_RDWR | O_CREAT)) == FILEOPS_INVALID_FP) {
LOG(X_CRITICAL("Unable to open file for writing: %s"), path);
return -1;
}
fStreamOut.offset = 0;
esdsDescr.pStreamOut = &fStreamOut;
rc = mp4_readSamplesFromTrack(&mp4BoxSet.tk, pMp4->pStream, esds_cbWriteSample_mp4wrap,
&esdsDescr, startHz, durationHz);
fileops_Close(fStreamOut.fp);
return rc;
}
int dtls_netsock_setclient(NETIO_SOCK_T *pnetsock, int client) {
int rc = 0;
if(!pnetsock || !(pnetsock->flags & NETIO_FLAG_SSL_DTLS) || !pnetsock->ssl.pCtxt) {
return -1;
}
if(client) {
LOG(X_DEBUG("DTLS handshake SSL_set_connect_state"));
SSL_set_connect_state(pnetsock->ssl.pCtxt);
pnetsock->flags &= ~NETIO_FLAG_SSL_DTLS_SERVER;
} else {
LOG(X_DEBUG("DTLS handshake SSL_set_accept_state"));
SSL_set_accept_state(pnetsock->ssl.pCtxt);
pnetsock->flags |= NETIO_FLAG_SSL_DTLS_SERVER;
}
rc = 0;
return rc;
}
static int check_status(SYS_PROC_T *pProc) {
HTTP_STATUS_T httpStatus;
unsigned char buf[2048];
unsigned int szdata = sizeof(buf);
const char *page = NULL;
char host[256];
char tmp[64];
PROC_STATUS_RESP_DATA_T status;
snprintf(host, sizeof(host), "http://127.0.0.1:%d", MGR_GET_PORT_STATUS(pProc->startPort));
VSX_DEBUG_MGR( LOG(X_DEBUG("MGR - Sending local status command: '%s' to: %s"), VSX_STATUS_URL, host); );
int rtmp_create_chunksz(RTMP_CTXT_T *pRtmp) {
int rc;
const unsigned int hdrlen = 12;
if((rc = rtmp_create_hdr(&pRtmp->out.buf[pRtmp->out.idx],
RTMP_STREAM_IDX_CTRL, 0, 4, RTMP_CONTENT_TYPE_CHUNKSZ, 0, hdrlen)) < 0) {
return rc;
}
*((uint32_t *) &pRtmp->out.buf[pRtmp->out.idx + rc]) = htonl(pRtmp->chunkSzOut);
pRtmp->out.idx += (rc + 4);
VSX_DEBUG_RTMP(LOG(X_DEBUG("RTMP - rtmp_create_chunksz: %d"), pRtmp->chunkSzOut); );
char *metafile_find(const char *pathmedia,
char *pathbuf,
unsigned int szpathbuf,
int *ploaddefault) {
int sz;
struct stat st;
int loaddefault = 0;
if(!pathmedia) {
}
if(ploaddefault) {
loaddefault = *ploaddefault;
*ploaddefault = 0;
}
VSX_DEBUG_METAFILE( LOG(X_DEBUG("META - metafile_find pathmedia: '%s', loaddefault: %d"),
pathmedia, loaddefault));
//
// Check if the media resource is actually a meta file
//
if(metafile_isvalidFile(pathmedia)) {
return (char *) pathmedia;
}
//
// Try to load the metafile for the media resource
//
snprintf(pathbuf, szpathbuf, "%s%s", pathmedia, METAFILE_EXT);
if(fileops_stat(pathbuf, &st) == 0) {
return pathbuf;
}
//
// Try to load the directory wide metafile
//
if(loaddefault && (sz = mediadb_getdirlen(pathmedia)) > 0) {
strncpy(pathbuf, pathmedia, szpathbuf);
strncpy(&pathbuf[sz], METAFILE_DEFAULT, szpathbuf - sz);
if(fileops_stat(pathbuf, &st) == 0) {
if(ploaddefault) {
*ploaddefault = 1;
}
return pathbuf;
}
}
return NULL;
}
int rtmp_auth_cache_store(RTMP_AUTH_PERSIST_STORAGE_T *pcachedAuth, const RTMP_AUTH_PERSIST_T *pElem) {
int rc = -1;
unsigned int sz = 0;
TIME_VAL tm;
RTMP_AUTH_PERSIST_NODE_T *p, *p_prev = NULL;
RTMP_AUTH_PERSIST_NODE_T *pinsert = NULL;
RTMP_AUTH_PERSIST_NODE_T *poldest = NULL;
if(pElem->opaque[0] == '\0') {
return -1;
}
VSX_DEBUG_RTMP( LOG(X_DEBUG("RTMP auth cache storing opaque: '%s', salt: '%s', challenge: '%s'"),
pElem->opaque, pElem->salt, pElem->challenge); );
static int clearTn(const char *pathMedia, const char *pathDb,
const FILE_LIST_T *pFileList) {
DIR *pdir;
struct dirent *direntry;
char buf[VSX_MAX_PATH_LEN];
char buf2[VSX_MAX_PATH_LEN];
size_t sz,sz2;
if(!(pdir = fileops_OpenDir(pathDb))) {
return -1;
}
buf[sizeof(buf) - 1] = '\0';
while((direntry = fileops_ReadDir(pdir))) {
if(!(direntry->d_type & DT_DIR)) {
// "_tn[idx].jpg"
if((sz = strlen(direntry->d_name)) > 9 &&
(!strncasecmp(&direntry->d_name[sz - 4], ".jpg", 4) ||
!strncasecmp(&direntry->d_name[sz - VSXTMP_EXT_LEN], VSXTMP_EXT, VSXTMP_EXT_LEN) ||
!strncasecmp(&direntry->d_name[sz - NOTN_EXT_LEN], NOTN_EXT, NOTN_EXT_LEN))) {
strncpy(buf, direntry->d_name, sizeof(buf) - 1);
for(sz2 = sz - 4; sz2 > sz - 12; sz2--) {
if(buf[sz2] == '_') {
break;
}
}
buf[sz2] = '\0';
//fprintf(stdout, "check '%s' '%s'\n", buf, direntry->d_name);
if(file_list_find(pFileList, buf) == NULL) {
mediadb_prepend_dir(pathDb, direntry->d_name, buf2, sizeof(buf));
LOG(X_DEBUG("Removing thumbnail '%s'\n"), buf2);
if(fileops_DeleteFile(buf2) != 0) {
LOG(X_ERROR("Failed to delete thumbnail %s"), buf2);
}
}
}
}
}
fileops_CloseDir(pdir);
return 0;
}
static void procdb_dump(SYS_PROCLIST_T *pProcs, int lock) {
SYS_PROC_T *p;
if(lock) {
pthread_mutex_lock(&pProcs->mtx);
}
p = pProcs->procs;
while(p) {
LOG(X_DEBUG("name:'%s', id:'%s' instance:%s, flags:0x%x, numActive: %d, numPendingActive: %d"),
p->name, p->id, p->instanceId, p->flags, p->numActive, p->numPendingActive);
p = p->pnext;
}
if(lock) {
pthread_mutex_unlock(&pProcs->mtx);
}
}
static int mp4_extractMp4Vid(const MP4_CONTAINER_T *pMp4, const char *path,
float fStart, float fDuration) {
FILE_STREAM_T fStreamOut;
MP4_TRAK_MP4V_T mp4BoxSet;
MPG4V_CBDATA_WRITE_SAMPLE_T mpg4vDescr;
uint64_t startHz = 0;
uint64_t durationHz = 0;
uint32_t sampledelta = 0;
int rc = 0;
if(!pMp4|| !pMp4->pStream || pMp4->pStream == FILEOPS_INVALID_FP) {
return -1;
}
LOG(X_DEBUG("Extracting mpeg-4 video from %s"), pMp4->pStream->cbGetName(pMp4->pStream));
if(mp4_initMp4vTrack(pMp4, &mp4BoxSet) < 0) {
return -1;
}
durationHz = (uint64_t) (fDuration * mp4BoxSet.tk.pMdhd->timescale);
startHz = (uint64_t) (fStart * mp4BoxSet.tk.pMdhd->timescale);
if((fStreamOut.fp = fileops_Open(path, O_RDWR | O_CREAT)) == FILEOPS_INVALID_FP) {
LOG(X_CRITICAL("Unable to open file for writing: %s"), path);
return -1;
}
fStreamOut.offset = 0;
if((sampledelta = mp4_getSttsSampleDelta(&mp4BoxSet.tk.pStts->list)) == 0) {
LOG(X_WARNING("Unable to get video sample timing from stts w/ %d entries"),
mp4BoxSet.tk.pStts->list.entrycnt);
}
rc = mpg4v_writeStart(&fStreamOut, mp4BoxSet.pEsds->specific.startcodes,
mp4BoxSet.pEsds->specific.type.length);
if(rc >= 0) {
mpg4vDescr.pStreamOut = &fStreamOut;
rc = mp4_readSamplesFromTrack(&mp4BoxSet.tk, pMp4->pStream,
mpg4v_cbWriteSample_mp4wrap, &mpg4vDescr, startHz, durationHz);
}
fileops_Close(fStreamOut.fp);
return rc;
}
int httplive_init(HTTPLIVE_DATA_T *pLive) {
struct stat st;
int rc = 0;
if(!pLive) {
return -1;
}
pLive->tvNextRoll.tv_sec = 0;
pLive->tvPriorRoll.tv_sec = 0;
if(pLive->duration <= 0) {
pLive->duration = HTTPLIVE_DURATION_DEFAULT;
}
if(pLive->fs.fp != FILEOPS_INVALID_FP) {
CloseMediaFile(&pLive->fs);
}
if(fileops_stat(pLive->dir, &st) != 0) {
LOG(X_ERROR("HTTPLive dir '%s' does not exist."), pLive->dir);
return -1;
}
if(pLive->fileprefix[0] == '\0') {
strncpy(pLive->fileprefix, HTTPLIVE_TS_NAME_PRFX, sizeof(pLive->fileprefix));
}
if(pLive->indexCount == 0) {
pLive->indexCount = HTTPLIVE_NUM_INDEXES_M3U_DEFAULT;
} else if(pLive->indexCount < HTTPLIVE_NUM_INDEXES_M3U_MIN) {
pLive->indexCount = HTTPLIVE_NUM_INDEXES_M3U_MIN;
} else if(pLive->indexCount > HTTPLIVE_NUM_INDEXES_M3U_MAX) {
pLive->indexCount = HTTPLIVE_NUM_INDEXES_M3U_MAX;
}
httplive_delete(pLive);
LOG(X_DEBUG("HTTPLive dir: '%s' duration: %.2fs file prefix: '%s'"),
pLive->dir, pLive->duration, pLive->fileprefix);
#if defined(HTTPLIVE_INCLUDE_PROGRAM_DATE_TIME)
if(s_httplive_tm == 0) {
s_httplive_tm = time(NULL);
}
#endif // HTTPLIVE_INCLUDE_PROGRAM_DATE_TIME
return rc;
}
int xcoder_silk_init_decoder(CODEC_WRAP_CTXT_T *pCtxt) {
IXCODE_AUDIO_CTXT_T *pXcode = NULL;
SILK_DECODER_CODEC_CTXT_T *pSilk = NULL;
int ret = 0;
if(!pCtxt || !pCtxt->pAVCtxt || !pCtxt->pXcode) {
return -1;
}
pXcode = (IXCODE_AUDIO_CTXT_T *) pCtxt->pXcode;
if(!(pSilk = (SILK_DECODER_CODEC_CTXT_T *) pCtxt->pctxt)) {
pCtxt->pctxt = decoder_silk_alloc();
}
if(!(pSilk = (SILK_DECODER_CODEC_CTXT_T *) pCtxt->pctxt)) {
return -1;
}
pCtxt->pAVCtxt->dec_channels = pXcode->cfgChannelsIn;
pCtxt->pAVCtxt->decbps = 2;
pCtxt->pAVCtxt->dec_samplerate = pXcode->cfgSampleRateIn;
switch(pCtxt->pAVCtxt->dec_samplerate) {
case 24000:
case 16000:
case 12000:
case 8000:
break;
default:
LOG(X_ERROR("Unsupported SILK decoder output sample rate %dHz"), pCtxt->pAVCtxt->dec_samplerate);
return -1;
}
pSilk->decControl.framesPerPacket = 1;
pSilk->decControl.API_sampleRate = pCtxt->pAVCtxt->dec_samplerate;
//if((ret = SKP_Silk_SDK_InitDecoder(pSilk->psDec)) != 0) {
if((ret = pSilk->fInitDecoder(pSilk->psDec)) != 0) {
return -1;
}
LOG(X_DEBUG("Initialized SILK decoder %dHz, channels:%d"),
pCtxt->pAVCtxt->dec_samplerate, pCtxt->pAVCtxt->dec_channels);
return 0;
}
