SRV_CONF_T *conf_parse(const char *path) {
FILE_HANDLE fp;
SRV_CONF_T *pConf = NULL;
KEYVAL_PAIR_T kv;
KEYVAL_PAIR_T *pKv = NULL;
KEYVAL_PAIR_T *pKvPrev = NULL;
char buf[1024];
unsigned int numEntries = 0;
if(!path) {
return NULL;
}
if((fp = fileops_Open(path, O_RDONLY)) == FILEOPS_INVALID_FP) {
LOG(X_CRITICAL("Unable to open file for reading: %s"), path);
return NULL;
}
pConf = (SRV_CONF_T *) avc_calloc(1, sizeof(SRV_CONF_T));
while(fileops_fgets(buf, sizeof(buf) - 1, fp)) {
if(conf_parse_keyval(&kv, buf, strlen(buf), '=', 0) > 0) {
if((pKv = (KEYVAL_PAIR_T *) avc_calloc(1, sizeof(KEYVAL_PAIR_T))) == NULL) {
LOG(X_CRITICAL("Failed to allocate %d"), sizeof(KEYVAL_PAIR_T));
break;
}
memcpy(pKv->key, kv.key, sizeof(pKv->key));
memcpy(pKv->val, kv.val, sizeof(pKv->val));
if(pKvPrev == NULL) {
pConf->pKeyvals = pKv;
} else {
pKvPrev->pnext = pKv;
}
pKvPrev = pKv;
numEntries++;
}
}
fileops_Close(fp);
return pConf;
}
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;
}
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); );
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);
}
return p;
}
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;
}
void *avc_realloc(void *porig, size_t size) {
void *p;
if((p = realloc(porig, size)) == NULL) {
LOG(X_CRITICAL("Failed to realloc %d"), size);
return NULL;
}
return p;
}
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;
}
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;
}
void mediadb_proc(void *parg) {
MEDIADB_DESCR_T *pMediaDb = (MEDIADB_DESCR_T *) parg;
struct stat st;
char buf[VSX_MAX_PATH_LEN];
const char *avcthumb = NULL;
size_t sz;
int rc;
unsigned int iterIdx = 0;
if(!pMediaDb->mediaDir) {
return;
}
memset(buf, 0, sizeof(buf));
sz = mediadb_getdirlen(pMediaDb->dbDir);
strncpy(buf, pMediaDb->dbDir, sizeof(buf) - 1);
buf[sz] = '\0';
LOG(X_DEBUG("Database dir: '%s'"), pMediaDb->dbDir);
if(fileops_stat(buf, &st) != 0) {
//
// Create database root dir
//
LOG(X_DEBUG("Creating dir '%s'"), buf);
if(fileops_MkDir(buf, S_IRWXU | S_IRWXG | S_IRWXO ) < 0) {
LOG(X_CRITICAL("Unable to create database dir '%s'"), buf);
return;
}
}
if(fileops_stat(pMediaDb->dbDir, &st) != 0) {
//
// Create database subdir specific for mediaDir
//
LOG(X_DEBUG("Creating dir '%s'"), pMediaDb->dbDir);
if(fileops_MkDir(pMediaDb->dbDir, S_IRWXU | S_IRWXG | S_IRWXO ) < 0) {
LOG(X_CRITICAL("Unable to create database dir '%s'"), pMediaDb->dbDir);
return;
}
}
//
// Check thumbnail creation script
//
if(pMediaDb->avcthumb) {
if(fileops_stat(pMediaDb->avcthumb, &st) == 0) {
//
// Truncate the avcthumblog
//
if(pMediaDb->avcthumblog) {
snprintf(buf, sizeof(buf), DATE_CMD" > %s", pMediaDb->avcthumblog);
//LOG(X_DEBUG("Executing system command '%s'"), buf);
rc = system(buf);
if(fileops_stat(pMediaDb->avcthumblog, &st) != 0) {
pMediaDb->avcthumblog = NULL;
}
}
if(pMediaDb->lgTnWidth == 0 || pMediaDb->lgTnWidth == 0) {
pMediaDb->lgTnWidth = LG_THUMB_WIDTH;
pMediaDb->lgTnHeight = LG_THUMB_HEIGHT;
}
if(pMediaDb->smTnWidth == 0 || pMediaDb->smTnHeight == 0) {
pMediaDb->smTnWidth = SM_THUMB_WIDTH;
pMediaDb->smTnHeight = SM_THUMB_HEIGHT;
}
LOG(X_DEBUG("Using %s to generate thumbnails %dx%d %dx%d"),
pMediaDb->avcthumb,
pMediaDb->smTnWidth, pMediaDb->smTnHeight,
pMediaDb->lgTnWidth, pMediaDb->lgTnHeight);
} else {
LOG(X_WARNING("Unable to find %s Video thumbnails disabled."), pMediaDb->avcthumb);
pMediaDb->avcthumb = NULL;
}
} else {
LOG(X_WARNING("Not using video thumbnails. Please set '%s=' in the configuration file."),
SRV_CONF_KEY_AVCTHUMB);
}
//
// Set avchumb to null and do not create thumbnails on first
// iteration to allow all avcfidx files to be created quickly
//
avcthumb = pMediaDb->avcthumb;
pMediaDb->avcthumb = NULL;
if(g_proc_exit == 0) {
iterate_subdirs(pMediaDb, pMediaDb->dbDir, pMediaDb->mediaDir, 1, 0);
pMediaDb->avcthumb = avcthumb;
usleep(2000000);
}
while(g_proc_exit == 0) {
iterate_subdirs(pMediaDb, pMediaDb->dbDir, pMediaDb->mediaDir, 1, iterIdx++);
usleep(10000000);
}
}
