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;
}
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;
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;
}
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;
}
status af_write_uint16_le (const uint16_t *value, AFvirtualfile *vf)
{
uint16_t v;
v = HOST_TO_LENDIAN_INT16(*value);
if (af_fwrite(&v, sizeof (v), 1, vf) != 1)
return AF_FAIL;
return AF_SUCCEED;
}
void g711run_push (_AFmoduleinst *i)
{
g711_data *d = (g711_data *)i->modspec;
AFframecount frames2write = i->inc->nframes;
AFframecount samps2write = i->inc->nframes * i->inc->f.channelCount;
int framesize = sizeof (g711samp) * (i->inc->f.channelCount);
AFframecount nfr;
assert(d->trk->f.compressionType == AF_COMPRESSION_G711_ULAW ||
d->trk->f.compressionType == AF_COMPRESSION_G711_ALAW);
/* Compress frames into i->outc. */
if (d->trk->f.compressionType == AF_COMPRESSION_G711_ULAW)
linear2ulaw_buf(i->inc->buf, i->outc->buf, samps2write);
else
linear2alaw_buf(i->inc->buf, i->outc->buf, samps2write);
/* Write the compressed data. */
nfr = af_fwrite(i->outc->buf, framesize, frames2write, d->fh);
CHNK(printf("writing %d frames to g711 file\n", frames2write));
if (nfr != frames2write)
{
/* report error if we haven't already */
if (d->trk->filemodhappy)
{
/* i/o error */
if (nfr < 0)
_af_error(AF_BAD_WRITE,
"unable to write data (%s) -- "
"wrote %d out of %d frames",
strerror(errno),
d->trk->nextfframe + nfr,
d->trk->nextfframe + frames2write);
/* usual disk full error */
else
_af_error(AF_BAD_WRITE,
"unable to write data (disk full) -- "
"wrote %d out of %d frames",
d->trk->nextfframe + nfr,
d->trk->nextfframe + frames2write);
d->trk->filemodhappy = AF_FALSE;
}
}
d->trk->nextfframe += nfr;
d->trk->totalfframes = d->trk->nextfframe;
d->trk->fpos_next_frame += (nfr>0) ? nfr/framesize : 0;
assert(!d->seekok || (af_ftell(d->fh) == d->trk->fpos_next_frame));
}
/**
* Write an Unitex file content (to system filesystem or filespace)
* it write from two buffer (prefix and suffix). This is useful for writing both header and footer (or BOM and text...)
*/
UNITEX_FUNC int UNITEX_CALL WriteUnitexFile(const char*name,const void*buffer_prefix,size_t size_prefix,const void*buffer_suffix,size_t size_suffix)
{
ABSTRACTFILE* vfWrite = af_fopen(name, "wb");
if (vfWrite == NULL)
{
return 1;
}
int retValue = 0;
if (size_prefix > 0)
if (size_prefix != af_fwrite(buffer_prefix,1,size_prefix,vfWrite))
retValue = 1;
if (retValue==0 && (size_suffix > 0))
if (size_suffix != af_fwrite(buffer_suffix,1,size_suffix,vfWrite))
retValue = 1;
af_fclose(vfWrite);
return retValue;
}
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;
}
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;
}
uLong ZCALLBACK afwrite_file_func (
voidpf opaque,
voidpf stream,
const void* buf,
uLong size)
{
uLong ret;
(void)opaque;
ret = (uLong)af_fwrite(buf, 1, (size_t)size, (ABSTRACTFILE *)stream);
return ret;
}
static status WriteData (AFfilehandle file)
{
_Track *track;
u_int32_t frameSize, chunkSize;
_WAVEInfo *waveinfo;
assert(file);
waveinfo = file->formatSpecific;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_fwrite("data", 4, 1, file->fh);
waveinfo->dataSizeOffset = af_ftell(file->fh);
frameSize = _af_format_frame_size(&track->f, AF_FALSE);
chunkSize = frameSize * track->totalfframes;
chunkSize = HOST_TO_LENDIAN_INT32(chunkSize);
af_fwrite(&chunkSize, 4, 1, file->fh);
track->fpos_first_frame = af_ftell(file->fh);
return AF_SUCCEED;
}
status af_write_pstring (const char *s, AFvirtualfile *vf)
{
size_t length = strlen(s);
if (length > 255)
return AF_FAIL;
uint8_t sizeByte = (uint8_t) length;
af_write_uint8(&sizeByte, vf);
af_fwrite(s, sizeByte, 1, vf);
/*
Add a pad byte if the length of the Pascal-style string
(including the size byte) is odd.
*/
if ((length % 2) == 0)
{
uint8_t zero = 0;
af_write_uint8(&zero, vf);
}
return AF_SUCCEED;
}
static status WriteData (AFfilehandle file)
{
_Track *track;
uint32_t chunkSize;
_WAVEInfo *waveinfo;
assert(file);
waveinfo = file->formatSpecific;
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_fwrite("data", 4, 1, file->fh);
waveinfo->dataSizeOffset = af_ftell(file->fh);
chunkSize = (int) _af_format_frame_size(&track->f, false) *
track->totalfframes;
af_write_uint32_le(&chunkSize, file->fh);
track->fpos_first_frame = af_ftell(file->fh);
return AF_SUCCEED;
}
static status WriteFormat (AFfilehandle file)
{
_Track *track = NULL;
uint16_t formatTag, channelCount;
uint32_t sampleRate, averageBytesPerSecond;
uint16_t blockAlign;
uint32_t chunkSize;
uint16_t bitsPerSample;
assert(file != NULL);
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
af_fwrite("fmt ", 4, 1, file->fh);
switch (track->f.compressionType)
{
case AF_COMPRESSION_NONE:
chunkSize = 16;
if (track->f.sampleFormat == AF_SAMPFMT_FLOAT ||
track->f.sampleFormat == AF_SAMPFMT_DOUBLE)
{
formatTag = WAVE_FORMAT_IEEE_FLOAT;
}
else if (track->f.sampleFormat == AF_SAMPFMT_TWOSCOMP ||
track->f.sampleFormat == AF_SAMPFMT_UNSIGNED)
{
formatTag = WAVE_FORMAT_PCM;
}
else
{
_af_error(AF_BAD_COMPTYPE, "bad sample format");
return AF_FAIL;
}
blockAlign = _af_format_frame_size(&track->f, false);
bitsPerSample = 8 * _af_format_sample_size(&track->f, false);
break;
/*
G.711 compression uses eight bits per sample.
*/
case AF_COMPRESSION_G711_ULAW:
chunkSize = 18;
formatTag = IBM_FORMAT_MULAW;
blockAlign = track->f.channelCount;
bitsPerSample = 8;
break;
case AF_COMPRESSION_G711_ALAW:
chunkSize = 18;
formatTag = IBM_FORMAT_ALAW;
blockAlign = track->f.channelCount;
bitsPerSample = 8;
break;
default:
_af_error(AF_BAD_COMPTYPE, "bad compression type");
return AF_FAIL;
}
af_write_uint32_le(&chunkSize, file->fh);
af_write_uint16_le(&formatTag, file->fh);
channelCount = track->f.channelCount;
af_write_uint16_le(&channelCount, file->fh);
sampleRate = track->f.sampleRate;
af_write_uint32_le(&sampleRate, file->fh);
averageBytesPerSecond =
track->f.sampleRate * _af_format_frame_size(&track->f, false);
af_write_uint32_le(&averageBytesPerSecond, file->fh);
blockAlign = _af_format_frame_size(&track->f, false);
af_write_uint16_le(&blockAlign, file->fh);
af_write_uint16_le(&bitsPerSample, file->fh);
if (track->f.compressionType == AF_COMPRESSION_G711_ULAW ||
track->f.compressionType == AF_COMPRESSION_G711_ALAW)
{
uint16_t zero = 0;
af_write_uint16_le(&zero, 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_write_uint8 (const uint8_t *value, AFvirtualfile *vf)
{
if (af_fwrite(value, 1, 1, vf) != 1)
return AF_FAIL;
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;
}
static int do_extract_from_opened_pack_archive_currentfile(
unzFile uf,
const int* popt_extract_without_path,
const char* prefix_extracting_name,
int transform_path_separator, int quiet)
{
char filename_inzip[0x200];
char* filename_withoutpath;
char* p;
int err=UNZ_OK;
ABSTRACTFILE *fout=NULL;
void* buf;
uInt size_buf;
unz_file_info file_info;
err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
if (err!=UNZ_OK)
{
error("error %d with zipfile in unzGetCurrentFileInfo\n",err);
return err;
}
size_buf = UNPACK_WRITEBUFFERSIZE;
buf = (void*)malloc(size_buf);
if (buf==NULL)
{
error("Error allocating memory\n");
return UNZ_INTERNALERROR;
}
p = filename_withoutpath = filename_inzip;
while ((*p) != '\0')
{
if (((*p)=='/') || ((*p)=='\\'))
filename_withoutpath = p+1;
p++;
}
if ((*filename_withoutpath)=='\0')
{
if ((*popt_extract_without_path)==0)
{
{
size_t len_prefix = strlen(prefix_extracting_name);
size_t len_directory_in_zip = strlen(filename_inzip);
size_t total_len = len_prefix + len_directory_in_zip;
char* provis_dir_name = NULL;
if (len_directory_in_zip > 0)
provis_dir_name = (char*)malloc(total_len + 2);
if (provis_dir_name)
{
strcpy(provis_dir_name, prefix_extracting_name);
strcpy(provis_dir_name + len_prefix, filename_inzip);
transform_fileName_separator(provis_dir_name + len_prefix, transform_path_separator);
if (quiet == 0)
u_printf("creating directory: %s\n", provis_dir_name);
mkDirPortable(provis_dir_name);
free(provis_dir_name);
}
}
}
}
else
{
char* previousPathCreated = NULL;
const char* write_filename;
int skip=0;
if ((*popt_extract_without_path)==0)
write_filename = filename_inzip;
else
write_filename = filename_withoutpath;
err = unzOpenCurrentFile(uf);
if (err!=UNZ_OK)
{
error("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
}
if ((skip==0) && (err==UNZ_OK))
{
char* provis_concat_name = NULL;
if (prefix_extracting_name == NULL)
prefix_extracting_name = "";
if (prefix_extracting_name != NULL)
{
size_t len_prefix = strlen(prefix_extracting_name);
size_t total_len = len_prefix + strlen(write_filename);
provis_concat_name = (char*)malloc(total_len+2);
if (provis_concat_name != NULL)
{
strcpy(provis_concat_name,prefix_extracting_name);
strcat(provis_concat_name,write_filename);
transform_fileName_separator(provis_concat_name + len_prefix, transform_path_separator);
}
}
const char* useFileName = (provis_concat_name != NULL) ? provis_concat_name : write_filename;
if ((*popt_extract_without_path)==0)
{
char* newPathOnlyPortion = (char*)malloc(strlen(useFileName)+1);
if (newPathOnlyPortion != NULL)
{
strcpy(newPathOnlyPortion,useFileName);
removeNoPathPortionInFileName(newPathOnlyPortion);
int can_skip_creating = 0;
if (previousPathCreated != NULL)
if (strcmp(previousPathCreated,newPathOnlyPortion) == 0)
can_skip_creating = 1;
if (can_skip_creating == 0)
{
if (quiet == 0)
u_printf("Creating directory: %s\n",newPathOnlyPortion);
mkDirPortable(newPathOnlyPortion);
}
if (previousPathCreated != NULL)
free(previousPathCreated);
previousPathCreated = newPathOnlyPortion;
}
}
fout=af_fopen(useFileName,"wb");
if (quiet == 0)
u_printf("extracting %s to %s...",filename_inzip,useFileName);
if (fout==NULL)
{
error("error opening %s\n",useFileName);
}
if (provis_concat_name != NULL)
free(provis_concat_name);
/* some zipfile don't contain directory alone before file */
if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
(filename_withoutpath!=(char*)filename_inzip))
{
char c=*(filename_withoutpath-1);
*(filename_withoutpath-1)='\0';
mkDirPortable(write_filename);
*(filename_withoutpath-1)=c;
fout=af_fopen(write_filename,"wb");
}
if (quiet == 0)
u_printf(" done\n");
}
if (fout!=NULL)
{
af_setsizereservation(fout, (long)file_info.uncompressed_size);
do
{
err = unzReadCurrentFile(uf,buf,(unsigned)size_buf);
if (err<0)
{
error("error %d with zipfile in unzReadCurrentFile\n",err);
break;
}
if (err>0)
if (af_fwrite(buf,err,1,fout)!=1)
{
error("error in writing extracted file\n");
err=UNZ_ERRNO;
break;
}
}
while (err>0);
if (fout)
af_fclose(fout);
/*
if (err==0)
change_file_date(write_filename,file_info.dosDate,
file_info.tmu_date);
*/
}
if (err==UNZ_OK)
{
err = unzCloseCurrentFile (uf);
if (err!=UNZ_OK)
{
error("error %d with zipfile in unzCloseCurrentFile\n",err);
}
}
else
unzCloseCurrentFile(uf); /* don't lose the error */
if (previousPathCreated != NULL)
free(previousPathCreated);
}
free(buf);
return err;
}
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;
}
static status WriteFormat (AFfilehandle file)
{
_Track *track = NULL;
u_int16_t formatTag, channelCount;
u_int32_t sampleRate, averageBytesPerSecond;
u_int16_t blockAlign;
u_int32_t chunkSize;
u_int16_t bitsPerSample;
_WAVEInfo *waveinfo = NULL;
assert(file != NULL);
track = _af_filehandle_get_track(file, AF_DEFAULT_TRACK);
waveinfo = (_WAVEInfo *) file->formatSpecific;
af_fwrite("fmt ", 4, 1, file->fh);
switch (track->f.compressionType)
{
case AF_COMPRESSION_NONE:
chunkSize = 16;
formatTag = WAVE_FORMAT_PCM;
blockAlign = _af_format_frame_size(&track->f, AF_FALSE);
bitsPerSample = 8 * _af_format_sample_size(&track->f, AF_FALSE);
break;
case AF_COMPRESSION_G711_ULAW:
chunkSize = 18;
formatTag = IBM_FORMAT_MULAW;
blockAlign = _af_format_frame_size(&track->f, AF_FALSE);
bitsPerSample = 8 * _af_format_sample_size(&track->f, AF_FALSE);
break;
case AF_COMPRESSION_G711_ALAW:
chunkSize = 18;
formatTag = IBM_FORMAT_ALAW;
blockAlign = _af_format_frame_size(&track->f, AF_FALSE);
bitsPerSample = 8 * _af_format_sample_size(&track->f, AF_FALSE);
break;
default:
_af_error(AF_BAD_COMPTYPE, "bad compression type");
return AF_FAIL;
}
chunkSize = HOST_TO_LENDIAN_INT32(chunkSize);
af_fwrite(&chunkSize, 4, 1, file->fh);
formatTag = HOST_TO_LENDIAN_INT16(formatTag);
af_fwrite(&formatTag, 2, 1, file->fh);
formatTag = LENDIAN_TO_HOST_INT16(formatTag);
channelCount = track->f.channelCount;
channelCount = HOST_TO_LENDIAN_INT16(channelCount);
af_fwrite(&channelCount, 2, 1, file->fh);
sampleRate = track->f.sampleRate;
sampleRate = HOST_TO_LENDIAN_INT32(sampleRate);
af_fwrite(&sampleRate, 4, 1, file->fh);
averageBytesPerSecond =
track->f.sampleRate * _af_format_frame_size(&track->f, AF_FALSE);
averageBytesPerSecond = HOST_TO_LENDIAN_INT32(averageBytesPerSecond);
af_fwrite(&averageBytesPerSecond, 4, 1, file->fh);
blockAlign = _af_format_frame_size(&track->f, AF_FALSE);
blockAlign = HOST_TO_LENDIAN_INT16(blockAlign);
af_fwrite(&blockAlign, 2, 1, file->fh);
bitsPerSample = HOST_TO_LENDIAN_INT16(bitsPerSample);
af_fwrite(&bitsPerSample, 2, 1, file->fh);
/*
If the data is compressed we have additional
format-specific information to write as well as the
'fact' (frame count) chunk.
*/
if (track->f.compressionType != AF_COMPRESSION_NONE)
{
u_int32_t factSize = 4;
u_int32_t totalFrameCount = 0;
if (track->f.compressionType == AF_COMPRESSION_G711_ULAW ||
track->f.compressionType == AF_COMPRESSION_G711_ALAW)
{
u_int16_t zero = 0;
af_fwrite(&zero, 2, 1, file->fh);
}
af_fwrite("fact", 4, 1, file->fh);
factSize = HOST_TO_LENDIAN_INT32(factSize);
af_fwrite(&factSize, 4, 1, file->fh);
waveinfo->fileSizeOffset = af_ftell(file->fh);
totalFrameCount = HOST_TO_LENDIAN_INT32(totalFrameCount);
af_fwrite(&totalFrameCount, 4, 1, file->fh);
}
return AF_SUCCEED;
}
