status _af_wave_update (AFfilehandle file)
{
_Track *track;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
if (track->fpos_first_frame != 0)
{
size_t dataLength, fileLength;
/*
We call _af_format_frame_size to calculate the
frame size of normal PCM data or compressed data.
*/
dataLength = track->totalfframes * _af_format_frame_size(&track->f, AF_FALSE);
dataLength = HOST_TO_LENDIAN_INT32(dataLength);
af_fseek(file->fh, track->fpos_first_frame - 4, SEEK_SET);
af_fwrite(&dataLength, 4, 1, file->fh);
fileLength = af_flength(file->fh);
fileLength -= 8;
fileLength = HOST_TO_LENDIAN_INT32(fileLength);
af_fseek(file->fh, 4, SEEK_SET);
af_fwrite(&fileLength, 4, 1, file->fh);
}
return AF_SUCCEED;
}
static status next_write_header (AFfilehandle file)
{
_Track *track;
int frameSize;
uint32_t offset, length, encoding, sampleRate, channelCount;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
frameSize = _af_format_frame_size(&track->f, false);
offset = track->fpos_first_frame;
length = track->totalfframes * frameSize;
encoding = nextencodingtype(&track->f);
sampleRate = track->f.sampleRate;
channelCount = track->f.channelCount;
if (af_fseek(file->fh, 0, SEEK_SET) != 0)
_af_error(AF_BAD_LSEEK, "bad seek");
af_fwrite(".snd", 4, 1, file->fh);
af_write_uint32_be(&offset, file->fh);
af_write_uint32_be(&length, file->fh);
af_write_uint32_be(&encoding, file->fh);
af_write_uint32_be(&sampleRate, file->fh);
af_write_uint32_be(&channelCount, file->fh);
return AF_SUCCEED;
}
static status WriteFrameCount (AFfilehandle file)
{
_Track *track = NULL;
_WAVEInfo *waveinfo = NULL;
u_int32_t factSize = 4;
u_int32_t totalFrameCount;
assert(file != NULL);
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
waveinfo = (_WAVEInfo *) file->formatSpecific;
/* We only write the fact chunk for compressed audio. */
if (track->f.compressionType == AF_COMPRESSION_NONE)
return AF_SUCCEED;
/*
If the offset for the fact chunk hasn't been set yet,
set it to the file's current position.
*/
if (waveinfo->factOffset == 0)
waveinfo->factOffset = af_ftell(file->fh);
else
af_fseek(file->fh, waveinfo->factOffset, SEEK_SET);
af_fwrite("fact", 4, 1, file->fh);
factSize = HOST_TO_LENDIAN_INT32(factSize);
af_fwrite(&factSize, 4, 1, file->fh);
totalFrameCount = HOST_TO_LENDIAN_INT32(track->totalfframes);
af_fwrite(&totalFrameCount, 4, 1, file->fh);
return AF_SUCCEED;
}
static status WriteFrameCount (AFfilehandle file)
{
_Track *track = NULL;
_WAVEInfo *waveinfo = NULL;
uint32_t factSize = 4;
uint32_t totalFrameCount;
assert(file != NULL);
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
waveinfo = (_WAVEInfo *) file->formatSpecific;
/* Omit the fact chunk only for uncompressed integer audio formats. */
if (track->f.compressionType == AF_COMPRESSION_NONE &&
(track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP ||
track->f.sampleFormat == AF_SAMPFMT_UNSIGNED))
return AF_SUCCEED;
/*
If the offset for the fact chunk hasn't been set yet,
set it to the file's current position.
*/
if (waveinfo->factOffset == 0)
waveinfo->factOffset = af_ftell(file->fh);
else
af_fseek(file->fh, waveinfo->factOffset, SEEK_SET);
af_fwrite("fact", 4, 1, file->fh);
af_write_uint32_le(&factSize, file->fh);
totalFrameCount = track->totalfframes;
af_write_uint32_le(&totalFrameCount, file->fh);
return AF_SUCCEED;
}
long ZCALLBACK afseek_file_func (
voidpf opaque,
voidpf stream,
uLong offset,
int origin)
{
int fseek_origin=0;
long ret;
(void)opaque;
switch (origin)
{
case ZLIB_FILEFUNC_SEEK_CUR :
fseek_origin = SEEK_CUR;
break;
case ZLIB_FILEFUNC_SEEK_END :
fseek_origin = SEEK_END;
break;
case ZLIB_FILEFUNC_SEEK_SET :
fseek_origin = SEEK_SET;
break;
default: return -1;
}
ret = 0;
af_fseek((ABSTRACTFILE *)stream, offset, fseek_origin);
return ret;
}
status WriteMiscellaneous (AFfilehandle filehandle)
{
_WAVEInfo *wave = (_WAVEInfo *) filehandle->formatSpecific;
if (filehandle->miscellaneousCount != 0)
{
int i;
u_int32_t miscellaneousBytes;
/* Start at 4 to account for 'INFO' chunk id. */
miscellaneousBytes = 4;
for (i=0; i<filehandle->miscellaneousCount; i++)
{
/* Account for miscellaneous type and size. */
miscellaneousBytes += 8;
miscellaneousBytes += filehandle->miscellaneous[i].size;
/* Add a pad byte if necessary. */
if (filehandle->miscellaneous[i].size % 2 != 0)
miscellaneousBytes++;
assert(miscellaneousBytes % 2 == 0);
}
wave->miscellaneousStartOffset = af_ftell(filehandle->fh);
wave->totalMiscellaneousSize = miscellaneousBytes;
/* Add 8 to account for length of 'LIST' chunk id and size. */
af_fseek(filehandle->fh, miscellaneousBytes + 8, SEEK_CUR);
}
return AF_SUCCEED;
}
static status next_write_header (AFfilehandle file)
{
_Track *track;
int frameSize;
u_int32_t offset, length, encoding, sampleRate, channelCount;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
frameSize = _af_format_frame_size(&track->f, AF_FALSE);
if (track->f.compressionType == AF_COMPRESSION_G711_ULAW ||
track->f.compressionType == AF_COMPRESSION_G711_ALAW)
frameSize = frameSize / 2;
offset = HOST_TO_BENDIAN_INT32(track->fpos_first_frame);
length = HOST_TO_BENDIAN_INT32(track->totalfframes * frameSize);
encoding = HOST_TO_BENDIAN_INT32(nextencodingtype(&track->f));
sampleRate = HOST_TO_BENDIAN_INT32(track->f.sampleRate);
channelCount = HOST_TO_BENDIAN_INT32(track->f.channelCount);
if (af_fseek(file->fh, 0, SEEK_SET) != 0)
_af_error(AF_BAD_LSEEK, "bad seek");
af_fwrite(".snd", 4, 1, file->fh);
af_fwrite(&offset, 4, 1, file->fh);
af_fwrite(&length, 4, 1, file->fh);
af_fwrite(&encoding, 4, 1, file->fh);
af_fwrite(&sampleRate, 4, 1, file->fh);
af_fwrite(&channelCount, 4, 1, file->fh);
return AF_SUCCEED;
}
void InstallLogger::LoadParamFile(const char* parameter_filename) {
init_done = 0;
ABSTRACTFILE *af_fin = af_fopen_unlogged((parameter_filename != NULL) ?
parameter_filename : "unitex_logging_parameters.txt","rb");
if (af_fin!=NULL)
{
size_t size_param=0;
if (af_fseek(af_fin, 0, SEEK_END) == 0)
{
size_param = af_ftell(af_fin);
af_fseek(af_fin, 0, SEEK_SET);
}
char* param=(char*)malloc(size_param+1);
*(param+size_param)=0;
if (af_fread(param,1,size_param,af_fin) == size_param)
{
int write_file_out=0;
char*szPath = (char*)malloc(size_param+1);
*szPath=0;
sscanf(param,"%s\n%u",szPath,&write_file_out);
write_file_out+=0;
if ((*szPath) != 0)
{
ClearUniLoggerSpaceStruct(0);
ule.szPathLog = szPath;
ule.szNameLog = NULL;
ule.store_file_out_content = write_file_out;
if (AddActivityLogger(&ule) != 0)
init_done = 1;
else
{
ClearUniLoggerSpaceStruct(1);
}
}
else
free(szPath);
}
af_fclose(af_fin);
free(param);
}
}
status _af_wave_update (AFfilehandle file)
{
_Track *track;
_WAVEInfo *wave = (_WAVEInfo *) file->formatSpecific;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
if (track->fpos_first_frame != 0)
{
u_int32_t dataLength, fileLength;
/* Update the frame count chunk if present. */
WriteFrameCount(file);
/* Update the length of the data chunk. */
af_fseek(file->fh, wave->dataSizeOffset, SEEK_SET);
/*
We call _af_format_frame_size to calculate the
frame size of normal PCM data or compressed data.
*/
dataLength = (u_int32_t) track->totalfframes *
_af_format_frame_size(&track->f, AF_FALSE);
dataLength = HOST_TO_LENDIAN_INT32(dataLength);
af_fwrite(&dataLength, 4, 1, file->fh);
/* Update the length of the RIFF chunk. */
fileLength = (u_int32_t) af_flength(file->fh);
fileLength -= 8;
fileLength = HOST_TO_LENDIAN_INT32(fileLength);
af_fseek(file->fh, 4, SEEK_SET);
af_fwrite(&fileLength, 4, 1, file->fh);
}
/*
Write the actual data that was set after initializing
the miscellaneous IDs. The size of the data will be
unchanged.
*/
WriteMiscellaneous(file);
/* Write the new positions; the size of the data will be unchanged. */
WriteCues(file);
return AF_SUCCEED;
}
/*
Parse marker chunks, which contain the positions and names of loop markers.
*/
static status ParseMARK (AFfilehandle file, AFvirtualfile *fh, u_int32_t type,
size_t size)
{
_Track *track;
int i;
u_int16_t numMarkers;
assert(!memcmp(&type, "MARK", 4));
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_fread(&numMarkers, sizeof (u_int16_t), 1, fh);
numMarkers = BENDIAN_TO_HOST_INT16(numMarkers);
track->markerCount = numMarkers;
if (numMarkers)
track->markers = _af_marker_new(numMarkers);
for (i=0; i<numMarkers; i++)
{
u_int16_t markerID = 0;
u_int32_t markerPosition = 0;
u_int8_t sizeByte = 0;
char *markerName = NULL;
af_fread(&markerID, sizeof (u_int16_t), 1, fh);
markerID = BENDIAN_TO_HOST_INT16(markerID);
af_fread(&markerPosition, sizeof (u_int32_t), 1, fh);
markerPosition = BENDIAN_TO_HOST_INT32(markerPosition);
af_fread(&sizeByte, sizeof (unsigned char), 1, fh);
markerName = _af_malloc(sizeByte + 1);
af_fread(markerName, sizeof (unsigned char), sizeByte, fh);
markerName[sizeByte] = '\0';
#ifdef DEBUG
printf("marker id: %d, position: %d, name: %s\n",
markerID, markerPosition, markerName);
printf("size byte: %d\n", sizeByte);
#endif
/*
If sizeByte is even, then 1+sizeByte (the length
of the string) is odd. Skip an extra byte to
make it even.
*/
if ((sizeByte % 2) == 0)
af_fseek(fh, 1, SEEK_CUR);
track->markers[i].id = markerID;
track->markers[i].position = markerPosition;
track->markers[i].name = markerName;
track->markers[i].comment = _af_strdup("");
}
return AF_SUCCEED;
}
bool _af_iff_recognize (AFvirtualfile *fh)
{
uint8_t buffer[8];
af_fseek(fh, 0, SEEK_SET);
if (af_fread(buffer, 1, 8, fh) != 8 || memcmp(buffer, "FORM", 4) != 0)
return false;
if (af_fread(buffer, 1, 4, fh) != 4 || memcmp(buffer, "8SVX", 4) != 0)
return false;
return true;
}
bool _af_iff_recognize (AFvirtualfile *fh)
{
u_int8_t buffer[8];
af_fseek(fh, 0, SEEK_SET);
if (af_fread(buffer, 1, 8, fh) != 8 || memcmp(buffer, "FORM", 4) != 0)
return AF_FALSE;
if (af_fread(buffer, 1, 4, fh) != 4 || memcmp(buffer, "8SVX", 4) != 0)
return AF_FALSE;
return AF_TRUE;
}
status _af_wave_write_init (AFfilesetup setup, AFfilehandle filehandle)
{
u_int32_t zero = 0;
if (_af_filesetup_make_handle(setup, filehandle) == AF_FAIL)
return AF_FAIL;
filehandle->formatSpecific = waveinfo_new();
af_fseek(filehandle->fh, 0, SEEK_SET);
af_fwrite("RIFF", 4, 1, filehandle->fh);
af_fwrite(&zero, 4, 1, filehandle->fh);
af_fwrite("WAVE", 4, 1, filehandle->fh);
WriteMiscellaneous(filehandle);
WriteFormat(filehandle);
WriteData(filehandle);
return AF_SUCCEED;
}
status _af_avr_update (AFfilehandle file)
{
_Track *track;
uint32_t size, loopStart, loopEnd;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
/* Seek to the position of the size field. */
af_fseek(file->fh, 26, SEEK_SET);
size = track->totalfframes;
/* For the case of no loops, loopStart = 0 and loopEnd = size. */
loopStart = 0;
loopEnd = size;
af_write_uint32_be(&size, file->fh);
af_write_uint32_be(&loopStart, file->fh);
af_write_uint32_be(&loopEnd, file->fh);
return AF_SUCCEED;
}
static status WriteCues (AFfilehandle file)
{
int i, *markids, markCount;
uint32_t numCues, cueChunkSize, listChunkSize;
_WAVEInfo *wave;
assert(file);
markCount = afGetMarkIDs(file, AF_DEFAULT_TRACK, NULL);
if (markCount == 0)
return AF_SUCCEED;
wave = file->formatSpecific;
if (wave->markOffset == 0)
wave->markOffset = af_ftell(file->fh);
else
af_fseek(file->fh, wave->markOffset, SEEK_SET);
af_fwrite("cue ", 4, 1, file->fh);
/*
The cue chunk consists of 4 bytes for the number of cue points
followed by 24 bytes for each cue point record.
*/
cueChunkSize = 4 + markCount * 24;
af_write_uint32_le(&cueChunkSize, file->fh);
numCues = markCount;
af_write_uint32_le(&numCues, file->fh);
markids = _af_calloc(markCount, sizeof (int));
assert(markids != NULL);
afGetMarkIDs(file, AF_DEFAULT_TRACK, markids);
/* Write each marker to the file. */
for (i=0; i < markCount; i++)
{
uint32_t identifier, position, chunkStart, blockStart;
uint32_t sampleOffset;
AFframecount markposition;
identifier = markids[i];
af_write_uint32_le(&identifier, file->fh);
position = i;
af_write_uint32_le(&position, file->fh);
/* For now the RIFF id is always the first data chunk. */
af_fwrite("data", 4, 1, file->fh);
/*
For an uncompressed WAVE file which contains
only one data chunk, chunkStart and blockStart
are zero.
*/
chunkStart = 0;
af_fwrite(&chunkStart, sizeof (uint32_t), 1, file->fh);
blockStart = 0;
af_fwrite(&blockStart, sizeof (uint32_t), 1, file->fh);
markposition = afGetMarkPosition(file, AF_DEFAULT_TRACK, markids[i]);
/* Sample offsets are stored in the WAVE file as frames. */
sampleOffset = markposition;
af_write_uint32_le(&sampleOffset, file->fh);
}
/*
Now write the cue names which is in a master list chunk
with a subchunk for each cue's name.
*/
listChunkSize = 4;
for (i=0; i<markCount; i++)
{
const char *name;
name = afGetMarkName(file, AF_DEFAULT_TRACK, markids[i]);
/*
Each label chunk consists of 4 bytes for the
"labl" chunk ID, 4 bytes for the chunk data
size, 4 bytes for the cue point ID, and then
the length of the label as a Pascal-style string.
In all, this is 12 bytes plus the length of the
string, its size byte, and a trailing pad byte
if the length of the chunk is otherwise odd.
*/
listChunkSize += 12 + (strlen(name) + 1) +
((strlen(name) + 1) % 2);
}
af_fwrite("LIST", 4, 1, file->fh);
af_write_uint32_le(&listChunkSize, file->fh);
af_fwrite("adtl", 4, 1, file->fh);
for (i=0; i<markCount; i++)
{
const char *name;
uint32_t labelSize, cuePointID;
name = afGetMarkName(file, AF_DEFAULT_TRACK, markids[i]);
/* Make labelSize even if it is not already. */
labelSize = 4+(strlen(name)+1) + ((strlen(name) + 1) % 2);
cuePointID = markids[i];
af_fwrite("labl", 4, 1, file->fh);
af_write_uint32_le(&labelSize, file->fh);
af_write_uint32_le(&cuePointID, file->fh);
af_fwrite(name, strlen(name) + 1, 1, file->fh);
/*
If the name plus the size byte comprises an odd
length, add another byte to make the string an
even length.
*/
if (((strlen(name) + 1) % 2) != 0)
{
uint8_t zero=0;
af_write_uint8(&zero, file->fh);
}
}
free(markids);
return AF_SUCCEED;
}
status WriteMiscellaneous (AFfilehandle filehandle)
{
_WAVEInfo *wave = (_WAVEInfo *) filehandle->formatSpecific;
if (filehandle->miscellaneousCount != 0)
{
int i;
uint32_t miscellaneousBytes;
uint32_t chunkSize;
/* Start at 12 to account for 'LIST', size, and 'INFO'. */
miscellaneousBytes = 12;
/* Then calculate the size of the whole INFO chunk. */
for (i=0; i<filehandle->miscellaneousCount; i++)
{
uint32_t miscid;
/* Skip miscellaneous data of an unsupported type. */
if (misc_type_to_wave(filehandle->miscellaneous[i].type,
&miscid) == AF_FAIL)
continue;
/* Account for miscellaneous type and size. */
miscellaneousBytes += 8;
miscellaneousBytes += filehandle->miscellaneous[i].size;
/* Add a pad byte if necessary. */
if (filehandle->miscellaneous[i].size % 2 != 0)
miscellaneousBytes++;
assert(miscellaneousBytes % 2 == 0);
}
if (wave->miscellaneousStartOffset == 0)
wave->miscellaneousStartOffset = af_ftell(filehandle->fh);
else
af_fseek(filehandle->fh, wave->miscellaneousStartOffset, SEEK_SET);
wave->totalMiscellaneousSize = miscellaneousBytes;
/*
Write the data. On the first call to this
function (from _af_wave_write_init), the
data won't be available, af_fseek is used to
reserve space until the data has been provided.
On subseuent calls to this function (from
_af_wave_update), the data will really be written.
*/
/* Write 'LIST'. */
af_fwrite("LIST", 4, 1, filehandle->fh);
/* Write the size of the following chunk. */
chunkSize = miscellaneousBytes-8;
af_write_uint32_le(&chunkSize, filehandle->fh);
/* Write 'INFO'. */
af_fwrite("INFO", 4, 1, filehandle->fh);
/* Write each miscellaneous chunk. */
for (i=0; i<filehandle->miscellaneousCount; i++)
{
uint32_t miscsize = filehandle->miscellaneous[i].size;
uint32_t miscid = 0;
/* Skip miscellaneous data of an unsupported type. */
if (misc_type_to_wave(filehandle->miscellaneous[i].type,
&miscid) == AF_FAIL)
continue;
af_fwrite(&miscid, 4, 1, filehandle->fh);
af_write_uint32_le(&miscsize, filehandle->fh);
if (filehandle->miscellaneous[i].buffer != NULL)
{
uint8_t zero = 0;
af_fwrite(filehandle->miscellaneous[i].buffer, filehandle->miscellaneous[i].size, 1, filehandle->fh);
/* Pad if necessary. */
if ((filehandle->miscellaneous[i].size%2) != 0)
af_write_uint8(&zero, filehandle->fh);
}
else
{
int size;
size = filehandle->miscellaneous[i].size;
/* Pad if necessary. */
if ((size % 2) != 0)
size++;
af_fseek(filehandle->fh, size, SEEK_CUR);
}
}
}
return AF_SUCCEED;
}
status _af_iff_read_init (AFfilesetup setup, AFfilehandle file)
{
uint32_t type, size, formtype;
size_t index;
_Track *track;
assert(file != NULL);
assert(file->fh != NULL);
af_fseek(file->fh, 0, SEEK_SET);
af_fread(&type, 4, 1, file->fh);
af_read_uint32_be(&size, file->fh);
af_fread(&formtype, 4, 1, file->fh);
if (memcmp(&type, "FORM", 4) != 0 || memcmp(&formtype, "8SVX", 4) != 0)
return AF_FAIL;
file->instrumentCount = 0;
file->instruments = NULL;
file->miscellaneousCount = 0;
file->miscellaneous = NULL;
/* IFF/8SVX files have only one track. */
track = _af_track_new();
file->trackCount = 1;
file->tracks = track;
/* Set the index to include the form type ('8SVX' in this case). */
index = 4;
while (index < size)
{
uint32_t chunkid = 0, chunksize = 0;
status result = AF_SUCCEED;
af_fread(&chunkid, 4, 1, file->fh);
af_read_uint32_be(&chunksize, file->fh);
if (!memcmp("VHDR", &chunkid, 4))
{
result = ParseVHDR(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("BODY", &chunkid, 4))
{
result = ParseBODY(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("NAME", &chunkid, 4) ||
!memcmp("AUTH", &chunkid, 4) ||
!memcmp("(c) ", &chunkid, 4) ||
!memcmp("ANNO", &chunkid, 4))
{
ParseMiscellaneous(file, file->fh, chunkid, chunksize);
}
if (result == AF_FAIL)
return AF_FAIL;
/*
Increment the index by the size of the chunk
plus the size of the chunk header.
*/
index += chunksize + 8;
/* All chunks must be aligned on an even number of bytes. */
if ((index % 2) != 0)
index++;
/* Set the seek position to the beginning of the next chunk. */
af_fseek(file->fh, index + 8, SEEK_SET);
}
/* The file has been successfully parsed. */
return AF_SUCCEED;
}
status _af_avr_write_init (AFfilesetup setup, AFfilehandle filehandle)
{
_Track *track;
char name[8];
uint16_t mono, resolution, sign, loop, midi;
uint32_t rate, size, loopStart, loopEnd;
char reserved[26];
char user[64];
if (_af_filesetup_make_handle(setup, filehandle) == AF_FAIL)
return AF_FAIL;
filehandle->formatSpecific = NULL;
track = _af_filehandle_get_track(filehandle, AF_DEFAULT_TRACK);
if (af_fseek(filehandle->fh, 0, SEEK_SET) != 0)
{
_af_error(AF_BAD_LSEEK, "bad seek");
return AF_FAIL;
}
af_fwrite("2BIT", 4, 1, filehandle->fh);
memset(name, 0, 8);
if (filehandle->fileName != NULL)
strncpy(name, af_basename(filehandle->fileName), 8);
af_fwrite(name, 8, 1, filehandle->fh);
if (track->f.channelCount == 1)
mono = 0x0;
else
mono = 0xffff;
af_write_uint16_be(&mono, filehandle->fh);
resolution = track->f.sampleWidth;
af_write_uint16_be(&resolution, filehandle->fh);
if (track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
sign = 0x0;
else
sign = 0xffff;
af_write_uint16_be(&sign, filehandle->fh);
/* We do not currently support loops. */
loop = 0;
af_write_uint16_be(&loop, filehandle->fh);
midi = 0xffff;
af_write_uint16_be(&midi, filehandle->fh);
rate = track->f.sampleRate;
/* Set the high-order byte of rate to 0xff. */
rate |= 0xff000000;
size = track->totalfframes;
loopStart = 0;
loopEnd = size;
af_write_uint32_be(&rate, filehandle->fh);
af_write_uint32_be(&size, filehandle->fh);
af_write_uint32_be(&loopStart, filehandle->fh);
af_write_uint32_be(&loopEnd, filehandle->fh);
memset(reserved, 0, 26);
af_fwrite(reserved, 26, 1, filehandle->fh);
memset(user, 0, 64);
af_fwrite(user, 64, 1, filehandle->fh);
if (track->fpos_first_frame == 0)
track->fpos_first_frame = af_ftell(filehandle->fh);
return AF_SUCCEED;
}
int afWriteFrames (AFfilehandle file, int trackid, const void *samples,
int nvframes2write)
{
_AFmoduleinst *firstmod;
_AFchunk *userc;
_Track *track;
int bytes_per_vframe;
AFframecount vframe;
if (!_af_filehandle_ok(file))
return -1;
if (!_af_filehandle_can_write(file))
return -1;
if ((track = _af_filehandle_get_track(file, trackid)) == NULL)
return -1;
if (track->ms.modulesdirty)
{
if (_AFsetupmodules(file, track) != AF_SUCCEED)
return -1;
}
/*if (file->seekok) {*/
if (af_fseek(file->fh, track->fpos_next_frame, SEEK_SET) < 0)
{
_af_error(AF_BAD_LSEEK, "unable to position write pointer at next frame");
return -1;
}
/* } */
bytes_per_vframe = _af_format_frame_size(&track->v, AF_TRUE);
firstmod = &track->ms.module[0];
userc = &track->ms.chunk[0];
track->filemodhappy = AF_TRUE;
vframe = 0;
#ifdef UNLIMITED_CHUNK_NVFRAMES
/*
OPTIMIZATION: see the comment at the very end of
arrangemodules() in modules.c for an explanation of this:
*/
if (!trk->ms.mustuseatomicnvframes)
{
userc->buf = (char *)buf;
userc->nframes = nvframes2write;
(*firstmod->mod->run_push)(firstmod);
/* Count this chunk if there was no i/o error. */
if (trk->filemodhappy)
vframe += userc->nframes;
}
else
#else
/* Optimization must be off. */
assert(track->ms.mustuseatomicnvframes);
#endif
{
while (vframe < nvframes2write)
{
userc->buf = (char *) samples + bytes_per_vframe * vframe;
if (vframe <= nvframes2write - _AF_ATOMIC_NVFRAMES)
userc->nframes = _AF_ATOMIC_NVFRAMES;
else
userc->nframes = nvframes2write - vframe;
(*firstmod->mod->run_push)(firstmod);
if (track->filemodhappy == AF_FALSE)
break;
vframe += userc->nframes;
}
}
track->nextvframe += vframe;
track->totalvframes += vframe;
return vframe;
}
int afReadFrames (AFfilehandle file, int trackid, void *samples,
int nvframeswanted)
{
_Track *track;
_AFmoduleinst *firstmod;
_AFchunk *userc;
AFframecount nvframesleft, nvframes2read;
int bytes_per_vframe;
AFframecount vframe;
if (!_af_filehandle_ok(file))
return -1;
if (!_af_filehandle_can_read(file))
return -1;
if ((track = _af_filehandle_get_track(file, trackid)) == NULL)
return -1;
if (track->ms.modulesdirty)
{
if (_AFsetupmodules(file, track) != AF_SUCCEED)
return -1;
}
/*if (file->seekok) {*/
if (af_fseek(file->fh, track->fpos_next_frame, SEEK_SET) < 0)
{
_af_error(AF_BAD_LSEEK, "unable to position read pointer at next frame");
return -1;
}
/* } */
if (track->totalvframes == -1)
nvframes2read = nvframeswanted;
else
{
nvframesleft = track->totalvframes - track->nextvframe;
nvframes2read = (nvframeswanted > nvframesleft) ?
nvframesleft : nvframeswanted;
}
bytes_per_vframe = _af_format_frame_size(&track->v, AF_TRUE);
firstmod = &track->ms.module[track->ms.nmodules-1];
userc = &track->ms.chunk[track->ms.nmodules];
track->filemodhappy = AF_TRUE;
vframe = 0;
if (!track->ms.mustuseatomicnvframes)
{
assert(track->frames2ignore == 0);
userc->buf = samples;
userc->nframes = nvframes2read;
(*firstmod->mod->run_pull)(firstmod);
if (track->filemodhappy)
vframe += userc->nframes;
}
else
{
bool eof = AF_FALSE;
if (track->frames2ignore != 0)
{
userc->nframes = track->frames2ignore;
userc->buf = _af_malloc(track->frames2ignore * bytes_per_vframe);
if (userc->buf == AF_NULL)
return 0;
(*firstmod->mod->run_pull)(firstmod);
/* Have we hit EOF? */
if (userc->nframes < track->frames2ignore)
eof = AF_TRUE;
track->frames2ignore = 0;
free(userc->buf);
userc->buf = NULL;
}
/*
Now start reading useful frames, until EOF or
premature EOF.
*/
while (track->filemodhappy && !eof && vframe < nvframes2read)
{
AFframecount nvframes2pull;
userc->buf = (char *) samples + bytes_per_vframe * vframe;
if (vframe <= nvframes2read - _AF_ATOMIC_NVFRAMES)
nvframes2pull = _AF_ATOMIC_NVFRAMES;
else
nvframes2pull = nvframes2read - vframe;
userc->nframes = nvframes2pull;
(*firstmod->mod->run_pull)(firstmod);
if (track->filemodhappy)
{
vframe += userc->nframes;
if (userc->nframes < nvframes2pull)
eof = AF_TRUE;
}
}
}
track->nextvframe += vframe;
return vframe;
}
status _af_aiff_read_init (AFfilesetup setup, AFfilehandle file)
{
u_int32_t type, size, formtype;
size_t index = 0;
bool hasCOMM, hasFVER, hasSSND, hasMARK, hasINST;
bool hasAESD, hasNAME, hasAUTH, hasCOPY;
_Track *track;
hasCOMM = AF_FALSE;
hasFVER = AF_FALSE;
hasSSND = AF_FALSE;
hasMARK = AF_FALSE;
hasINST = AF_FALSE;
hasAESD = AF_FALSE;
hasNAME = AF_FALSE;
hasAUTH = AF_FALSE;
hasCOPY = AF_FALSE;
assert(file != NULL);
assert(file->fh != NULL);
af_fseek(file->fh, 0, SEEK_SET);
af_fread(&type, 4, 1, file->fh);
af_fread(&size, 4, 1, file->fh);
size = BENDIAN_TO_HOST_INT32(size);
af_fread(&formtype, 4, 1, file->fh);
if (memcmp(&type, "FORM", 4) != 0 ||
(memcmp(&formtype, "AIFF", 4) && memcmp(&formtype, "AIFC", 4)))
return AF_FAIL;
#ifdef DEBUG
printf("size: %d\n", size);
#endif
file->instrumentCount = 0;
file->instruments = NULL;
file->miscellaneousCount = 0;
file->miscellaneous = NULL;
/* AIFF files have only one track. */
track = _af_track_new();
file->trackCount = 1;
file->tracks = track;
/* Include the offset of the form type. */
index += 4;
while (index < size)
{
u_int32_t chunkid = 0, chunksize = 0;
status result = AF_SUCCEED;
#ifdef DEBUG
printf("index: %d\n", index);
#endif
af_fread(&chunkid, 4, 1, file->fh);
af_fread(&chunksize, 4, 1, file->fh);
chunksize = BENDIAN_TO_HOST_INT32(chunksize);
#ifdef DEBUG
_af_printid(chunkid);
printf(" size: %d\n", chunksize);
#endif
if (!memcmp("COMM", &chunkid, 4))
{
hasCOMM = AF_TRUE;
result = ParseCOMM(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("FVER", &chunkid, 4))
{
hasFVER = AF_TRUE;
ParseFVER(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("INST", &chunkid, 4))
{
hasINST = AF_TRUE;
ParseINST(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("MARK", &chunkid, 4))
{
hasMARK = AF_TRUE;
ParseMARK(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("AESD", &chunkid, 4))
{
hasAESD = AF_TRUE;
ParseAESD(file, file->fh, chunkid, chunksize);
}
else if (!memcmp("NAME", &chunkid, 4) ||
!memcmp("AUTH", &chunkid, 4) ||
!memcmp("(c) ", &chunkid, 4) ||
!memcmp("ANNO", &chunkid, 4) ||
!memcmp("APPL", &chunkid, 4) ||
!memcmp("MIDI", &chunkid, 4))
{
ParseMiscellaneous(file, file->fh, chunkid, chunksize);
}
/*
The sound data chunk is required if there are more than
zero sample frames.
*/
else if (!memcmp("SSND", &chunkid, 4))
{
if (hasSSND)
{
_af_error(AF_BAD_AIFF_SSND, "AIFF file has more than one SSND chunk");
return AF_FAIL;
}
hasSSND = AF_TRUE;
result = ParseSSND(file, file->fh, chunkid, chunksize);
}
if (result == AF_FAIL)
return AF_FAIL;
index += chunksize + 8;
/* all chunks must be aligned on an even number of bytes */
if ((index % 2) != 0)
index++;
af_fseek(file->fh, index + 8, SEEK_SET);
}
if (!hasCOMM)
{
_af_error(AF_BAD_AIFF_COMM, "bad AIFF COMM chunk");
}
/* The file has been successfully parsed. */
return AF_SUCCEED;
}
static struct ExecutionLogging* BuildAllocInitExecutionLoggingForIncrementedNumber(void* privateLoggerPtr)
{
struct ExecutionLogging* pEL = NULL;
struct UniLoggerSpace * pULS=(struct UniLoggerSpace *)privateLoggerPtr;
struct ActivityLoggerPrivateData* pALPD = (struct ActivityLoggerPrivateData*) pULS->privateUnloggerData;
char szNumFileSuffix[256];
if (pULS -> auto_increment_logfilename == 0)
{
return NULL;
}
/* we take a mutex, to be sure two thread don't increment and use same number at same time */
SyncGetMutex(pALPD->pMutexLog);
if (pULS->szNameLog == NULL) {
unsigned int current_number = 0;
const char* szNumFile = buildDupFileNameWithPrefixDir(pULS->szPathLog,"unitex_logging_parameters_count.txt");
/* here : we will need protect with a mutex */
ABSTRACTFILE *af_fin = af_fopen_unlogged(szNumFile,"rb");
if (af_fin!=NULL)
{
size_t size_num_file=0;
if (af_fseek(af_fin, 0, SEEK_END) == 0)
{
size_num_file = af_ftell(af_fin);
af_fseek(af_fin, 0, SEEK_SET);
}
char* buf_num_file=(char*)malloc(size_num_file+1);
*(buf_num_file+size_num_file)=0;
if (af_fread(buf_num_file,1,size_num_file,af_fin) == size_num_file)
{
sscanf(buf_num_file,"%u",¤t_number);
}
af_fclose(af_fin);
free(buf_num_file);
}
current_number++;
ABSTRACTFILE *af_fout = af_fopen_unlogged(szNumFile,"wb");
if (af_fout!=NULL)
{
char szNumOut[32];
sprintf(szNumOut,"%010u",current_number);
af_fwrite(szNumOut,1,strlen(szNumOut),af_fout);
af_fclose(af_fout);
}
free((void*)szNumFile);
sprintf(szNumFileSuffix,"unitex_log_%08u.ulp",current_number);
}
else {
sprintf(szNumFileSuffix,"%s",pULS->szNameLog);
}
SyncReleaseMutex(pALPD->pMutexLog);
const char* szLogFileName = buildDupFileNameWithPrefixDir(pULS->szPathLog,szNumFileSuffix);
pEL=BuildAllocInitExecutionLogging(privateLoggerPtr,szLogFileName);
free((void*)szLogFileName);
return pEL;
}