int BufWriteCmd::Init(char *inData, int inSize)
{
#ifdef NO_LIBSNDFILE
SendFailure(&mReplyAddress, "/b_write", "scsynth compiled without libsndfile\n");
scprintf("scsynth compiled without libsndfile\n");
return false;
#else
sc_msg_iter msg(inSize, inData);
mBufIndex = msg.geti();
const char *filename = msg.gets();
if (!filename) return kSCErr_WrongArgType;
if(mWorld->mRestrictedPath){
mFilename = allocAndRestrictPath(mWorld, filename, mWorld->mRestrictedPath);
}else{
mFilename = (char*)World_Alloc(mWorld, strlen(filename)+1);
strcpy(mFilename, filename);
}
const char *headerFormatString = msg.gets("aiff");
const char *sampleFormatString = msg.gets("int16");
mNumFrames = msg.geti(-1);
mBufOffset = msg.geti();
mLeaveFileOpen = msg.geti();
GET_COMPLETION_MSG(msg);
memset(&mFileInfo, 0, sizeof(mFileInfo));
return sndfileFormatInfoFromStrings(&mFileInfo, headerFormatString, sampleFormatString);
#endif
}
void World_NonRealTimeSynthesis(struct World *world, WorldOptions *inOptions)
{
if (inOptions->mLoadGraphDefs) {
World_LoadGraphDefs(world);
}
int bufLength = world->mBufLength;
int fileBufFrames = inOptions->mPreferredHardwareBufferFrameSize;
if (fileBufFrames <= 0) fileBufFrames = 8192;
int bufMultiple = (fileBufFrames + bufLength - 1) / bufLength;
fileBufFrames = bufMultiple * bufLength;
// batch process non real time audio
if (!inOptions->mNonRealTimeOutputFilename)
throw std::runtime_error("Non real time output filename is NULL.\n");
SF_INFO inputFileInfo, outputFileInfo;
float *inputFileBuf = 0;
float *outputFileBuf = 0;
int numInputChannels = 0;
int numOutputChannels;
outputFileInfo.samplerate = inOptions->mPreferredSampleRate;
numOutputChannels = outputFileInfo.channels = world->mNumOutputs;
sndfileFormatInfoFromStrings(&outputFileInfo,
inOptions->mNonRealTimeOutputHeaderFormat, inOptions->mNonRealTimeOutputSampleFormat);
world->hw->mNRTOutputFile = sf_open(inOptions->mNonRealTimeOutputFilename, SFM_WRITE, &outputFileInfo);
sf_command(world->hw->mNRTOutputFile, SFC_SET_CLIPPING, NULL, SF_TRUE);
if (!world->hw->mNRTOutputFile)
throw std::runtime_error("Couldn't open non real time output file.\n");
outputFileBuf = (float*)calloc(1, world->mNumOutputs * fileBufFrames * sizeof(float));
if (inOptions->mNonRealTimeInputFilename) {
world->hw->mNRTInputFile = sf_open(inOptions->mNonRealTimeInputFilename, SFM_READ, &inputFileInfo);
if (!world->hw->mNRTInputFile)
throw std::runtime_error("Couldn't open non real time input file.\n");
inputFileBuf = (float*)calloc(1, inputFileInfo.channels * fileBufFrames * sizeof(float));
if (world->mNumInputs != (uint32)inputFileInfo.channels)
scprintf("WARNING: input file channels didn't match number of inputs specified in options.\n");
numInputChannels = world->mNumInputs = inputFileInfo.channels; // force it.
if (inputFileInfo.samplerate != (int)inOptions->mPreferredSampleRate)
scprintf("WARNING: input file sample rate does not equal output sample rate.\n");
} else {
world->hw->mNRTInputFile = 0;
}
FILE *cmdFile;
if (inOptions->mNonRealTimeCmdFilename) {
#ifdef _WIN32
cmdFile = fopen(inOptions->mNonRealTimeCmdFilename, "rb");
#else
cmdFile = fopen(inOptions->mNonRealTimeCmdFilename, "r");
#endif
} else cmdFile = stdin;
if (!cmdFile)
throw std::runtime_error("Couldn't open non real time command file.\n");
OSC_Packet packet;
memset(&packet, 0, sizeof(packet));
packet.mData = (char *)malloc(8192);
packet.mIsBundle = true;
packet.mReplyAddr.mReplyFunc = null_reply_func;
int64 schedTime;
if (nextOSCPacket(cmdFile, &packet, schedTime))
throw std::runtime_error("command file empty.\n");
int64 prevTime = schedTime;
World_SetSampleRate(world, inOptions->mPreferredSampleRate);
World_Start(world);
int64 oscTime = 0;
double oscToSeconds = 1. / pow(2.,32.);
double oscToSamples = inOptions->mPreferredSampleRate * oscToSeconds;
int64 oscInc = (int64)((double)bufLength / oscToSamples);
if(inOptions->mVerbosity >= 0) {
printf("start time %g\n", schedTime * oscToSeconds);
}
bool run = true;
int inBufStep = numInputChannels * bufLength;
int outBufStep = numOutputChannels * bufLength;
float* inputBuses = world->mAudioBus + world->mNumOutputs * bufLength;
float* outputBuses = world->mAudioBus;
int32* inputTouched = world->mAudioBusTouched + world->mNumOutputs;
int32* outputTouched = world->mAudioBusTouched;
for (; run;) {
int bufFramesCalculated = 0;
float* inBufPos = inputFileBuf;
float* outBufPos = outputFileBuf;
if (world->hw->mNRTInputFile) {
int framesRead = sf_readf_float(world->hw->mNRTInputFile, inputFileBuf, fileBufFrames);
if (framesRead < fileBufFrames) {
memset(inputFileBuf + framesRead * numInputChannels, 0,
(fileBufFrames - framesRead) * numInputChannels * sizeof(float));
}
}
for (int i=0; i<bufMultiple && run; ++i) {
int bufCounter = world->mBufCounter;
// deinterleave input to input buses
if (inputFileBuf) {
float *inBus = inputBuses;
for (int j=0; j<numInputChannels; ++j, inBus += bufLength) {
float *inFileBufPtr = inBufPos + j;
for (int k=0; k<bufLength; ++k) {
inBus[k] = *inFileBufPtr;
inFileBufPtr += numInputChannels;
}
inputTouched[j] = bufCounter;
}
}
// execute ready commands
int64 nextTime = oscTime + oscInc;
while (schedTime <= nextTime) {
float diffTime = (float)(schedTime - oscTime) * oscToSamples + 0.5;
float diffTimeFloor = floor(diffTime);
world->mSampleOffset = (int)diffTimeFloor;
world->mSubsampleOffset = diffTime - diffTimeFloor;
if (world->mSampleOffset < 0) world->mSampleOffset = 0;
else if (world->mSampleOffset >= bufLength) world->mSampleOffset = bufLength-1;
PerformOSCBundle(world, &packet);
if (nextOSCPacket(cmdFile, &packet, schedTime)) { run = false; break; }
if(inOptions->mVerbosity >= 0) {
printf("nextOSCPacket %g\n", schedTime * oscToSeconds);
}
if (schedTime < prevTime) {
scprintf("ERROR: Packet time stamps out-of-order.\n");
run = false;
goto Bail;
}
prevTime = schedTime;
}
World_Run(world);
// interleave output to output buffer
float *outBus = outputBuses;
for (int j=0; j<numOutputChannels; ++j, outBus += bufLength) {
float *outFileBufPtr = outBufPos + j;
if (outputTouched[j] == bufCounter) {
for (int k=0; k<bufLength; ++k) {
*outFileBufPtr = outBus[k];
outFileBufPtr += numOutputChannels;
}
} else {
for (int k=0; k<bufLength; ++k) {
*outFileBufPtr = 0.f;
outFileBufPtr += numOutputChannels;
}
}
}
bufFramesCalculated += bufLength;
inBufPos += inBufStep;
outBufPos += outBufStep;
world->mBufCounter++;
oscTime = nextTime;
}
Bail:
// write output
sf_writef_float(world->hw->mNRTOutputFile, outputFileBuf, bufFramesCalculated);
}
if (cmdFile != stdin) fclose(cmdFile);
sf_close(world->hw->mNRTOutputFile);
world->hw->mNRTOutputFile = 0;
if (world->hw->mNRTInputFile) {
sf_close(world->hw->mNRTInputFile);
world->hw->mNRTInputFile = 0;
}
free(packet.mData);
World_Cleanup(world,true);
}
int prSFOpenWrite(struct VMGlobals *g, int numArgsPushed)
{
PyrSlot *a, *b;
char filename[PATH_MAX];
SNDFILE *file;
SF_INFO info;
PyrSlot *headerSlot;
PyrSlot *formatSlot;
int error;
a = g->sp - 1;
b = g->sp;
headerSlot = (slotRawObject(a)->slots + 1);
formatSlot = (slotRawObject(a)->slots + 2);
if (!isKindOfSlot(headerSlot, class_string)) return errWrongType;
if (!isKindOfSlot(formatSlot, class_string)) return errWrongType;
if (!isKindOfSlot(b, class_string)) return errWrongType;
if (slotRawObject(b)->size > PATH_MAX - 1) return errFailed;
memcpy(filename, slotRawString(b)->s, slotRawObject(b)->size);
filename[slotRawString(b)->size] = 0;
#ifdef SC_WIN32
char* headerFormat = (char *)malloc(slotRawObject(headerSlot)->size);
#else
char headerFormat[slotRawString(headerSlot)->size];
#endif
memcpy(headerFormat, slotRawString(headerSlot)->s, slotRawObject(headerSlot)->size);
headerFormat[slotRawString(headerSlot)->size] = 0;
#ifdef SC_WIN32
char* sampleFormat = (char *)malloc(slotRawString(formatSlot)->size);
#else
char sampleFormat[slotRawString(formatSlot)->size];
#endif
memcpy(sampleFormat, slotRawString(formatSlot)->s, slotRawObject(formatSlot)->size);
sampleFormat[slotRawString(formatSlot)->size] = 0;
error = sndfileFormatInfoFromStrings(&info, headerFormat, sampleFormat);
if(error) {
#ifdef SC_WIN32
free(sampleFormat);
free(headerFormat);
#endif
return errFailed;
}
if(error) return errFailed;
//slotIntVal(slotRawObject(a)->slots + 3, &info.frames);
slotIntVal(slotRawObject(a)->slots + 4, &info.channels);
slotIntVal(slotRawObject(a)->slots + 5, &info.samplerate);
file = sf_open(filename, SFM_WRITE, &info);
sf_command(file, SFC_SET_CLIPPING, NULL, SF_TRUE);
if (file) {
SetPtr(slotRawObject(a)->slots+0, file);
SetTrue(a);
} else {
SetNil(a);
SetFalse(a);
}
return errNone;
}
