char * updateFilename(in_file_structPtr in_fp){
if(in_fp->filename!='\0'){
free(in_fp->filename);
}
in_fp->filename = createFilename(in_fp->basename,in_fp->extension);
return in_fp->filename;
}
TimeSliceObservableCDT::TimeSliceObservableCDT(unsigned int writeFrequency, unsigned int T) :
Observable(writeFrequency, 1, false),
filename(createFilename("cdtslice")),
file(filename.c_str()),
T(T),
volumeProfile(T) {
}
AudioRecord::AudioRecord()
: sndFormat_(AudioFormat::MONO())
, filename_(createFilename())
, savePath_()
, recorder_(this, Manager::instance().getRingBufferPool())
{
RING_DBG("Generate filename for this call %s ", filename_.c_str());
}
SpectralDimensionObservable::SpectralDimensionObservable(unsigned int writeFrequency) :
Observable(writeFrequency, 0, true),
sigmaMax(READ_CONF("spec.sigmaMax", 1000)),
diffusionConst(READ_CONF("spec.diff", 1.0)),
dualLattice(READ_CONF("spec.dualLattice", false)),
filename(createFilename("specdim")),
file(filename.c_str()),
specDim(sigmaMax),
specDim1(sigmaMax) {
}
void AudioRecord::initFilename(const std::string &peerNumber)
{
RING_DBG("Initialize audio record for peer : %s", peerNumber.c_str());
// if savePath_ don't contains filename
if (savePath_.find(".wav") == std::string::npos) {
filename_ = createFilename();
filename_.append("-" + sanitize(peerNumber) + "-" PACKAGE);
filename_.append(".wav");
} else {
filename_ = "";
}
}
static Bool
JPEGFileToImage (CompDisplay *d,
const char *path,
const char *name,
int *width,
int *height,
int *stride,
void **data)
{
Bool status = FALSE;
char *fileName, *extension;
JPEG_DISPLAY (d);
fileName = createFilename (path, name);
if (!fileName)
return FALSE;
/* Do some testing here to see if it's got a .jpg or .jpeg extension */
extension = strrchr (fileName, '.');
if (extension)
{
if (strcasecmp (extension, ".jpeg") == 0 ||
strcasecmp (extension, ".jpg") == 0)
{
FILE *file;
file = fopen (fileName, "rb");
if (file)
{
status = readJPEGFileToImage (file, width, height, data);
fclose (file);
if (status) /* Success! */
{
free (fileName);
*stride = *width * 4;
return TRUE;
}
}
}
}
free (fileName);
/* Isn't a JPEG - pass to the next in the chain. */
UNWRAP (jd, d, fileToImage);
status = (*d->fileToImage) (d, path, name, width, height, stride, data);
WRAP (jd, d, fileToImage, JPEGFileToImage);
return status;
}
void K3bVideoDVDRippingDialog::slotUpdateFilenames()
{
QString baseDir = K3b::prepareDir( m_w->m_editBaseDir->url() );
d->fsInfo.setPath( baseDir );
for( QMap<QCheckListItem*, K3bVideoDVDRippingJob::TitleRipInfo>::iterator it = m_titleRipInfos.begin();
it != m_titleRipInfos.end(); ++it ) {
QString f = d->fsInfo.fixupPath( createFilename( it.data(), m_w->m_comboFilenamePattern->currentText() ) );
if( m_w->m_checkBlankReplace->isChecked() )
f.replace( QRegExp( "\\s" ), m_w->m_editBlankReplace->text() );
it.data().filename = baseDir + f;
it.key()->setText( 3, f );
}
}
AudioRecord::AudioRecord() : fp (NULL)
, channels_ (1)
, byteCounter_ (0)
, sndSmplRate_ (8000)
, nbSamplesMic_ (0)
, nbSamplesSpk_ (0)
, nbSamplesMax_ (3000)
, recordingEnabled_ (false)
, mixBuffer_ (NULL)
, micBuffer_ (NULL)
, spkBuffer_ (NULL)
{
mixBuffer_ = new SFLDataFormat[nbSamplesMax_];
micBuffer_ = new SFLDataFormat[nbSamplesMax_];
spkBuffer_ = new SFLDataFormat[nbSamplesMax_];
createFilename();
}
static Bool
JPEGImageToFile (CompDisplay *d,
const char *path,
const char *name,
const char *format,
int width,
int height,
int stride,
void *data)
{
Bool status = FALSE;
char *fileName;
FILE *file;
/* Not a JPEG */
if (strcasecmp (format, "jpeg") != 0 && strcasecmp (format, "jpg") != 0)
{
JPEG_DISPLAY (d);
UNWRAP (jd, d, imageToFile);
status = (*d->imageToFile) (d, path, name, format,
width, height, stride, data);
WRAP (jd, d, imageToFile, JPEGImageToFile);
return status;
}
/* Is a JPEG */
fileName = createFilename (path, name);
if (!fileName)
return FALSE;
file = fopen (fileName, "wb");
if (file)
{
status = writeJPEG (d, data, file, width, height, stride);
fclose (file);
}
free (fileName);
return status;
}
bool
ReadData::process( SocketPackage& cPackageIn
, SocketPackage& cPackageOut )
{
std::string sBuffer,
sFilename;
bool bCanRead = false;
std::ifstream cFile;
cPackageIn.resetCounter();
cPackageIn.getString( sBuffer ); // action name
createFilename( cPackageIn, sFilename, false ); // read two strings
cFile.open( sFilename.c_str(), std::ios::in|std::ios::binary );
bCanRead = cFile.is_open();
if ( bCanRead )
{
struct _stat nStatus;
int nSize;
std::vector<char> caBuffer;
::_stat( sFilename.c_str(), &nStatus );
nSize = nStatus.st_size;
caBuffer.resize( nSize );
cFile.read( &caBuffer[0], nSize );
cFile.close();
cPackageOut.resetCounter();
cPackageOut.add( &caBuffer[0], nSize );
cPackageOut.done();
}
else
cPackageOut.resetCounter();
return bCanRead;
}
CTCObservable::CTCObservable(unsigned long writeFrequency) :
Observable(writeFrequency, 1, true),
filename(createFilename("ctc")),
file(filename.c_str()) {
}
int io_writeImage(sParameterStruct * sSO2Parameters, sConfigStruct * config)
{
FILE *fp;
short *stBuffer;
IplImage *img;
CvMat *png;
int l;
int writen_bytes;
char filename[512];
int filenamelength = 512;
int state;
char *buffer;
stBuffer = sSO2Parameters->stBuffer;
/* generate filenames */
state = createFilename(sSO2Parameters, config, filename, filenamelength, "png");
if (state) {
log_error("could not create txt filename");
return state;
}
log_debug("filename created: %s", filename);
/* convert the image buffer to an openCV image */
// TODO: check if this has already been done
// TODO: check return code
img = bufferToImage(stBuffer);
/*
* encode image as png to buffer
* playing with the compression is a huge waste of time with no benefit
*/
png = cvEncodeImage(".png", img, 0);
l = png->rows * png->cols;
cvReleaseImage(&img);
// pry the actual buffer pointer from png
buffer = (char *)malloc(l);
memcpy(buffer, png->data.s, l);
cvReleaseMat(&png);
/* add headers */
log_debug("insert headers %i", l);
l = insertHeaders(&buffer, sSO2Parameters, config, l);
/* save image to disk */
log_debug("open new png file %i", l);
fp = fopen(filename, "wb");
if (fp) {
writen_bytes = fwrite(buffer, 1, l, fp);
state = writen_bytes == l ? 0 : 1;
if (state) {
log_error("PNG image wasn't written correctly");
}
fclose(fp);
} else {
state = 1;
log_error("Couldn't open png file");
}
/* cleanup */
free(buffer);
if (!state) {
log_message("png image written");
}
return state;
}
/*!
* \brief Remove temporary directory.
* \param basePath [in] Path of temporary directory.
*/
void removeTempDir(char const *basePath) {
/* If failure open directory. */
if (unlikely(basePath == NULL)) {
logger->printWarnMsg("Illegal directory path.");
return;
}
/* Open directory. */
DIR *dir = opendir(basePath);
/* If failure open directory. */
if (unlikely(dir == NULL)) {
logger->printWarnMsgWithErrno("Couldn't open directory.");
return;
}
/* Store error number. */
int oldErrNum = errno;
/* Read file in directory. */
struct dirent *entry = NULL;
while ((entry = readdir(dir)) != NULL) {
/* Check file name. */
if (strcmp(entry->d_name, "..") == 0 || strcmp(entry->d_name, ".") == 0) {
continue;
}
/* Get remove file's full path. */
char *removePath = createFilename(basePath, entry->d_name);
/* All file need remove. */
if (unlikely(removePath == NULL || unlink(removePath) != 0)) {
/* Skip file remove. */
if (removePath == NULL) {
errno = ENOMEM; // This error may be caused by ENOMEM because malloc()
// failed.
}
char *printPath = (removePath != NULL) ? removePath : entry->d_name;
logger->printWarnMsgWithErrno("Failure remove file. path: \"%s\"",
printPath);
}
/* Cleanup. */
free(removePath);
oldErrNum = errno;
}
/* If failure in read directory. */
if (unlikely(errno != oldErrNum)) {
logger->printWarnMsgWithErrno("Failure search file in directory.");
}
/* Cleanup. */
closedir(dir);
/* Get mutex. */
ENTER_PTHREAD_SECTION(&directoryMutex) {
/* Remove directory. */
if (unlikely(rmdir(basePath) != 0)) {
/* Skip directory remove. */
logger->printWarnMsgWithErrno("Failure remove directory.");
}
}
/* Release mutex. */
EXIT_PTHREAD_SECTION(&directoryMutex)
}
/**
* Dive into a folder and recurse depth-first to perform a pre-set operation lsAction:
* LS_Count - Add +1 to nrFiles for every file within the parent
* LS_GetFilename - Get the filename of the file indexed by nrFiles
* LS_SerialPrint - Print the full path of each file to serial output
*/
void CardReader::lsDive(const char *prepend, SdFile parent, const char * const match/*=NULL*/) {
dir_t p;
uint8_t cnt = 0;
// Read the next entry from a directory
while (parent.readDir(p, longFilename) > 0) {
// If the entry is a directory and the action is LS_SerialPrint
if (DIR_IS_SUBDIR(&p) && lsAction != LS_Count && lsAction != LS_GetFilename) {
// Get the short name for the item, which we know is a folder
char lfilename[FILENAME_LENGTH];
createFilename(lfilename, p);
// Allocate enough stack space for the full path to a folder, trailing slash, and nul
boolean prepend_is_empty = (prepend[0] == '\0');
int len = (prepend_is_empty ? 1 : strlen(prepend)) + strlen(lfilename) + 1 + 1;
char path[len];
// Append the FOLDERNAME12/ to the passed string.
// It contains the full path to the "parent" argument.
// We now have the full path to the item in this folder.
strcpy(path, prepend_is_empty ? "/" : prepend); // root slash if prepend is empty
strcat(path, lfilename); // FILENAME_LENGTH-1 characters maximum
strcat(path, "/"); // 1 character
// Serial.print(path);
// Get a new directory object using the full path
// and dive recursively into it.
SdFile dir;
if (!dir.open(parent, lfilename, O_READ)) {
if (lsAction == LS_SerialPrint) {
ECHO_LMV(ER, MSG_SD_CANT_OPEN_SUBDIR, lfilename);
}
}
lsDive(path, dir);
// close() is done automatically by destructor of SdFile
}
else {
char pn0 = p.name[0];
if (pn0 == DIR_NAME_FREE) break;
if (pn0 == DIR_NAME_DELETED || pn0 == '.') continue;
if (longFilename[0] == '.') continue;
if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue;
filenameIsDir = DIR_IS_SUBDIR(&p);
if (!filenameIsDir && (p.name[8] != 'G' || p.name[9] == '~')) continue;
switch (lsAction) {
case LS_Count:
nrFiles++;
break;
case LS_SerialPrint:
createFilename(filename, p);
ECHO_V(prepend);
ECHO_EV(filename);
break;
case LS_GetFilename:
createFilename(filename, p);
if (match != NULL) {
if (strcasecmp(match, filename) == 0) return;
}
else if (cnt == nrFiles) return;
cnt++;
break;
}
}
} // while readDir
}
/*!
* \brief Copy data as avoid overwriting.
* \param sourceFile [in] Path of source file.
* \param destPath [in] Path of directory put duplicated file.
* \param destName [in] Name of duplicated file.<br>
* Don't rename, if value is null.
* \return Value is zero, if process is succeed.<br />
* Value is error number a.k.a. "errno", if process is failure.
*/
int copyFile(char const *sourceFile, char const *destPath,
char const *destName) {
char rpath[PATH_MAX];
if (unlikely(!isCopiablePath(sourceFile, rpath))) {
return EINVAL;
}
int result = 0;
/* Make file name. */
char *newFile = destName == NULL
? createFilename(destPath, (char *)sourceFile)
: createFilename(destPath, (char *)destName);
/* Failure make filename. */
if (unlikely(newFile == NULL)) {
logger->printWarnMsg("Couldn't allocate copy source file path.");
/*
* Because exist below two pattern when "createFilename" return NULL.
* 1, Illegal argument. "errno" don't change.
* 2, No usable memory. "errno" maybe "ENOMEM".
*/
return (errno != 0) ? errno : EINVAL;
}
/* Get uniq file name. */
char *destFile = createUniquePath(newFile, false);
if (unlikely(destFile == NULL)) {
logger->printWarnMsg("Couldn't allocate unique destination file name.");
free(newFile);
return ENOMEM;
}
/* Open copy source file. */
int sourceFd = open(sourceFile, O_RDONLY);
if (unlikely(sourceFd < 0)) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't open copy source file.");
free(newFile);
free(destFile);
return result;
}
/* Get source file size */
struct stat st;
if (unlikely(fstat(sourceFd, &st) != 0)) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't open copy destination file.");
free(newFile);
free(destFile);
close(sourceFd);
return result;
}
/* Open destination file. */
int destFd = open(destFile, O_CREAT | O_EXCL | O_WRONLY, S_IRUSR | S_IWUSR);
if (unlikely(destFd < 0)) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't open copy destination file.");
free(newFile);
free(destFile);
close(sourceFd);
return result;
}
/* Copy data */
if (st.st_size > 0) {
if (unlikely(sendfile64(destFd, sourceFd, NULL, st.st_size) == -1)) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't copy file.");
}
} else { /* This route is for files in procfs */
char buf[1024];
ssize_t read_size;
while ((read_size = read(sourceFd, buf, 1024)) > 0) {
if (write(destFd, buf, (size_t)read_size) == -1) {
read_size = -1;
break;
}
}
if (read_size == -1) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't copy file.");
}
}
/* Clean up */
close(sourceFd);
if (unlikely((close(destFd) != 0) && (result == 0))) {
result = errno;
logger->printWarnMsgWithErrno("Couldn't write copy file data.");
}
free(newFile);
free(destFile);
return result;
}
void CardReader::lsDive(const char *prepend,SdFile parent)
{
dir_t p;
uint8_t cnt=0;
while (parent.readDir(p, longFilename) > 0)
{
if( DIR_IS_SUBDIR(&p) && lsAction!=LS_Count && lsAction!=LS_GetFilename) // hence LS_SerialPrint
{
char path[13*2];
char lfilename[13];
createFilename(lfilename,p);
path[0]=0;
if(strlen(prepend)==0) //avoid leading / if already in prepend
{
strcat(path,"/");
}
strcat(path,prepend);
strcat(path,lfilename);
strcat(path,"/");
//Serial.print(path);
SdFile dir;
if(!dir.open(parent,lfilename, O_READ))
{
if(lsAction==LS_SerialPrint)
{
SERIAL_ECHO_START;
SERIAL_ECHOLN(MSG_SD_CANT_OPEN_SUBDIR);
SERIAL_ECHOLN(lfilename);
}
}
lsDive(path,dir);
//close done automatically by destructor of SdFile
}
else
{
if (p.name[0] == DIR_NAME_FREE) break;
if (p.name[0] == DIR_NAME_DELETED || p.name[0] == '.'|| p.name[0] == '_') continue;
if ( p.name[0] == '.')
{
if ( p.name[1] != '.')
continue;
}
if (!DIR_IS_FILE_OR_SUBDIR(&p)) continue;
filenameIsDir=DIR_IS_SUBDIR(&p);
if(!filenameIsDir)
{
if(p.name[8]!='G') continue;
if(p.name[9]=='~') continue;
}
//if(cnt++!=nr) continue;
createFilename(filename,p);
if(lsAction==LS_SerialPrint)
{
SERIAL_PROTOCOL(prepend);
SERIAL_PROTOCOLLN(filename);
}
else if(lsAction==LS_Count)
{
nrFiles++;
}
else if(lsAction==LS_GetFilename)
{
if(cnt==nrFiles)
return;
cnt++;
}
}
}
}
int io_writeDump(sParameterStruct * sSO2Parameters, sConfigStruct * config)
{
FILE *imageFile;
FILE *fp;
char headerfile[512];
int headerfilelength = 512;
char rawfile[512];
int rawfilelength = 512;
int fwriteReturn;
int state = 0;
char iso_date[25];
/* generate filenames */
state = createFilename(sSO2Parameters, config, headerfile, headerfilelength, "txt");
if(state){
log_error("could not create txt filename");
}
state = createFilename(sSO2Parameters, config, rawfile, rawfilelength, "raw");
if (state) {
log_error("could not create txt filename");
}
/* Open a new file for the image (writeable, binary) */
imageFile = fopen(rawfile, "wb");
if (imageFile != NULL) {
fwriteReturn = fwrite(sSO2Parameters->stBuffer, 1, config->dBufferlength * 2, imageFile);
if(fwriteReturn != config->dBufferlength * 2){
log_debug("could not write raw file %i != %i", config->dBufferlength, fwriteReturn);
log_error("could not write raw file");
}
fclose(imageFile);
} else {
log_error("not opened raw file");
}
/* write a text file containing header information */
fp = fopen(headerfile, "ab");
if (fp != NULL) {
fprintf(fp, "dBufferlength %i\n", config->dBufferlength);
fprintf(fp, "dHistMinInterval %i\n", config->dHistMinInterval);
fprintf(fp, "dHistPercentage %i\n", config->dHistPercentage);
fprintf(fp, "dDarkCurrent %i\n", (int)sSO2Parameters->dDarkCurrent);
fprintf(fp, "dImageCounter %i\n", (int)config->dImageCounter);
fprintf(fp, "dInterFrameDelay %i\n", (int)config->dInterFrameDelay);
fprintf(fp, "dTriggerPulseWidth %i\n", (int)sSO2Parameters->dTriggerPulseWidth);
fprintf(fp, "dExposureTime %f\n", sSO2Parameters->dExposureTime);
fprintf(fp, "cConfigFileName %s\n", config->cConfigFileName);
fprintf(fp, "cFileNamePrefix %s\n", config->cFileNamePrefix);
fprintf(fp, "cImagePath %s\n", config->cImagePath);
fprintf(fp, "dFixTime %i\n", config->dFixTime);
dateStructToISO8601(sSO2Parameters->timestampBefore, iso_date);
fprintf(fp, "timestampBefore %s\n", iso_date);
fclose(fp);
} else {
log_error("not opened text file");
}
log_message("dumb image written");
return 0;
}
