static int writeGenericSample(FILE_STREAM_T *pStreamIn, uint32_t sampleSize,
void *pCbData, int chunk_idx, uint32_t sampleDurationHz) {
CBDATA_WRITE_GENERIC_SAMPLE_T *pCbDataGeneric = NULL;
unsigned int idxByteInSample = 0;
unsigned int lenRead;
int idxArena = 0;
int rc = 0;
if((pCbDataGeneric = (CBDATA_WRITE_GENERIC_SAMPLE_T *) pCbData) == NULL) {
return -1;
}
while(idxByteInSample < sampleSize) {
if((lenRead = sampleSize - idxByteInSample) > sizeof(pCbDataGeneric->arena) - idxArena) {
lenRead = sizeof(pCbDataGeneric->arena) - idxArena;
}
if(ReadFileStream(pStreamIn, &pCbDataGeneric->arena[idxArena], lenRead) < 0) {
return -1;
}
if((rc = WriteFileStream(pCbDataGeneric->pStreamOut,
pCbDataGeneric->arena, lenRead + idxArena)) < 0) {
return -1;
}
idxArena = 0;
idxByteInSample += lenRead;
}
return rc;
}
int strutil_isTextFile(const char *path) {
FILE_STREAM_T fs;
int rc = 0;
unsigned char buf[256];
size_t sz;
size_t idx;
FILE_OFFSET_T fSize;
if(OpenMediaReadOnly(&fs, path) != 0) {
return 0;
}
fSize = fs.size;
while(fs.offset < fSize) {
sz = sizeof(buf);
if(fs.offset + sz > fSize) {
sz = (size_t) (fSize - fs.offset);
}
if(ReadFileStream(&fs, buf, sz) != sz) {
break;
}
// Simply check if the file is a text file
for(idx = 0; idx < sz; idx++) {
//if(!isascii(buf[idx])) {
if(!avc_istextchar(buf[idx])) {
CloseMediaFile(&fs);
return 0;
}
}
if(fs.offset == fSize) {
rc = 1;
}
}
CloseMediaFile(&fs);
return rc;
}
int esds_cbWriteSample(FILE_STREAM_T *pStreamIn, uint32_t sampleSize,
void *pCbData, int chunkIdx, uint32_t sampleDurationHz) {
ESDS_CBDATA_WRITE_SAMPLE_T *pCbDataEsds = NULL;
unsigned int idxByteInSample = 0;
unsigned int lenRead;
int idx= 0;
int rc = 0;
//fprintf(stderr, "esds_cbWriteSample chunkIdx:%d sampleSize:%d sampleDurationHz:%d\n", chunkIdx, sampleSize, sampleDurationHz);
if((pCbDataEsds = (ESDS_CBDATA_WRITE_SAMPLE_T *) pCbData) == NULL) {
return -1;
}
if((idx= aac_encodeADTSHdr(pCbDataEsds->bs.buf, pCbDataEsds->bs.sz,
&pCbDataEsds->decoderCfg, sampleSize)) < 0) {
LOG(X_ERROR("Failed to create ADTS header for frame"));
return -1;
}
while(idxByteInSample < sampleSize) {
if((lenRead = sampleSize - idxByteInSample) > pCbDataEsds->bs.sz - idx) {
lenRead = pCbDataEsds->bs.sz - idx;
}
if(ReadFileStream(pStreamIn, &pCbDataEsds->bs.buf[idx], lenRead) < 0) {
return -1;
}
if((rc = WriteFileStream(pCbDataEsds->pStreamOut, pCbDataEsds->bs.buf,
lenRead + idx)) < 0) {
return -1;
}
idx= 0;
idxByteInSample += lenRead;
}
return rc;
}
static Bool Read(void* handle, void* buf, S64 size, S64 loop_pos)
{
SWav* handle2 = reinterpret_cast<SWav*>(handle);
U8* dst = static_cast<U8*>(buf);
S64 remain = size;
while (remain > 0)
{
S64 actual_read = static_cast<S64>(ReadFileStream(handle2->FileStream, remain, dst));
if (actual_read <= 0)
{
if (loop_pos == -1)
{
memset(dst, 0x00, static_cast<size_t>(remain));
return True;
}
S64 align = handle2->BitsPerSample / 8 * (handle2->Steleo ? 2 : 1);
SeekFileStream(handle2->FileStream, handle2->Begin + loop_pos / align * align, SEEK_SET);
continue;
}
remain -= actual_read;
dst += actual_read;
}
return False;
}
int image_open(const char *path, IMAGE_GENERIC_DESCR_T *pImg,
enum MEDIA_FILE_TYPE mediaType) {
int rc = 0;
uint32_t sz;
FILE_STREAM_T fs;
if(!path || !pImg) {
return -1;
}
pImg->mediaType = mediaType;
memset(&fs, 0, sizeof(fs));
if(OpenMediaReadOnly(&fs, path) < 0) {
return -1;
}
if(fs.size > IMAGE_MAX_SIZE) {
LOG(X_ERROR("File %s size %llu exceeds max %d"),
fs.filename, fs.size, IMAGE_MAX_SIZE);
rc = -1;
} else if(fs.size < 4) {
LOG(X_ERROR("File %s size is too small %llu"), fs.filename, fs.size);
rc = -1;
}
if(rc >= 0) {
memset(&pImg->bs, 0, sizeof(pImg->bs));
pImg->bs.sz = (unsigned int) fs.size;
if(!(pImg->bs.buf = avc_calloc(1, pImg->bs.sz))) {
rc = -1;
}
}
if(rc >= 0) {
while(pImg->bs.idx < fs.size) {
if((sz = (uint32_t) (fs.size - pImg->bs.idx)) > 4096) {
sz = 4096;
}
if((rc = ReadFileStream(&fs, &pImg->bs.buf[pImg->bs.idx], sz)) != sz) {
rc = -1;
break;
}
pImg->bs.idx += rc;
}
if(rc >= 0) {
rc = pImg->bs.idx;
}
pImg->bs.idx = 0;
}
CloseMediaFile(&fs);
pImg->width = 0;
pImg->height = 0;
if(rc >= 0) {
switch(mediaType) {
case MEDIA_FILE_TYPE_PNG:
png_parse(pImg);
break;
case MEDIA_FILE_TYPE_BMP:
bmp_parse_hdr(pImg);
break;
default:
break;
}
}
return rc;
}
int metafile_isvalidFile(const char *path) {
FILE_STREAM_T fs;
int rc = 0;
unsigned char buf[128];
struct stat st;
size_t sz;
size_t idx;
int is_nl = 0;
FILE_OFFSET_T fSize;
if(!path) {
return 0;
}
if(fileops_stat(path, &st) != 0 || (st.st_mode & S_IFDIR)) {
return 0;
}
if(OpenMediaReadOnly(&fs, path) != 0) {
return 0;
}
if((fSize = fs.size) > METAFILE_FILE_CHK_SZMAX) {
fSize = METAFILE_FILE_CHK_SZMAX;
}
while(fs.offset < fSize && rc != 1) {
sz = sizeof(buf);
if(fs.offset + sz > fSize) {
sz = (size_t) (fSize - fs.offset);
}
if(ReadFileStream(&fs, buf, sz) != sz) {
break;
}
for(idx = 0; idx < sz; idx++) {
if(!avc_istextchar(buf[idx])) {
CloseMediaFile(&fs);
return 0;
}
if(buf[idx] == '\n') {
is_nl = 1;
} else {
if(is_nl) {
if(!memcmp(&buf[idx], METAFILE_KEY_FILE, strlen(METAFILE_KEY_FILE)) ||
!memcmp(&buf[idx], METAFILE_KEY_DEVICE, strlen(METAFILE_KEY_DEVICE)) ||
!memcmp(&buf[idx], METAFILE_KEY_TITLE, strlen(METAFILE_KEY_TITLE)) ||
!memcmp(&buf[idx], METAFILE_KEY_DESCRIPTION, strlen(METAFILE_KEY_DESCRIPTION)) ||
!memcmp(&buf[idx], METAFILE_KEY_IGNORE, strlen(METAFILE_KEY_IGNORE)) ||
!memcmp(&buf[idx], METAFILE_KEY_RTMP_PROXY, strlen(METAFILE_KEY_RTMP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_RTSP_PROXY, strlen(METAFILE_KEY_RTSP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_HTTP_PROXY, strlen(METAFILE_KEY_HTTP_PROXY)) ||
!memcmp(&buf[idx], METAFILE_KEY_METHODS, strlen(METAFILE_KEY_METHODS)) ||
!memcmp(&buf[idx], METAFILE_KEY_TOKEN, strlen(METAFILE_KEY_TOKEN)) ||
!memcmp(&buf[idx], METAFILE_KEY_XCODEARGS, strlen(METAFILE_KEY_XCODEARGS))) {
rc = 1;
break;
}
}
is_nl = 0;
}
}
}
CloseMediaFile(&fs);
return rc;
}
void* LoadWav(const Char* path, S64* channel, S64* samples_per_sec, S64* bits_per_sample, S64* total, void(**func_close)(void*), Bool(**func_read)(void*, void*, S64, S64))
{
*func_close = Close;
*func_read = Read;
SWav* result = static_cast<SWav*>(AllocMem(sizeof(SWav)));
Bool success = False;
for (; ; )
{
result->FileStream = OpenFileStream(path);
if (result->FileStream == NULL)
{
THROW(0xe9170007);
break;
}
U8 str[4];
if (ReadFileStream(result->FileStream, 4, str) != 4)
break;
if (str[0] != 0x52 || str[1] != 0x49 || str[2] != 0x46 || str[3] != 0x46) // 'RIFF'
break;
if (!SeekFileStream(result->FileStream, 4, SEEK_CUR))
break;
if (ReadFileStream(result->FileStream, 4, str) != 4)
break;
if (str[0] != 0x57 || str[1] != 0x41 || str[2] != 0x56 || str[3] != 0x45) // 'WAVE'
break;
Bool fmt_chunk = False;
Bool data_chunk = False;
for (; ; )
{
U32 size;
if (ReadFileStream(result->FileStream, 4, str) != 4)
break;
if (ReadFileStream(result->FileStream, 4, &size) != 4)
break;
if (str[0] == 0x66 && str[1] == 0x6d && str[2] == 0x74 && str[3] == 0x20) // 'fmt '
{
if ((size_t)size != sizeof(PCMWAVEFORMAT))
break;
{
PCMWAVEFORMAT fmt;
if (ReadFileStream(result->FileStream, sizeof(PCMWAVEFORMAT), &fmt) != sizeof(PCMWAVEFORMAT))
break;
if (fmt.wf.wFormatTag != 1)
break;
switch (fmt.wf.nChannels)
{
case 1: result->Steleo = False; break;
case 2: result->Steleo = True; break;
default:
THROW(0xe9170008);
break;
}
*channel = static_cast<S64>(fmt.wf.nChannels);
result->SamplesPerSec = static_cast<U32>(fmt.wf.nSamplesPerSec);
*samples_per_sec = static_cast<S64>(fmt.wf.nSamplesPerSec);
result->BitsPerSample = static_cast<U32>(fmt.wBitsPerSample);
*bits_per_sample = static_cast<S64>(fmt.wBitsPerSample);
}
fmt_chunk = True;
continue;
}
if (str[0] == 0x64 && str[1] == 0x61 && str[2] == 0x74 && str[3] == 0x61) // 'data'
{
result->WaveSize = size;
*total = static_cast<S64>(size);
data_chunk = True;
break;
}
if (!SeekFileStream(result->FileStream, size, SEEK_CUR))
break;
}
if (!fmt_chunk || !data_chunk)
break;
result->Begin = TellFileStream(result->FileStream);
success = True;
break;
}
if (!success)
{
FreeMem(result);
return NULL;
}
return result;
}
int stream_net_h264_getSliceBytes(void *pArg, unsigned char *pBuf, unsigned int len) {
STREAM_H264_T *pStreamH264 = (STREAM_H264_T *) pArg;
uint32_t szSlice;
unsigned int lenToRead = len;
unsigned int bufIdx = 0;
unsigned int fsIdxInSlice;
if(pStreamH264->frame.pSlice == NULL) {
return 0;
}
fsIdxInSlice = pStreamH264->frame.idxInSlice;
szSlice = pStreamH264->frame.pSlice->content.sizeWr;
if(pStreamH264->includeAnnexBHdr) {
szSlice += 4;
}
if(len > szSlice - pStreamH264->frame.idxInSlice) {
LOG(X_WARNING("Decreasing copy length from %u to (%u - %u)"),
len, szSlice, pStreamH264->frame.idxInSlice);
len = szSlice - pStreamH264->frame.idxInSlice;
}
if(pStreamH264->includeAnnexBHdr) {
if(pStreamH264->frame.idxInSlice < 4) {
while(pStreamH264->frame.idxInAnnexBHdr < 4 && bufIdx < len) {
pBuf[bufIdx++] = (pStreamH264->frame.idxInAnnexBHdr == 3 ? 0x01 : 0x00);
pStreamH264->frame.idxInAnnexBHdr++;
lenToRead--;
pStreamH264->frame.idxInSlice++;
}
}
if(pStreamH264->frame.idxInSlice < 4) {
return pStreamH264->frame.idxInSlice;
} else {
fsIdxInSlice = pStreamH264->frame.idxInSlice - 4;
}
}
/*
if(pStreamH264->frame.pSlice == &pStreamH264->audSlice) {
if(fsIdxInSlice + lenToRead > 2) {
LOG(X_ERROR("Attempt to read AUD[%d] + %d > AUD len: 2\n"),
fsIdxInSlice, lenToRead, 2);
return -1;
}
pBuf[bufIdx] = pStreamH264->audSlice.hdr;
//
// Mpeg4-Part10AVC Table 7-2 "Meaning of primary_pic_type"
// 3 bits 0 - 7 ((7 << 5) = I,Si,P,SP,B possible slice types in primary coded picture)
//
pBuf[bufIdx + 1] = H264_AUD_I_SI_P_SP_B;
} else
*/
if(pStreamH264->frame.pSlice == &pStreamH264->spsSlice) {
if(fsIdxInSlice + lenToRead > pStreamH264->pH264->spspps.sps_len) {
LOG(X_ERROR("Attempt to read sps[%d] + %d > sps len: %d\n"),
fsIdxInSlice, lenToRead, pStreamH264->pH264->spspps.sps_len);
return -1;
}
memcpy(&pBuf[bufIdx], &pStreamH264->pH264->spspps.sps[fsIdxInSlice], lenToRead);
} else if(pStreamH264->frame.pSlice == &pStreamH264->ppsSlice) {
if(fsIdxInSlice + lenToRead > pStreamH264->pH264->spspps.pps_len) {
LOG(X_ERROR("Attempt to read pps[%d] + %d > pps len: %d\n"),
fsIdxInSlice, lenToRead, pStreamH264->pH264->spspps.pps_len);
return -1;
}
memcpy(&pBuf[bufIdx], &pStreamH264->pH264->spspps.pps[fsIdxInSlice], lenToRead);
} else {
if(SeekMediaFile(pStreamH264->frame.pFileStream,
pStreamH264->frame.pSlice->content.fileOffset +
fsIdxInSlice, SEEK_SET) != 0) {
return -1;
}
if(ReadFileStream(pStreamH264->frame.pFileStream, &pBuf[bufIdx], lenToRead) < 0) {
return -1;
}
}
//if(pStreamH264->frame.idxInSlice <= 4) {
//fprintf(stderr, "h264 frameId:%d\n", pStreamH264->frame.frameId);
//if(pStreamH264->frame.pSlice->content.sizeWr > 65530) fprintf(stderr, "\n\n\n\nh264 size:%d\n", pStreamH264->frame.pSlice->content.sizeWr);
//fprintf(stderr, "h264 size:%d\n", pStreamH264->frame.pSlice->content.sizeWr);
//avc_dumpHex(stderr, pBuf, 16, 1);
//}
pStreamH264->frame.idxInSlice += lenToRead;
return len;
}
