statement& statement::bind(int idx, const std::string& value, bool blob, bool fstatic)
{
if (blob)
{
THROW_ERR(sqlite3_bind_blob(stmt_, idx, value.c_str(), static_cast<int>(value.size()), fstatic ? SQLITE_STATIC : SQLITE_TRANSIENT));
}
else
{
THROW_ERR(sqlite3_bind_text(stmt_, idx, value.c_str(), static_cast<int>(value.size()), fstatic ? SQLITE_STATIC : SQLITE_TRANSIENT));
}
return *this;
}
int main (void)
{
#ifdef AUDIO_HW_TEST_THROUGHPUT
if (audio_setup(NULL)) {
THROW_ERR("Error setting up audio.");
}
audio_start();
while(1) {
}
#else
if (audio_setup(NULL)) {
THROW_ERR("Error setting up audio.");
}
if (midi_setup(NULL)) {
THROW_ERR("Error setting up MIDI.");
}
SampleTable_init();
signal_chain_setup();
synth_control_setup();
scheduler_setup();
leds_setup();
timers_setup();
switches_setup();
adc_setup_dma_scan(adc_mode_1SHOT);
adc_channel_setup();
synth_adc_control_setup();
adc_start_conversion();
int midi_channel = -1;
int reset_request = 0;
supo_get_midi_channel(&midi_channel);
supo_get_preset_reset_rqst(&reset_request);
sc_presets_init(reset_request,&midi_channel);
synth_switch_control_setup();
synth_midi_control_setup(midi_channel);
audio_start();
#if defined(TIMER_EVENT_TEST) || defined(TIMER_TEST)
timers_enable();
#endif
while(1) {
}
#endif /* AUDIO_HW_TEST_THROUGHPUT */
return(0);
}
int main (void)
{
if (audio_setup(NULL)) {
THROW_ERR("Error setting up audio.");
}
leds_setup();
switches_setup();
sdt_setup();
audio_start();
while(1) {
}
}
float pseudo_inv(const Eigen::MatrixXf *mat_in,
Eigen::MatrixXf *mat_out) {
int dim = 0;
// Get matrices dimension :
if (mat_in->cols () != mat_in->rows ()) {
THROW_ERR("Cannot compute matrix pseudo_inverse");
} else {
dim = mat_in->cols ();
}
mat_out->resize (dim, dim);
Eigen::MatrixXf U (dim,dim);
Eigen::MatrixXf eig_val (dim, 1);
Eigen::MatrixXf eig_val_inv (dim, dim);
Eigen::MatrixXf V (dim, dim);
float det;
eig_val_inv = Eigen::MatrixXf::Identity(dim,dim);
// Compute the SVD decomposition
Eigen::JacobiSVD<Eigen::MatrixXf> svd(*mat_in, Eigen::ComputeFullU | Eigen::ComputeFullV);
eig_val = svd.singularValues();
U = svd.matrixU();
V = svd.matrixV();
// Compute pseudo-inverse
// - quick'n'dirty inversion of eigen matrix
for (int i = 0; i<dim; ++i) {
if (eig_val(i,0) != 0.f)
eig_val_inv(i,i) = 1.f / eig_val(i,0);
else
eig_val_inv(i,i) = 0.f;
}
*mat_out = V.transpose() * eig_val_inv * U.transpose();
// Compute determinant from eigenvalues..
det = 1.f;
for (int i=0; i<dim; ++i) {
det *= eig_val(i,0);
}
return det;
}
void RedClient::calc_pixmap_cach_and_glz_window_size(uint32_t display_channels_hint,
uint32_t pci_mem_hint)
{
#ifdef WIN32
display_channels_hint = MAX(1, display_channels_hint);
uint64_t max_cache_size = display_channels_hint * MAX_DISPLAY_PIXMAP_CACHE;
uint64_t min_cache_size = display_channels_hint * MIN_DISPLAY_PIXMAP_CACHE;
MEMORYSTATUSEX mem_status;
mem_status.dwLength = sizeof(mem_status);
if (!GlobalMemoryStatusEx(&mem_status)) {
THROW("get mem status failed %u", GetLastError());
}
//ullTotalPageFile is physical memory plus the size of the page file, minus a small overhead
uint64_t free_mem = mem_status.ullAvailPageFile;
if (free_mem < (min_cache_size + MIN_MEM_FOR_OTHERS + MIN_GLZ_WINDOW_SIZE)) {
THROW_ERR(SPICEC_ERROR_CODE_NOT_ENOUGH_MEMORY, "low memory condition");
}
free_mem -= MIN_MEM_FOR_OTHERS;
_glz_window_size = MIN(MAX_GLZ_WINDOW_SIZE, pci_mem_hint / 2);
_glz_window_size = (int)MIN(free_mem / 3, _glz_window_size);
_glz_window_size = MAX(MIN_GLZ_WINDOW_SIZE, _glz_window_size);
free_mem -= _glz_window_size;
_pixmap_cache_size = MIN(free_mem, mem_status.ullAvailVirtual);
_pixmap_cache_size = MIN(free_mem, max_cache_size);
#else
//for now
_glz_window_size = (int)MIN(MAX_GLZ_WINDOW_SIZE, pci_mem_hint / 2);
_glz_window_size = MAX(MIN_GLZ_WINDOW_SIZE, _glz_window_size);
_pixmap_cache_size = MAX_DISPLAY_PIXMAP_CACHE;
#endif
_pixmap_cache_size /= 4;
_glz_window_size /= 4;
}
void RedClient::on_agent_reply(VDAgentReply* reply)
{
DBG(0, "agent reply type: %d", reply->type);
switch (reply->error) {
case VD_AGENT_SUCCESS:
break;
case VD_AGENT_ERROR:
THROW_ERR(SPICEC_ERROR_CODE_AGENT_ERROR, "vdagent error");
default:
THROW("unknown vdagent error");
}
switch (reply->type) {
case VD_AGENT_MONITORS_CONFIG:
case VD_AGENT_DISPLAY_CONFIG:
if (_agent_reply_wait_type == reply->type) {
send_main_attach_channels();
_application.deactivate_interval_timer(*_agent_timer);
_agent_reply_wait_type = VD_AGENT_END_MESSAGE;
}
break;
default:
THROW("unexpected vdagent reply type");
}
}
statement& statement::bind(int idx, void const* value, int n, bool fstatic)
{
THROW_ERR(sqlite3_bind_blob(stmt_, idx, value, n, fstatic ? SQLITE_STATIC : SQLITE_TRANSIENT));
return *this;
}
statement& statement::bind(int idx, char const* value, bool fstatic)
{
THROW_ERR(sqlite3_bind_text(stmt_, idx, value, strlen(value), fstatic ? SQLITE_STATIC : SQLITE_TRANSIENT));
return *this;
}
statement& statement::bind(int idx, uint64_t value)
{
THROW_ERR(sqlite3_bind_int64(stmt_, idx, static_cast<int64_t>(value)));
return *this;
}
statement& statement::bind(int idx, int64_t value)
{
THROW_ERR(sqlite3_bind_int64(stmt_, idx, value));
return *this;
}
statement& statement::bind(int idx, double value)
{
THROW_ERR(sqlite3_bind_double(stmt_, idx, value));
return *this;
}
void statement::finish()
{
THROW_ERR(efinish());
}
void statement::prepare(char const* stmt)
{
THROW_ERR(eprepare(stmt));
}
int CTechnologyCollection::LoadTechnologies()
{
// Load all files in techs/ and subdirectories.
THROW_ERR( fs_util::ForEachFile(g_VFS, L"technologies/", LoadTechThunk, (uintptr_t)this, L"*.xml", fs_util::DIR_RECURSIVE));
return 0;
}
void RedChannelBase::link(uint32_t connection_id, const std::string& password,
int protocol)
{
SpiceLinkHeader header;
SpiceLinkMess link_mess;
SpiceLinkReply* reply;
uint32_t link_res;
uint32_t i;
EVP_PKEY *pubkey;
int nRSASize;
BIO *bioKey;
RSA *rsa;
uint8_t *buffer, *p;
uint32_t expected_major;
header.magic = SPICE_MAGIC;
header.size = sizeof(link_mess);
if (protocol == 1) {
/* protocol 1 == major 1, old 0.4 protocol, last active minor */
expected_major = header.major_version = 1;
header.minor_version = 3;
} else if (protocol == 2) {
/* protocol 2 == current */
expected_major = header.major_version = SPICE_VERSION_MAJOR;
header.minor_version = SPICE_VERSION_MINOR;
} else {
THROW("unsupported protocol version specified");
}
link_mess.connection_id = connection_id;
link_mess.channel_type = _type;
link_mess.channel_id = _id;
link_mess.num_common_caps = get_common_caps().size();
link_mess.num_channel_caps = get_caps().size();
link_mess.caps_offset = sizeof(link_mess);
header.size += (link_mess.num_common_caps + link_mess.num_channel_caps) * sizeof(uint32_t);
buffer =
new uint8_t[sizeof(header) + sizeof(link_mess) +
_common_caps.size() * sizeof(uint32_t) +
_caps.size() * sizeof(uint32_t)];
p = buffer;
memcpy(p, (uint8_t*)&header, sizeof(header));
p += sizeof(header);
memcpy(p, (uint8_t*)&link_mess, sizeof(link_mess));
p += sizeof(link_mess);
for (i = 0; i < _common_caps.size(); i++) {
*(uint32_t *)p = _common_caps[i];
p += sizeof(uint32_t);
}
for (i = 0; i < _caps.size(); i++) {
*(uint32_t *)p = _caps[i];
p += sizeof(uint32_t);
}
send(buffer, p - buffer);
delete [] buffer;
recive((uint8_t*)&header, sizeof(header));
if (header.magic != SPICE_MAGIC) {
THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "bad magic");
}
if (header.major_version != expected_major) {
THROW_ERR(SPICEC_ERROR_CODE_VERSION_MISMATCH,
"version mismatch: expect %u got %u",
expected_major,
header.major_version);
}
_remote_major = header.major_version;
_remote_minor = header.minor_version;
AutoArray<uint8_t> reply_buf(new uint8_t[header.size]);
recive(reply_buf.get(), header.size);
reply = (SpiceLinkReply *)reply_buf.get();
if (reply->error != SPICE_LINK_ERR_OK) {
THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "connect error %u - %s",
reply->error, spice_link_error_string(reply->error));
}
uint32_t num_caps = reply->num_channel_caps + reply->num_common_caps;
if ((uint8_t *)(reply + 1) > reply_buf.get() + header.size ||
(uint8_t *)reply + reply->caps_offset + num_caps * sizeof(uint32_t) >
reply_buf.get() + header.size) {
THROW_ERR(SPICEC_ERROR_CODE_CONNECT_FAILED, "access violation");
}
uint32_t *caps = (uint32_t *)((uint8_t *)reply + reply->caps_offset);
_remote_common_caps.clear();
for (i = 0; i < reply->num_common_caps; i++, caps++) {
_remote_common_caps.resize(i + 1);
_remote_common_caps[i] = *caps;
}
_remote_caps.clear();
for (i = 0; i < reply->num_channel_caps; i++, caps++) {
_remote_caps.resize(i + 1);
_remote_caps[i] = *caps;
}
bioKey = BIO_new(BIO_s_mem());
if (bioKey != NULL) {
BIO_write(bioKey, reply->pub_key, SPICE_TICKET_PUBKEY_BYTES);
pubkey = d2i_PUBKEY_bio(bioKey, NULL);
rsa = pubkey->pkey.rsa;
nRSASize = RSA_size(rsa);
AutoArray<unsigned char> bufEncrypted(new unsigned char[nRSASize]);
/*
The use of RSA encryption limit the potential maximum password length.
for RSA_PKCS1_OAEP_PADDING it is RSA_size(rsa) - 41.
*/
if (RSA_public_encrypt(password.length() + 1, (unsigned char *)password.c_str(),
(uint8_t *)bufEncrypted.get(),
rsa, RSA_PKCS1_OAEP_PADDING) > 0) {
send((uint8_t*)bufEncrypted.get(), nRSASize);
} else {
THROW("could not encrypt password");
}
memset(bufEncrypted.get(), 0, nRSASize);
} else {
THROW("Could not initiate BIO");
}
BIO_free(bioKey);
recive((uint8_t*)&link_res, sizeof(link_res));
if (link_res != SPICE_LINK_ERR_OK) {
int error_code = (link_res == SPICE_LINK_ERR_PERMISSION_DENIED) ?
SPICEC_ERROR_CODE_CONNECT_FAILED : SPICEC_ERROR_CODE_CONNECT_FAILED;
THROW_ERR(error_code, "connect failed %u", link_res);
}
}
statement& statement::bind(int idx)
{
THROW_ERR(sqlite3_bind_null(stmt_, idx));
return *this;
}
void command::execute()
{
THROW_ERR(eexecute());
}
statement& statement::reset()
{
THROW_ERR(sqlite3_reset(stmt_));
return *this;
}
