static
void
start_rabbit_game(CORE_DATA *cd, PLAYER *p, int bty, int special)
{
/* store rabbit's pid in user data */
ud(cd)->rabbit_pid = p->pid;
/* announce the game to the arena */
ArenaMessageFmt("%s is now the rabbit!", p->name);
ArenaMessageFmt("%s is now the rabbit!", p->name);
ArenaMessageFmt("%s is now the rabbit!", p->name);
/* announce the game to the player */
PrivMessageFmt(p, "You are now the rabbit! The game will end if you enter safe!");
/* prize the bounty/special */
PrivMessageFmt(p, "*prize %d", bty);
if (special)
PrivMessageFmt(p, "*prize #%d", special);
/*
* send *where to get rabbits location and set the bot to parse messages looking
* for the response
*/
PrivMessage(p, "*where");
ud(cd)->expecting_where = 1;
/* set the timer for the next *where to be sent */
ud(cd)->where_timer = SetTimer(SPAM_INTERVAL_MS, 0, 0);
/* set the timer that signifies the game's end */
ud(cd)->gameover_timer = SetTimer(GAME_LENGTH_MS, 0, 0);
}
int genRandom(int min, int max)
{
std::random_device rd;
std::default_random_engine e1(rd());
std::uniform_int_distribution<int> ud(min, max);
int mean = ud(e1);
return mean;
}
/*
* select random sample of k elements from vector of int
* with equal probability
*
* O(n) time O(1) space
*
* select random 1 and add 1 to it randomly
*
*/
void Arrays::randomSampling(int k, std::vector<int> &vect) {
// select random index between 0 to n-1
// swap it with a[i] from 0 to k
int size = vect.size();
std::random_device rd;
std::default_random_engine ran_gen(rd());
for (int i = 0; i < k; i++) {
std::uniform_int_distribution<int> ud(i,size-1);
std::swap(vect[i],vect[static_cast<int>(ud(ran_gen))]);
}
}
void ud(int l,int r,int pos,int i,int x)
{
if(l==r&&l==pos)
{
seg[i]=x;
return;
}
int mid=(l+r)>>1;
if(mid>=pos)
ud(l,mid,pos,2*i,x);
else
ud(mid+1,r,pos,2*i+1,x);
up(i);
}
void MkOrthogonalCamera::UpdateViewProjectionMatrix(void)
{
// view matrix
D3DXVECTOR3 ep(m_Position.x + 0.5f, m_Position.y - 0.5f, -(MKDEF_CAMERA_DEPTH_OFFSET)); // magic number
D3DXVECTOR3 lp(ep.x, ep.y, 0.f);
D3DXVECTOR3 ud(0.f, 1.f, 0.f);
D3DXMatrixLookAtLH(&m_ViewMatrix, &ep, &lp, &ud);
// projection matrix
D3DXMatrixOrthoLH(&m_ProjectionMatrix, m_Size.x, m_Size.y, m_NearClip, m_FarClip);
}
void ezQtCurve1DEditorWidget::SetCurves(ezCurveGroupData& curves, double fMinCurveLength, bool bCurveLengthIsFixed)
{
ezQtScopedUpdatesDisabled ud(this);
ezQtScopedBlockSignals bs(this);
m_Curves.CloneFrom(curves);
CurveEdit->SetCurves(&curves, fMinCurveLength, bCurveLengthIsFixed);
m_fCurveDuration = CurveEdit->GetMaxCurveExtent();
UpdateSpinBoxes();
}
int main()
{
const size_t count = 10000000;
std::vector<int> data(count);
std::random_device rd;
std::mt19937 mt;
auto seed_data = std::array<int, std::mt19937::state_size> {};
std::generate(std::begin(seed_data), std::end(seed_data), std::ref(rd));
std::seed_seq seq(std::begin(seed_data), std::end(seed_data));
mt.seed(seq);
std::uniform_int_distribution<> ud(1, 100);
std::generate_n(std::begin(data), count, [&mt, &ud]() {return ud(mt); });
auto start = std::chrono::system_clock::now();
auto r1 = alter(data, [](int const e) {return e * e; });
auto end = std::chrono::system_clock::now();
auto t1 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "time: " << t1.count() << "ms" << std::endl;
start = std::chrono::system_clock::now();
auto r2 = palter(data, [](int const e) {return e * e; });
end = std::chrono::system_clock::now();
auto t2 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "time: " << t2.count() << "ms" << std::endl;
start = std::chrono::system_clock::now();
auto r3 = palter2(data, [](int const e) {return e * e; });
end = std::chrono::system_clock::now();
auto t3 = std::chrono::duration_cast<std::chrono::milliseconds>(end - start);
std::cout << "time: " << t3.count() << "ms" << std::endl;
assert(r1 == r2);
assert(r1 == r3);
}
PropertyHelper<UDim>::return_type
PropertyHelper<UDim>::fromString(const String& str)
{
UDim ud(0.0f, 0.0f);
if (str.empty())
return ud;
std::stringstream& sstream = SharedStringstream::GetPreparedStream(str);
sstream >> ud;
if (sstream.fail())
throwParsingException(getDataTypeName(), str);
return ud;
}
void ud(int x,int y,int i,int n)
{
if(seg[i].l==seg[i].r&&seg[i].a==seg[i].b)
{
seg[i].sum+=n;
return;
}
int xm=(seg[i].l+seg[i].r)>>1;
int ym=(seg[i].a+seg[i].b)>>1;
if(xm>=x&&ym>=y)
{
if(!seg[i].ch[0])
seg[i].ch[0]=get(seg[i].l,xm,seg[i].a,ym);
ud(x,y,seg[i].ch[0],n);
}
if(xm>=x&&ym<y)
{
if(!seg[i].ch[1])
seg[i].ch[1]=get(seg[i].l,xm,ym+1,seg[i].b);
ud(x,y,seg[i].ch[1],n);
}
if(xm<x&&ym>=y)
{
if(!seg[i].ch[2])
seg[i].ch[2]=get(xm+1,seg[i].r,seg[i].a,ym);
ud(x,y,seg[i].ch[2],n);
}
if(xm<x&&ym<y)
{
if(!seg[i].ch[3])
seg[i].ch[3]=get(xm+1,seg[i].r,ym+1,seg[i].b);
ud(x,y,seg[i].ch[3],n);
}
up(i);
}
void
AACEncode::pushBuffer(const uint8_t* const data, size_t size, IMetadata& metadata)
{
const size_t sampleCount = size / m_bytesPerSample;
const size_t aac_packet_count = sampleCount / kSamplesPerFrame;
const size_t required_bytes = aac_packet_count * m_outputPacketMaxSize;
if(m_outputBuffer.total() < (required_bytes)) {
m_outputBuffer.resize(required_bytes);
}
uint8_t* p = m_outputBuffer();
uint8_t* p_out = (uint8_t*)data;
for ( size_t i = 0 ; i < aac_packet_count ; ++i ) {
UInt32 num_packets = 1;
AudioBufferList l;
l.mNumberBuffers=1;
l.mBuffers[0].mDataByteSize = m_outputPacketMaxSize * num_packets;
l.mBuffers[0].mData = p;
std::unique_ptr<UserData> ud(new UserData());
ud->size = static_cast<int>(kSamplesPerFrame * m_bytesPerSample);
ud->data = const_cast<uint8_t*>(p_out);
ud->packetSize = static_cast<int>(m_bytesPerSample);
AudioStreamPacketDescription output_packet_desc[num_packets];
m_converterMutex.lock();
AudioConverterFillComplexBuffer(m_audioConverter, AACEncode::ioProc, ud.get(), &num_packets, &l, output_packet_desc);
m_converterMutex.unlock();
p += output_packet_desc[0].mDataByteSize;
p_out += kSamplesPerFrame * m_bytesPerSample;
}
const size_t totalBytes = p - m_outputBuffer();
auto output = m_output.lock();
if(output && totalBytes) {
if(!m_sentConfig) {
output->pushBuffer((const uint8_t*)m_asc, sizeof(m_asc), metadata);
m_sentConfig = true;
}
output->pushBuffer(m_outputBuffer(), totalBytes, metadata);
}
}
std::string Detect(agi::fs::path const& file) {
agi::read_file_mapping fp(file);
// If it's over 100 MB it's either binary or big enough that we won't
// be able to do anything useful with it anyway
if (fp.size() > 100 * 1024 * 1024)
return "binary";
uint64_t binaryish = 0;
#ifdef WITH_UCHARDET
agi::scoped_holder<uchardet_t> ud(uchardet_new(), uchardet_delete);
for (uint64_t offset = 0; offset < fp.size(); ) {
auto read = std::min<uint64_t>(4096, fp.size() - offset);
auto buf = fp.read(offset, read);
uchardet_handle_data(ud, buf, read);
uchardet_data_end(ud);
if (*uchardet_get_charset(ud))
return uchardet_get_charset(ud);
offset += read;
// A dumb heuristic to detect binary files
for (size_t i = 0; i < read; ++i) {
if ((unsigned char)buf[i] < 32 && (buf[i] != '\r' && buf[i] != '\n' && buf[i] != '\t'))
++binaryish;
}
if (binaryish > offset / 8)
return "binary";
}
return uchardet_get_charset(ud);
#else
auto read = std::min<uint64_t>(4096, fp.size());
auto buf = fp.read(0, read);
for (size_t i = 0; i < read; ++i) {
if ((unsigned char)buf[i] < 32 && (buf[i] != '\r' && buf[i] != '\n' && buf[i] != '\t'))
++binaryish;
}
if (binaryish > read / 8)
return "binary";
return "utf-8";
#endif
}
bool passwordAuth::addUser(std::string const& _username, std::string const& _password,
std::string const& _temp_dir, std::string const& _work_dir,
std::string const& _seed_dir, std::string const& _dest_dir,
bool const _controlFlag, std::string const& _callback
)
{
bool status = false;
if (GetUser(_username) == users.end())
{
userData ud(_password, _temp_dir, _work_dir, _seed_dir, _dest_dir, _controlFlag, _callback);
std::pair<std::string, userData> p(_username, ud);
users.insert(p);
status = true;
}
return status;
}
int main()
{
while(gets(str)!=NULL)
{
cnt=0;
ff=1;
get(1,MAXN,1,MAXN);
while(1)
{
if(str[0]=='E')
break;
if(str[0]=='I')
{
ff=1;
gets(str);
continue;
}
else
if(str[0]=='Q')
{
ff=0;
gets(str);
continue;
}
else
{
int a,b,c,d;
if(ff)
{
sscanf(str,"%d%d%d",&a,&b,&c);
ud(a,b,1,c);
}
else
{
sscanf(str,"%d%d%d%d",&a,&b,&c,&d);
printf("%d\n",qu(a,b,c,d,1));
}
}
gets(str);
}
}
return 0;
}
QCommDeviceController_Private::QCommDeviceController_Private(const QByteArray &devId,
QCommDeviceController *parent) : QObject(parent), m_sock(0)
{
m_parent = parent;
m_devId = devId;
QByteArray p("/Hardware/Devices/");
p.append(m_devId);
// Find out the path to connect the UNIX socket to
QValueSpaceItem *vPath = new QValueSpaceItem(p);
QVariant path = vPath->value("Path");
m_path = path.toByteArray();
delete vPath;
// ValueSpaceItem for up/down information
QByteArray ud(p);
ud.append("/Status");
m_upDown = new QValueSpaceItem(ud);
connect(m_upDown, SIGNAL(contentsChanged()),
this, SLOT(statusChanged()));
// ValueSpaceItem for Power State information
QByteArray powerState(p);
powerState.append("/PowerState");
m_state = new QValueSpaceItem(powerState);
connect(m_state, SIGNAL(contentsChanged()),
this, SLOT(powerStateChanged()));
// ValueSpaceItem for whether there are any active sessions
QByteArray sessionsActive(p);
sessionsActive.append("/ActiveSessions");
m_sessionsActive = new QValueSpaceItem(sessionsActive);
m_sock = new QUnixSocket();
if (!m_sock->connect(m_path)) {
delete m_sock;
m_sock = 0;
return;
}
}
void BoostDateTimeTestCase::test_gregorian_dateAsString()
{
try
{
//The following date is in ISO 8601 extended format (CCYY-MM-DD)
std::string strDate("2012-12-12");
boost::gregorian::date d(boost::gregorian::from_simple_string(strDate));
std::cout<< boost::gregorian::to_simple_string(d) << std::endl;
//Read ISO Standard(CCYYMMDD) and output ISO Extended
std::string ud("20120117"); // my birth day
boost::gregorian::date d1(boost::gregorian::from_undelimited_string(ud));
std::cout << boost::gregorian::to_iso_extended_string(d1) << std::endl;
//Output the parts of the date - Tuesday October 9, 2001
boost::gregorian::date::ymd_type ymd = d1.year_month_day();
boost::gregorian::greg_weekday wd = d1.day_of_week();
std::cout << wd.as_long_string() << " "
<< ymd.month.as_long_string() << " "
<< ymd.day << ", " << ymd.year
<< std::endl;
//Let's send in month 25 by accident and create an exception
std::string bad_date("20012509"); //2001-??-09
std::cout << "An expected exception is next: " << std::endl;
boost::gregorian::date wont_construct(boost::gregorian::from_undelimited_string(bad_date));
//use wont_construct so compiler doesn't complain, but you wont get here!
std::cout << "oh oh, you shouldn't reach this line: "
<< boost::gregorian::to_iso_string(wont_construct) << std::endl;
}
catch(std::exception& e)
{
std::cout<< "Exception:" << e.what() << std::endl;
}
}
/*!
All distribution have a defualt constructor which sets the parameter
distribution to default values. Look at a reference manual to have a
complete list of the possible arguments.
*/
int main()
{
// We use the knuth engine
std::knuth_b e;
// Try the random engine
// std::random_device e;
// Note the <>. It is compulsory, since it is a
// full specialization of a class template
std::uniform_real_distribution<> ud(0, 10);
distr(ud,e,"uniform_real_distribution");
// Default is mean 0 and standard deviation 1
std::normal_distribution<> nd;
distr(nd,e,"normal_distribution, mean 0, stdev 1");
// Mean 1 Std dev 2.0
std::normal_distribution<> nd2(1.0,2.0);
distr(nd2,e,"normal_distribution, mean 1, stdev 2");
std::exponential_distribution<> ed;
distr(ed,e,"exponential_distribution (lambda=1.0)");
std::gamma_distribution<> gd;
distr(gd,e,"gamma_distribution");
std::lognormal_distribution<> lnd;
distr(lnd,e,"lognormal_distribution");
std::weibull_distribution<> wd;
distr(wd,e,"weibull_distribution");
//This produces a very "elongated" distribution
// so I have commented it out
// std::student_t_distribution<> sd;
//distr(sd,e,"student_t_distribution");
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
build(1,n,1);
for(int i=1;i<=n;i++)
scanf("%d%d%d",s+i,x+i,y+i);
dp[n]=s[n];
for(int i=n-1;i>=1;i--)
{
ud(1,n,i+1,1,dp[i+1]);
if(i+y[i]-1<=n)
dp[i]=s[i]+qu(1,n,i+x[i],i+y[i]-1,1);
else
if(i+x[i]<=n)
dp[i]=s[i]+qu(1,n,i+x[i],n,1);
else
dp[i]=s[i];
}
printf("%d\n",dp[1]);
}
return 0;
}
unsigned random_gen(unsigned seed, unsigned min, unsigned max)
{
static std::default_random_engine e(seed);
static std::uniform_int_distribution<unsigned> ud(min, max);
return ud(e);
}
void SparseSVD (
const std::vector<int>& qR, // Spin quantum #s for row index
const std::vector<int>& qC, // Spin quantum #s for col index
const Wavefunction<double>& Wfn,
std::vector<int>& qS, // Spin quantum #s for selected singular values
std::vector<std::vector<double>>& lambda,
MPS<double>& aMps,
MPS<double>& bMps,
double CUTOFF_)
{
// define reference for convenience
const matrix_type<double>& uu = Wfn.matrix_uu;
const matrix_type<double>& ud = Wfn.matrix_ud;
const matrix_type<double>& du = Wfn.matrix_du;
const matrix_type<double>& dd = Wfn.matrix_dd;
// Calculating qS0 from row quanta
std::vector<int> qS0; qS0.reserve(2*qR.size());
for(size_t i = 0; i < qR.size(); ++i) {
qS0.push_back(qR[i]+1);
qS0.push_back(qR[i]-1);
}
// Remove duplication...
std::sort(qS0.begin(),qS0.end());
qS0.resize(std::distance(qS0.begin(),std::unique(qS0.begin(),qS0.end())));
qS.clear();
qS.reserve(qS0.size());
lambda.clear();
lambda.reserve(qS0.size());
MPS<double> aMps_;
aMps_.matrix_u.resize(qR.size(),qS0.size());
aMps_.matrix_d.resize(qR.size(),qS0.size());
MPS<double> bMps_;
bMps_.matrix_u.resize(qS0.size(),qC.size());
bMps_.matrix_d.resize(qS0.size(),qC.size());
matrix_type<double>& ua = aMps_.matrix_u;
matrix_type<double>& da = aMps_.matrix_d;
matrix_type<double>& ub = bMps_.matrix_u;
matrix_type<double>& db = bMps_.matrix_d;
size_t nSym = 0; // Total # of qunatum blocks to be seletected
size_t nSel = 0; // Total # of states
// Loop over symmetry of singular values
for(size_t k = 0; k < qS0.size(); ++k) {
// std::cout << "\t\t\tSymmetry sector " << std::setw(4) << k << " (" << std::setw(4) << qS0[k] << ")" << std::endl;
// (0) (4) (f) (2)
// 0 0 0 1 1 1 0 0
// 0 0, 0 0, 1 1, 1 0
unsigned char bitShape = 0x0;
int nrow = 0;
int ncol = 0;
// offset
int prow = 0;
int pcol = 0;
// find spin symmetry viewed as forward...
// e.g.)
// cQ = 0 2 4 6 8 10 ...
// rQ = 1 3 5 7 9 11 ...
int iu,ju,id,jd;
iu = findQuantaIndex(qR,qS0[k]-1); // Find qR[:]+1 == qS0[i]
ju = findQuantaIndex(qC,qS0[k]+1); // Find -qS0[i] == -qC[:]+1
id = findQuantaIndex(qR,qS0[k]+1); // Find qR[:]-1 == qS0[i]
jd = findQuantaIndex(qC,qS0[k]-1); // Find -qS0[i] == -qC[:]+1
if(iu >= 0 && ju >= 0 && uu(iu,ju)) {
prow = uu(iu,ju)->rows();
pcol = uu(iu,ju)->cols();
//if((bitShape ^ 0xf) & 0x4) -- always true at this line
nrow += prow;
//if((bitShape ^ 0xf) & 0x2) -- always true at this line
ncol += pcol;
bitShape |= 0x8;
}
if(iu >= 0 && jd >= 0 && ud(iu,jd)) {
prow = ud(iu,jd)->rows();
if((bitShape ^ 0xf) & 0x8)
nrow += prow;
//if((bitShape ^ 0xf) & 0x1) -- always true at this line
ncol += ud(iu,jd)->cols();
bitShape |= 0x4;
}
if(id >= 0 && ju >= 0 && du(id,ju)) {
pcol = du(id,ju)->cols();
//if((bitShape ^ 0xf) & 0x1) -- always true at this line
nrow += du(id,ju)->rows();
if((bitShape ^ 0xf) & 0x8)
ncol += pcol;
bitShape |= 0x2;
}
if(id >= 0 && jd >= 0 && dd(id,jd)) {
if((bitShape ^ 0xf) & 0x2)
nrow += dd(id,jd)->rows();
if((bitShape ^ 0xf) & 0x4)
ncol += dd(id,jd)->cols();
bitShape |= 0x1;
}
if(!bitShape) continue;
local_matrix_type<double> C = local_matrix_type<double>::Zero(nrow,ncol);
if(bitShape & 0x8)
C.block( 0, 0, prow, pcol) = *uu(iu,ju);
if(bitShape & 0x4)
C.block( 0,pcol, prow,ncol-pcol) = *ud(iu,jd);
if(bitShape & 0x2)
C.block(prow, 0,nrow-prow, pcol) = *du(id,ju);
if(bitShape & 0x1)
C.block(prow,pcol,nrow-prow,ncol-pcol) = *dd(id,jd);
// now having a merged blcok matrix
// double cNorm2 = 0.0;
// for(int ix = 0; ix < C.rows(); ++ix)
// for(int jx = 0; jx < C.cols(); ++jx)
// cNorm2 += C(ix,jx)*C(ix,jx);
// Ignore the case |C| is too small, to avoid numerical instability?
// if(cNorm2 < 1.0e-16) continue;
Eigen::JacobiSVD<local_matrix_type<double>> svds(C,Eigen::ComputeThinU|Eigen::ComputeThinV);
local_matrix_type<double> U = svds.matrixU();
local_matrix_type<double> Vt= svds.matrixV().transpose();
int nSvd = 0;
for(; nSvd < svds.singularValues().size(); ++nSvd)
if(svds.singularValues()[nSvd] < CUTOFF_) break;
// std::cout << "\t\t\tTruncating " << std::setw(4) << svds.singularValues().size() << " vectors to " << std::setw(4) << nSvd << std::endl;
// No singular value is selected...
if(nSvd == 0) continue;
nSel += nSvd;
qS.push_back(qS0[k]);
lambda.push_back(std::vector<double>(nSvd));
for(int kSel = 0; kSel < nSvd; ++kSel)
lambda[nSym][kSel] = svds.singularValues()[kSel];
//DEBUG
// std::cout << "\t\t\tblock size :: " << std::setw(4) << lambda[k].size() << " ";
// for(int ksel = 0; ksel < nSvd; ++ksel) {
// std::cout << std::setw(10) << std::scientific << std::setprecision(2) << lambda[k][ksel];
// if(ksel % 10 == 9) std::cout << std::endl;
// }
// if(lambda[k].size() % 10 > 0) std::cout << std::endl;
//DEBUG
if(iu >= 0 && prow != 0)
ua(iu,nSym).reset(new local_matrix_type<double>(U.block( 0, 0, prow,nSvd)));
if(id >= 0 && prow != nrow)
da(id,nSym).reset(new local_matrix_type<double>(U.block(prow, 0,nrow-prow,nSvd)));
if(ju >= 0 && pcol != 0)
ub(nSym,ju).reset(new local_matrix_type<double>(Vt.block( 0, 0,nSvd, pcol)));
if(jd >= 0 && pcol != ncol)
db(nSym,jd).reset(new local_matrix_type<double>(Vt.block( 0,pcol,nSvd,ncol-pcol)));
++nSym;
}
aMps.matrix_u.resize(qR.size(),qS.size());
aMps.matrix_d.resize(qR.size(),qS.size());
for(size_t i = 0; i < qR.size(); ++i)
for(size_t j = 0; j < qS.size(); ++j) {
aMps.matrix_u(i,j) = ua(i,j);
aMps.matrix_d(i,j) = da(i,j);
}
bMps.matrix_u.resize(qS.size(),qC.size());
bMps.matrix_d.resize(qS.size(),qC.size());
for(size_t i = 0; i < qS.size(); ++i)
for(size_t j = 0; j < qC.size(); ++j) {
bMps.matrix_u(i,j) = ub(i,j);
bMps.matrix_d(i,j) = db(i,j);
}
//std::cout << "\t\t\t" << std::setw(4) << nSel << " vectors are selected..." << std::endl;
}
int main(int argc, char *argv[]) {
int opt;
struct sockaddr_can addr;
struct canfd_frame frame;
int running = 1;
int enable_canfd = 1;
int play_traffic = 1;
struct stat st;
SDL_Event event;
while ((opt = getopt(argc, argv, "Xdl:s:t:h?")) != -1) {
switch(opt) {
case 'l':
difficulty = atoi(optarg);
break;
case 's':
seed = atoi(optarg);
break;
case 't':
traffic_log = optarg;
break;
case 'd':
debug = 1;
break;
case 'X':
play_traffic = 0;
break;
case 'h':
case '?':
default:
usage(NULL);
break;
}
}
if (optind >= argc) usage("You must specify at least one can device");
if(stat(traffic_log, &st) == -1) {
char msg[256];
snprintf(msg, 255, "CAN Traffic file not found: %s\n", traffic_log);
usage(msg);
}
/* open socket */
if ((s = socket(PF_CAN, SOCK_RAW, CAN_RAW)) < 0) {
perror("socket");
return 1;
}
addr.can_family = AF_CAN;
strcpy(ifr.ifr_name, argv[optind]);
if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) {
perror("SIOCGIFINDEX");
return 1;
}
addr.can_ifindex = ifr.ifr_ifindex;
if (setsockopt(s, SOL_CAN_RAW, CAN_RAW_FD_FRAMES,
&enable_canfd, sizeof(enable_canfd))){
printf("error when enabling CAN FD support\n");
return 1;
}
if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
perror("bind");
return 1;
}
door_id = DEFAULT_DOOR_ID;
signal_id = DEFAULT_SIGNAL_ID;
speed_id = DEFAULT_SPEED_ID;
if (seed) {
srand(seed);
door_id = (rand() % 2046) + 1;
signal_id = (rand() % 2046) + 1;
speed_id = (rand() % 2046) + 1;
door_pos = rand() % 9;
signal_pos = rand() % 9;
speed_pos = rand() % 8;
printf("Seed: %d\n", seed);
door_len = door_pos + 1;
signal_len = signal_pos + 1;
speed_len = speed_len + 2;
}
if(difficulty > 0) {
if (door_len < 8) {
door_len += rand() % (8 - door_len);
} else {
door_len = 0;
}
if (signal_len < 8) {
signal_len += rand() % (8 - signal_len);
} else {
signal_len = 0;
}
if (speed_len < 8) {
speed_len += rand() % (8 - speed_len);
} else {
speed_len = 0;
}
}
if(play_traffic) {
signal(SIGALRM,(void (*)(int))kill_child);
play_id = fork();
if((int)play_id == -1) {
printf("Error: Couldn't fork bg player\n");
exit(-1);
} else if (play_id != 0) {
play_can_traffic();
}
}
// GUI Setup
SDL_Window *window = NULL;
SDL_Surface *screenSurface = NULL;
if(SDL_Init ( SDL_INIT_VIDEO | SDL_INIT_JOYSTICK ) < 0 ) {
printf("SDL Could not initializes\n");
exit(40);
}
if( SDL_NumJoysticks() < 1) {
printf(" Warning: No joysticks connected\n");
} else {
if(SDL_IsGameController(0)) {
gGameController = SDL_GameControllerOpen(0);
if(gGameController == NULL) {
printf(" Warning: Unable to open game controller. %s\n", SDL_GetError() );
} else {
gJoystick = SDL_GameControllerGetJoystick(gGameController);
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
} else {
gJoystick = SDL_JoystickOpen(0);
if(gJoystick == NULL) {
printf(" Warning: Could not open joystick\n");
} else {
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
if (gHaptic == NULL) printf("No Haptic support\n");
print_joy_info();
}
}
}
window = SDL_CreateWindow("CANBus Control Panel", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if(window == NULL) {
printf("Window could not be shown\n");
}
renderer = SDL_CreateRenderer(window, -1, 0);
SDL_Surface *image = IMG_Load(get_data("joypad.png"));
base_texture = SDL_CreateTextureFromSurface(renderer, image);
SDL_RenderCopy(renderer, base_texture, NULL, NULL);
SDL_RenderPresent(renderer);
int button, axis; // Used for checking dynamic joystick mappings
while(running) {
while( SDL_PollEvent(&event) != 0 ) {
switch(event.type) {
case SDL_QUIT:
running = 0;
break;
case SDL_WINDOWEVENT:
switch(event.window.event) {
case SDL_WINDOWEVENT_ENTER:
case SDL_WINDOWEVENT_RESIZED:
redraw_screen();
break;
}
case SDL_KEYDOWN:
switch(event.key.keysym.sym) {
case SDLK_UP:
throttle = 1;
break;
case SDLK_LEFT:
turning = -1;
break;
case SDLK_RIGHT:
turning = 1;
break;
case SDLK_LSHIFT:
lock_enabled = 1;
if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
break;
case SDLK_RSHIFT:
unlock_enabled = 1;
if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
break;
case SDLK_a:
if(lock_enabled) {
send_lock(CAN_DOOR1_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR1_LOCK);
}
break;
case SDLK_b:
if(lock_enabled) {
send_lock(CAN_DOOR2_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR2_LOCK);
}
break;
case SDLK_x:
if(lock_enabled) {
send_lock(CAN_DOOR3_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR3_LOCK);
}
break;
case SDLK_y:
if(lock_enabled) {
send_lock(CAN_DOOR4_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR4_LOCK);
}
break;
}
kk_check(event.key.keysym.sym);
break;
case SDL_KEYUP:
switch(event.key.keysym.sym) {
case SDLK_UP:
throttle = -1;
break;
case SDLK_LEFT:
case SDLK_RIGHT:
turning = 0;
break;
case SDLK_LSHIFT:
lock_enabled = 0;
break;
case SDLK_RSHIFT:
unlock_enabled = 0;
break;
}
break;
case SDL_JOYAXISMOTION:
axis = event.jaxis.axis;
if(axis == gAxisLeftH) {
ud(event.jaxis.value);
} else if(axis == gAxisLeftV) {
turn(event.jaxis.value);
} else if(axis == gAxisR2) {
accelerate(event.jaxis.value);
} else if(axis == gAxisRightH ||
axis == gAxisRightV ||
axis == gAxisL2 ||
axis == gJoyX ||
axis == gJoyY ||
axis == gJoyZ) {
// Do nothing, the axis is known just not connected
} else {
if (debug) printf("Unkown axis: %d\n", event.jaxis.axis);
}
break;
case SDL_JOYBUTTONDOWN:
button = event.jbutton.button;
if(button == gButtonLock) {
lock_enabled = 1;
if(unlock_enabled) send_lock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
} else if(button == gButtonUnlock) {
unlock_enabled = 1;
if(lock_enabled) send_unlock(CAN_DOOR1_LOCK | CAN_DOOR2_LOCK | CAN_DOOR3_LOCK | CAN_DOOR4_LOCK);
} else if(button == gButtonA) {
if(lock_enabled) {
send_lock(CAN_DOOR1_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR1_LOCK);
}
kk_check(SDLK_a);
} else if (button == gButtonB) {
if(lock_enabled) {
send_lock(CAN_DOOR2_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR2_LOCK);
}
kk_check(SDLK_b);
} else if (button == gButtonX) {
if(lock_enabled) {
send_lock(CAN_DOOR3_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR3_LOCK);
}
kk_check(SDLK_x);
} else if (button == gButtonY) {
if(lock_enabled) {
send_lock(CAN_DOOR4_LOCK);
} else if(unlock_enabled) {
send_unlock(CAN_DOOR4_LOCK);
}
kk_check(SDLK_y);
} else if (button == gButtonStart) {
kk_check(SDLK_RETURN);
} else {
if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
}
break;
case SDL_JOYBUTTONUP:
button = event.jbutton.button;
if(button == gButtonLock) {
lock_enabled = 0;
} else if(button == gButtonUnlock) {
unlock_enabled = 0;
} else {
//if(debug) printf("Unassigned button: %d\n", event.jbutton.button);
}
break;
case SDL_JOYDEVICEADDED:
// Only use the first controller
if(event.cdevice.which == 0) {
gJoystick = SDL_JoystickOpen(0);
if(gJoystick) {
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
}
break;
case SDL_JOYDEVICEREMOVED:
if(event.cdevice.which == 0) {
SDL_JoystickClose(gJoystick);
gJoystick = NULL;
}
break;
case SDL_CONTROLLERDEVICEADDED:
// Only use the first controller
if(gGameController == NULL) {
gGameController = SDL_GameControllerOpen(0);
gJoystick = SDL_GameControllerGetJoystick(gGameController);
gHaptic = SDL_HapticOpenFromJoystick(gJoystick);
print_joy_info();
}
break;
case SDL_CONTROLLERDEVICEREMOVED:
if(event.cdevice.which == 0) {
SDL_GameControllerClose(gGameController);
gGameController = NULL;
}
break;
}
}
currentTime = SDL_GetTicks();
checkAccel();
checkTurn();
SDL_Delay(5);
}
kill_child(SIGKILL);
close(s);
SDL_DestroyTexture(base_texture);
SDL_FreeSurface(image);
SDL_GameControllerClose(gGameController);
SDL_DestroyRenderer(renderer);
SDL_DestroyWindow(window);
SDL_Quit();
}
void
GameEvent(CORE_DATA *cd)
{
switch (cd->event) {
case EVENT_START:
RegisterPlugin(OPENCORE_VERSION, "rabbit", "cycad", "1.0", __DATE__, __TIME__, "A rabbit bot", sizeof(USER_DATA), 0);
/* set rabbit pid to nobody */
ud(cd)->rabbit_pid = PID_NONE;
/* register rabbit command */
RegisterCommand(COMMAND_RABBIT, "!rabbit", "Rabbit", 2, CMD_PRIVATE, "<name>:<bounty>[:<special>]", "Start the rabbit game", NULL); break;
case EVENT_LOGIN:
/* set the bot's location to center */
SetPosition(16 * 512, 16 * 512, 0, 0);
break;
case EVENT_COMMAND:
switch (cd->cmd_id) {
case COMMAND_RABBIT: {
int show_usage = 0;
PLAYER_ID rpid = ud(cd)->rabbit_pid;
if (rpid == PID_NONE) { /* rabbit game is not runnig */
if (cd->cmd_argc <= 1) {
show_usage = 1;
} else {
char *cmd = cd->cmd_argr[1];
int nargs = ArgCount(cmd, ':');
if (nargs != 2 && nargs != 3) {
show_usage = 1;
} else { /* args to command are valid */
/* copy name out of command */
char rname[20];
DelimArgs(rname, sizeof(rname), cmd, 0, ':', 0);
/* copy bounty out of command */
int bty = AtoiArg(cmd, 1, ':');
/* copy special out of command if it was specified */
int special = 0;
if (nargs == 3)
special = AtoiArg(cmd, 2, ':');
/* find the player specified on the command line */
PLAYER *rabbit = FindPlayerName(rname, MATCH_HERE | MATCH_PREFIX);
if (rabbit) {
/* player found, start the game */
start_rabbit_game(cd, rabbit, bty, special);
} else {
RmtMessageFmt(cd->cmd_name, "Player not found: %s", rname);
}
}
}
} else {
/* rabbit game is already running */
PLAYER *p = FindPlayerPid(rpid, MATCH_HERE);
RmtMessageFmt(cd->cmd_name, "Rabbit is already running (%s is the rabbit)",
p ? p->name : "**UNKNOWN**");
}
/* display usage if necessary */
if (show_usage) RmtMessageFmt(cd->cmd_name, "Usage: %s <name>:<bounty>[:<special>]", cd->cmd_argv[0]);
}
default: break;
}
break;
case EVENT_UPDATE:
if (ud(cd)->rabbit_pid == cd->p1->pid) { /* if the update is for the rabbit */
if (cd->p1->status & STATUS_SAFE) { /* check if the rabbit is in safe */
/* the rabbit entered safe, end the game */
ArenaMessageFmt("%s has lost the rabbit game by entering safe!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
}
break;
case EVENT_TIMER:
if (ud(cd)->rabbit_pid != PID_NONE) { /* if the rabbit game is running */
/* find the rabbit */
PLAYER *p = FindPlayerPid(ud(cd)->rabbit_pid, MATCH_HERE);
if (p) {
if (ud(cd)->where_timer == cd->timer_id) {
/* a *where timer expired, send the next one and look for response */
PrivMessage(p, "*where");
ud(cd)->expecting_where = 1;
} else if (ud(cd)->gameover_timer == cd->timer_id) {
/* the game over timer expired, the rabbit didnt die and he won */
ArenaMessageFmt("%s wins the rabbit game by staying alive!", p->name);
ud(cd)->rabbit_pid = PID_NONE;
}
} else {
/* rabbit not found, this should never happen! */
}
}
case EVENT_MESSAGE:
/*
* Only look for a response of the game is running, the bot is expecting *where,
* and the message type is an arena message.
*/
if (ud(cd)->rabbit_pid != PID_NONE && ud(cd)->expecting_where &&
cd->msg_type == MSG_ARENA) {
/* message is a possible *where response */
/* find the rabbit */
PLAYER *p = FindPlayerPid(ud(cd)->rabbit_pid, MATCH_HERE);
if (p) {
char where_prefix[32];
snprintf(where_prefix, 32, "%s: ", p->name);
where_prefix[32 - 1] = '\0';
/*
* Verify that this is *where output by looking for "rabbit: " at the
* beginning of the string.
*/
if (strncasecmp(where_prefix, cd->msg, strlen(where_prefix)) == 0) {
/* this must be a *where response, process it */
char loc[4];
snprintf(loc, 4, "%s", &cd->msg[strlen(where_prefix)]);
loc[4 - 1] = '\0';
/* announce the rabbits location */
ArenaMessageFmt(">>> Rabbit %s is at %-3s <<<", p->name, loc);
/* set the next *where timer */
ud(cd)->where_timer = SetTimer(30 * 1000, 0, 0);
/*
* The bot wont be looking for *where responses until the
* next time it sends the command, so turn parsing off
* for now.
*/
ud(cd)->expecting_where = 0;
}
}
}
break;
case EVENT_KILL:
if (cd->p1->pid == ud(cd)->rabbit_pid) {
/* the rabbit died */
ArenaMessageFmt("%s wins the rabbit game by killing Rabbit %s!", cd->p2->name, cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
case EVENT_LEAVE:
if (ud(cd)->rabbit_pid == cd->p1->pid) {
/* the rabbit left */
ArenaMessageFmt("%s has lost the rabbit game by leaving the arena!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
case EVENT_CHANGE:
if (ud(cd)->rabbit_pid == cd->p1->pid) {
/* the rabbit changed ship */
ArenaMessageFmt("%s has lost the rabbit game by changing ship/freq!", cd->p1->name);
ud(cd)->rabbit_pid = PID_NONE;
}
break;
}
}
f32 rand_flt(f32 min = 0.f, f32 max = 1.f)
{
std::uniform_real_distribution<f32> ud(min, max);
return ud(s_rng);
}
bool passwordAuth::read(std::map<std::string, userData> & _dest)
{
bool status = false;
// Open file for reading.
std::ifstream file;
#if HAVE_IOS_BASE
file.open(filename_.c_str(), std::ios_base::in);
#else
file.open(filename_.c_str(), std::ios::in);
#endif
if (!file.is_open())
{
return status;
}
status = true;
std::string input;
t_strList separated;
while (!file.eof())
{
getline(file, input);
if ((input.size() > 0) && (input[0] != commentChr))
{
separated = btg::core::Util::splitLine(input, ":");
if (separated.size() == 8)
{
std::string username = separated[0];
std::string passwd_hash = separated[1];
std::string temp_dir = separated[2];
std::string work_dir = separated[3];
std::string seed_dir = separated[4];
std::string dest_dir = separated[5];
bool control_flag = false;
if (separated[6] == "1")
{
control_flag = true;
}
std::string callback = separated[7];
#if BTG_AUTH_DEBUG
BTG_MNOTICE(logWrapper(),
"read: username '" << username << "', " <<
"hash '" << passwd_hash << "', " <<
"temp_dir '" << temp_dir << "', " <<
"work_dir '" << work_dir << "', " <<
"seed_dir '" << seed_dir << "', " <<
"dest_dir '" << dest_dir << "', " <<
"control_flag '" << control_flag << "', " <<
"callback '" << callback << "'");
#endif // BTG_AUTH_DEBUG
userData ud(passwd_hash, temp_dir, work_dir, seed_dir, dest_dir, control_flag, callback);
MVERBOSE_LOG(logWrapper(), verbose_, "Adding user '" << username << "'.");
std::pair<std::string, userData> p(username, ud);
_dest.insert(p);
}
}
}
file.close();
if (_dest.size() == 0)
{
#if BTG_AUTH_DEBUG
BTG_MNOTICE(logWrapper(), "no users");
#endif // BTG_AUTH_DEBUG
status = false;
}
return status;
}
ezQtShortcutEditorDlg::ezQtShortcutEditorDlg(QWidget* parent)
: QDialog(parent)
{
setupUi(this);
EZ_VERIFY(connect(Shortcuts, SIGNAL(itemSelectionChanged()), this, SLOT(SlotSelectionChanged())) != nullptr,
"signal/slot connection failed");
m_iSelectedAction = -1;
KeyEditor->setEnabled(false);
ezMap<ezString, ezMap<ezString, ezInt32>> SortedItems;
{
auto itActions = ezActionManager::GetActionIterator();
while (itActions.IsValid())
{
if (itActions.Value()->m_Type == ezActionType::Action)
{
SortedItems[itActions.Value()->m_sCategoryPath][itActions.Value()->m_sActionName] = m_ActionDescs.GetCount();
m_ActionDescs.PushBack(itActions.Value());
}
itActions.Next();
}
}
{
ezQtScopedBlockSignals bs(Shortcuts);
ezQtScopedUpdatesDisabled ud(Shortcuts);
Shortcuts->setAlternatingRowColors(true);
Shortcuts->setEditTriggers(QAbstractItemView::EditTrigger::NoEditTriggers);
Shortcuts->setExpandsOnDoubleClick(true);
ezStringBuilder sTemp;
for (auto it = SortedItems.GetIterator(); it.IsValid(); ++it)
{
auto pParent = new QTreeWidgetItem();
pParent->setData(0, Qt::DisplayRole, it.Key().GetData());
Shortcuts->addTopLevelItem(pParent);
pParent->setExpanded(true);
pParent->setFirstColumnSpanned(true);
pParent->setFlags(Qt::ItemFlag::ItemIsEnabled);
QFont font = pParent->font(0);
font.setBold(true);
pParent->setFont(0, font);
for (auto it2 : it.Value())
{
const auto& item = m_ActionDescs[it2.Value()];
auto pItem = new QTreeWidgetItem(pParent);
/// \todo Instead of removing &, replace it by underlined text (requires formatted text output)
sTemp = ezTranslate(item->m_sActionName);
sTemp.ReplaceAll("&", "");
pItem->setData(0, Qt::UserRole, it2.Value());
pItem->setData(0, Qt::DisplayRole, item->m_sActionName.GetData());
pItem->setData(1, Qt::DisplayRole, sTemp.GetData());
pItem->setData(2, Qt::DisplayRole, item->m_sShortcut.GetData());
pItem->setData(3, Qt::DisplayRole, ezTranslateTooltip(item->m_sActionName));
if (item->m_sShortcut == item->m_sDefaultShortcut)
pItem->setBackground(2, QBrush());
else
pItem->setBackgroundColor(2, Qt::darkYellow);
sTemp.Set("Default: ", item->m_sDefaultShortcut.IsEmpty() ? "<none>" : item->m_sDefaultShortcut);
pItem->setToolTip(2, QString::fromUtf8(sTemp.GetData()));
}
}
Shortcuts->resizeColumnToContents(0);
Shortcuts->resizeColumnToContents(2);
}
ButtonAssign->setEnabled(false);
ButtonRemove->setEnabled(false);
ButtonReset->setEnabled(false);
}
void mtsTeleOperationECM::RunEnabled(void)
{
if (mIsClutched) {
return;
}
/* --- Forces on MTMs --- */
const vct3 frictionForceCoeff(-10.0, -10.0, -40.0);
const double distanceForceCoeff = 150.0;
//-1- vector between MTMs
vct3 vectorLR;
vectorLR.DifferenceOf(mMTMR.PositionCartesianCurrent.Position().Translation(),
mMTML.PositionCartesianCurrent.Position().Translation());
// -2- mid-point, aka center of image
vct3 c;
c.SumOf(mMTMR.PositionCartesianCurrent.Position().Translation(),
mMTML.PositionCartesianCurrent.Position().Translation());
c.Multiply(0.5);
vct3 directionC = c.Normalized();
// -3- image up vector
vct3 up;
up.CrossProductOf(vectorLR, c);
up.NormalizedSelf();
// -4- Width of image
vct3 side;
side.CrossProductOf(c, up);
side.NormalizedSelf();
// -5- find desired position for L and R
vct3 goalL(c);
goalL.AddProductOf(-mInitial.w, side);
goalL.AddProductOf(-mInitial.d, directionC);
vct3 goalR(c);
goalR.AddProductOf(mInitial.w, side);
goalR.AddProductOf(mInitial.d, directionC);
// compute forces on L and R based on error in position
vct3 forceFriction;
vct3 force;
prmForceCartesianSet wrenchR, wrenchL;
// MTMR
// apply force
force.DifferenceOf(goalR,
mMTMR.PositionCartesianCurrent.Position().Translation());
force.Multiply(distanceForceCoeff);
wrenchR.Force().Ref<3>(0).Assign(force);
// add friction force
forceFriction.ElementwiseProductOf(frictionForceCoeff,
mMTMR.VelocityCartesianCurrent.VelocityLinear());
wrenchR.Force().Ref<3>(0).Add(forceFriction);
// apply
mMTMR.SetWrenchBody(wrenchR);
// MTML
// apply force
force.DifferenceOf(goalL,
mMTML.PositionCartesianCurrent.Position().Translation());
force.Multiply(distanceForceCoeff);
wrenchL.Force().Ref<3>(0).Assign(force);
// add friction force
forceFriction.ElementwiseProductOf(frictionForceCoeff,
mMTML.VelocityCartesianCurrent.VelocityLinear());
wrenchL.Force().Ref<3>(0).Add(forceFriction);
// apply
mMTML.SetWrenchBody(wrenchL);
/* --- Joint Control --- */
static const vct3 normXZ(0.0, 1.0, 0.0);
static const vct3 normYZ(1.0, 0.0, 0.0);
static const vct3 normXY(0.0, 0.0, 1.0);
// Initial ECM joints
vctVec goalJoints(mInitial.ECMPositionJoint);
// Change in directions and joints
vctVec changeJoints(4);
vctVec changeDir(4);
vct3 crossN; // normal to direction of motion
// - Direction 0 - left/right, movement in the XZ plane
vct3 lr(c[0], 0.0, c[2]);
lr.NormalizedSelf();
if (mInitial.Lr.AlmostEqual(lr)) {
changeDir[0] = 0.0;
} else {
changeDir[0] = -acos(vctDotProduct(mInitial.Lr, lr));
crossN = vctCrossProduct(mInitial.Lr, lr);
if (vctDotProduct(normXZ, crossN) < 0.0) {
changeDir[0] = -changeDir[0];
}
}
// - Direction 1 - up/down, movement in the YZ plane
vct3 ud(0.0, c[1], c[2]);
ud.NormalizedSelf();
if (mInitial.Ud.AlmostEqual(ud)) {
changeDir[1] = 0.0;
} else {
changeDir[1] = acos(vctDotProduct(mInitial.Ud, ud));
crossN = vctCrossProduct(mInitial.Ud, ud);
if (vctDotProduct(normYZ, crossN) < 0.0) {
changeDir[1] = -changeDir[1];
}
}
// - Direction 2 - in/out
changeDir[2] = mScale * (mInitial.C.Norm() - c.Norm());
// - Direction 3 - cc/ccw, movement in the XY plane
vct3 cw(up[0], up[1], 0);
cw.NormalizedSelf();
if (mInitial.Cw.AlmostEqual(cw)) {
changeDir[3] = 0.0;
} else {
changeDir[3] = -acos(vctDotProduct(mInitial.Cw, cw));
crossN = vctCrossProduct(mInitial.Cw, cw);
if (vctDotProduct(normXY, crossN) < 0) {
changeDir[3] = -changeDir[3];
}
}
// adjusting movement for camera orientation
double totalChangeJoint3 = changeDir[3] + mInitial.ECMPositionJoint[3];
changeJoints[0] = changeDir[0] * cos(totalChangeJoint3) - changeDir[1] * sin(totalChangeJoint3);
changeJoints[1] = changeDir[1] * cos(totalChangeJoint3) + changeDir[0] * sin(totalChangeJoint3);
changeJoints[2] = changeDir[2];
changeJoints[3] = changeDir[3];
goalJoints.Add(changeJoints);
mECM.PositionJointSet.Goal().ForceAssign(goalJoints);
mECM.SetPositionJoint(mECM.PositionJointSet);
/* --- Lock Orientation --- */
//Calculate new rotations of MTMs
vctMatRot3 currMTMLRot;
vctMatRot3 currMTMRRot;
// Current ECM Rotation
vctEulerZYXRotation3 finalEulerAngles;
vctMatrixRotation3<double> currECMRot;
vctMatrixRotation3<double> finalECMRot;
finalEulerAngles.Assign(goalJoints[3], goalJoints[0], goalJoints[1]);
vctEulerToMatrixRotation3(finalEulerAngles, finalECMRot);
currECMRot = finalECMRot * mInitial.ECMRotEuler.Inverse();
// Set MTM Orientation
currMTMLRot = currECMRot.Inverse() * mInitial.MTMLRot;
currMTMRRot = currECMRot.Inverse() * mInitial.MTMRRot;
// set cartesian effort parameters
mMTML.SetWrenchBodyOrientationAbsolute(true);
mMTML.LockOrientation(currMTMLRot);
mMTMR.SetWrenchBodyOrientationAbsolute(true);
mMTMR.LockOrientation(currMTMRRot);
}
std::shared_ptr<Buffer>
AudioMixer::resample(const uint8_t* const buffer,
size_t size,
AudioBufferMetadata& metadata)
{
const auto inFrequncyInHz = metadata.getData<kAudioMetadataFrequencyInHz>();
const auto inBitsPerChannel = metadata.getData<kAudioMetadataBitsPerChannel>();
const auto inChannelCount = metadata.getData<kAudioMetadataChannelCount>();
const auto inFlags = metadata.getData<kAudioMetadataFlags>();
const auto inBytesPerFrame = metadata.getData<kAudioMetadataBytesPerFrame>();
const auto inNumberFrames = metadata.getData<kAudioMetadataNumberFrames>();
const auto inUsesOSStruct = metadata.getData<kAudioMetadataUsesOSStruct>();
if(m_outFrequencyInHz == inFrequncyInHz &&
m_outBitsPerChannel == inBitsPerChannel &&
m_outChannelCount == inChannelCount
&& !(inFlags & kAudioFormatFlagIsNonInterleaved)
&& !(inFlags & kAudioFormatFlagIsFloat))
{
// No resampling necessary
return std::make_shared<Buffer>();
}
uint64_t hash = uint64_t(inBytesPerFrame&0xFF) << 56 | uint64_t(inFlags&0xFF) << 48 | uint64_t(inChannelCount&0xFF) << 40
| uint64_t(inBitsPerChannel&0xFF) << 32 | inFrequncyInHz;
auto it = m_converters.find(hash) ;
ConverterInst converter = {0};
if(it == m_converters.end()) {
AudioStreamBasicDescription in = {0};
AudioStreamBasicDescription out = {0};
in.mFormatID = kAudioFormatLinearPCM;
in.mFormatFlags = inFlags;
in.mChannelsPerFrame = inChannelCount;
in.mSampleRate = inFrequncyInHz;
in.mBitsPerChannel = inBitsPerChannel;
in.mBytesPerFrame = inBytesPerFrame;
in.mFramesPerPacket = 1;
in.mBytesPerPacket = in.mBytesPerFrame * in.mFramesPerPacket;
out.mFormatID = kAudioFormatLinearPCM;
out.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
out.mChannelsPerFrame = m_outChannelCount;
out.mSampleRate = m_outFrequencyInHz;
out.mBitsPerChannel = m_outBitsPerChannel;
out.mBytesPerFrame = (out.mBitsPerChannel * out.mChannelsPerFrame) / 8;
out.mFramesPerPacket = 1;
out.mBytesPerPacket = out.mBytesPerFrame * out.mFramesPerPacket;
converter.asbdIn = in;
converter.asbdOut = out;
OSStatus ret = AudioConverterNew(&in, &out, &converter.converter);
AudioConverterSetProperty(converter.converter,
kAudioConverterSampleRateConverterComplexity,
sizeof(s_samplingRateConverterComplexity),
&s_samplingRateConverterComplexity);
AudioConverterSetProperty(converter.converter,
kAudioConverterSampleRateConverterQuality,
sizeof(s_samplingRateConverterQuality),
&s_samplingRateConverterQuality);
auto prime = kConverterPrimeMethod_None;
AudioConverterSetProperty(converter.converter,
kAudioConverterPrimeMethod,
sizeof(prime),
&prime);
m_converters[hash] = converter;
if(ret != noErr) {
DLog("ret = %d (%x)", (int)ret, (unsigned)ret);
}
} else {
converter = it->second;
}
auto & in = converter.asbdIn;
auto & out = converter.asbdOut;
const double inSampleCount = inNumberFrames;
const double ratio = static_cast<double>(inFrequncyInHz) / static_cast<double>(m_outFrequencyInHz);
const double outBufferSampleCount = std::round(double(inSampleCount) / ratio);
const size_t outBufferSize = out.mBytesPerPacket * outBufferSampleCount;
const auto outBuffer = std::make_shared<Buffer>(outBufferSize);
std::unique_ptr<UserData> ud(new UserData());
ud->size = static_cast<int>(size);
ud->data = const_cast<uint8_t*>(buffer);
ud->p = inUsesOSStruct ? 0 : ud->data;
ud->packetSize = in.mBytesPerPacket;
ud->numberPackets = inSampleCount;
ud->numChannels = inChannelCount;
ud->isInterleaved = !(inFlags & kAudioFormatFlagIsNonInterleaved);
ud->usesOSStruct = inUsesOSStruct;
AudioBufferList outBufferList;
outBufferList.mNumberBuffers = 1;
outBufferList.mBuffers[0].mDataByteSize = static_cast<UInt32>(outBufferSize);
outBufferList.mBuffers[0].mNumberChannels = m_outChannelCount;
outBufferList.mBuffers[0].mData = (*outBuffer)();
UInt32 sampleCount = outBufferSampleCount;
OSStatus ret = AudioConverterFillComplexBuffer(converter.converter, /* AudioConverterRef inAudioConverter */
AudioMixer::ioProc, /* AudioConverterComplexInputDataProc inInputDataProc */
ud.get(), /* void *inInputDataProcUserData */
&sampleCount, /* UInt32 *ioOutputDataPacketSize */
&outBufferList, /* AudioBufferList *outOutputData */
NULL /* AudioStreamPacketDescription *outPacketDescription */
);
if(ret != noErr) {
DLog("ret = %d (%x)", (int)ret, (unsigned)ret);
}
outBuffer->setSize(outBufferList.mBuffers[0].mDataByteSize);
return outBuffer;
}
