void MatLabEngine::executeInteractiveCommands( void ) {
std::string command;
while( true ) {
char *commandString = readline( ">> " );
if ( !commandString ) {
continue;
}
if ( *commandString ) {
add_history( commandString );
}
command = commandString;
free( commandString );
if ( command.substr( 0, 4 ) == "quit" ) {
break;
}
zeroBuffer();
if ( engEvalString( _ep, command.c_str() ) != 0 ) {
_ep = 0;
throw MatLabUdm::Exception( "MatLab connection lost." );
}
std::string output( getBuffer() );
output = output.substr( output.find( '\n' ) + 1 );
std::cout << output << std::endl;
}
}
// TODO: should we write ones rather than zeros?
void MultiplySP::step(stk::StkFrames& buffer, Tick tick, bool is_new_event) {
if (sources_.size() == 0) {
zeroBuffer(buffer);
} else {
// first source is written directly.
SampleProcessor *source = sources_.at(0);
source->step(buffer, tick, is_new_event);
for (long int i=1; i<sources_.size(); i++) {
source = sources_.at(i);
Tick buffer_start = tick;
Tick buffer_end = tick + buffer.frames();
Tick source_start = source->getStart();
Tick source_end = source->getEnd();
// TODO: write general SP::is_overlapping() method
if ((TickUtils::isIndefinite(source_start) || (source_start < buffer_end)) &&
(TickUtils::isIndefinite(source_end) || (source_end > buffer_start))) {
buffer_.resize(buffer.frames(), buffer.channels());
source->step(buffer_, tick, is_new_event);
stk::StkFloat *dst = &(buffer[0]);
stk::StkFloat *src = &(buffer_[0]);
for (int i=buffer.size()-1; i>=0; i--) {
*dst++ *= *src++;
}
}
}
}
}
/* Output appropriate for width * height real1 elements */
static CALresult createOutputBuffer2D(MWMemRes* mr, MWCALInfo* ci, CALuint width, CALuint height)
{
CALresult err;
CALuint flags = 0;
//CALuint flags = CAL_RESALLOC_GLOBAL_BUFFER;
err = calResAllocLocal2D(&mr->res, ci->dev, width, height, formatReal2, flags);
if (err != CAL_RESULT_OK)
{
cal_warn("Failed to create output resource", err);
releaseMWMemRes(ci->calctx, mr);
return err;
}
err = zeroBuffer(mr, 2, width, height);
if (err != CAL_RESULT_OK)
{
cal_warn("Failed to zero output buffer", err);
return err;
}
/* Get the handle for the context */
err = getMemoryHandle(mr, ci);
if (err != CAL_RESULT_OK)
{
cal_warn("Failed to create handle for output buffer", err);
return err;
}
return CAL_RESULT_OK;
}
//-----------------------------------------------------------------------------------------
void gsBEncoder::processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames)
{
int nin = (int)inputBuffers.size();
int nout = (int)outputBuffers.size();
int n = 0;
while(n < sampleFrames) {
int toprocess = MIN(bufferSize, (sampleFrames-n));
for(int i=0; i < nin; i++) {
FloatToSample(inputBuffers[i], inputs[i]+n, toprocess);
}
for(int i=nin; i < inputBuffers.size(); i++) {
zeroBuffer(inputBuffers[i], toprocess);
}
perform(
gen,
&(inputBuffers[0]), inputBuffers.size(),
&(outputBuffers[0]), outputBuffers.size(),
toprocess
);
for(int i=0; i < nout; i++) {
FloatFromSample(outputs[i]+n, outputBuffers[i], toprocess);
}
n += toprocess;
}
}
void listHandler(char *buffer, int sock)
{
printf("\nlisting users\n");
int loc = 0;
int x = 0;
zeroBuffer(buffer);
for (x = 0; x < MAX_USERS; x++) //grab all the users and print their names
{
if (users[x].username[0] != 0)
{
int len = strlen(users[x].username);
int y = 0;
for (y = 0; y < len; y++)
{
buffer[loc] = users[x].username[y];
loc++;
}
buffer[loc] = '\n';
loc++;
}
}
//send the message
printf("%s",buffer);
writeMessageDefined(sock, buffer);
}
void usernameHandler(char *buffer, int sock) //handles username requests
{
grabContents(buffer); //get the actual message minus command
chop(buffer); //chop off anything extraneous
int x = 0;
for (x = 0; x < MAX_USERS; x++) //check username with all users and return bad if not found
{
if (strcmp(users[x].username, buffer) == 0)
{
char tempBuffer[MAX_MESSAGE_SIZE];
sprintf(tempBuffer, " %dError: username '%s' all ready taken\n", NAME_TAKEN, buffer);
writeMessageDefined(sock, tempBuffer);
return;
}
}
//if good return a good call and establish the username
sprintf(users[sock].username, "%s", buffer);
printf("\nUsername established: %s\n", users[sock].username);
zeroBuffer(buffer);
sprintf(buffer, "Server: Username established '%s'\n", users[sock].username);
writeMessageDefined(sock, buffer);
}
void portHandler(char *buffer, int sock) //saves port to user for chatting
{
grabContents(buffer);
users[sock].address.sin_port = atoi(buffer);
printf("Port established for user '%s': %u\n", users[sock].username, users[sock].address.sin_port);
zeroBuffer(buffer);
sprintf(buffer, "Port established: %u\n", users[sock].address.sin_port);
writeMessageDefined(sock, buffer);
}
void LinsegSP::step(stk::StkFrames& buffer, Tick tick, bool is_new_event) {
if (breakpoints_.size() == 0) {
zeroBuffer(buffer);
} else {
int frame_count = buffer.frames();
int channel_count = buffer.channels();
for (int frame=0; frame<frame_count; frame++) {
for (int channel=0; channel<channel_count; channel++) {
buffer(frame, channel) = lerp(tick + frame);
}
}
}
}
void readMessage(char *buffer, int sock) //parse the commands read
{
int readStatus;
zeroBuffer(buffer);
readStatus = read(sock, buffer, MAX_MESSAGE_SIZE);
printf("command read: %d\n", (int)buffer[COMMAND_LOCATION]);
switch ((int)buffer[COMMAND_LOCATION])
{
case PORT:
portHandler(buffer, sock);
break;
case USERNAME:
usernameHandler(buffer, sock);
break;
case DISCONNECT:
disconnectHandler(buffer, sock);
break;
case LIST_USERS:
listHandler(buffer, sock);
break;
case MESSAGE:
messageUserHandler(buffer, sock);
break;
default:
printf("\nCommand not supported: (%d)\n", buffer[COMMAND_LOCATION]);
writeMessageDefined(sock, buffer);
break;
}
if (readStatus < 0)
{
error("ERROR reading from socket");
}
else
{
if(!chop(buffer)) //remove any unwanted characters
{
memset(buffer, 0, MAX_MESSAGE_SIZE);
buffer = TIMEOUT_CALL;
}
}
}
bool PagesLFB::resize(vec2i dim)
{
if (!LinkedLFB::resize(dim))
return false;
semaphores->resize(sizeof(unsigned int) * totalPixels);
counts->resize(sizeof(unsigned int) * totalPixels);
memory["Semaphores"] = semaphores->size();
memory["Counts"] = counts->size();
zeroBuffer(semaphores);
return true;
}
void
WebGLContext::BufferData(GLenum target, WebGLsizeiptr size, GLenum usage)
{
if (IsContextLost())
return;
if (!ValidateBufferTarget(target, "bufferData"))
return;
WebGLRefPtr<WebGLBuffer>& bufferSlot = GetBufferSlotByTarget(target);
if (size < 0)
return ErrorInvalidValue("bufferData: negative size");
if (!ValidateBufferUsageEnum(usage, "bufferData: usage"))
return;
// careful: WebGLsizeiptr is always 64-bit, but GLsizeiptr is like intptr_t.
if (!CheckedInt<GLsizeiptr>(size).isValid())
return ErrorOutOfMemory("bufferData: bad size");
WebGLBuffer* boundBuffer = bufferSlot.get();
if (!boundBuffer)
return ErrorInvalidOperation("bufferData: no buffer bound!");
UniquePtr<uint8_t> zeroBuffer((uint8_t*)calloc(size, 1));
if (!zeroBuffer)
return ErrorOutOfMemory("bufferData: out of memory");
MakeContextCurrent();
InvalidateBufferFetching();
GLenum error = CheckedBufferData(target, size, zeroBuffer.get(), usage);
if (error) {
GenerateWarning("bufferData generated error %s", ErrorName(error));
return;
}
boundBuffer->SetByteLength(size);
if (!boundBuffer->ElementArrayCacheBufferData(nullptr, size)) {
return ErrorOutOfMemory("bufferData: out of memory");
}
}
void dng_stream::PutZeros (uint64 count)
{
const uint32 kZeroBufferSize = 4096;
if (count >= kZeroBufferSize)
{
dng_memory_data zeroBuffer (kZeroBufferSize);
DoZeroBytes (zeroBuffer.Buffer (),
kZeroBufferSize);
while (count)
{
uint64 blockSize = Min_uint64 (count, kZeroBufferSize);
Put (zeroBuffer.Buffer (), (uint32) blockSize);
count -= blockSize;
}
}
else
{
uint32 count32 = (uint32) count;
for (uint32 j = 0; j < count32; j++)
{
Put_uint8 (0);
}
}
}
void FileReadSP::step(stk::StkFrames& buffer, Tick tick, bool is_new_event) {
if (!file_read_.isOpen()) {
file_read_.open(file_name_);
}
Tick s = std::max((long)0, (long)tick);
Tick e = std::min((long)(file_read_.fileSize()), (long)(tick+buffer.frames()));
Tick n_frames = e - s;
if (n_frames <= 0) {
// no overlap at all
zeroBuffer(buffer);
} else if (n_frames == buffer.frames()) {
// file spans whole buffer
file_read_.read(buffer, s, do_normalize_);
} else {
// partial overlap. Read into a temp buffer and copy
// the active part into buffer.
temp_buffer_.resize(n_frames, buffer.channels());
file_read_.read(temp_buffer_, s, do_normalize_);
copyBuffer(temp_buffer_, 0, buffer, s - tick, n_frames);
}
}
void forward(std::vector<Mat*> &inputs, std::vector<Mat> &outputs, std::vector<Mat> &internals)
{
CV_TRACE_FUNCTION();
CV_TRACE_ARG_VALUE(name, "name", name.c_str());
checkInputs(inputs);
Mat& buffer = internals[0], sumChannelMultiplier = internals[1],
sumSpatialMultiplier = internals[2];
sumChannelMultiplier.setTo(1.0);
sumSpatialMultiplier.setTo(1.0);
const Mat& inp0 = *inputs[0];
size_t num = inp0.size[0];
size_t channels = inp0.size[1];
size_t channelSize = inp0.size[2] * inp0.size[3];
Mat zeroBuffer(channels, channelSize, CV_32F, Scalar(0));
Mat absDiff;
Mat scale = blobs[0];
for (size_t j = 0; j < inputs.size(); j++)
{
for (size_t n = 0; n < num; ++n)
{
Mat src = Mat(channels, channelSize, CV_32F, inputs[j]->ptr<float>(n));
Mat dst = Mat(channels, channelSize, CV_32F, outputs[j].ptr<float>(n));
buffer = src.mul(src);
if (_across_spatial)
{
absdiff(buffer, zeroBuffer, absDiff);
// add eps to avoid overflow
double absSum = sum(absDiff)[0] + _eps;
float norm = sqrt(absSum);
dst = src / norm;
}
else
{
Mat norm(channelSize, 1, buffer.type()); // 1 x channelSize
// (_channels x channelSize)T * _channels x 1 -> channelSize x 1
gemm(buffer, sumChannelMultiplier, 1, norm, 0, norm, GEMM_1_T);
// compute norm
pow(norm, 0.5f, norm);
// scale the layer
// _channels x 1 * (channelSize x 1)T -> _channels x channelSize
gemm(sumChannelMultiplier, norm, 1, buffer, 0, buffer, GEMM_2_T);
dst = src / buffer;
}
// scale the output
if (_channel_shared)
{
// _scale: 1 x 1
dst *= scale.at<float>(0, 0);
}
else
{
// _scale: _channels x 1
// _channels x 1 * 1 x channelSize -> _channels x channelSize
gemm(scale, sumSpatialMultiplier, 1, buffer, 0, buffer);
dst = dst.mul(buffer);
}
}
}
}
void PagesLFB::initBuffers()
{
LinkedLFB::initBuffers();
zeroBuffer(counts);
//don't need to zero semaphores each render
}
void disconnectHandler(char *buffer, int sock)
{
memset(users[sock].username, 0, USERNAME_SIZE); //clear out that users name
zeroBuffer(buffer);
}
