int
main(int argc, char **argv, char** envp)
{
if (argc == 3 && !strcmp(argv[1], "-H")) {
hvport = atoi(argv[2]);
if (hvport < 1024 || hvport > 65000) {
printf("Invalid port\n");
exit(1);
}
/* keep program name for vpcs */
#ifdef cygwin
/* using windows native API to get 'real' path */
if (GetModuleFileName(NULL, prgname, PATH_MAX) == 0) {
#else
if (!getpath(argv[0])) {
#endif
printf("Can not get file path\n");
return 1;
}
return hypervisor(hvport);
}
/* go to vpcs */
return vpcs(argc, argv);
}
int
hypervisor(int port)
{
struct sockaddr_in serv;
int on = 1;
setsid();
#if 1
if (daemon(1, 1)) {
perror("Daemonize fail");
goto ret;
}
#endif
memset(vpcs_list, 0, MAX_DAEMONS * sizeof(struct list));
if (openpty(&ptyfdm, &ptyfds, NULL, NULL, NULL)) {
perror("Create pseudo-terminal");
goto ret;
}
signal(SIGCHLD, SIG_IGN);
signal(SIGPIPE, SIG_IGN);
fptys = fdopen(ptyfds, "w");
rls = readline_init(50, 128);
rls->fdin = ptyfds;
rls->fdout = ptyfds;
if ((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) >= 0) {
(void) setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
(char *)&on, sizeof(on));
//fcntl(sock, F_SETFD, fcntl(sock, F_GETFD) | FD_CLOEXEC);
bzero((char *) &serv, sizeof(serv));
serv.sin_family = AF_INET;
serv.sin_addr.s_addr = htonl(INADDR_ANY);
serv.sin_port = htons(port);
if (bind(sock, (struct sockaddr *) &serv, sizeof(serv)) < 0) {
perror("Daemon bind port");
goto ret;
}
if (listen(sock, 5) < 0) {
perror("Daemon listen");
goto ret;
}
loop();
close(sock);
}
ret:
if (rls)
readline_free(rls);
return 1;
}
static void*
pty_master(void *arg)
{
int i;
u_char buf[128];
while (!cmd_quit) {
memset(buf, 0, sizeof(buf));
i = read(ptyfdm, buf, sizeof(buf));
if (i > 0 && write(sock_cli, buf, i))
;
}
return NULL;
}
int
main(int argc, char **argv)
{
SDL_Window *window;
SDL_RWops *handle;
/* Enable standard application logging */
SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
if (SDL_Init(SDL_INIT_VIDEO) < 0) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't initialize SDL: %s\n", SDL_GetError());
return 1;
}
/* load the moose images */
handle = SDL_RWFromFile("moose.dat", "rb");
if (handle == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Can't find the file moose.dat !\n");
quit(2);
}
SDL_RWread(handle, MooseFrames, MOOSEFRAME_SIZE, MOOSEFRAMES_COUNT);
SDL_RWclose(handle);
/* Create the window and renderer */
window = SDL_CreateWindow("Happy Moose",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
MOOSEPIC_W*4, MOOSEPIC_H*4,
SDL_WINDOW_RESIZABLE);
if (!window) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create window: %s\n", SDL_GetError());
quit(3);
}
renderer = SDL_CreateRenderer(window, -1, 0);
if (!renderer) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create renderer: %s\n", SDL_GetError());
quit(4);
}
MooseTexture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, MOOSEPIC_W, MOOSEPIC_H);
if (!MooseTexture) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't set create texture: %s\n", SDL_GetError());
quit(5);
}
/* Loop, waiting for QUIT or the escape key */
frame = 0;
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop(loop, 0, 1);
#else
while (!done) {
loop();
}
#endif
SDL_DestroyRenderer(renderer);
quit(0);
return 0;
}
shared_ptr<Parser> loop1(shared_ptr<Parser> re)
{
return seq(re, loop(re));
}
void pulsesequence() {
/* Internal variable declarations *********************/
int shapelist90,shapelist180,shapelistte=0;
double kzero,thk2fact,thk3fact;
double te1=0.0,te1_delay,te2_delay,te3_delay,tr_delay,te_delay1=0.0,te_delay2=0.0;
double crushm0,pem0,gcrushr,gcrushp,gcrushs;
double freq90[MAXNSLICE],freq180[MAXNSLICE],freqte[MAXNSLICE];
char autocrush[MAXSTR];
/* Phase encode variables */
FILE *fp;
int tab[4096],petab[4096],odd,seg0,tabscheme;
char tabname[MAXSTR],tabfile[MAXSTR];
int i,j,k;
/* Diffusion variables */
double Gro,Gss; // "gdiff" for readout/readout refocus and slice/slice refocus
double dgro,Dgro; // delta and DELTA for readout dephase & readout
double dgss,Dgss; // delta and DELTA for excitation ss
double dgss3,Dgss3; // delta and DELTA for spin echo prep ss
double dcrush3,Dcrush3; // delta and DELTA for spin echo prep crusher
double dgss2,Dgss2; // delta and DELTA for refocus ss
double dcrush2,Dcrush2; // delta and DELTA for refocus crusher
/* Real-time variables used in this sequence **********/
int vpe_ctr = v2; // PE loop counter
int vpe_mult = v3; // PE multiplier, ranges from -PE/2 to PE/2
int vms_slices = v4; // Number of slices
int vms_ctr = v5; // Slice loop counter
int vseg = v6; // Number of ETL segments
int vseg_ctr = v7; // Segment counter
int vetl = v8; // Echo train length
int vetl_ctr = v9; // Echo train loop counter
int vpe2_steps = v10; // Number of PE2 steps
int vpe2_ctr = v11; // PE2 loop counter
int vpe2_mult = v12; // PE2 multiplier
int vpe2_offset = v13; // PE2/2 for non-table offset
int vssc = v14; // Compressed steady-states
int vtrimage = v15; // Counts down from nt, trimage delay when 0
int vacquire = v16; // Argument for setacqvar, to skip steady state acquires
int vphase180 = v17; // phase of 180 degree refocusing pulse
int vtrigblock = v18; // Number of slices per trigger block
/* Initialize paramaters ******************************/
init_mri();
kzero = getval("kzero");
getstr("autocrush",autocrush);
tabscheme = getval("tabscheme");
getstr("spoilflag",spoilflag);
/* Allow ROxPE2 projection ****************************/
if (profile[0] == 'y' && profile[1] == 'n') {
etl=1; kzero=1; nv=nv2;
} else {
/* Check kzero is valid *****************************/
if (kzero<1) kzero=1; if (kzero>etl) kzero=etl;
putCmd("kzero = %d",(int)kzero);
}
/* Set petable name and full path *********************/
sprintf(tabname,"fse%d_%d_%d",(int)nv,(int)etl,(int)kzero);
putCmd("petable = '%s'",tabname);
strcpy(tabfile,userdir);
strcat(tabfile,"/tablib/");
strcat(tabfile,tabname);
/* Generate phase encode table ************************/
if (tabscheme) { /* New scheme */
/* Calculate PE table for kzero=1 */
seg0=nseg/2;
for (j=0;j<seg0;j++) {
for (i=0;i<etl/2;i++) tab[j*(int)etl+i] = i*nseg+seg0-j;
for (i=1;i<=etl/2;i++) tab[(j+1)*(int)etl-i] = tab[j*(int)etl]-i*nseg;
}
for (j=seg0;j<nseg;j++) {
for (i=0;i<=etl/2;i++) tab[j*(int)etl+i] = i*nseg+seg0-j;
for (i=1;i<etl/2;i++) tab[(j+1)*(int)etl-i] = tab[j*(int)etl]-i*nseg;
}
/* Adjust for kzero */
for (i=0;i<nseg;i++) {
k=i*etl;
for (j=0;j<kzero-1;j++) petab[k+j]=tab[k+(int)etl-(int)kzero+j+1];
for (j=kzero-1;j<etl;j++) petab[k+j]=tab[k+j-(int)kzero+1];
}
} else { /* Original scheme */
/* Calculate PE table for kzero=1 */
odd=(int)nseg%2; seg0=nseg/2+odd;
k=0; for (i=0;i<etl;i++) for (j=seg0-odd*i%2-1;j>=0;j--) tab[j*(int)etl+i] = k--;
k=1; for (i=0;i<etl;i++) for (j=seg0-odd*i%2;j<nseg;j++) tab[j*(int)etl+i] = k++;
/* Adjust for kzero */
for (i=0;i<nseg;i++) {
k=i*etl;
for (j=0;j<kzero-1;j++) petab[k+j]=tab[k+(int)etl-j-1];
for (j=kzero-1;j<etl;j++) petab[k+j]=tab[k+j-(int)kzero+1];
}
}
/* Set petable name and full path *********************/
sprintf(tabname,"fse%d_%d_%d",(int)nv,(int)etl,(int)kzero);
putCmd("petable = '%s'",tabname);
strcpy(tabfile,userdir);
strcat(tabfile,"/tablib/");
strcat(tabfile,tabname);
/* Write to tabfile ***********************************/
fp=fopen(tabfile,"w");
fprintf(fp,"t1 =");
for (i=0;i<nseg;i++) {
fprintf(fp,"\n");
for (j=0;j<etl;j++) fprintf(fp,"%3d\t",petab[i*(int)etl+j]);
}
fclose(fp);
/* Set pelist to contain table order ******************/
putCmd("pelist = 0"); /* Re-initialize pelist */
for (i=0;i<nseg*etl;i++) putCmd("pelist[%d] = %d",i+1,petab[i]);
/* Avoid gradient slew rate errors */
for (i=0;i<nseg*etl;i++) if (abs(petab[i]) > nv/2) petab[i]=0;
/* Set phase encode table *****************************/
settable(t1,(int)etl*nseg,petab);
/* RF Power & Bandwidth Calculations ******************/
shape_rf(&p1_rf,"p1",p1pat,p1,flip1,rof1,rof2);
shape_rf(&p2_rf,"p2",p2pat,p2,flip2,rof1,rof2);
calc_rf(&p1_rf,"tpwr1","tpwr1f");
calc_rf(&p2_rf,"tpwr2","tpwr2f");
/* Calculate thk2fact to ensure gss=gss2 for the choice of p1 and p2
so that the sequence remains robust in the absence of correct
balancing of slice select and slice refocus gradients */
thk2fact=p2_rf.bandwidth/p1_rf.bandwidth;
putvalue("thk2fact",thk2fact);
/* Initialize gradient structures *********************/
init_readout(&ro_grad,"ro",lro,np,sw);
ro_grad.pad1=alfa; ro_grad.pad2=alfa;
init_readout_refocus(&ror_grad,"ror");
init_phase(&pe_grad,"pe",lpe,nv);
init_phase(&pe2_grad,"pe2",lpe2,nv2);
init_slice(&ss_grad,"ss",thk);
init_slice(&ss2_grad,"ss2",thk*thk2fact);
init_slice_refocus(&ssr_grad,"ssr");
init_dephase(&crush_grad,"crush");
/* Gradient calculations ******************************/
calc_readout(&ro_grad,WRITE,"gro","sw","at");
calc_readout_refocus(&ror_grad,&ro_grad,WRITE,"gror");
calc_phase(&pe_grad,NOWRITE,"","");
calc_phase(&pe2_grad,NOWRITE,"","");
calc_slice(&ss_grad,&p1_rf,WRITE,"gss");
calc_slice(&ss2_grad,&p2_rf,WRITE,"");
calc_slice_refocus(&ssr_grad,&ss_grad,WRITE,"gssr");
/* Equalize refocus gradient durations ****************/
calc_sim_gradient(&ror_grad,&null_grad,&ssr_grad,0.0,WRITE);
/* Equalize PE gradient durations *********************/
calc_sim_gradient(&pe_grad,&pe2_grad,&null_grad,0.0,WRITE);
/* Set crushing gradient moment ***********************/
crushm0=fabs(gcrush*tcrush);
if (spoilflag[0] == 'y') {
init_generic(&spoil_grad,"spoil",gspoil,tspoil);
calc_generic(&spoil_grad,WRITE,"gspoil","tspoil");
}
/* Create optional prepulse events ********************/
if (sat[0] == 'y') create_satbands();
if (fsat[0] == 'y') create_fatsat();
if (mt[0] == 'y') create_mtc();
if (ir[0] == 'y') create_inversion_recovery();
if (diff[0] == 'y') init_diffusion(&diffusion,&diff_grad,"diff",gdiff,tdelta);
if (diff[0] == 'y') { /* Diffusion encoding is during spin echo preparation */
spinecho[0]='y';
putCmd("spinecho='y'");
}
if (spinecho[0] == 'y') { /* spin echo preparation */
shape_rf(&p3_rf,"p3",p3pat,p3,flip3,rof1,rof2);
calc_rf(&p3_rf,"tpwr3","tpwr3f");
/* Calculate thk3fact to ensure gss=gss2=gss3 for the choice of
p1, p2 and p3 so that the sequence remains robust in the absence
of correct balancing of slice select and slice refocus gradients */
thk3fact=p3_rf.bandwidth/p1_rf.bandwidth;
putvalue("thk3fact",thk3fact);
init_slice(&ss3_grad,"ss3",thk*thk3fact);
calc_slice(&ss3_grad,&p3_rf,WRITE,"");
putvalue("gss3",ss3_grad.ssamp);
offsetlist(pss,ss3_grad.ssamp,0,freqte,ns,seqcon[1]);
shapelistte = shapelist(p3_rf.pulseName,ss3_grad.rfDuration,freqte,ns,ss3_grad.rfFraction,seqcon[1]);
/* Automatically set crushers to avoid unwanted echoes */
if (autocrush[0] == 'y') {
if (crushm0 < 0.6*ro_grad.m0) crushm0=0.6*ro_grad.m0;
}
}
/* Make sure crushing in PE dimensions does not refocus signal from 180 */
pem0 = (pe_grad.m0 > pe2_grad.m0) ? pe_grad.m0 : pe2_grad.m0;
calc_dephase(&crush_grad,WRITE,crushm0+pem0,"","");
gcrushr = crush_grad.amp*crushm0/crush_grad.m0;
gcrushp = crush_grad.amp*(crushm0+pe_grad.m0)/crush_grad.m0;
gcrushs = crush_grad.amp*(crushm0+pe2_grad.m0)/crush_grad.m0;
sgl_error_check(sglerror);
/* Set up frequency offset pulse shape list ***********/
offsetlist(pss,ss_grad.amp,0,freq90,ns,seqcon[1]);
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shapelist90 = shapelist(p1_rf.pulseName,ss_grad.rfDuration,freq90,ns,ss_grad.rfFraction,seqcon[1]);
shapelist180 = shapelist(p2_rf.pulseName,ss2_grad.rfDuration,freq180,ns,ss2_grad.rfFraction,seqcon[1]);
/* To ensure proper overlap spin and stimulated echoes ensure that the
middle of the refocusing RF pulse is the centre of the pulse and that
echoes are formed in the centre of the acquisition window */
if (ss2_grad.rfFraction != 0.5)
abort_message(
"ERROR %s: Refocusing RF pulse must be symmetric (RF fraction = %.2f)",
seqfil,ss2_grad.rfFraction);
if (ro_grad.echoFraction != 1)
abort_message("ERROR %s: Echo Fraction must be 1",seqfil);
/* Find sum of all events in each half-echo period ****/
esp = granularity(esp,2*GRADIENT_RES);
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + GRADIENT_RES;
tau2 = ss2_grad.rfCenterBack + crush_grad.duration + pe_grad.duration + ro_grad.timeToEcho + GRADIENT_RES;
tau3 = ro_grad.timeFromEcho + pe_grad.duration + crush_grad.duration + ss2_grad.rfCenterFront + GRADIENT_RES;
espmin = 2*MAX(MAX(tau1,tau2),tau3); // Minimum echo spacing
if (minesp[0] == 'y') {
esp = espmin;
putvalue("esp",esp);
}
if (FP_LT(esp,espmin)) {
abort_message("ERROR %s: Echo spacing too small, minimum is %.3fms\n",seqfil,espmin*1000);
}
te1_delay = esp/2.0 - tau1 + GRADIENT_RES; // Intra-esp delays
te2_delay = esp/2.0 - tau2 + GRADIENT_RES;
te3_delay = esp/2.0 - tau3 + GRADIENT_RES;
/* Spin echo preparation ******************************/
if (spinecho[0] == 'y') {
te = granularity(te,2*GRADIENT_RES);
te1 = te-kzero*esp;
tau1 = ss_grad.rfCenterBack + ssr_grad.duration + crush_grad.duration + ss3_grad.duration/2.0 + GRADIENT_RES;
tau2 = ss3_grad.duration/2.0 + crush_grad.duration + GRADIENT_RES;
temin = 2*MAX(tau1,tau2);
/* Diffusion */
if (diff[0] == 'y') {
/* granulate tDELTA */
tDELTA = granularity(tDELTA,GRADIENT_RES);
/* taudiff is the duration of events between diffusion gradients */
taudiff = ss3_grad.duration + 2*crush_grad.duration;
/* set minimum diffusion structure requirements for gradient echo: taudiff, tDELTA, te and minte[0] */
set_diffusion(&diffusion,taudiff,tDELTA,te1,minte[0]);
/* set additional diffusion structure requirements for spin echo: tau1 and tau2 */
set_diffusion_se(&diffusion,tau1,tau2);
/* calculate the diffusion structure delays.
address &temin is required in order to update temin accordingly */
calc_diffTime(&diffusion,&temin);
}
/* TE delays */
if (minte[0] == 'y') {
te1 = temin;
te = te1+kzero*esp;
putvalue("te",te);
}
te_delay1 = te1/2 - tau1 + GRADIENT_RES;
te_delay2 = te1/2 - tau2 + GRADIENT_RES;
if (FP_LT(te,temin+kzero*esp)) {
abort_message("ERROR %s: TE too short, minimum TE = %.3f ms\n",seqfil,temin*1000);
}
}
else
putvalue("te",kzero*esp); // Return effective TE
/* Check nsblock, the number of slices blocked together
(used for triggering and/or inversion recovery) */
check_nsblock();
/* Calculate B values *********************************/
if (ix==1) {
/* Calculate bvalues according to main diffusion gradients */
calc_bvalues(&diffusion,"dro","dpe","dsl");
/* Add components from additional diffusion encoding imaging gradients peculiar to this sequence */
/* Initialize variables */
dgro = 0.5*(ror_grad.duration+ro_grad.timeToEcho); // readout dephase & readout delta
Gro = ro_grad.m0ref/dgro; // readout dephase & readout gradient strength
Dgro = dgro+2*crush_grad.duration+ss2_grad.duration+te2_delay+pe_grad.duration; // readout dephase & readout DELTA
dgss = 0.5*(ss_grad.rfCenterBack+ssr_grad.duration); // slice & slice refocus delta
Gss = ss_grad.m0ref/dgss; // slice & slice refocus gradient strength
Dgss = dgss; // slice & slice refocus DELTA
dgss2 = (ss2_grad.duration-ss2_grad.tramp)/2.0; // refocus slice select delta
Dgss2 = dgss2; // refocus slice select DELTA
dcrush2 = crush_grad.duration-crush_grad.tramp; // refocus crusher delta
Dcrush2 = crush_grad.duration+ss2_grad.duration; // refocus crusher DELTA
dcrush3 = crush_grad.duration-crush_grad.tramp; // spin echo prep crusher delta
Dcrush3 = crush_grad.duration+ss3_grad.duration; // spin echo prep crusher DELTA
dgss3 = (ss3_grad.duration-ss3_grad.tramp)/2.0; // spin echo prep slice select delta
Dgss3 = dgss3; // spin echo prep slice select DELTA
for (i = 0; i < diffusion.nbval; i++) {
/* set droval, dpeval and dslval */
set_dvalues(&diffusion,&droval,&dpeval,&dslval,i);
/* Readout */
diffusion.bro[i] += bval(Gro,dgro,Dgro);
diffusion.bro[i] += bval(gcrushr,dcrush2,Dcrush2);
diffusion.bro[i] += bval_nested(Gro,dgro,Dgro,gcrushr,dcrush2,Dcrush2);
/* Phase */
diffusion.bpe[i] += bval(gcrushp,dcrush2,Dcrush2);
/* Slice */
diffusion.bsl[i] += bval(Gss,dgss,Dgss);
diffusion.bsl[i] += bval(gcrushs,dcrush2,Dcrush2);
diffusion.bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
diffusion.bsl[i] += bval_nested(gcrushs,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2);
/* Readout/Phase Cross-terms */
diffusion.brp[i] += bval2(gcrushr,gcrushp,dcrush2,Dcrush2);
/* Readout/Slice Cross-terms */
diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,gcrushs,dcrush2,Dcrush2);
diffusion.brs[i] += bval_cross(Gro,dgro,Dgro,ss2_grad.ssamp,dgss2,Dgss2);
diffusion.brs[i] += bval2(gcrushr,gcrushs,dcrush2,Dcrush2);
diffusion.brs[i] += bval_cross(gcrushr,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2);
/* Slice/Phase Cross-terms */
diffusion.bsp[i] += bval2(gcrushs,gcrushp,dcrush2,Dcrush2);
diffusion.bsp[i] += bval_cross(gcrushp,dcrush2,Dcrush2,ss2_grad.ssamp,dgss2,Dgss2);
if (spinecho[0] == 'y') {
/* Readout */
diffusion.bro[i] += bval(crush_grad.amp,dcrush3,Dcrush3);
diffusion.bro[i] += bval_nested(gdiff*droval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3);
/* Slice */
diffusion.bsl[i] += bval(ss3_grad.amp,dgss3,Dgss3);
diffusion.bsl[i] += bval_nested(gdiff*dslval,tdelta,tDELTA,ss3_grad.ssamp,dgss3,Dgss3);
/* Readout/Slice Cross-terms */
diffusion.brs[i] += bval_cross(gdiff*dslval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3);
diffusion.brs[i] += bval_cross(gdiff*droval,tdelta,tDELTA,ss3_grad.amp,dgss3,Dgss3);
diffusion.brs[i] += bval_cross(crush_grad.amp,dcrush3,Dcrush3,ss3_grad.amp,dgss3,Dgss3);
/* Readout/Phase Cross-terms */
diffusion.brp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,crush_grad.amp,dcrush3,Dcrush3);
/* Slice/Phase Cross-terms */
diffusion.bsp[i] += bval_cross(gdiff*dpeval,tdelta,tDELTA,ss3_grad.amp,dgss3,Dgss3);
}
} /* End for-all-directions */
/* Write the values */
write_bvalues(&diffusion,"bval","bvalue","max_bval");
}
/* Minimum TR *****************************************/
trmin = ss_grad.rfCenterFront + etl*esp + ro_grad.timeFromEcho + pe_grad.duration + te3_delay + 2*GRADIENT_RES;
if (spoilflag[0] == 'y') trmin += spoil_grad.duration;
/* Increase TR if any options are selected ************/
if (sat[0] == 'y') trmin += satTime;
if (fsat[0] == 'y') trmin += fsatTime;
if (mt[0] == 'y') trmin += mtTime;
if (spinecho[0] == 'y') trmin += te1;
if (ticks > 0) trmin += GRADIENT_RES;
/* Adjust for all slices ******************************/
trmin *= ns;
/* Inversion recovery *********************************/
if (ir[0] == 'y') {
/* tauti is the additional time beyond IR component to be included in ti */
/* satTime, fsatTime and mtTime all included as those modules will be after IR */
tauti = satTime + fsatTime + mtTime + GRADIENT_RES + ss_grad.rfCenterFront;
/* calc_irTime checks ti and returns the time of all IR components */
trmin += calc_irTime(tauti,trmin,mintr[0],tr,&trtype);
}
if (mintr[0] == 'y') {
tr = trmin;
putvalue("tr",tr);
}
if (FP_LT(tr,trmin)) {
abort_message("ERROR %s: TR too short, minimum TR = %.3fms\n",seqfil,trmin*1000);
}
/* Calculate tr delay *********************************/
tr_delay = granularity((tr-trmin)/ns,GRADIENT_RES);
/* Set number of segments for profile or full image ***/
nseg = prep_profile(profile[0],nseg,&pe_grad,&null_grad);
pe2_steps = prep_profile(profile[1],nv2,&pe2_grad,&null_grad);
F_initval(pe2_steps/2.0,vpe2_offset);
/* Shift DDR for pro **********************************/
roff = -poffset(pro,ro_grad.roamp);
/* Adjust experiment time for VnmrJ *******************/
if (ssc<0) {
if (seqcon[2] == 's' && seqcon[3]=='s') g_setExpTime(trmean*ntmean*arraydim - ssc*arraydim);
else if (seqcon[2]=='s') g_setExpTime(trmean*nseg*(ntmean*pe2_steps*arraydim - ssc*arraydim));
else if (seqcon[3]=='s') g_setExpTime(trmean*pe2_steps*(ntmean*nseg*arraydim - ssc*arraydim));
else g_setExpTime(trmean*(ntmean*pe_steps*pe2_steps*arraydim - ssc*arraydim));
}
else g_setExpTime(trmean*ntmean*nseg*pe2_steps*arraydim + tr*ssc);
/* PULSE SEQUENCE *************************************/
status(A); // Set status A
rotate(); // Set gradient rotation according to psi, phi and theta
triggerSelect(trigger); // Select trigger input 1/2/3
obsoffset(resto); // Set spectrometer frequency
delay(GRADIENT_RES); // Delay for frequency setting
initval(fabs(ssc),vssc); // Compressed steady-state counter
if (seqcon[2]=='s' && seqcon[3]=='s') assign(zero,vssc); // Zero for standard peloop and pe2loop
assign(one,vacquire); // real-time acquire flag
/* Phase cycle: Alternate 180 phase to cancel residual FID */
mod2(ct,vphase180); // 0101
dbl(vphase180,vphase180); // 0202
add(vphase180,one,vphase180); // 1313 Phase difference from 90
add(vphase180,oph,vphase180);
/* trigger */
if (ticks > 0) F_initval((double)nsblock,vtrigblock);
/* Begin phase-encode loop ****************************/
peloop2(seqcon[3],pe2_steps,vpe2_steps,vpe2_ctr);
/* Begin phase-encode loop ****************************/
peloop(seqcon[2],nseg,vseg,vseg_ctr);
if (trtype) delay(ns*tr_delay); // relaxation delay
/* Compressed steady-states: 1st array & transient, all arrays if ssc is negative */
if ((ix > 1) && (ssc > 0))
assign(zero,vssc);
if (seqcon[2] == 'c')
sub(vseg_ctr,vssc,vseg_ctr); // vseg_ctr counts up from -ssc
else if (seqcon[3] == 'c')
sub(vpe2_ctr,vssc,vpe2_ctr); // vpe2_ctr counts up from -ssc
assign(zero,vssc);
if (seqcon[2] == 's' && seqcon[3]=='s')
assign(zero,vacquire); // Always acquire for non-compressed loop
else {
if (seqcon[2] == 'c') {
ifzero(vseg_ctr);
assign(zero,vacquire); // Start acquiring when vseg_ctr reaches zero
endif(vseg_ctr);
}
else if (seqcon[3] == 'c') {
ifzero(vpe2_ctr);
assign(zero,vacquire); // Start acquiring when vpe2_ctr reaches zero
endif(vpe2_ctr);
}
}
setacqvar(vacquire); // Turn on acquire when vacquire is zero
/* Use standard encoding order for 2nd PE dimension */
ifzero(vacquire);
sub(vpe2_ctr,vpe2_offset,vpe2_mult);
elsenz(vacquire);
sub(zero,vpe2_offset,vpe2_mult);
endif(vacquire);
msloop(seqcon[1],ns,vms_slices,vms_ctr);
if (!trtype) delay(tr_delay); // Relaxation delay
if (ticks > 0) {
modn(vms_ctr,vtrigblock,vtest);
ifzero(vtest); // if the beginning of an trigger block
xgate(ticks);
grad_advance(gpropdelay);
delay(GRADIENT_RES);
elsenz(vtest);
delay(GRADIENT_RES);
endif(vtest);
}
sp1on(); delay(GRADIENT_RES); sp1off(); // Scope trigger
/* Prepulse options ***********************************/
if (ir[0] == 'y') inversion_recovery();
if (sat[0] == 'y') satbands();
if (fsat[0] == 'y') fatsat();
if (mt[0] == 'y') mtc();
/* 90 degree pulse ************************************/
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(GRADIENT_RES);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0,0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shapelist90,ss_grad.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Spin echo preparation ******************************/
if (spinecho[0] == 'y') {
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0.0,0.0,-ssr_grad.amp,WAIT);
if (diff[0] == 'y') {
delay(diffusion.d1);
diffusion_dephase(&diffusion,dro,dpe,dsl);
delay(diffusion.d2);
}
else
delay(te_delay1);
obspower(p3_rf.powerCoarse);
obspwrf(p3_rf.powerFine);
obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0.0,0.0,WAIT);
obl_shapedgradient(ss3_grad.name,ss3_grad.duration,0,0,ss3_grad.amp,NOWAIT);
delay(ss3_grad.rfDelayFront);
shapedpulselist(shapelistte,ss3_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr);
delay(ss3_grad.rfDelayBack);
obl_shapedgradient(crush_grad.name,crush_grad.duration,crush_grad.amp,0.0,0.0,WAIT);
if (diff[0] == 'y') {
delay(diffusion.d3);
diffusion_rephase(&diffusion,dro,dpe,dsl);
delay(diffusion.d4);
}
else
delay(te_delay2);
delay(ss_grad.duration/2.0);
delay(te1_delay);
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
obl_shapedgradient(ror_grad.name,ror_grad.duration,ror_grad.amp,0.0,0.0,WAIT);
}
else {
/* Read dephase and Slice refocus */
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,ror_grad.amp,0.0,-ssr_grad.amp,WAIT);
/* First half-TE delay */
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(te1_delay);
}
F_initval(etl,vetl);
loop(vetl,vetl_ctr);
mult(vseg_ctr,vetl,vpe_ctr);
add(vpe_ctr,vetl_ctr,vpe_ctr);
getelem(t1,vpe_ctr,vpe_mult);
/* 180 degree pulse *********************************/
obl_shapedgradient(crush_grad.name,crush_grad.duration,gcrushr,gcrushp,gcrushs,WAIT);
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0,0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shapelist180,ss2_grad.rfDuration,vphase180,rof1,rof2,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
obl_shapedgradient(crush_grad.name,crush_grad.duration,gcrushr,gcrushp,gcrushs,WAIT);
/* Second half-TE period ****************************/
delay(te2_delay);
/* Phase-encode gradient ****************************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,-pe_grad.increment,-pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Readout gradient *********************************/
obl_shapedgradient(ro_grad.name,ro_grad.duration,ro_grad.roamp,0,0,NOWAIT);
delay(ro_grad.atDelayFront-alfa);
/* Acquire data *************************************/
startacq(alfa);
acquire(np,1.0/sw);
endacq();
delay(ro_grad.atDelayBack);
/* Rewinding phase-encode gradient ******************/
pe2_shapedgradient(pe_grad.name,pe_grad.duration,0,0,0,pe_grad.increment,pe2_grad.increment,vpe_mult,vpe2_mult,WAIT);
/* Second half-TE delay *****************************/
delay(te3_delay);
endloop(vetl_ctr);
if (spoilflag[0] == 'y')
obl_shapedgradient(spoil_grad.name,spoil_grad.duration,spoil_grad.amp,spoil_grad.amp,spoil_grad.amp,WAIT);
endmsloop(seqcon[1],vms_ctr);
endpeloop(seqcon[2],vseg_ctr);
endpeloop(seqcon[3],vpe2_ctr);
/* Inter-image delay **********************************/
sub(ntrt,ct,vtrimage);
decr(vtrimage);
ifzero(vtrimage);
delay(trimage);
endif(vtrimage);
}
SDL_bool
WatchGameController(SDL_GameController * gamecontroller)
{
const char *name = SDL_GameControllerName(gamecontroller);
const char *basetitle = "Game Controller Test: ";
const size_t titlelen = SDL_strlen(basetitle) + SDL_strlen(name) + 1;
char *title = (char *)SDL_malloc(titlelen);
SDL_Window *window = NULL;
retval = SDL_FALSE;
done = SDL_FALSE;
if (title) {
SDL_snprintf(title, titlelen, "%s%s", basetitle, name);
}
/* Create a window to display controller state */
window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, 0);
SDL_free(title);
title = NULL;
if (window == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create window: %s\n", SDL_GetError());
return SDL_FALSE;
}
screen = SDL_CreateRenderer(window, -1, 0);
if (screen == NULL) {
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create renderer: %s\n", SDL_GetError());
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetRenderDrawColor(screen, 0x00, 0x00, 0x00, SDL_ALPHA_OPAQUE);
SDL_RenderClear(screen);
SDL_RenderPresent(screen);
SDL_RaiseWindow(window);
/* scale for platforms that don't give you the window size you asked for. */
SDL_RenderSetLogicalSize(screen, SCREEN_WIDTH, SCREEN_HEIGHT);
background = LoadTexture(screen, "controllermap.bmp", SDL_FALSE);
button = LoadTexture(screen, "button.bmp", SDL_TRUE);
axis = LoadTexture(screen, "axis.bmp", SDL_TRUE);
if (!background || !button || !axis) {
SDL_DestroyRenderer(screen);
SDL_DestroyWindow(window);
return SDL_FALSE;
}
SDL_SetTextureColorMod(button, 10, 255, 21);
SDL_SetTextureColorMod(axis, 10, 255, 21);
/* !!! FIXME: */
/*SDL_RenderSetLogicalSize(screen, background->w, background->h);*/
/* Print info about the controller we are watching */
SDL_Log("Watching controller %s\n", name ? name : "Unknown Controller");
/* Loop, getting controller events! */
#ifdef __EMSCRIPTEN__
emscripten_set_main_loop_arg(loop, gamecontroller, 0, 1);
#else
while (!done) {
loop(gamecontroller);
}
#endif
SDL_DestroyRenderer(screen);
screen = NULL;
background = NULL;
button = NULL;
axis = NULL;
SDL_DestroyWindow(window);
return retval;
}
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
/* Reset of all peripherals, Initializes the Flash interface and the Systick. */
HAL_Init();
/* Configure the system clock */
SystemClock_Config();
/* Initialize all configured peripherals */
MX_GPIO_Init();
MX_FMC_Init();
MX_I2C3_Init();
MX_LTDC_Init();
MX_SPI5_Init();
MX_UART5_Init();
MX_USART1_UART_Init();
MX_USB_OTG_HS_PCD_Init();
/* USER CODE BEGIN 2 */
/* these calls are from arduino main */
init();
initVariant();
HAL_Delay(7000); /* Wait 7 seconds to enable a serial coms channel */
/*
Usart6 is linked to printf for diagnostic use It is also mapped to
alternate function pins 12 and 14. This code is adapted from
the prinf demo in the STM32F401 Nucleo examples folder
*/
//printf("Serial backchannel enabled.\r\n");
/* Arduino optionally sets up USB callback stream here
#if defined(USBCON)
USBDevice.attach();
#endif
*/
setup();
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
while (1)
{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
loop();
/* Arduino callback if (serialEventRun) serialEventRun(); */
}
/* USER CODE END 3 */
}
/** This loop just calls loop().
* @param event includes the current and the last time stamps this function was called.
* @return error code
*/
int vorausLoop(const ros::TimerEvent& event) { return loop(event); }
void init(void)
{
uint8_t i;
drv_pwm_config_t pwm_params;
printfSupportInit();
initEEPROM();
ensureEEPROMContainsValidData();
readEEPROM();
systemState |= SYSTEM_STATE_CONFIG_LOADED;
// Configure the System clock frequency, HCLK, PCLK2 and PCLK1 prescalers
// Configure the Flash Latency cycles and enable prefetch buffer
SetSysClock(masterConfig.emf_avoidance);
detectHardwareRevision();
systemInit();
// Latch active features to be used for feature() in the remainder of init().
latchActiveFeatures();
ledInit();
if (feature(FEATURE_RX_SERIAL)) {
switch (masterConfig.rxConfig.serialrx_provider) {
case SERIALRX_SPEKTRUM1024:
case SERIALRX_SPEKTRUM2048:
// Spektrum satellite binding if enabled on startup.
// Must be called before that 100ms sleep so that we don't lose satellite's binding window after startup.
// The rest of Spektrum initialization will happen later - via spektrumInit()
spektrumBind(&masterConfig.rxConfig);
break;
}
}
delay(100);
timerInit(); // timer must be initialized before any channel is allocated
serialInit(&masterConfig.serialConfig, feature(FEATURE_SOFTSERIAL));
mixerInit(masterConfig.mixerMode, masterConfig.customMotorMixer, masterConfig.customServoMixer);
memset(&pwm_params, 0, sizeof(pwm_params));
const sonarHardware_t *sonarHardware = NULL;
if (feature(FEATURE_SONAR)) {
sonarHardware = sonarGetHardwareConfiguration(&masterConfig.batteryConfig);
sonarGPIOConfig_t sonarGPIOConfig = {
.gpio = SONAR_GPIO,
.triggerPin = sonarHardware->echo_pin,
.echoPin = sonarHardware->trigger_pin,
};
pwm_params.sonarGPIOConfig = &sonarGPIOConfig;
}
// when using airplane/wing mixer, servo/motor outputs are remapped
if (masterConfig.mixerMode == MIXER_AIRPLANE || masterConfig.mixerMode == MIXER_FLYING_WING || masterConfig.mixerMode == MIXER_CUSTOM_AIRPLANE)
pwm_params.airplane = true;
else
pwm_params.airplane = false;
pwm_params.useUART2 = doesConfigurationUsePort(SERIAL_PORT_USART2);
pwm_params.useVbat = feature(FEATURE_VBAT);
pwm_params.useSoftSerial = feature(FEATURE_SOFTSERIAL);
pwm_params.useParallelPWM = feature(FEATURE_RX_PARALLEL_PWM);
pwm_params.useRSSIADC = feature(FEATURE_RSSI_ADC);
pwm_params.useCurrentMeterADC = feature(FEATURE_CURRENT_METER)
&& masterConfig.batteryConfig.currentMeterType == CURRENT_SENSOR_ADC;
pwm_params.useLEDStrip = feature(FEATURE_LED_STRIP);
pwm_params.usePPM = feature(FEATURE_RX_PPM);
pwm_params.useSerialRx = feature(FEATURE_RX_SERIAL);
pwm_params.useSonar = feature(FEATURE_SONAR);
pwm_params.useServos = isMixerUsingServos();
pwm_params.useChannelForwarding = feature(FEATURE_CHANNEL_FORWARDING);
pwm_params.servoCenterPulse = masterConfig.escAndServoConfig.servoCenterPulse;
pwm_params.servoPwmRate = masterConfig.servo_pwm_rate;
pwm_params.useOneshot = feature(FEATURE_ONESHOT125);
pwm_params.motorPwmRate = masterConfig.motor_pwm_rate;
pwm_params.idlePulse = masterConfig.escAndServoConfig.mincommand;
if (feature(FEATURE_3D))
pwm_params.idlePulse = masterConfig.flight3DConfig.neutral3d;
if (pwm_params.motorPwmRate > 500)
pwm_params.idlePulse = 0; // brushed motors
pwmRxInit(masterConfig.inputFilteringMode);
pwmOutputConfiguration_t *pwmOutputConfiguration = pwmInit(&pwm_params);
mixerUsePWMOutputConfiguration(pwmOutputConfiguration);
if (!feature(FEATURE_ONESHOT125))
motorControlEnable = true;
systemState |= SYSTEM_STATE_MOTORS_READY;
beeperConfig_t beeperConfig = {
.gpioPeripheral = BEEP_PERIPHERAL,
.gpioPin = BEEP_PIN,
.gpioPort = BEEP_GPIO,
.gpioMode = Mode_Out_PP,
.isInverted = true
};
beeperInit(&beeperConfig);
initInverter();
spiInit(SPI1);
spiInit(SPI2);
updateHardwareRevision();
serialRemovePort(SERIAL_PORT_USART3);
i2cInit(I2C_DEVICE);
drv_adc_config_t adc_params;
adc_params.enableVBat = feature(FEATURE_VBAT);
adc_params.enableRSSI = feature(FEATURE_RSSI_ADC);
adc_params.enableCurrentMeter = feature(FEATURE_CURRENT_METER);
adc_params.enableExternal1 = true;
// optional ADC5 input on rev.5 hardware
adcInit(&adc_params);
initBoardAlignment(&masterConfig.boardAlignment);
if (feature(FEATURE_DISPLAY)) {
displayInit(&masterConfig.rxConfig);
}
if (!sensorsAutodetect(&masterConfig.sensorAlignmentConfig, masterConfig.gyro_lpf, masterConfig.acc_hardware, masterConfig.mag_hardware, masterConfig.baro_hardware, currentProfile->mag_declination)) {
// if gyro was not detected due to whatever reason, we give up now.
failureMode(FAILURE_MISSING_ACC);
}
systemState |= SYSTEM_STATE_SENSORS_READY;
LED1_ON;
LED0_OFF;
for (i = 0; i < 10; i++) {
LED1_TOGGLE;
LED0_TOGGLE;
delay(25);
BEEP_ON;
delay(25);
BEEP_OFF;
}
LED0_OFF;
LED1_OFF;
if (sensors(SENSOR_MAG))
compassInit();
imuInit();
mspInit(&masterConfig.serialConfig);
cliInit(&masterConfig.serialConfig);
failsafeInit(&masterConfig.rxConfig, masterConfig.flight3DConfig.deadband3d_throttle);
rxInit(&masterConfig.rxConfig);
if (feature(FEATURE_GPS)) {
gpsInit(
&masterConfig.serialConfig,
&masterConfig.gpsConfig
);
navigationInit(
¤tProfile->gpsProfile,
¤tProfile->pidProfile
);
}
if (feature(FEATURE_SONAR)) {
sonarInit(sonarHardware);
}
ledStripInit(masterConfig.ledConfigs, masterConfig.colors);
if (feature(FEATURE_LED_STRIP)) {
ledStripEnable();
}
if (feature(FEATURE_TELEMETRY)) {
telemetryInit();
}
m25p16_init();
flashfsInit();
initBlackbox();
previousTime = micros();
if (masterConfig.mixerMode == MIXER_GIMBAL) {
accSetCalibrationCycles(CALIBRATING_ACC_CYCLES);
}
gyroSetCalibrationCycles(CALIBRATING_GYRO_CYCLES);
baroSetCalibrationCycles(CALIBRATING_BARO_CYCLES);
// start all timers
// TODO - not implemented yet
timerStart();
ENABLE_STATE(SMALL_ANGLE);
DISABLE_ARMING_FLAG(PREVENT_ARMING);
// Now that everything has powered up the voltage and cell count be determined.
if (feature(FEATURE_VBAT | FEATURE_CURRENT_METER))
batteryInit(&masterConfig.batteryConfig);
if (feature(FEATURE_DISPLAY)) {
displayResetPageCycling();
displayEnablePageCycling();
}
// Latch active features AGAIN since some may be modified by init().
latchActiveFeatures();
motorControlEnable = true;
systemState |= SYSTEM_STATE_READY;
}
int main(void) {
init();
//Mine
printf("\r\n");
printf("Init Finished!\r\n");
printf("System Init need %d ms\r\n", millis());
printf("############# Begin Test ###############\r\n");
printf("############# End Test ###############\r\n");
while (1) {
loop();
}
}
void HardFault_Handler(void)
{
// fall out of the sky
uint8_t requiredState = SYSTEM_STATE_CONFIG_LOADED | SYSTEM_STATE_MOTORS_READY;
if ((systemState & requiredState) == requiredState) {
stopMotors();
}
while (1);
}
bool AudioBufferSourceHandler::renderFromBuffer(AudioBus* bus, unsigned destinationFrameOffset, size_t numberOfFrames)
{
ASSERT(context()->isAudioThread());
// Basic sanity checking
ASSERT(bus);
ASSERT(buffer());
if (!bus || !buffer())
return false;
unsigned numberOfChannels = this->numberOfChannels();
unsigned busNumberOfChannels = bus->numberOfChannels();
bool channelCountGood = numberOfChannels && numberOfChannels == busNumberOfChannels;
ASSERT(channelCountGood);
if (!channelCountGood)
return false;
// Sanity check destinationFrameOffset, numberOfFrames.
size_t destinationLength = bus->length();
bool isLengthGood = destinationLength <= 4096 && numberOfFrames <= 4096;
ASSERT(isLengthGood);
if (!isLengthGood)
return false;
bool isOffsetGood = destinationFrameOffset <= destinationLength && destinationFrameOffset + numberOfFrames <= destinationLength;
ASSERT(isOffsetGood);
if (!isOffsetGood)
return false;
// Potentially zero out initial frames leading up to the offset.
if (destinationFrameOffset) {
for (unsigned i = 0; i < numberOfChannels; ++i)
memset(m_destinationChannels[i], 0, sizeof(float) * destinationFrameOffset);
}
// Offset the pointers to the correct offset frame.
unsigned writeIndex = destinationFrameOffset;
size_t bufferLength = buffer()->length();
double bufferSampleRate = buffer()->sampleRate();
// Avoid converting from time to sample-frames twice by computing
// the grain end time first before computing the sample frame.
unsigned endFrame = m_isGrain ? AudioUtilities::timeToSampleFrame(m_grainOffset + m_grainDuration, bufferSampleRate) : bufferLength;
// This is a HACK to allow for HRTF tail-time - avoids glitch at end.
// FIXME: implement tailTime for each AudioNode for a more general solution to this problem.
// https://bugs.webkit.org/show_bug.cgi?id=77224
if (m_isGrain)
endFrame += 512;
// Do some sanity checking.
if (endFrame > bufferLength)
endFrame = bufferLength;
// If the .loop attribute is true, then values of m_loopStart == 0 && m_loopEnd == 0 implies
// that we should use the entire buffer as the loop, otherwise use the loop values in m_loopStart and m_loopEnd.
double virtualEndFrame = endFrame;
double virtualDeltaFrames = endFrame;
if (loop() && (m_loopStart || m_loopEnd) && m_loopStart >= 0 && m_loopEnd > 0 && m_loopStart < m_loopEnd) {
// Convert from seconds to sample-frames.
double loopStartFrame = m_loopStart * buffer()->sampleRate();
double loopEndFrame = m_loopEnd * buffer()->sampleRate();
virtualEndFrame = std::min(loopEndFrame, virtualEndFrame);
virtualDeltaFrames = virtualEndFrame - loopStartFrame;
}
// If we're looping and the offset (virtualReadIndex) is past the end of the loop, wrap back to
// the beginning of the loop. For other cases, nothing needs to be done.
if (loop() && m_virtualReadIndex >= virtualEndFrame)
m_virtualReadIndex = (m_loopStart < 0) ? 0 : (m_loopStart * buffer()->sampleRate());
double computedPlaybackRate = computePlaybackRate();
// Sanity check that our playback rate isn't larger than the loop size.
if (computedPlaybackRate > virtualDeltaFrames)
return false;
// Get local copy.
double virtualReadIndex = m_virtualReadIndex;
// Render loop - reading from the source buffer to the destination using linear interpolation.
int framesToProcess = numberOfFrames;
const float** sourceChannels = m_sourceChannels.get();
float** destinationChannels = m_destinationChannels.get();
ASSERT(virtualReadIndex >= 0);
ASSERT(virtualDeltaFrames >= 0);
ASSERT(virtualEndFrame >= 0);
// Optimize for the very common case of playing back with computedPlaybackRate == 1.
// We can avoid the linear interpolation.
if (computedPlaybackRate == 1 && virtualReadIndex == floor(virtualReadIndex)
&& virtualDeltaFrames == floor(virtualDeltaFrames)
&& virtualEndFrame == floor(virtualEndFrame)) {
unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
unsigned deltaFrames = static_cast<unsigned>(virtualDeltaFrames);
endFrame = static_cast<unsigned>(virtualEndFrame);
while (framesToProcess > 0) {
int framesToEnd = endFrame - readIndex;
int framesThisTime = std::min(framesToProcess, framesToEnd);
framesThisTime = std::max(0, framesThisTime);
for (unsigned i = 0; i < numberOfChannels; ++i)
memcpy(destinationChannels[i] + writeIndex, sourceChannels[i] + readIndex, sizeof(float) * framesThisTime);
writeIndex += framesThisTime;
readIndex += framesThisTime;
framesToProcess -= framesThisTime;
// It can happen that framesThisTime is 0. Assert that we will actually exit the loop in
// this case. framesThisTime is 0 only if readIndex >= endFrame;
ASSERT(framesThisTime ? true : readIndex >= endFrame);
// Wrap-around.
if (readIndex >= endFrame) {
readIndex -= deltaFrames;
if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, framesToProcess))
break;
}
}
virtualReadIndex = readIndex;
} else {
while (framesToProcess--) {
unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
double interpolationFactor = virtualReadIndex - readIndex;
// For linear interpolation we need the next sample-frame too.
unsigned readIndex2 = readIndex + 1;
if (readIndex2 >= bufferLength) {
if (loop()) {
// Make sure to wrap around at the end of the buffer.
readIndex2 = static_cast<unsigned>(virtualReadIndex + 1 - virtualDeltaFrames);
} else {
readIndex2 = readIndex;
}
}
// Final sanity check on buffer access.
// FIXME: as an optimization, try to get rid of this inner-loop check and put assertions and guards before the loop.
if (readIndex >= bufferLength || readIndex2 >= bufferLength)
break;
// Linear interpolation.
for (unsigned i = 0; i < numberOfChannels; ++i) {
float* destination = destinationChannels[i];
const float* source = sourceChannels[i];
double sample1 = source[readIndex];
double sample2 = source[readIndex2];
double sample = (1.0 - interpolationFactor) * sample1 + interpolationFactor * sample2;
destination[writeIndex] = narrowPrecisionToFloat(sample);
}
writeIndex++;
virtualReadIndex += computedPlaybackRate;
// Wrap-around, retaining sub-sample position since virtualReadIndex is floating-point.
if (virtualReadIndex >= virtualEndFrame) {
virtualReadIndex -= virtualDeltaFrames;
if (renderSilenceAndFinishIfNotLooping(bus, writeIndex, framesToProcess))
break;
}
}
}
bus->clearSilentFlag();
m_virtualReadIndex = virtualReadIndex;
return true;
}
void loop(Int<I> i, Int<F> n, auto& container, auto f)
{
f(at(container,i));
loop( i + Int<1>{} ,n,container,f);
}
int main(void) {
setup();
while(true){loop();}
}
void loop(IntD i, IntD n, auto& container, auto f)
{
f(at(container,i));
if (i + 1 !=n)
loop(i+1,n,container,f);
}
void DelayDispatcher::send_with_callback_and_delay(NetQueryPtr query, ActorShared<NetQueryCallback> callback,
double delay) {
queue_.push({std::move(query), std::move(callback), delay});
loop();
} // namespace td
int
WndForm::ShowModal(Window *mouse_allowed)
{
assert_none_locked();
#define OPENCLOSESUPPRESSTIME 500
#ifdef ENABLE_SDL
ContainerWindow *root = get_root_owner();
WindowReference old_focus_reference = root->GetFocusedWindowReference();
#else
HWND oldFocusHwnd;
#endif /* !ENABLE_SDL */
PeriodClock enter_clock;
if (is_embedded() && !is_altair())
enter_clock.update();
show_on_top();
mModalResult = 0;
#ifndef ENABLE_SDL
oldFocusHwnd = ::GetFocus();
if (oldFocusHwnd != NULL)
::SendMessage(oldFocusHwnd, WM_CANCELMODE, 0, 0);
#endif /* !ENABLE_SDL */
set_focus();
focus_first_control();
bool hastimed = false;
WndForm::timeAnyOpenClose.update(); // when current dlg opens or child closes
main_window.add_dialog(this);
#ifdef ENABLE_SDL
main_window.refresh();
#endif
#ifdef ANDROID
EventLoop loop(*event_queue, main_window);
Event event;
#elif defined(ENABLE_SDL)
EventLoop loop(main_window);
SDL_Event event;
#else
DialogEventLoop loop(*this);
MSG event;
#endif
while (mModalResult == 0 && loop.get(event)) {
if (!main_window.FilterEvent(event, this, mouse_allowed))
continue;
// hack to stop exiting immediately
if (is_embedded() && !is_altair() && !hastimed &&
is_user_input(event)) {
if (!enter_clock.check(200))
/* ignore user input in the first 200ms */
continue;
else
hastimed = true;
}
if (is_embedded() && is_mouse_up(event) &&
!timeAnyOpenClose.check(OPENCLOSESUPPRESSTIME))
/* prevents child click from being repeat-handled by parent if
buttons overlap */
continue;
if (mOnKeyDownNotify != NULL && is_key_down(event) &&
#ifndef ENABLE_SDL
identify_descendant(event.hwnd) &&
#endif
!check_special_key(this, event) &&
mOnKeyDownNotify(*this, get_key_code(event)))
continue;
#if defined(ENABLE_SDL) && !defined(ANDROID)
if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_TAB) {
/* the Tab key moves the keyboard focus */
const Uint8 *keystate = ::SDL_GetKeyState(NULL);
event.key.keysym.sym = keystate[SDLK_LSHIFT] || keystate[SDLK_RSHIFT]
? SDLK_UP : SDLK_DOWN;
}
#endif
if (is_key_down(event) &&
#ifndef ENABLE_SDL
identify_descendant(event.hwnd) &&
#endif
(get_key_code(event) == VK_UP || get_key_code(event) == VK_DOWN)) {
/* VK_UP and VK_DOWN move the focus only within the current
control group - but we want it to behave like Shift-Tab and
Tab */
if (!check_key(this, event)) {
/* this window doesn't handle VK_UP/VK_DOWN */
if (get_key_code(event) == VK_DOWN)
focus_next_control();
else
focus_previous_control();
continue;
}
}
#ifdef ENABLE_SDL
if (is_key_down(event) && get_key_code(event) == VK_ESCAPE) {
mModalResult = mrCancel;
break;
}
#endif
loop.dispatch(event);
} // End Modal Loop
main_window.remove_dialog(this);
// static. this is current open/close or child open/close
WndForm::timeAnyOpenClose.update();
#ifdef ENABLE_SDL
if (old_focus_reference.Defined()) {
Window *old_focus = old_focus_reference.Get(*root);
if (old_focus != NULL)
old_focus->set_focus();
}
#else
SetFocus(oldFocusHwnd);
#endif /* !ENABLE_SDL */
return mModalResult;
}
int main(int argc, char **argv){
int status = 0;
init_globals();
atexit(cleanup);
/*
* PROBLEM
* We used to call init_signals() only after init_daemon(). But in
* that case, when started with -F or -D -D, the signals are
* not caught in Linunx and OSX (they are caught in FreeBSD). nbspd and
* npemwind die, but leave the pid file and the web server.
* [It seems that the signals are not blocked in the main thread as
* the code in signal.c should ensure.]
* Adding this call here
*
* status = init_signals();
*
* makes OSX and Linux respond well when the daemon is run in the foreground.
* If the call is made after the tcl configure(), the problem repeats;
* it has to be before the configure() function.
*
* The problem is that in FreeBSD-7.1, when init_signals() is called here,
* then no threads are spawned afterwards.
*
* The solution was to split init_signals() in two parts, one that
* block the signals and the other spawns the thread. I don't fully
* understand what in tcl is causing this (Fri Mar 13 11:43:09 AST 2009).
*/
status = init_signals_block();
if(status == 0){
/*
* This will configure it with the default configuration
* file, if it exists.
*
* This note and Tcl... code line is taken from the nbsp source code.
* [First initialize the tcl library once and for all. It was not
* necessary to call this in unix, but cygwin needs it or EvalFile
* seg faults.]
*/
Tcl_FindExecutable(argv[0]);
status = configure();
}
if(status == 0)
status = parse_args(argc, argv);
if(status == 0){
if(g.configfile != NULL){
/*
* This will reconfigure it with the user-supplied config file
*/
status = configure();
}
}
/*
* if [-C] was given, print the configuration and exit.
*/
if(status == 0){
if(g.option_C == 1){
print_confoptions();
return(0);
}
}
if(status == 0)
status = validate_configuration();
/*
* user and group are configurable so this must be done after reading
* configuration options.
*/
if(status == 0)
status = drop_privs();
if(status == 0)
status = init_server_list();
if(status == 0)
status = init_directories();
/*
* The last configuration step, just before becoming a daemon.
*/
if(status == 0)
status = exec_startscript();
if((status == 0) && (g.f_ndaemon == 0))
status = init_daemon();
set_log_debug(g.f_debug);
set_log_verbose(g.f_verbose);
if(status == 0)
status = init_signals_thread();
/*
* This has to be done after daemon() so that the lock file contains the
* daemon's pid, not the starting program's.
*/
if(status == 0)
status = init_lock();
/*
* There are no shared queues in npemwin, otherwise the initialization
* would go here.
*
* if(status == 0)
* status = init_queues();
*/
if(status == 0){
if(g.serverprotocol != PROTOCOL_NONE) {
g.f_server_enabled = 1;
status = init_server();
}
}
if(status == 0){
if(g.httpd_enable > 0){
status = spawn_httpd_server();
}
}
if(status == 0){
if(g.bbserver_enable > 0){
status = spawn_bbregistrar();
}
}
if(status == 0)
status = init_emwin_qfiles();
if(status == 0)
init_periodic();
/*
* If there are initialization errors, ask all threads to quit.
*/
if(status != 0)
set_quit_flag();
while(get_quit_flag() == 0){
status = loop();
}
if(status != 0)
status = EXIT_FAILURE;
return(status);
}
int main() {
setup();
while (1)
loop();
}
int main(void)
{
uint8_t i;
drv_pwm_config_t pwm_params;
drv_adc_config_t adc_params;
#if 0
// PC12, PA15
// using this to write asm for bootloader :)
RCC->APB2ENR |= RCC_APB2Periph_GPIOA | RCC_APB2Periph_GPIOC | RCC_APB2Periph_AFIO; // GPIOA/C+AFIO only
AFIO->MAPR &= 0xF0FFFFFF;
AFIO->MAPR = 0x02000000;
GPIOA->CRH = 0x34444444; // PIN 15 Output 50MHz
GPIOA->BRR = 0x8000; // set low 15
GPIOC->CRH = 0x44434444; // PIN 12 Output 50MHz
GPIOC->BRR = 0x1000; // set low 12
#endif
#if 0
// using this to write asm for bootloader :)
RCC->APB2ENR |= RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO; // GPIOB + AFIO
AFIO->MAPR &= 0xF0FFFFFF;
AFIO->MAPR = 0x02000000;
GPIOB->BRR = 0x18; // set low 4 & 3
GPIOB->CRL = 0x44433444; // PIN 4 & 3 Output 50MHz
#endif
systemInit();
init_printf(NULL, _putc);
checkFirstTime(false);
readEEPROM();
// configure power ADC
if (mcfg.power_adc_channel > 0 && (mcfg.power_adc_channel == 1 || mcfg.power_adc_channel == 9))
adc_params.powerAdcChannel = mcfg.power_adc_channel;
else {
adc_params.powerAdcChannel = 0;
mcfg.power_adc_channel = 0;
}
adcInit(&adc_params);
// We have these sensors; SENSORS_SET defined in board.h depending on hardware platform
sensorsSet(SENSORS_SET);
mixerInit(); // this will set useServo var depending on mixer type
// when using airplane/wing mixer, servo/motor outputs are remapped
if (mcfg.mixerConfiguration == MULTITYPE_AIRPLANE || mcfg.mixerConfiguration == MULTITYPE_FLYING_WING)
pwm_params.airplane = true;
else
pwm_params.airplane = false;
pwm_params.useUART = feature(FEATURE_GPS) || feature(FEATURE_SPEKTRUM); // spektrum support uses UART too
pwm_params.usePPM = feature(FEATURE_PPM);
pwm_params.enableInput = !feature(FEATURE_SPEKTRUM); // disable inputs if using spektrum
pwm_params.useServos = useServo;
pwm_params.extraServos = cfg.gimbal_flags & GIMBAL_FORWARDAUX;
pwm_params.motorPwmRate = mcfg.motor_pwm_rate;
pwm_params.servoPwmRate = mcfg.servo_pwm_rate;
pwm_params.failsafeThreshold = cfg.failsafe_detect_threshold;
switch (mcfg.power_adc_channel) {
case 1:
pwm_params.adcChannel = PWM2;
break;
case 9:
pwm_params.adcChannel = PWM8;
break;
default:
pwm_params.adcChannel = 0;
break;
}
pwmInit(&pwm_params);
// configure PWM/CPPM read function. spektrum below will override that
rcReadRawFunc = pwmReadRawRC;
if (feature(FEATURE_SPEKTRUM)) {
spektrumInit();
rcReadRawFunc = spektrumReadRawRC;
} else {
// spektrum and GPS are mutually exclusive
// Optional GPS - available in both PPM and PWM input mode, in PWM input, reduces number of available channels by 2.
if (feature(FEATURE_GPS))
gpsInit(mcfg.gps_baudrate);
}
#ifdef SONAR
// sonar stuff only works with PPM
if (feature(FEATURE_PPM)) {
if (feature(FEATURE_SONAR))
Sonar_init();
}
#endif
LED1_ON;
LED0_OFF;
for (i = 0; i < 10; i++) {
LED1_TOGGLE;
LED0_TOGGLE;
delay(25);
BEEP_ON;
delay(25);
BEEP_OFF;
}
LED0_OFF;
LED1_OFF;
// drop out any sensors that don't seem to work, init all the others. halt if gyro is dead.
sensorsAutodetect();
imuInit(); // Mag is initialized inside imuInit
// Check battery type/voltage
if (feature(FEATURE_VBAT))
batteryInit();
serialInit(mcfg.serial_baudrate);
previousTime = micros();
if (mcfg.mixerConfiguration == MULTITYPE_GIMBAL)
calibratingA = 400;
calibratingG = 1000;
calibratingB = 200; // 10 seconds init_delay + 200 * 25 ms = 15 seconds before ground pressure settles
f.SMALL_ANGLES_25 = 1;
// loopy
while (1) {
loop();
}
}
int
WndForm::ShowModal()
{
AssertNoneLocked();
#define OPENCLOSESUPPRESSTIME 500
#ifndef USE_GDI
ContainerWindow *root = GetRootOwner();
WindowReference old_focus_reference = root->GetFocusedWindowReference();
#else
HWND oldFocusHwnd;
#endif /* USE_GDI */
PeriodClock enter_clock;
if (IsEmbedded() && !IsAltair())
enter_clock.Update();
ShowOnTop();
modal_result = 0;
SingleWindow &main_window = GetMainWindow();
main_window.CancelMode();
#ifdef USE_GDI
oldFocusHwnd = ::GetFocus();
#endif /* USE_GDI */
SetFocus();
if (default_focus)
default_focus->SetFocus();
else
client_area.FocusFirstControl();
bool hastimed = false;
main_window.AddDialog(this);
#ifndef USE_GDI
main_window.Refresh();
#endif
#if defined(ANDROID) || defined(USE_EGL)
EventLoop loop(*event_queue, main_window);
#elif defined(ENABLE_SDL)
EventLoop loop(main_window);
#else
DialogEventLoop loop(*this);
#endif
Event event;
while ((modal_result == 0 || force) && loop.Get(event)) {
if (!main_window.FilterEvent(event, this)) {
if (modeless && event.IsMouseDown())
break;
else
continue;
}
// hack to stop exiting immediately
if (IsEmbedded() && !IsAltair() && !hastimed &&
event.IsUserInput()) {
if (!enter_clock.Check(200))
/* ignore user input in the first 200ms */
continue;
else
hastimed = true;
}
if (event.IsKeyDown()) {
if (key_down_function &&
#ifdef USE_GDI
IdentifyDescendant(event.msg.hwnd) &&
#endif
!CheckSpecialKey(this, event) &&
key_down_function(event.GetKeyCode()))
continue;
#ifdef ENABLE_SDL
if (event.GetKeyCode() == SDLK_TAB) {
/* the Tab key moves the keyboard focus */
const Uint8 *keystate = ::SDL_GetKeyState(NULL);
event.event.key.keysym.sym =
keystate[SDLK_LSHIFT] || keystate[SDLK_RSHIFT]
? SDLK_UP : SDLK_DOWN;
}
#endif
if (
#ifdef USE_GDI
IdentifyDescendant(event.msg.hwnd) &&
#endif
(event.GetKeyCode() == KEY_UP || event.GetKeyCode() == KEY_DOWN)) {
/* KEY_UP and KEY_DOWN move the focus only within the current
control group - but we want it to behave like Shift-Tab and
Tab */
if (!CheckKey(this, event)) {
/* this window doesn't handle KEY_UP/KEY_DOWN */
if (event.GetKeyCode() == KEY_DOWN)
FocusNextControl();
else
FocusPreviousControl();
continue;
}
}
#if !defined USE_GDI || defined _WIN32_WCE
/* The Windows CE dialog manager does not handle KEY_ESCAPE and
so we have to do it by ourself */
// On Altair, the RemoteKey ("E" Button) shall also close the analyse-page
if (IsAltair()) {
#ifdef GNAV
if (event.GetKeyCode() == KEY_ESCAPE || event.GetKeyCode() == KEY_F15) {
modal_result = mrOK;
continue;
}
#endif
} else if (event.GetKeyCode() == KEY_ESCAPE) {
modal_result = mrCancel;
continue;
}
#endif
}
if (event.IsCharacter() && character_function &&
character_function(event.GetCharacter()))
continue;
loop.Dispatch(event);
} // End Modal Loop
main_window.RemoveDialog(this);
#ifdef USE_GDI
::SetFocus(oldFocusHwnd);
#else
if (old_focus_reference.Defined()) {
Window *old_focus = old_focus_reference.Get(*root);
if (old_focus != NULL)
old_focus->SetFocus();
}
#endif /* !USE_GDI */
return modal_result;
}
int
main(int argc, char **argv)
{
char *p, *endp;
struct passwd *pw;
int arglen, ch, len, readstdin;
#ifndef DEBUG
if (geteuid())
errx(1, "NOT super-user");
#endif
nosync = NULL;
readstdin = 0;
/*
* Test for the special case where the utility is called as
* "poweroff", for which it runs 'shutdown -p now'.
*/
if ((p = strrchr(argv[0], '/')) == NULL)
p = argv[0];
else
++p;
if (strcmp(p, "poweroff") == 0) {
if (getopt(argc, argv, "") != -1)
usage((char *)NULL);
argc -= optind;
argv += optind;
if (argc != 0)
usage((char *)NULL);
dopower = 1;
offset = 0;
(void)time(&shuttime);
goto poweroff;
}
while ((ch = getopt(argc, argv, "-hknopr")) != -1)
switch (ch) {
case '-':
readstdin = 1;
break;
case 'h':
dohalt = 1;
break;
case 'k':
killflg = 1;
break;
case 'n':
nosync = "-n";
break;
case 'o':
oflag = 1;
break;
case 'p':
dopower = 1;
break;
case 'r':
doreboot = 1;
break;
case '?':
default:
usage((char *)NULL);
}
argc -= optind;
argv += optind;
if (argc < 1)
usage((char *)NULL);
if (killflg + doreboot + dohalt + dopower > 1)
usage("incompatible switches -h, -k, -p and -r");
if (oflag && !(dohalt || dopower || doreboot))
usage("-o requires -h, -p or -r");
if (nosync != NULL && !oflag)
usage("-n requires -o");
getoffset(*argv++);
poweroff:
if (*argv) {
for (p = mbuf, len = sizeof(mbuf); *argv; ++argv) {
arglen = strlen(*argv);
if ((len -= arglen) <= 2)
break;
if (p != mbuf)
*p++ = ' ';
memmove(p, *argv, arglen);
p += arglen;
}
*p = '\n';
*++p = '\0';
}
if (readstdin) {
p = mbuf;
endp = mbuf + sizeof(mbuf) - 2;
for (;;) {
if (!fgets(p, endp - p + 1, stdin))
break;
for (; *p && p < endp; ++p);
if (p == endp) {
*p = '\n';
*++p = '\0';
break;
}
}
}
mbuflen = strlen(mbuf);
if (offset)
(void)printf("Shutdown at %.24s.\n", ctime(&shuttime));
else
(void)printf("Shutdown NOW!\n");
if (!(whom = getlogin()))
whom = (pw = getpwuid(getuid())) ? pw->pw_name : "???";
#ifdef DEBUG
(void)putc('\n', stdout);
#else
(void)setpriority(PRIO_PROCESS, 0, PRIO_MIN);
{
int forkpid;
forkpid = fork();
if (forkpid == -1)
err(1, "fork");
if (forkpid)
errx(0, "[pid %d]", forkpid);
}
setsid();
#endif
openlog("shutdown", LOG_CONS, LOG_AUTH);
loop();
return(0);
}
void Switch::Check() { loop(); }
void AudioBufferSourceNode::renderFromBuffer(AudioBus* bus, unsigned destinationFrameOffset, size_t numberOfFrames)
{
ASSERT(context()->isAudioThread());
// Basic sanity checking
ASSERT(bus);
ASSERT(buffer());
if (!bus || !buffer())
return;
unsigned numberOfChannels = this->numberOfChannels();
unsigned busNumberOfChannels = bus->numberOfChannels();
// FIXME: we can add support for sources with more than two channels, but this is not a common case.
bool channelCountGood = numberOfChannels == busNumberOfChannels && (numberOfChannels == 1 || numberOfChannels == 2);
ASSERT(channelCountGood);
if (!channelCountGood)
return;
// Get the destination pointers.
float* destinationL = bus->channel(0)->data();
ASSERT(destinationL);
if (!destinationL)
return;
float* destinationR = (numberOfChannels < 2) ? 0 : bus->channel(1)->data();
bool isStereo = destinationR;
// Sanity check destinationFrameOffset, numberOfFrames.
size_t destinationLength = bus->length();
bool isLengthGood = destinationLength <= 4096 && numberOfFrames <= 4096;
ASSERT(isLengthGood);
if (!isLengthGood)
return;
bool isOffsetGood = destinationFrameOffset <= destinationLength && destinationFrameOffset + numberOfFrames <= destinationLength;
ASSERT(isOffsetGood);
if (!isOffsetGood)
return;
// Potentially zero out initial frames leading up to the offset.
if (destinationFrameOffset) {
memset(destinationL, 0, sizeof(float) * destinationFrameOffset);
if (destinationR)
memset(destinationR, 0, sizeof(float) * destinationFrameOffset);
}
// Offset the pointers to the correct offset frame.
destinationL += destinationFrameOffset;
if (destinationR)
destinationR += destinationFrameOffset;
size_t bufferLength = buffer()->length();
double bufferSampleRate = buffer()->sampleRate();
// Calculate the start and end frames in our buffer that we want to play.
// If m_isGrain is true, then we will be playing a portion of the total buffer.
unsigned startFrame = m_isGrain ? static_cast<unsigned>(m_grainOffset * bufferSampleRate) : 0;
unsigned endFrame = m_isGrain ? static_cast<unsigned>(startFrame + m_grainDuration * bufferSampleRate) : bufferLength;
ASSERT(endFrame >= startFrame);
if (endFrame < startFrame)
return;
unsigned deltaFrames = endFrame - startFrame;
// This is a HACK to allow for HRTF tail-time - avoids glitch at end.
// FIXME: implement tailTime for each AudioNode for a more general solution to this problem.
if (m_isGrain)
endFrame += 512;
// Do some sanity checking.
if (startFrame >= bufferLength)
startFrame = !bufferLength ? 0 : bufferLength - 1;
if (endFrame > bufferLength)
endFrame = bufferLength;
if (m_virtualReadIndex >= endFrame)
m_virtualReadIndex = startFrame; // reset to start
// Get pointers to the start of the sample buffer.
float* sourceL = m_buffer->getChannelData(0)->data();
float* sourceR = m_buffer->numberOfChannels() == 2 ? m_buffer->getChannelData(1)->data() : 0;
double pitchRate = totalPitchRate();
// Get local copy.
double virtualReadIndex = m_virtualReadIndex;
// Render loop - reading from the source buffer to the destination using linear interpolation.
// FIXME: optimize for the very common case of playing back with pitchRate == 1.
// We can avoid the linear interpolation.
int framesToProcess = numberOfFrames;
while (framesToProcess--) {
unsigned readIndex = static_cast<unsigned>(virtualReadIndex);
double interpolationFactor = virtualReadIndex - readIndex;
// For linear interpolation we need the next sample-frame too.
unsigned readIndex2 = readIndex + 1;
if (readIndex2 >= endFrame) {
if (loop()) {
// Make sure to wrap around at the end of the buffer.
readIndex2 -= deltaFrames;
} else
readIndex2 = readIndex;
}
// Final sanity check on buffer access.
// FIXME: as an optimization, try to get rid of this inner-loop check and put assertions and guards before the loop.
if (readIndex >= bufferLength || readIndex2 >= bufferLength)
break;
// Linear interpolation.
double sampleL1 = sourceL[readIndex];
double sampleL2 = sourceL[readIndex2];
double sampleL = (1.0 - interpolationFactor) * sampleL1 + interpolationFactor * sampleL2;
*destinationL++ = narrowPrecisionToFloat(sampleL);
if (isStereo) {
double sampleR1 = sourceR[readIndex];
double sampleR2 = sourceR[readIndex2];
double sampleR = (1.0 - interpolationFactor) * sampleR1 + interpolationFactor * sampleR2;
*destinationR++ = narrowPrecisionToFloat(sampleR);
}
virtualReadIndex += pitchRate;
// Wrap-around, retaining sub-sample position since virtualReadIndex is floating-point.
if (virtualReadIndex >= endFrame) {
virtualReadIndex -= deltaFrames;
if (!loop()) {
// If we're not looping, then stop playing when we get to the end.
m_isPlaying = false;
if (framesToProcess > 0) {
// We're not looping and we've reached the end of the sample data, but we still need to provide more output,
// so generate silence for the remaining.
memset(destinationL, 0, sizeof(float) * framesToProcess);
if (isStereo)
memset(destinationR, 0, sizeof(float) * framesToProcess);
}
finish();
break;
}
}
}
m_virtualReadIndex = virtualReadIndex;
}
bool CWizXmlRpcServerBase::xmlRpcCall(const QString& strMethodName, CWizXmlRpcResult& result, CWizXmlRpcValue* pParam1, CWizXmlRpcValue* pParam2 /*= NULL*/, CWizXmlRpcValue* pParam3 /*= NULL*/, CWizXmlRpcValue* pParam4 /*= NULL*/)
{
CWizXmlRpcRequest data(strMethodName);
data.addParam(pParam1);
if (pParam2)
{
data.addParam(pParam2);
}
if (pParam3)
{
data.addParam(pParam3);
}
if (pParam4)
{
data.addParam(pParam4);
}
QNetworkRequest request;
request.setUrl(QUrl(m_strUrl));
request.setHeader(QNetworkRequest::ContentTypeHeader, QVariant("text/xml"));
//
int nCounter = 0;
while (true)
{
QNetworkReply* reply = m_network->post(request, data.toData());
CWizXmlRpcEventLoop loop(reply);
// qDebug() << "[Sync]Start a xml rpc event loop";
loop.exec();
// qDebug() << "[Sync]Xml rpc event loop finished";
//
if (loop.error() && nCounter == 0)
{
nCounter ++;
continue;
}
//
if (loop.error())
{
m_nLastErrorCode = loop.error();
m_strLastErrorMessage = loop.errorString();
return false;
}
//
QString strXml = loop.result();
//
CWizXMLDocument doc;
if (!doc.LoadXML(strXml)) {
m_nLastErrorCode = -1;
m_strLastErrorMessage = "Invalid xml";
return false;
}
CWizXmlRpcValue* pRet = NULL;
if (!WizXmlRpcResultFromXml(doc, &pRet)) {
m_nLastErrorCode = -1;
m_strLastErrorMessage = "Can not parse xmlrpc";
return false;
}
Q_ASSERT(pRet);
if (CWizXmlRpcFaultValue* pFault = dynamic_cast<CWizXmlRpcFaultValue *>(pRet)) {
m_nLastErrorCode = pFault->GetFaultCode();
m_strLastErrorMessage = pFault->GetFaultString();
TOLOG2(_T("XmlRpcCall failed : %1, %2"), QString::number(m_nLastErrorCode), m_strLastErrorMessage);
return false;
}
//
result.SetResult(strMethodName, pRet);
break;
}
//
return true;
}
pulsesequence() {
/* Acquisition variables */
double dw; /* nominal dwell time, = 1/sw */
double aqtm = getval("aqtm");
/* Delay variables */
double tref,
te_delay1, te_delay2, tr_delay, ti_delay,
del1, del2, del3, del4, del5, /* before and after diffusion gradients */
busy1, busy2, /* time spent on rf pulses etc. in TE periods */
seqtime, invTime;
int use_minte;
/* RF and receiver frequency variables */
double freq90[MAXNSLICE],freq180[MAXNSLICE],freqIR[MAXNSLICE]; /* frequencies for multi-slice */
int shape90=0, shape180=0, shapeIR=0; /* List ID for RF shapes */
double roff1, roff2, roffn; /* Receiver offsets when FOV is offset along readout */
/* Gradient amplitudes, may vary depending on "image" parameter */
double peramp, perinc, peamp, roamp, roramp;
/* diffusion variables */
#define MAXDIR 1024 /* Will anybody do more than 1024 directions or b-values? */
int diff_in_one = 0;
double tmp, tmp_ss2;
double roarr[MAXDIR], pearr[MAXDIR], slarr[MAXDIR];
int nbval, /* Total number of bvalues*directions */
nbro, nbpe, nbsl; /* bvalues*directions along RO, PE, and SL */
double bro[MAXDIR], bpe[MAXDIR], bsl[MAXDIR], /* b-values along RO, PE, SL */
brs[MAXDIR], brp[MAXDIR], bsp[MAXDIR], /* the cross-terms */
btrace[MAXDIR], /* and the trace */
max_bval=0,
dcrush, dgss2, /* "delta" for crusher and gss2 gradients */
Dro, Dcrush, Dgss2; /* "DELTA" for readout, crusher and gss2 gradients */
/* loop variable */
int i;
/* Real-time variables used in this sequence **************/
int vms_slices = v3; // Number of slices
int vms_ctr = v4; // Slice loop counter
int vnseg = v5; // Number of segments
int vnseg_ctr = v6; // Segment loop counter
int vetl = v7; // Number of choes in readout train
int vetl_ctr = v8; // etl loop counter
int vblip = v9; // Sign on blips in multi-shot experiment
int vssepi = v10; // Number of Gradient Steady States lobes
int vssepi_ctr = v11; // Steady State counter
int vacquire = v12; // Argument for setacqvar, to skip steady states
/******************************************************/
/* VARIABLE INITIALIZATIONS ***************************/
/******************************************************/
get_parameters();
euler_test();
if (tep < 0) { // adjust by reducing gpropdelay by that amount
gpropdelay += tep;
tep = 0;
}
setacqmode(WACQ|NZ); // Necessary for variable rate sampling
use_minte = (minte[0] == 'y');
/******************************************************/
/* CALCULATIONS ***************************************/
/******************************************************/
if (ix == 1) {
/* Calculate RF pulse */
init_rf(&p1_rf,p1pat,p1,flip1,rof1,rof2);
calc_rf(&p1_rf,"tpwr1","tpwr1f");
/* Calculate gradients: */
init_slice(&ss_grad,"ss",thk);
calc_slice(&ss_grad, &p1_rf,WRITE,"gss");
init_slice_refocus(&ssr_grad,"ssr");
calc_slice_refocus(&ssr_grad, &ss_grad, WRITE,"gssr");
if (spinecho[0] == 'y') {
init_rf(&p2_rf,p2pat,p2,flip2,rof1,rof1);
calc_rf(&p2_rf,"tpwr2","tpwr2f");
init_slice_butterfly(&ss2_grad,"ss2",thk,gcrush,tcrush);
calc_slice(&ss2_grad,&p2_rf,WRITE,"gss2");
}
else ss2_grad.duration = 0; /* used for diffusion calculations */
init_readout(&epiro_grad,"epiro",lro,np,sw);
init_readout_refocus(&ror_grad,"ror");
init_phase(&epipe_grad, "epipe",lpe,nv);
init_phase(&per_grad,"per",lpe,nv);
init_readout(&nav_grad,"nav",lro,np,sw);
init_epi(&epi_grad);
if (!strcmp(orient,"oblique")) {
if ((phi != 90) || (psi != 90) || (theta != 90)) {
/* oblique slice - this should take care of most cases */
epiro_grad.slewRate /= 3; /* = gmax/trise */
epipe_grad.slewRate /= 3;
}
}
calc_epi(&epi_grad,&epiro_grad,&epipe_grad,&ror_grad,&per_grad,&nav_grad,NOWRITE);
/* Make sure the slice refocus, readout refocus,
and phase dephaser fit in the same duration */
tref = calc_sim_gradient(&ror_grad, &per_grad, &null_grad, getval("tpe"), WRITE);
if (sgldisplay) displayEPI(&epi_grad);
/* calc_sim_gradient recalculates per_grad, so reset its
base amplitude for centric ordering or fractional k-space*/
switch(ky_order[0]) {
case 'l':
per_grad.amp *= (fract_ky/(epipe_grad.steps/2));
break;
case 'c':
per_grad.amp = (nseg/2-1)*per_grad.increment;
break;
}
if (ir[0] == 'y') {
init_rf(&ir_rf,pipat,pi,flipir,rof1,rof1);
calc_rf(&ir_rf,"tpwri","tpwrif");
init_slice_butterfly(&ssi_grad,"ssi",thk,gcrush,tcrush);
calc_slice(&ssi_grad,&ir_rf,WRITE,"gssi");
}
if (fsat[0] == 'y') {
create_fatsat();
}
if (diff[0] == 'y') {
init_generic(&diff_grad,"diff",gdiff,tdelta);
diff_grad.maxGrad = gmax;
calc_generic(&diff_grad,NOWRITE,"","");
/* adjust duration, so tdelta is from start ramp up to start ramp down */
if (ix == 1) {
diff_grad.duration += diff_grad.tramp;
calc_generic(&diff_grad,WRITE,"","");
}
}
/* Acquire top-down or bottom-up ? */
if (ky_order[1] == 'r') {
epipe_grad.amp *= -1;
per_grad.amp *= -1;
per_grad.increment *= -1;
}
} /* end gradient setup if ix == 1 */
/* Load table used to determine multi-shot direction */
settable(t2,(int) nseg,epi_grad.table2);
/* What is happening in the 2 TE/2 periods (except for diffusion)? */
busy1 = ss_grad.rfCenterBack + ssr_grad.duration;
busy2 = tep + nav_grad.duration*(epi_grad.center_echo + 0.5);
if (navigator[0] == 'y')
busy2 += (tep + nav_grad.duration + per_grad.duration);
/* How much extra time do we have in each TE/2 period? */
if (spinecho[0] == 'y') {
busy1 += (GDELAY + ss2_grad.rfCenterFront);
busy2 += ss2_grad.rfCenterBack;
temin = MAX(busy1,busy2)*2;
if (use_minte) te = temin;
te_delay1 = te/2 - busy1;
te_delay2 = te/2 - busy2;
if (temin > te) { /* Use min TE and try and catch further violations of min TE */
te_delay1 = temin/2 - busy1;
te_delay2 = temin/2 - busy2;
}
}
else { /* Gradient echo */
temin = (busy1 + busy2);
if (use_minte) te = temin;
te_delay1 = te - temin;
te_delay2 = 0;
if (temin > te) te_delay1 = 0;
}
/* Now fill in the diffusion delays:
del1 = between 90 and 1st diffusion gradient
del2 = after 1st diffusion gradient
del3 = before 2nd diffusion gradient when both in same TE/2 period
del4 = before 2nd diffusion gradient when in different TE/2 period
del5 = before acquisition
Ie, the order is:
90 - del1 - diff - del2 - (diff - del3) - 180 - (del4 - diff) - del5 - acq
where one and only one of the two options (diff - del3) or (del4 - diff) is used
*/
if (diff[0] == 'y') {
tmp_ss2 = GDELAY + ss2_grad.duration; /* ss2 grad + 4us delay */
del1 = del2 = del3 = del4 = del5 = 0;
if (tDELTA < (diff_grad.duration + tmp_ss2)) /* Minimum DELTA */
abort_message("ERROR %s: tDELTA is too short, minimum is %.2fms\n",
seqfil,(diff_grad.duration + tmp_ss2)*1000+0.005);
if (tDELTA + diff_grad.duration > te_delay1 + tmp_ss2 + te_delay2) {
if (!use_minte) {
abort_message("ERROR %s: Maximum tDELTA is %.2fms",
seqfil,te_delay1 + ss2_grad.duration + te_delay2 - diff_grad.duration);
}
else {
tmp = (tDELTA + diff_grad.duration) - (te_delay1 + tmp_ss2 + te_delay2);
if (spinecho[0] == 'y') {
te_delay1 += (tmp/2);
te_delay2 += (tmp/2);
}
else
te_delay1 += tmp;
temin += tmp;
}
}
if (spinecho[0] == 'y') {
if (te_delay1 >= (tDELTA + diff_grad.duration)) { /* Put them both in 1st TE/2 period, */
diff_in_one = (diff[0] == 'y'); /* no need to increase temin */
del2 = tDELTA - diff_grad.duration; /* time between diffusion gradients */
del3 = te_delay1 - (tDELTA+diff_grad.duration); /* time after diffusion gradients */
del5 = te_delay2; /* delay in second TE/2 period */
}
else { /* put them on each side of the 180 */
diff_in_one = 0;
busy1 += diff_grad.duration;
busy2 += diff_grad.duration;
temin = 2*MAX(busy1,busy2);
/* Optimally, the 2nd diff grad is right after the 180 */
del2 = tDELTA - diff_grad.duration - tmp_ss2; /* This is always > 0, or we would have aborted above */
del1 = te_delay1 - (diff_grad.duration + del2);
if (del1 < 0) {
del1 = 0; /* Place the 1st right after the 90 and push the 2nd out */
del4 = tDELTA - te_delay1 - ss2_grad.duration;
}
del5 = te_delay2 - (del4 + diff_grad.duration);
/* del5 could still be < 0, when te_delay2 < diff_grad.duration */
if (del5 < 0) {
del1 += fabs(del5); /* Increase each TE/2 period by abs(del5) */
del5 = 0;
}
}
}
else { /* gradient echo */
diff_in_one = (diff[0] == 'y');
del1 = 0;
del2 = tDELTA - diff_grad.duration; /* time between diffusion gradients */
del3 = 0;
del4 = 0;
if (!use_minte) /* user defined TE */
del5 = te_delay1 - (tDELTA + diff_grad.duration);
}
} /* End of Diffusion block */
else {
del1 = te_delay1;
del5 = te_delay2;
del2 = del3 = del4 = 0;
}
if (sgldisplay) {
text_message("busy1/2, temin = %f, %f, %f",busy1*1e3, busy2*1e3, temin*1e3);
text_message("te_delay1/2 = %f, %f",te_delay1*1e3, te_delay2*1e3);
text_message("delays 1-5: %.2f, %.2f, %.2f, %.2f, %.2fms\n",del1*1000,del2*1000,del3*1000,del4*1000,del5*1000);
}
/* Check if TE is long enough */
temin = ceil(temin*1e6)/1e6; /* round to nearest us */
if (use_minte) {
te = temin;
putvalue("te",te);
}
else if (temin > te) {
abort_message("TE too short, minimum is %.2f ms\n",temin*1000);
}
if (ir[0] == 'y') {
ti_delay = ti - (pi*ssi_grad.rfFraction + rof2 + ssi_grad.rfDelayBack)
- (ss_grad.rfDelayFront + rof1 + p1*(1-ss_grad.rfFraction));
if (ti_delay < 0) {
abort_message("TI too short, minimum is %.2f ms\n",(ti-ti_delay)*1000);
}
}
else ti_delay = 0;
invTime = GDELAY + ssi_grad.duration + ti_delay;
/* Minimum TR per slice, w/o options */
seqtime = GDELAY + ss_grad.rfCenterFront // Before TE
+ te
+ (epiro_grad.duration - nav_grad.duration*(epi_grad.center_echo+0.5)); // After TE
/* Add in time for options outside of TE */
if (ir[0] == 'y') seqtime += invTime;
if (fsat[0] == 'y') seqtime += fsatTime;
trmin = seqtime + 4e-6; /* ensure a minimum of 4us in tr_delay */
trmin *= ns;
if (tr - trmin < 0.0) {
abort_message("%s: Requested tr too short. Min tr = %.2f ms\n",
seqfil,ceil(trmin*100000)/100.00);
}
/* spread out multi-slice acquisition over total TR */
tr_delay = (tr - ns*seqtime)/ns;
/******************************************************/
/* Return gradient values to VnmrJ interface */
/******************************************************/
putvalue("etl",epi_grad.etl+2*ssepi);
putvalue("gro",epiro_grad.amp);
putvalue("rgro",epiro_grad.tramp);
putvalue("gror",ror_grad.amp);
putvalue("tror",ror_grad.duration);
putvalue("rgror",ror_grad.tramp);
putvalue("gpe",epipe_grad.amp);
putvalue("rgpe",epipe_grad.tramp);
putvalue("gped",per_grad.amp);
putvalue("tped",per_grad.duration);
putvalue("rgped",per_grad.tramp);
putvalue("gss",ss_grad.amp);
putvalue("gss2",ss2_grad.ssamp);
putvalue("rgss",ss_grad.tramp);
putvalue("gssr",ssr_grad.amp);
putvalue("tssr",ssr_grad.duration);
putvalue("rgssr",ssr_grad.tramp);
putvalue("rgss2",ss2_grad.crusher1RampToSsDuration);
putvalue("rgssi",ssi_grad.crusher1RampToSsDuration);
putvalue("rgcrush",ssi_grad.crusher1RampToCrusherDuration);
putvalue("at_full",epi_grad.duration);
putvalue("at_one",nav_grad.duration);
putvalue("rcrush",ss2_grad.crusher1RampToCrusherDuration);
putvalue("np_ramp",epi_grad.np_ramp);
putvalue("np_flat",epi_grad.np_flat);
if (diff[0] == 'y') { /* CALCULATE B VALUES */
/* Get multiplication factors and make sure they have same # elements */
/* All this is only necessary because putCmd only work for ix==1 */
nbro = (int) getarray("dro",roarr); nbval = nbro;
nbpe = (int) getarray("dpe",pearr); if (nbpe > nbval) nbval = nbpe;
nbsl = (int) getarray("dsl",slarr); if (nbsl > nbval) nbval = nbsl;
if ((nbro != nbval) && (nbro != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (readout)",seqfil);
if ((nbpe != nbval) && (nbpe != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (phase)",seqfil);
if ((nbsl != nbval) && (nbsl != 1))
abort_message("%s: Number of directions/b-values must be the same for all axes (slice)",seqfil);
if (nbro == 1) for (i = 1; i < nbval; i++) roarr[i] = roarr[0];
if (nbpe == 1) for (i = 1; i < nbval; i++) pearr[i] = pearr[0];
if (nbsl == 1) for (i = 1; i < nbval; i++) slarr[i] = slarr[0];
}
else {
nbval = 1;
roarr[0] = 0;
pearr[0] = 0;
slarr[0] = 0;
}
for (i = 0; i < nbval; i++) {
/* We need to worry about slice gradients & crushers for slice gradients */
/* Everything else is outside diffusion gradients, and thus constant */
/* for all b-values/directions */
/* Readout */
bro[i] = bval(gdiff*roarr[i],tdelta,tDELTA);
/* Phase */
bpe[i] = bval(gdiff*pearr[i],tdelta,tDELTA);
/* Slice */
dgss2 = p2/2; Dgss2 = dgss2;
dcrush = tcrush; Dcrush = dcrush + p2;
bsl[i] = bval(gdiff*slarr[i],tdelta,tDELTA);
if (spinecho[0] == 'y') {
bsl[i] += bval(ss2_grad.ssamp,dgss2,Dgss2);
bsl[i] += bval(gcrush,dcrush,Dcrush);
bsl[i] += bval_nested(gcrush,dcrush,Dcrush,ss2_grad.ssamp,dgss2,Dgss2);
}
if (!diff_in_one) {
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsl[i] += bval_nested(gdiff*slarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
}
/* Readout/Slice Cross-terms */
brs[i] = bval2(gdiff*roarr[i],gdiff*slarr[i],tdelta,tDELTA);
if (spinecho[0] == 'y') {
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
brs[i] += bval_cross(gdiff*roarr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
}
/* Readout/Phase Cross-terms */
brp[i] = bval2(gdiff*roarr[i],gdiff*pearr[i],tdelta,tDELTA);
/* Slice/Phase Cross-terms */
bsp[i] = bval2(gdiff*slarr[i],gdiff*pearr[i],tdelta,tDELTA);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,gcrush,dcrush,Dcrush);
bsp[i] += bval_cross(gdiff*pearr[i],tdelta,tDELTA,ss2_grad.ssamp,dgss2,Dgss2);
btrace[i] = (bro[i]+bsl[i]+bpe[i]);
if (max_bval < btrace[i]) {
max_bval = (bro[i]+bsl[i]+bpe[i]);
}
} /* End for-all-directions */
putarray("bvalrr",bro,nbval);
putarray("bvalpp",bpe,nbval);
putarray("bvalss",bsl,nbval);
putarray("bvalrp",brp,nbval);
putarray("bvalrs",brs,nbval);
putarray("bvalsp",bsp,nbval);
putarray("bvalue",btrace,nbval);
putvalue("max_bval",max_bval);
/* Set all gradients depending on whether we do */
/* Use separate variables, because we only initialize & calculate gradients for ix==1 */
peamp = epipe_grad.amp;
perinc = per_grad.increment;
peramp = per_grad.amp;
roamp = epiro_grad.amp;
roramp = ror_grad.amp;
switch ((int)image) {
case 1: /* Real image scan, don't change anything */
break;
case 0: /* Normal reference scan */
peamp = 0;
perinc = 0;
peramp = 0;
roamp = epiro_grad.amp;
roramp = ror_grad.amp;
break;
case -1: /* Inverted image scan */
roamp = -epiro_grad.amp;
roramp = -ror_grad.amp;
break;
case -2: /* Inverted reference scan */
peamp = 0;
perinc = 0;
peramp = 0;
roamp = -epiro_grad.amp;
roramp = -ror_grad.amp;
break;
default: break;
}
/* Generate phase-ramped pulses: 90, 180, and IR */
offsetlist(pss,ss_grad.ssamp,0,freq90,ns,seqcon[1]);
shape90 = shapelist(p1pat,ss_grad.rfDuration,freq90,ns,0,seqcon[1]);
if (spinecho[0] == 'y') {
offsetlist(pss,ss2_grad.ssamp,0,freq180,ns,seqcon[1]);
shape180 = shapelist(p2pat,ss2_grad.rfDuration,freq180,ns,0,seqcon[1]);
}
if (ir[0] == 'y') {
offsetlist(pss,ssi_grad.ssamp,0,freqIR,ns,seqcon[1]);
shapeIR = shapelist(pipat,ssi_grad.rfDuration,freqIR,ns,0,seqcon[1]);
}
sgl_error_check(sglerror);
roff1 = -poffset(pro,epi_grad.amppos);
roff2 = -poffset(pro,epi_grad.ampneg);
roffn = -poffset(pro,nav_grad.amp);
roff1 = -poffset(pro,epi_grad.amppos*roamp/epiro_grad.amp);
roff2 = -poffset(pro,epi_grad.ampneg*roamp/epiro_grad.amp);
roffn = -poffset(pro,nav_grad.amp);
dw = granularity(1/sw,1/epi_grad.ddrsr);
/* Total Scan Time */
g_setExpTime(tr*nt*nseg*arraydim);
/******************************************************/
/* PULSE SEQUENCE *************************************/
/******************************************************/
rotate();
F_initval(epi_grad.etl/2, vetl);
/* vetl is the loop counter in the acquisition loop */
/* that includes both a positive and negative readout lobe */
F_initval(nseg, vnseg);
/* NB. F_initval(-ssepi,vssepi); currently gives errors */
initval(-ssepi,vssepi); /* gradient steady state lobes */
obsoffset(resto); delay(GDELAY);
ifzero(rtonce); grad_advance(gpropdelay); endif(rtonce);
loop(vnseg,vnseg_ctr); /* Loop through segments in segmented EPI */
msloop(seqcon[1],ns,vms_slices,vms_ctr); /* Multislice loop */
assign(vssepi,vssepi_ctr);
sp1on(); delay(4e-6); sp1off(); /* Output trigger to look at scope */
if (ticks) {
xgate(ticks);
grad_advance(gpropdelay);
delay(4e-6);
}
getelem(t2,vnseg_ctr,vblip); /* vblip = t2[vnseg_ctr]; either 1 or -1 for pos/neg blip */
/* Optional FAT SAT */
if (fsat[0] == 'y') {
fatsat();
}
/* Optional IR + TI delay */
if (ir[0] == 'y') {
obspower(ir_rf.powerCoarse);
obspwrf(ir_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ssi_grad.name,ssi_grad.duration,0.0,0.0,ssi_grad.amp,NOWAIT);
delay(ssi_grad.rfDelayBack);
shapedpulselist(shapeIR,ssi_grad.rfDuration,oph,rof1,rof1,seqcon[1],vms_ctr);
delay(ssi_grad.rfDelayBack);
delay(ti_delay);
}
/* 90 ss degree pulse */
obspower(p1_rf.powerCoarse);
obspwrf(p1_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ss_grad.name,ss_grad.duration,0.0,0.0,ss_grad.amp,NOWAIT);
delay(ss_grad.rfDelayFront);
shapedpulselist(shape90,p1_rf.rfDuration,oph,rof1,rof2,seqcon[1],vms_ctr);
delay(ss_grad.rfDelayBack);
/* Slice refocus */
obl_shapedgradient(ssr_grad.name,ssr_grad.duration,0,0,-ssr_grad.amp,WAIT);
delay(del1);
if (diff[0] == 'y')
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del2);
if (diff_in_one)
obl_shapedgradient(diff_grad.name,diff_grad.duration,
-diff_grad.amp*dro,-diff_grad.amp*dpe,-diff_grad.amp*dsl,WAIT);
delay(del3);
/* Optional 180 ss degree pulse with crushers */
if (spinecho[0] == 'y') {
obspower(p2_rf.powerCoarse);
obspwrf(p2_rf.powerFine);
delay(GDELAY);
obl_shapedgradient(ss2_grad.name,ss2_grad.duration,0.0,0.0,ss2_grad.amp,NOWAIT);
delay(ss2_grad.rfDelayFront);
shapedpulselist(shape180,ss2_grad.rfDuration,oph,rof1,rof1,seqcon[1],vms_ctr);
delay(ss2_grad.rfDelayBack);
}
delay(del4);
if ((diff[0] == 'y') && !diff_in_one)
obl_shapedgradient(diff_grad.name,diff_grad.duration,
diff_grad.amp*dro,diff_grad.amp*dpe,diff_grad.amp*dsl,WAIT);
delay(del5);
/* Optional navigator echo */
if (navigator[0] == 'y') {
obl_shapedgradient(ror_grad.name,ror_grad.duration,roramp,0,0,WAIT);
obl_shapedgradient(nav_grad.name,nav_grad.duration,
-nav_grad.amp,0,0,NOWAIT);
delay(tep);
roff = roffn; /* Set receiver offset for navigator gradient */
delay(epi_grad.skip-alfa); /* ramp up */
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw);
delay((epi_grad.dwell[i] - dw));
}
sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
/* Phase encode dephaser here if navigator echo was acquired */
var_shapedgradient(per_grad.name,per_grad.duration,0,-peramp,0,perinc,vnseg_ctr,WAIT);
}
else {
var_shapedgradient(per_grad.name,per_grad.duration,
-roramp,-peramp,0,perinc,vnseg_ctr,WAIT);
}
/* Start readout and phase encode gradient waveforms, NOWAIT */
/* If alternating ky-ordering, get polarity on blips from table */
var_shaped3gradient(epiro_grad.name,epipe_grad.name,"", /* patterns */
epiro_grad.duration, /* duration */
roamp,0,0, /* amplitudes */
peamp,vblip, /* step and multiplier */
NOWAIT); /* Don't wait */
delay(tep);
/* Acquisition loop */
assign(one,vacquire); // real-time acquire flag
nowait_loop(epi_grad.etl/2 + ssepi,vetl,vetl_ctr);
ifzero(vssepi_ctr); //vssepi_ctr = -ssepi, -ssepi+1, ..., 0, 1,2,...
assign(zero,vacquire); // turn on acquisition after all ss lobes
endif(vssepi_ctr);
incr(vssepi_ctr);
setacqvar(vacquire); // Set acquire flag
roff = roff1; /* Set receiver offset for positive gradient */
delay(epi_grad.skip-alfa); /* ramp up */
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw); //dw = 1/sw
delay((epi_grad.dwell[i] - dw));
}
if (aqtm > at) sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
roff = roff2; /* Set receiver offset for negative gradient */
delay(epi_grad.skip-alfa);
startacq(alfa);
for(i=0;i<np/2;i++){
sample(dw);
delay((epi_grad.dwell[i] - dw));
}
if (aqtm > at) sample(aqtm-at);
endacq();
delay(epi_grad.skip - dw - (aqtm-at));
nowait_endloop(vetl_ctr);
delay(tr_delay);
endmsloop(seqcon[1],vms_ctr); /* end multislice loop */
endloop(vnseg_ctr); /* end segments loop */
} /* end pulsesequence */
int loop(window& main_wnd)
{
main_wnd.on_unload.add([] { ::PostQuitMessage(0); });
return loop();
}
JNIEXPORT jint JNICALL Java_com_apple_dnssd_DNSSDEmbedded_Loop( JNIEnv *pEnv, jclass cls)
{
return loop();
}
static int do_server(int type)
{
int rv = -1;
static char log_ent[128] = DAEMON_NAME "-";
rv = setup_config(type);
if (rv < 0)
return rv;
if (!local) {
log_error("Cannot find myself in the configuration.");
exit(EXIT_FAILURE);
}
if (daemonize) {
if (daemon(0, 0) < 0) {
perror("daemon error");
exit(EXIT_FAILURE);
}
}
/* The lockfile must be written to _after_ the call to daemon(), so
* that the lockfile contains the pid of the daemon, not the parent. */
lock_fd = create_lockfile();
if (lock_fd < 0)
return lock_fd;
atexit(server_exit);
strcat(log_ent, type_to_string(local->type));
cl_log_set_entity(log_ent);
cl_log_enable_stderr(enable_stderr ? TRUE : FALSE);
cl_log_set_facility(HA_LOG_FACILITY);
cl_inherit_logging_environment(0);
log_info("BOOTH %s %s daemon is starting",
type_to_string(local->type), RELEASE_STR);
signal(SIGUSR1, (__sighandler_t)tickets_log_info);
signal(SIGTERM, (__sighandler_t)sig_exit_handler);
signal(SIGINT, (__sighandler_t)sig_exit_handler);
/* we'll handle errors there and then */
signal(SIGPIPE, SIG_IGN);
set_scheduler();
/* we don't want to be killed by the OOM-killer */
if (set_procfs_val("/proc/self/oom_score_adj", "-999"))
(void)set_procfs_val("/proc/self/oom_adj", "-16");
set_proc_title("%s %s %s for [%s]:%d",
DAEMON_NAME,
cl.configfile,
type_to_string(local->type),
local->addr_string,
booth_conf->port);
rv = limit_this_process();
if (rv)
return rv;
#ifdef COREDUMP_NURSING
if (cl_enable_coredumps(TRUE) < 0){
log_error("enabling core dump failed");
}
cl_cdtocoredir();
prctl(PR_SET_DUMPABLE, (unsigned long)TRUE, 0UL, 0UL, 0UL);
#else
if (chdir(BOOTH_CORE_DIR) < 0) {
log_error("cannot change working directory to %s", BOOTH_CORE_DIR);
}
#endif
signal(SIGCHLD, (__sighandler_t)wait_child);
rv = loop(lock_fd);
return rv;
}
uptr_t exec_special(uptr_t *env, uptr_t form) {
uptr_t fn = CAR(form);
uptr_t args = CDR(form);
switch(SVAL(fn)) {
case S_LET:
return let(env, args);
case S_FN:
return form;
case S_LOOP:
return loop(env, args);
case S_DO: {
uptr_t *body_p = refer(args), rval = NIL;
while (*body_p) {
rval = eval(env, CAR(*body_p));
*body_p = CDR(*body_p);
}
release(1); // body_p
return rval;
}
case S_RECUR: {
uptr_t rval, *fn_p = refer(fn);
rval = build_cons(*fn_p, eval_list(env, args));
release(1); // fn_p
return rval;
}
case S_QUOTE:
return CAR(args);
case S_CAR:
return CAR(eval(env, CAR(args)));
case S_CDR:
return CDR(eval(env, CAR(args)));
case S_AND: {
if (IS_NIL(args)) return PS_TRUE;
uptr_t *rem_args = refer(args),
rval = NIL;
while ((rval = eval(env, CAR(*rem_args))) && (*rem_args = CDR(*rem_args)));
release(1);
return rval;
}
case S_OR: {
if (IS_NIL(args)) return NIL;
uptr_t *rem_args = refer(args),
rval = NIL;
while (!(rval = eval(env, CAR(*rem_args))) && (*rem_args = CDR(*rem_args)));
release(1);
return rval;
}
case S_NOT: {
if (IS_NIL(args)) return NIL;
uptr_t rval = eval(env, CAR(args));
return rval ? NIL : PS_TRUE;
}
case S_IF: {
uptr_t rval = NIL, *clauses = refer(args);
if (eval(env, CAR(*clauses)) && CDR(*clauses))
rval = eval(env, CADR(*clauses));
else if (CDDR(*clauses))
rval = eval(env, CADDR(*clauses));
release(1); // clauses
return rval;
}
case S_WHEN: {
uptr_t rval = NIL, *cond_p = refer(CAR(args)), *body_p = refer(CDR(args));
if (eval(env, *cond_p))
while(*body_p) {
rval = eval(env, CAR(*body_p));
*body_p = CDR(*body_p);
}
release(2); // cond_p, body_p
return rval;
}
case S_CONS: {
uptr_t rval = NIL, *args_p = refer(args);
rval = build_cons(eval(env, CAR(*args_p)), eval(env, CADR(*args_p)));
release(1); // args_p
return rval;
}
case S_PRINT:
print_form(eval(env, CAR(args)));
printf_P(PSTR("\n"));
return NIL;
case S_DEF: {
uptr_t *args_p = refer(args),
*binding = refer(eval(env, CADR(args)));
assoc(env, CAR(*args_p), *binding);
release(2); // args_p, binding
return *binding; // Yeah, it's been "released", but the pointer is still valid.
}
case S_EVAL:
return eval(env, eval(env, CAR(args)));
#define _COMPR(rval) { \
if (IS_NIL(args)) return NIL; \
\
uptr_t *args_p = refer(args); \
while(CDR(*args_p) && (eval(env, CAR(*args_p)) _COMP_OPR eval(env, CADR(*args_p)))) \
*args_p = CDR(*args_p); \
\
if (IS_NIL(CDR(*args_p))) \
rval = eval(env, CAR(*args_p)); \
release(1); \
}
#define _COMP_OPR ==
case S_EQL: {
uptr_t rval = NIL;
_COMPR(rval);
return rval;
}
case S_NEQL: {
uptr_t rval = NIL;
_COMPR(rval);
return rval ? NIL : PS_TRUE;
}
#undef _COMP_OPR
#define _COMP_OPR <
case S_LT: {
uptr_t rval = NIL;
_COMPR(rval);
return rval;
}
#undef _COMP_OPR
#define _COMP_OPR <=
case S_LTE: {
uptr_t rval = NIL;
_COMPR(rval);
return rval;
}
#undef _COMP_OPR
#define _COMP_OPR >
case S_GT: {
uptr_t rval = NIL;
_COMPR(rval);
return rval;
}
#undef _COMP_OPR
#define _COMP_OPR >=
case S_GTE: {
uptr_t rval = NIL;
_COMPR(rval);
return rval;
}
#undef _COMP_OPR
#define _ARITH(coll) { \
uptr_t *rem_args = refer(args); \
coll = TO_INT(eval(env, CAR(*rem_args))); \
*rem_args = CDR(*rem_args); \
while (*rem_args) { \
coll _ARITH_OPR TO_INT(eval(env, CAR(*rem_args))); \
*rem_args = CDR(*rem_args); \
} \
release(1); \
}
#define _ARITH_OPR +=
case S_PLUS: {
if (! args) return INTERN_INT(0);
if (! CDR(args)) return eval(env, CAR(args));
int rval;
_ARITH(rval);
return INTERN_INT(rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR -=
case S_MINUS: {
if (! args) return NIL;
if (! CDR(args)) return INTERN_INT(0 - TO_INT(eval(env, CAR(args))));
int rval;
_ARITH(rval);
return INTERN_INT(rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR *=
case S_MULT: {
if (! args) return INTERN_INT(1);
if (! CDR(args)) return eval(env, CAR(args));
int rval;
_ARITH(rval);
return INTERN_INT(rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR /=
case S_DIV: {
if (! args) return NIL;
if (! CDR(args)) return INTERN_INT(eval(env, CAR(args)) == INTERN_INT(1) ? 1 : 0);
int rval;
_ARITH(rval);
return INTERN_INT(rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR &=
case S_BAND: {
if (! args) return NIL;
if (! CDR(args)) return eval(env, CAR(args));
uint8_t rval;
_ARITH(rval);
return INTERN_INT((int)rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR |=
case S_BOR: {
if (! args) return NIL;
if (! CDR(args)) return eval(env, CAR(args));
uint8_t rval;
_ARITH(rval);
return INTERN_INT((int)rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR ^=
case S_BXOR: {
if (! args) return NIL;
if (! CDR(args)) return eval(env, CAR(args));
uint8_t rval;
_ARITH(rval);
return INTERN_INT((int)rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR <<=
case S_BSL: {
if (! args) return NIL;
if (! CDR(args)) return eval(env, CAR(args));
uint8_t rval;
_ARITH(rval);
return INTERN_INT((int)rval);
}
#undef _ARITH_OPR
#define _ARITH_OPR >>=
case S_BSR: {
if (! args) return NIL;
if (! CDR(args)) return eval(env, CAR(args));
uint8_t rval;
_ARITH(rval);
return INTERN_INT((int)rval);
}
#undef _ARITH_OPR
case S_SREG: {
uptr_t *args_p = refer(args),
reg = eval(env, CAR(*args_p));
if (IS_REG(reg))
*BYTE_PTR(reg) = eval(env, CADR(*args_p));
else {
printf_P(PSTR("Invalid register: "));
print_form(reg);
printf_P(PSTR("\n"));
}
release(1); // args_p
return NIL;
}
case S_SLP:
_delay_ms(TO_INT(eval(env, CAR(args))));
return NIL;
default:
printf_P(PSTR("ERROR: "));
print_form(fn);
printf_P(PSTR(" is not a function.\n"));
return NIL;
}
}
int main(int argc, char** argv)
{
RemoveCrashDump removeCrashDump;
#ifdef OS_Darwin
struct rlimit rlp;
if (getrlimit(RLIMIT_NOFILE, &rlp) == 0) {
if (rlp.rlim_cur < 1000) {
rlp.rlim_cur = 1000;
setrlimit(RLIMIT_NOFILE, &rlp);
}
}
#endif
Rct::findExecutablePath(*argv);
bool daemon = false;
Server::Options serverOpts;
serverOpts.socketFile = String::format<128>("%s.rdm", Path::home().constData());
serverOpts.jobCount = std::max(2, ThreadPool::idealThreadCount());
serverOpts.headerErrorJobCount = -1;
serverOpts.rpVisitFileTimeout = DEFAULT_RP_VISITFILE_TIMEOUT;
serverOpts.rpIndexDataMessageTimeout = DEFAULT_RP_INDEXER_MESSAGE_TIMEOUT;
serverOpts.rpConnectTimeout = DEFAULT_RP_CONNECT_TIMEOUT;
serverOpts.rpConnectAttempts = DEFAULT_RP_CONNECT_ATTEMPTS;
serverOpts.maxFileMapScopeCacheSize = DEFAULT_RDM_MAX_FILE_MAP_CACHE_SIZE;
serverOpts.errorLimit = DEFAULT_ERROR_LIMIT;
serverOpts.rpNiceValue = INT_MIN;
serverOpts.options = Server::Wall|Server::SpellChecking;
serverOpts.maxCrashCount = DEFAULT_MAX_CRASH_COUNT;
serverOpts.completionCacheSize = DEFAULT_COMPLETION_CACHE_SIZE;
serverOpts.maxIncludeCompletionDepth = DEFAULT_MAX_INCLUDE_COMPLETION_DEPTH;
serverOpts.rp = defaultRP();
strcpy(crashDumpFilePath, "crash.dump");
#ifdef OS_FreeBSD
serverOpts.options |= Server::NoFileManagerWatch;
#endif
// #ifndef NDEBUG
// serverOpts.options |= Server::SuspendRPOnCrash;
// #endif
serverOpts.dataDir = String::format<128>("%s.rtags", Path::home().constData());
Path logFile;
Flags<LogFlag> logFlags = DontRotate|LogStderr;
LogLevel logLevel(LogLevel::Error);
LogLevel logFileLogLevel(LogLevel::Error);
bool sigHandler = true;
assert(Path::home().endsWith('/'));
int inactivityTimeout = 0;
const std::initializer_list<CommandLineParser::Option<OptionType> > opts = {
{ None, 0, 0, CommandLineParser::NoValue, "Options:" },
{ Help, "help", 'h', CommandLineParser::NoValue, "Display this page." },
{ Version, "version", 0, CommandLineParser::NoValue, "Display version." },
{ IncludePath, "include-path", 'I', CommandLineParser::Required, "Add additional include path to clang." },
{ Isystem, "isystem", 's', CommandLineParser::Required, "Add additional system include path to clang." },
{ Define, "define", 'D', CommandLineParser::Required, "Add additional define directive to clang" },
{ LogFile, "log-file", 'L', CommandLineParser::Required, "Log to this file." },
{ CrashDumpFile, "crash-dump-file", 0, CommandLineParser::Required, "File to dump crash log to (default is <datadir>/crash.dump)." },
{ SetEnv, "setenv", 'e', CommandLineParser::Required, "Set this environment variable (--setenv \"foobar=1\")." },
{ NoWall, "no-Wall", 'W', CommandLineParser::NoValue, "Don't use -Wall." },
{ Weverything, "Weverything", 'u', CommandLineParser::NoValue, "Use -Weverything." },
{ Verbose, "verbose", 'v', CommandLineParser::NoValue, "Change verbosity, multiple -v's are allowed." },
{ JobCount, "job-count", 'j', CommandLineParser::Required, String::format("Spawn this many concurrent processes for indexing (default %d).",
std::max(2, ThreadPool::idealThreadCount())) },
{ HeaderErrorJobCount, "header-error-job-count", 'H', CommandLineParser::Required, "Allow this many concurrent header error jobs (default std::max(1, --job-count / 2))." },
{ Test, "test", 't', CommandLineParser::Required, "Run this test." },
{ TestTimeout, "test-timeout", 'z', CommandLineParser::Required, "Timeout for test to complete." },
{ CleanSlate, "clean-slate", 'C', CommandLineParser::NoValue, "Clear out all data." },
{ DisableSigHandler, "disable-sighandler", 'x', CommandLineParser::NoValue, "Disable signal handler to dump stack for crashes." },
{ Silent, "silent", 'S', CommandLineParser::NoValue, "No logging to stdout/stderr." },
{ ExcludeFilter, "exclude-filter", 'X', CommandLineParser::Required, "Files to exclude from rdm, default \"" DEFAULT_EXCLUDEFILTER "\"." },
{ SocketFile, "socket-file", 'n', CommandLineParser::Required, "Use this file for the server socket (default ~/.rdm)." },
{ DataDir, "data-dir", 'd', CommandLineParser::Required, "Use this directory to store persistent data (default ~/.rtags)." },
{ IgnorePrintfFixits, "ignore-printf-fixits", 'F', CommandLineParser::NoValue, "Disregard any clang fixit that looks like it's trying to fix format for printf and friends." },
{ ErrorLimit, "error-limit", 'f', CommandLineParser::Required, "Set error limit to argument (-ferror-limit={arg} (default " STR(DEFAULT_ERROR_LIMIT) ")." },
{ BlockArgument, "block-argument", 'G', CommandLineParser::Required, "Block this argument from being passed to clang. E.g. rdm --block-argument -fno-inline" },
{ NoSpellChecking, "no-spell-checking", 'l', CommandLineParser::NoValue, "Don't pass -fspell-checking." },
{ LargeByValueCopy, "large-by-value-copy", 'r', CommandLineParser::Required, "Use -Wlarge-by-value-copy=[arg] when invoking clang." },
{ AllowMultipleSources, "allow-multiple-sources", 'm', CommandLineParser::NoValue, "Don't merge source files added with -c." },
{ NoStartupProject, "no-startup-project", 'o', CommandLineParser::NoValue, "Don't restore the last current project on startup." },
{ NoNoUnknownWarningsOption, "no-no-unknown-warnings-option", 'Y', CommandLineParser::NoValue, "Don't pass -Wno-unknown-warning-option." },
{ IgnoreCompiler, "ignore-compiler", 'b', CommandLineParser::Required, "Ignore this compiler." },
{ CompilerWrappers, "compiler-wrappers", 0, CommandLineParser::Required, "Consider these filenames compiler wrappers (split on ;), default " DEFAULT_COMPILER_WRAPPERS "\"." },
{ WatchSystemPaths, "watch-system-paths", 'w', CommandLineParser::NoValue, "Watch system paths for changes." },
{ RpVisitFileTimeout, "rp-visit-file-timeout", 'Z', CommandLineParser::Required, "Timeout for rp visitfile commands in ms (0 means no timeout) (default " STR(DEFAULT_RP_VISITFILE_TIMEOUT) ")." },
{ RpIndexerMessageTimeout, "rp-indexer-message-timeout", 'T', CommandLineParser::Required, "Timeout for rp indexer-message in ms (0 means no timeout) (default " STR(DEFAULT_RP_INDEXER_MESSAGE_TIMEOUT) ")." },
{ RpConnectTimeout, "rp-connect-timeout", 'O', CommandLineParser::Required, "Timeout for connection from rp to rdm in ms (0 means no timeout) (default " STR(DEFAULT_RP_CONNECT_TIMEOUT) ")." },
{ RpConnectAttempts, "rp-connect-attempts", 0, CommandLineParser::Required, "Number of times rp attempts to connect to rdm before giving up. (default " STR(DEFAULT_RP_CONNECT_ATTEMPTS) ")." },
{ RpNiceValue, "rp-nice-value", 'a', CommandLineParser::Required, "Nice value to use for rp (nice(2)) (default is no nicing)." },
{ SuspendRpOnCrash, "suspend-rp-on-crash", 'q', CommandLineParser::NoValue, "Suspend rp in SIGSEGV handler (default " DEFAULT_SUSPEND_RP ")." },
{ RpLogToSyslog, "rp-log-to-syslog", 0, CommandLineParser::NoValue, "Make rp log to syslog." },
{ StartSuspended, "start-suspended", 'Q', CommandLineParser::NoValue, "Start out suspended (no reindexing enabled)." },
{ SeparateDebugAndRelease, "separate-debug-and-release", 'E', CommandLineParser::NoValue, "Normally rdm doesn't consider release and debug as different builds. Pass this if you want it to." },
{ Separate32BitAnd64Bit, "separate-32-bit-and-64-bit", 0, CommandLineParser::NoValue, "Normally rdm doesn't consider -m32 and -m64 as different builds. Pass this if you want it to." },
{ SourceIgnoreIncludePathDifferencesInUsr, "ignore-include-path-differences-in-usr", 0, CommandLineParser::NoValue, "Don't consider sources that only differ in includepaths within /usr (not including /usr/home/) as different builds." },
{ MaxCrashCount, "max-crash-count", 'K', CommandLineParser::Required, "Max number of crashes before giving up a sourcefile (default " STR(DEFAULT_MAX_CRASH_COUNT) ")." },
{ CompletionCacheSize, "completion-cache-size", 'i', CommandLineParser::Required, "Number of translation units to cache (default " STR(DEFAULT_COMPLETION_CACHE_SIZE) ")." },
{ CompletionNoFilter, "completion-no-filter", 0, CommandLineParser::NoValue, "Don't filter private members and destructors from completions." },
{ CompletionLogs, "completion-logs", 0, CommandLineParser::NoValue, "Log more info about completions." },
{ MaxIncludeCompletionDepth, "max-include-completion-depth", 0, CommandLineParser::Required, "Max recursion depth for header completion (default " STR(DEFAULT_MAX_INCLUDE_COMPLETION_DEPTH) ")." },
{ AllowWpedantic, "allow-Wpedantic", 'P', CommandLineParser::NoValue, "Don't strip out -Wpedantic. This can cause problems in certain projects." },
{ AllowWErrorAndWFatalErrors, "allow-Werror", 0, CommandLineParser::NoValue, "Don't strip out -Werror and -Wfatal-error. By default these are stripped out. " },
{ EnableCompilerManager, "enable-compiler-manager", 'R', CommandLineParser::NoValue, "Query compilers for their actual include paths instead of letting clang use its own." },
{ EnableNDEBUG, "enable-NDEBUG", 'g', CommandLineParser::NoValue, "Don't remove -DNDEBUG from compile lines." },
{ Progress, "progress", 'p', CommandLineParser::NoValue, "Report compilation progress in diagnostics output." },
{ MaxFileMapCacheSize, "max-file-map-cache-size", 'y', CommandLineParser::Required, "Max files to cache per query (Should not exceed maximum number of open file descriptors allowed per process) (default " STR(DEFAULT_RDM_MAX_FILE_MAP_CACHE_SIZE) ")." },
#ifdef FILEMANAGER_OPT_IN
{ FileManagerWatch, "filemanager-watch", 'M', CommandLineParser::NoValue, "Use a file system watcher for filemanager." },
#else
{ NoFileManagerWatch, "no-filemanager-watch", 'M', CommandLineParser::NoValue, "Don't use a file system watcher for filemanager." },
#endif
{ NoFileManager, "no-filemanager", 0, CommandLineParser::NoValue, "Don't scan project directory for files. (rc -P won't work)." },
{ NoFileLock, "no-file-lock", 0, CommandLineParser::NoValue, "Disable file locking. Not entirely safe but might improve performance on certain systems." },
{ PchEnabled, "pch-enabled", 0, CommandLineParser::NoValue, "Enable PCH (experimental)." },
{ NoFilesystemWatcher, "no-filesystem-watcher", 'B', CommandLineParser::NoValue, "Disable file system watching altogether. Reindexing has to be triggered manually." },
{ ArgTransform, "arg-transform", 'V', CommandLineParser::Required, "Use arg to transform arguments. [arg] should be executable with (execv(3))." },
{ NoComments, "no-comments", 0, CommandLineParser::NoValue, "Don't parse/store doxygen comments." },
#ifdef RTAGS_HAS_LAUNCHD
{ Launchd, "launchd", 0, CommandLineParser::NoValue, "Run as a launchd job (use launchd API to retrieve socket opened by launchd on rdm's behalf)." },
#endif
{ InactivityTimeout, "inactivity-timeout", 0, CommandLineParser::Required, "Time in seconds after which rdm will quit if there's been no activity (N.B., once rdm has quit, something will need to re-run it!)." },
{ Daemon, "daemon", 0, CommandLineParser::NoValue, "Run as daemon (detach from terminal)." },
{ LogFileLogLevel, "log-file-log-level", 0, CommandLineParser::Required, "Log level for log file (default is error), options are: error, warning, debug or verbose-debug." },
{ WatchSourcesOnly, "watch-sources-only", 0, CommandLineParser::NoValue, "Only watch source files (not dependencies)." },
{ DebugLocations, "debug-locations", 0, CommandLineParser::NoValue, "Set debug locations." },
{ ValidateFileMaps, "validate-file-maps", 0, CommandLineParser::NoValue, "Spend some time validating project data on startup." },
{ TcpPort, "tcp-port", 0, CommandLineParser::Required, "Listen on this tcp socket (default none)." },
{ RpPath, "rp-path", 0, CommandLineParser::Required, String::format<256>("Path to rp (default %s).", defaultRP().constData()) },
{ LogTimestamp, "log-timestamp", 0, CommandLineParser::NoValue, "Add timestamp to logs." },
{ LogFlushOption, "log-flush", 0, CommandLineParser::NoValue, "Flush stderr/stdout after each log." },
{ SandboxRoot, "sandbox-root", 0, CommandLineParser::Required, "Create index using relative paths by stripping dir (enables copying of tag index db files without need to reindex)." },
{ PollTimer, "poll-timer", 0, CommandLineParser::Required, "Poll the database of the current project every <arg> seconds. " },
{ NoRealPath, "no-realpath", 0, CommandLineParser::NoValue, "Don't use realpath(3) for files" },
{ Noop, "config", 'c', CommandLineParser::Required, "Use this file (instead of ~/.rdmrc)." },
{ Noop, "no-rc", 'N', CommandLineParser::NoValue, "Don't load any rc files." }
};
std::function<CommandLineParser::ParseStatus(OptionType type, String &&value, size_t &idx, const List<String> &args)> cb;
cb = [&](OptionType type, String &&value, size_t &, const List<String> &) -> CommandLineParser::ParseStatus {
switch (type) {
case None:
case Noop:
break;
case Help: {
CommandLineParser::help(stdout, Rct::executablePath().fileName(), opts);
return { String(), CommandLineParser::Parse_Ok }; }
case Version: {
fprintf(stdout, "%s\n", RTags::versionString().constData());
return { String(), CommandLineParser::Parse_Ok }; }
case IncludePath: {
serverOpts.includePaths.append(Source::Include(Source::Include::Type_Include, Path::resolved(value)));
break; }
case Isystem: {
serverOpts.includePaths.append(Source::Include(Source::Include::Type_System, Path::resolved(value)));
break; }
case Define: {
const size_t eq = value.indexOf('=');
Source::Define def;
if (eq == String::npos) {
def.define = std::move(value);
} else {
def.define = value.left(eq);
def.value = value.mid(eq + 1);
}
serverOpts.defines.append(def);
break; }
case LogFile: {
logFile = std::move(value);
logFile.resolve();
logLevel = LogLevel::None;
break; }
case CrashDumpFile: {
strncpy(crashDumpFilePath, value.constData(), sizeof(crashDumpFilePath) - 1);
break; }
case SetEnv: {
putenv(&value[0]);
break; }
case NoWall: {
serverOpts.options &= ~Server::Wall;
break; }
case Weverything: {
serverOpts.options |= Server::Weverything;
break; }
case Verbose: {
if (logLevel != LogLevel::None)
++logLevel;
break; }
case JobCount: {
bool ok;
serverOpts.jobCount = String(value).toULong(&ok);
if (!ok) {
return { String::format<1024>("Can't parse argument to -j %s. -j must be a positive integer.\n", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case HeaderErrorJobCount: {
bool ok;
serverOpts.headerErrorJobCount = String(value).toULong(&ok);
if (!ok) {
return { String::format<1024>("Can't parse argument to -H %s. -H must be a positive integer.", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case Test: {
Path test(value);
if (!test.resolve() || !test.isFile()) {
return { String::format<1024>("%s doesn't seem to be a file", value.constData()), CommandLineParser::Parse_Error };
}
serverOpts.tests += test;
break; }
case TestTimeout: {
serverOpts.testTimeout = atoi(value.constData());
if (serverOpts.testTimeout <= 0) {
return { String::format<1024>("Invalid argument to -z %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case PollTimer: {
serverOpts.pollTimer = atoi(value.constData());
if (serverOpts.pollTimer < 0) {
return { String::format<1024>("Invalid argument to --poll-timer %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case CleanSlate: {
serverOpts.options |= Server::ClearProjects;
break; }
case DisableSigHandler: {
sigHandler = false;
break; }
case Silent: {
logLevel = LogLevel::None;
break; }
case ExcludeFilter: {
serverOpts.excludeFilters += String(value).split(';');
break; }
case SocketFile: {
serverOpts.socketFile = std::move(value);
serverOpts.socketFile.resolve();
break; }
case DataDir: {
serverOpts.dataDir = String::format<128>("%s", Path::resolved(value).constData());
break; }
case IgnorePrintfFixits: {
serverOpts.options |= Server::IgnorePrintfFixits;
break; }
case ErrorLimit: {
bool ok;
serverOpts.errorLimit = String(value).toULong(&ok);
if (!ok) {
return { String::format<1024>("Can't parse argument to --error-limit %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case BlockArgument: {
serverOpts.blockedArguments << value;
break; }
case NoSpellChecking: {
serverOpts.options &= ~Server::SpellChecking;
break; }
case LargeByValueCopy: {
int large = atoi(value.constData());
if (large <= 0) {
return { String::format<1024>("Can't parse argument to -r %s", value.constData()), CommandLineParser::Parse_Error };
}
serverOpts.defaultArguments.append("-Wlarge-by-value-copy=" + String(value)); // ### not quite working
break; }
case AllowMultipleSources: {
serverOpts.options |= Server::AllowMultipleSources;
break; }
case NoStartupProject: {
serverOpts.options |= Server::NoStartupCurrentProject;
break; }
case NoNoUnknownWarningsOption: {
serverOpts.options |= Server::NoNoUnknownWarningsOption;
break; }
case IgnoreCompiler: {
serverOpts.ignoredCompilers.insert(Path::resolved(value));
break; }
case CompilerWrappers: {
serverOpts.compilerWrappers = String(value).split(";", String::SkipEmpty).toSet();
break; }
case WatchSystemPaths: {
serverOpts.options |= Server::WatchSystemPaths;
break; }
case RpVisitFileTimeout: {
serverOpts.rpVisitFileTimeout = atoi(value.constData());
if (serverOpts.rpVisitFileTimeout < 0) {
return { String::format<1024>("Invalid argument to -Z %s", value.constData()), CommandLineParser::Parse_Error };
}
if (!serverOpts.rpVisitFileTimeout)
serverOpts.rpVisitFileTimeout = -1;
break; }
case RpIndexerMessageTimeout: {
serverOpts.rpIndexDataMessageTimeout = atoi(value.constData());
if (serverOpts.rpIndexDataMessageTimeout <= 0) {
return { String::format<1024>("Can't parse argument to -T %s.", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case RpConnectTimeout: {
serverOpts.rpConnectTimeout = atoi(value.constData());
if (serverOpts.rpConnectTimeout < 0) {
return { String::format<1024>("Invalid argument to -O %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case RpConnectAttempts: {
serverOpts.rpConnectAttempts = atoi(value.constData());
if (serverOpts.rpConnectAttempts <= 0) {
return { String::format<1024>("Invalid argument to --rp-connect-attempts %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case RpNiceValue: {
bool ok;
serverOpts.rpNiceValue = String(value).toLong(&ok);
if (!ok) {
return { String::format<1024>("Can't parse argument to -a %s.", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case SuspendRpOnCrash: {
serverOpts.options |= Server::SuspendRPOnCrash;
break; }
case RpLogToSyslog: {
serverOpts.options |= Server::RPLogToSyslog;
break; }
case StartSuspended: {
serverOpts.options |= Server::StartSuspended;
break; }
case SeparateDebugAndRelease: {
serverOpts.options |= Server::SeparateDebugAndRelease;
break; }
case Separate32BitAnd64Bit: {
serverOpts.options |= Server::Separate32BitAnd64Bit;
break; }
case SourceIgnoreIncludePathDifferencesInUsr: {
serverOpts.options |= Server::SourceIgnoreIncludePathDifferencesInUsr;
break; }
case MaxCrashCount: {
serverOpts.maxCrashCount = atoi(value.constData());
if (serverOpts.maxCrashCount <= 0) {
return { String::format<1024>("Invalid argument to -K %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case CompletionCacheSize: {
serverOpts.completionCacheSize = atoi(value.constData());
if (serverOpts.completionCacheSize <= 0) {
return { String::format<1024>("Invalid argument to -i %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case CompletionNoFilter: {
serverOpts.options |= Server::CompletionsNoFilter;
break; }
case CompletionLogs: {
serverOpts.options |= Server::CompletionLogs;
break; }
case MaxIncludeCompletionDepth: {
serverOpts.maxIncludeCompletionDepth = strtoul(value.constData(), 0, 10);
break; }
case AllowWpedantic: {
serverOpts.options |= Server::AllowPedantic;
break; }
case AllowWErrorAndWFatalErrors: {
serverOpts.options |= Server::AllowWErrorAndWFatalErrors;
break; }
case EnableCompilerManager: {
serverOpts.options |= Server::EnableCompilerManager;
break; }
case EnableNDEBUG: {
serverOpts.options |= Server::EnableNDEBUG;
break; }
case Progress: {
serverOpts.options |= Server::Progress;
break; }
case MaxFileMapCacheSize: {
serverOpts.maxFileMapScopeCacheSize = atoi(value.constData());
if (serverOpts.maxFileMapScopeCacheSize <= 0) {
return { String::format<1024>("Invalid argument to -y %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
#ifdef FILEMANAGER_OPT_IN
case FileManagerWatch: {
serverOpts.options &= ~Server::NoFileManagerWatch;
break; }
#else
case NoFileManagerWatch: {
serverOpts.options |= Server::NoFileManagerWatch;
break; }
#endif
case NoFileManager: {
serverOpts.options |= Server::NoFileManager;
break; }
case NoFileLock: {
serverOpts.options |= Server::NoFileLock;
break; }
case PchEnabled: {
serverOpts.options |= Server::PCHEnabled;
break; }
case NoFilesystemWatcher: {
serverOpts.options |= Server::NoFileSystemWatch;
break; }
case ArgTransform: {
serverOpts.argTransform = Process::findCommand(value);
if (!value.isEmpty() && serverOpts.argTransform.isEmpty()) {
return { String::format<1024>("Invalid argument to -V. Can't resolve %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case NoComments: {
serverOpts.options |= Server::NoComments;
break; }
#ifdef RTAGS_HAS_LAUNCHD
case Launchd: {
serverOpts.options |= Server::Launchd;
break; }
#endif
case InactivityTimeout: {
inactivityTimeout = atoi(value.constData()); // seconds.
if (inactivityTimeout <= 0) {
return { String::format<1024>("Invalid argument to --inactivity-timeout %s", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case Daemon: {
daemon = true;
logLevel = LogLevel::None;
break; }
case LogFileLogLevel: {
if (!strcasecmp(value.constData(), "verbose-debug")) {
logFileLogLevel = LogLevel::VerboseDebug;
} else if (!strcasecmp(value.constData(), "debug")) {
logFileLogLevel = LogLevel::Debug;
} else if (!strcasecmp(value.constData(), "warning")) {
logFileLogLevel = LogLevel::Warning;
} else if (!strcasecmp(value.constData(), "error")) {
logFileLogLevel = LogLevel::Error;
} else {
return { String::format<1024>("Unknown log level: %s options are error, warning, debug or verbose-debug", value.constData()),
CommandLineParser::Parse_Error };
}
break; }
case WatchSourcesOnly: {
serverOpts.options |= Server::WatchSourcesOnly;
break; }
case DebugLocations: {
if (value == "clear" || value == "none") {
serverOpts.debugLocations.clear();
} else {
serverOpts.debugLocations << value;
}
break; }
case ValidateFileMaps: {
serverOpts.options |= Server::ValidateFileMaps;
break; }
case TcpPort: {
serverOpts.tcpPort = atoi(value.constData());
if (!serverOpts.tcpPort) {
return { String::format<1024>("Invalid port %s for --tcp-port", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case RpPath: {
serverOpts.rp = std::move(value);
if (serverOpts.rp.isFile()) {
serverOpts.rp.resolve();
} else {
return { String::format<1024>("%s is not a file", value.constData()), CommandLineParser::Parse_Error };
}
break; }
case LogTimestamp: {
logFlags |= LogTimeStamp;
break; }
case LogFlushOption: {
logFlags |= LogFlush;
break; }
case SandboxRoot: {
serverOpts.sandboxRoot = std::move(value);
if (!serverOpts.sandboxRoot.endsWith('/'))
serverOpts.sandboxRoot += '/';
if (!serverOpts.sandboxRoot.resolve() || !serverOpts.sandboxRoot.isDir()) {
return {
String::format<1024>("%s is not a valid directory for sandbox-root",
serverOpts.sandboxRoot.constData()),
CommandLineParser::Parse_Error
};
}
break; }
case NoRealPath: {
Path::setRealPathEnabled(false);
serverOpts.options |= Server::NoRealPath;
break; }
}
return { String(), CommandLineParser::Parse_Exec };
};
const std::initializer_list<CommandLineParser::Option<CommandLineParser::ConfigOptionType> > configOpts = {
{ CommandLineParser::Config, "config", 'c', CommandLineParser::Required, "Use this file (instead of ~/.rdmrc)." },
{ CommandLineParser::NoRc, "no-rc", 'N', CommandLineParser::NoValue, "Don't load any rc files." }
};
const CommandLineParser::ParseStatus status = CommandLineParser::parse<OptionType>(argc, argv, opts, NullFlags, cb, "rdm", configOpts);
switch (status.status) {
case CommandLineParser::Parse_Error:
fprintf(stderr, "%s\n", status.error.constData());
return 1;
case CommandLineParser::Parse_Ok:
return 0;
case CommandLineParser::Parse_Exec:
break;
}
if (daemon) {
switch (fork()) {
case -1:
fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno));
return 1;
case 0:
setsid();
switch (fork()) {
case -1:
fprintf(stderr, "Failed to fork (%d) %s\n", errno, strerror(errno));
return 1;
case 0:
break;
default:
return 0;
}
break;
default:
return 0;
}
}
if (serverOpts.excludeFilters.isEmpty())
serverOpts.excludeFilters = String(DEFAULT_EXCLUDEFILTER).split(';');
if (serverOpts.compilerWrappers.isEmpty())
serverOpts.compilerWrappers = String(DEFAULT_COMPILER_WRAPPERS).split(';').toSet();
if (!serverOpts.headerErrorJobCount) {
serverOpts.headerErrorJobCount = std::max<size_t>(1, serverOpts.jobCount / 2);
} else {
serverOpts.headerErrorJobCount = std::min(serverOpts.headerErrorJobCount, serverOpts.jobCount);
}
if (sigHandler) {
signal(SIGSEGV, signalHandler);
signal(SIGBUS, signalHandler);
signal(SIGILL, signalHandler);
signal(SIGABRT, signalHandler);
}
if (!initLogging(argv[0], logFlags, logLevel, logFile, logFileLogLevel)) {
fprintf(stderr, "Can't initialize logging with %d %s %s\n",
logLevel.toInt(), logFile.constData(), logFlags.toString().constData());
return 1;
}
#ifdef RTAGS_HAS_LAUNCHD
if (serverOpts.options & Server::Launchd) {
// Clamp inactivity timeout. launchd starts to worry if the
// process runs for less than 10 seconds.
static const int MIN_INACTIVITY_TIMEOUT = 15; // includes
// fudge factor.
if (inactivityTimeout < MIN_INACTIVITY_TIMEOUT) {
inactivityTimeout = MIN_INACTIVITY_TIMEOUT;
fprintf(stderr, "launchd mode - clamped inactivity timeout to %d to avoid launchd warnings.\n", inactivityTimeout);
}
}
#endif
EventLoop::SharedPtr loop(new EventLoop);
loop->init(EventLoop::MainEventLoop|EventLoop::EnableSigIntHandler|EventLoop::EnableSigTermHandler);
std::shared_ptr<Server> server(new Server);
if (!serverOpts.tests.isEmpty()) {
char buf[1024];
Path path;
while (true) {
strcpy(buf, "/tmp/rtags-test-XXXXXX");
if (!mkdtemp(buf)) {
fprintf(stderr, "Failed to mkdtemp (%d)\n", errno);
return 1;
}
path = buf;
path.resolve();
break;
}
serverOpts.dataDir = path;
strcpy(buf, "/tmp/rtags-sock-XXXXXX");
const int fd = mkstemp(buf);
if (fd == -1) {
fprintf(stderr, "Failed to mkstemp (%d)\n", errno);
return 1;
}
close(fd);
serverOpts.socketFile = buf;
serverOpts.socketFile.resolve();
}
serverOpts.dataDir = serverOpts.dataDir.ensureTrailingSlash();
#ifdef HAVE_BACKTRACE
if (strlen(crashDumpFilePath)) {
if (crashDumpFilePath[0] != '/') {
const String f = crashDumpFilePath;
snprintf(crashDumpFilePath, sizeof(crashDumpFilePath), "%s%s", serverOpts.dataDir.constData(), f.constData());
}
snprintf(crashDumpTempFilePath, sizeof(crashDumpTempFilePath), "%s.tmp", crashDumpFilePath);
Path::mkdir(serverOpts.dataDir);
crashDumpFile = fopen(crashDumpTempFilePath, "w");
if (!crashDumpFile) {
fprintf(stderr, "Couldn't open temp file %s for write (%d)\n", crashDumpTempFilePath, errno);
return 1;
}
}
#endif
if (!server->init(serverOpts)) {
cleanupLogging();
return 1;
}
if (!serverOpts.tests.isEmpty()) {
return server->runTests() ? 0 : 1;
}
loop->setInactivityTimeout(inactivityTimeout * 1000);
loop->exec();
const int ret = server->exitCode();
server.reset();
cleanupLogging();
return ret;
}
pulsesequence()
{
/* DECLARE AND LOAD VARIABLES */
void makeHHdec(), makeCdec(); /* utility functions */
char f1180[MAXSTR], /* Flag to start t1 @ halfdwell */
mag_flg[MAXSTR], /* magic-angle coherence transfer gradients */
C13refoc[MAXSTR], /* C13 sech/tanh pulse in middle of t1*/
NH2only[MAXSTR], /* spectrum of only NH2 groups */
T1[MAXSTR], /* insert T1 relaxation delay */
T1rho[MAXSTR], /* insert T1rho relaxation delay */
T2[MAXSTR], /* insert T2 relaxation delay */
TROSY[MAXSTR], /* do TROSY on N15 and H1 */
Hdecflg[MAXSTR], /* HH-h**o decoupling flag */
Cdecflg[MAXSTR]; /* low power C-13 decoupling flag */
int icosel, /* used to get n and p type */
ihh=1, /* used in HH decouling to improve water suppression */
t1_counter, /* used for states tppi in t1 */
rTnum, /* number of relaxation times, relaxT */
rTcounter; /* to obtain maximum relaxT, ie relaxTmax */
double tau1, /* t1 delay */
lambda = 0.91/(4.0*getval("JNH")), /* 1/4J H1 evolution delay */
tNH = 1.0/(4.0*getval("JNH")), /* 1/4J N15 evolution delay */
relaxT = getval("relaxT"), /* total relaxation time */
rTarray[1000], /* to obtain maximum relaxT, ie relaxTmax */
maxrelaxT = getval("maxrelaxT"), /* maximum relaxT in all exps */
ncyc, /* number of pulsed cycles in relaxT */
pwr_dly, /* power delay */
/* the sech/tanh pulse is automatically calculated by the macro "proteincal", */
/* and is called directly from your shapelib. */
pwClvl = getval("pwClvl"), /* coarse power for C13 pulse */
pwC = getval("pwC"), /* C13 90 degree pulse length at pwClvl */
rf0, /* maximum fine power when using pwC pulses */
rfst, /* fine power for the stCall pulse */
compH = getval("compH"), /* adjustment for H1 amplifier compression */
compN = getval("compN"), /* adjustment for N15 amplifier compression */
compC = getval("compC"), /* adjustment for C13 amplifier compression */
calH = getval("calH"), /* multiplier on a pw pulse for H1 calibration */
tpwrsf = getval("tpwrsf"), /* fine power adustment for soft pulse */
pwHs = getval("pwHs"), /* H1 90 degree pulse length at tpwrs */
pwHH = 0.0, /* pwHH = pwHs for HH h**o-decoupling */
tpwrs, /* power for the pwHs ("H2Osinc") pulse */
pwNlvl = getval("pwNlvl"), /* power for N15 pulses */
pwN = getval("pwN"), /* N15 90 degree pulse length at pwNlvl */
calN = getval("calN"), /* multiplier on a pwN pulse for calibration */
slNlvl, /* power for N15 spin lock */
slNrf = 1500.0, /* RF field in Hz for N15 spin lock at 600 MHz */
sw1 = getval("sw1"),
gt1 = getval("gt1"), /* coherence pathway gradients */
gzcal = getval("gzcal"), /* dac to G/cm conversion */
gzlvl1 = getval("gzlvl1"),
gzlvl2 = getval("gzlvl2"),
BPpwrlimits, /* =0 for no limit, =1 for limit */
gt0 = getval("gt0"), /* other gradients */
gt3 = getval("gt3"),
gt4 = getval("gt4"),
gt5 = getval("gt5"),
gstab = getval("gstab"),
gzlvl0 = getval("gzlvl0"),
gzlvl3 = getval("gzlvl3"),
gzlvl4 = getval("gzlvl4"),
gzlvl5 = getval("gzlvl5");
P_getreal(GLOBAL,"BPpwrlimits",&BPpwrlimits,1);
getstr("f1180",f1180);
getstr("mag_flg",mag_flg);
getstr("C13refoc",C13refoc);
getstr("NH2only",NH2only);
getstr("T1",T1);
getstr("T1rho",T1rho);
getstr("T2",T2);
getstr("TROSY",TROSY);
getstr("Hdecflg", Hdecflg);
getstr("Cdecflg", Cdecflg);
/* LOAD PHASE TABLE */
settable(t3,2,phi3);
settable(t4,1,phx);
if (TROSY[A]=='y')
{settable(t1,1,ph_x);
settable(t9,1,phx);
settable(t10,1,phy);
settable(t11,1,phx);
settable(t12,2,recT);}
else
{settable(t1,1,phx);
settable(t9,8,phi9);
settable(t10,1,phx);
settable(t11,1,phy);
settable(t12,4,rec);}
/* INITIALIZE VARIABLES */
/* maximum fine power for pwC pulses (and initialize rfst) */
rf0 = 4095.0; rfst=0.0;
/* 180 degree adiabatic C13 pulse from 0 to 200 ppm */
if (C13refoc[A]=='y')
{rfst = (compC*4095.0*pwC*4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35));
rfst = (int) (rfst + 0.5);
if ( 1.0/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35)) < pwC )
{ text_error( " Not enough C13 RF. pwC must be %f usec or less.\n",
(1.0e6/(4000.0*sqrt((30.0*sfrq/600.0+7.0)/0.35))) ); psg_abort(1); }}
/* selective H20 one-lobe sinc pulse */
if(pwHs > 1e-6)
tpwrs = tpwr - 20.0*log10(pwHs/(compH*pw*1.69)); /* needs 1.69 times more */
else /* power than a square pulse */
tpwrs = 0.0;
tpwrs = (int) (tpwrs);
if (tpwrsf<4095.0) tpwrs = tpwrs + 6.0;
if (tpwrsf < 4095.0)
{
tpwrs = tpwrs + 6.0;
pwr_dly = POWER_DELAY + PWRF_DELAY;
}
else pwr_dly = POWER_DELAY;
/* power level for N15 spinlock (90 degree pulse length calculated first) */
slNlvl = 1/(4.0*slNrf*sfrq/600.0) ;
slNlvl = pwNlvl - 20.0*log10(slNlvl/(pwN*compN));
slNlvl = (int) (slNlvl + 0.5);
/* use 1/8J times for relaxation measurements of NH2 groups */
if ( (NH2only[A]=='y') && ((T1[A]=='y') || (T1rho[A]=='y') || (T2[A]=='y')) )
{ tNH = tNH/2.0; }
/* reset calH and calN for 2D if inadvertently left at 2.0 */
if (ni>1.0) {calH=1.0; calN=1.0;}
/* make shapes and set up parameters for HH h**o-decoupling */
if(Cdecflg[0] == 'y') makeCdec();
if(Hdecflg[0] == 'y') makeHHdec();
if(Hdecflg[0] != 'n')
{
pwHH = pwHs;
pwHs = 0.0;
}
/* CHECK VALIDITY OF PARAMETER RANGES */
if ((TROSY[A]=='y') && (gt1 < -2.0e-4 + pwHs + 1.0e-4 + 2.0*POWER_DELAY))
{ text_error( " gt1 is too small. Make gt1 equal to %f or more.\n",
(-2.0e-4 + pwHs + 1.0e-4 + 2.0*POWER_DELAY) ); psg_abort(1); }
if((dm[A] == 'y' || dm[B] == 'y' || dm[C] == 'y' ))
{ text_error("incorrect dec1 decoupler flags! Should be 'nnn' "); psg_abort(1); }
if((dm2[A] == 'y' || dm2[B] == 'y'))
{ text_error("incorrect dec2 decoupler flags! Should be 'nny' "); psg_abort(1); }
if( dpwr2 > 50 )
{ text_error("don't fry the probe, DPWR2 too large! "); psg_abort(1); }
if( pw > 50.0e-6 )
{ text_error("dont fry the probe, pw too high ! "); psg_abort(1); }
if( pwN > 100.0e-6 )
{ text_error("dont fry the probe, pwN too high ! "); psg_abort(1); }
/* RELAXATION TIMES AND FLAGS */
/* evaluate maximum relaxT, relaxTmax chosen by the user */
rTnum = getarray("relaxT", rTarray);
relaxTmax = rTarray[0];
for (rTcounter=1; rTcounter<rTnum; rTcounter++)
if (relaxTmax < rTarray[rTcounter]) relaxTmax = rTarray[rTcounter];
/* compare relaxTmax with maxrelaxT */
if (maxrelaxT > relaxTmax) relaxTmax = maxrelaxT;
if ( ((T1rho[A]=='y') || (T2[A]=='y')) && (relaxTmax > d1) )
{ text_error("Maximum relaxation time, relaxT, is greater than d1 ! "); psg_abort(1);}
if ( ((T1[A]=='y') && (T1rho[A]=='y')) || ((T1[A]=='y') && (T2[A]=='y')) ||
((T1rho[A]=='y') && (T2[A]=='y')) )
{ text_error("Choose only one relaxation measurement ! "); psg_abort(1); }
if ( ((T1[A]=='y') || (T1rho[A]=='y')) &&
((relaxT*100.0 - (int)(relaxT*100.0+1.0e-4)) > 1.0e-6) )
{ text_error("Relaxation time, relaxT, must be zero or multiple of 10msec"); psg_abort(1);}
if ( (T2[A]=='y') &&
(((relaxT+0.01)*50.0 - (int)((relaxT+0.01)*50.0+1.0e-4)) > 1.0e-6) )
{ text_error("Relaxation time, relaxT, must be odd multiple of 10msec"); psg_abort(1);}
if ( ((T1rho[A]=='y') || (T2[A]=='y')) && (relaxTmax > 0.25) && (ix==1) )
{ printf("WARNING, sample heating will result for relaxT>0.25sec"); }
if ( ((T1rho[A]=='y') || (T2[A]=='y')) && (relaxTmax > 0.5) )
{ text_error("relaxT greater than 0.5 seconds will heat sample"); psg_abort(1);}
if ( ((NH2only[A]=='y') || (T1[A]=='y') || (T1rho[A]=='y') || (T2[A]=='y'))
&& (TROSY[A]=='y') )
{ text_error("TROSY not implemented with NH2 spectrum, or relaxation exps."); psg_abort(1);}
if ((TROSY[A]=='y') && (dm2[C] == 'y'))
{ text_error("Choose either TROSY='n' or dm2='n' ! "); psg_abort(1); }
/* PHASES AND INCREMENTED TIMES */
/* Phase incrementation for hypercomplex 2D data, States-Haberkorn element */
if (TROSY[A]=='y')
{ if (phase1 == 2) icosel = -1;
else { tsadd(t4,2,4); tsadd(t10,2,4); icosel = +1; }
}
else { if (phase1 == 2) {tsadd(t10,2,4); icosel = +1;}
else icosel = -1;
}
if(Hdecflg[0] != 'n') ihh = icosel;
/* Set up f1180 */
tau1 = d2;
if((f1180[A] == 'y') && (ni > 1.0))
{ tau1 += ( 1.0 / (2.0*sw1) ); if(tau1 < 0.2e-6) tau1 = 0.0; }
tau1 = tau1/2.0;
/* Calculate modifications to phases for States-TPPI acquisition */
if( ix == 1) d2_init = d2;
t1_counter = (int) ( (d2-d2_init)*sw1 + 0.5 );
if(t1_counter % 2)
{ tsadd(t3,2,4); tsadd(t12,2,4); }
/* Correct inverted signals for NH2 only spectra */
if ((NH2only[A]=='y') && (T1[A]=='n') && (T1rho[A]=='n') && (T2[A]=='n'))
{ tsadd(t3,2,4); }
/* BEGIN PULSE SEQUENCE */
status(A);
obspower(tpwr);
decpower(pwClvl);
decpwrf(rf0);
dec2power(pwNlvl);
txphase(zero);
decphase(zero);
dec2phase(zero);
if(Hdecflg[0] != 'n')
{
delay(5.0e-5);
rgpulse(pw,zero,rof1,0.0);
rgpulse(pw,one,0.0,rof1);
zgradpulse(1.5*gzlvl0, 0.5e-3);
delay(5.0e-4);
rgpulse(pw,zero,rof1,0.0);
rgpulse(pw,one,0.0,rof1);
zgradpulse(-gzlvl0, 0.5e-3);
}
delay(d1);
/* xxxxxxxxxxxxxxxxx CONSTANT SAMPLE HEATING FROM N15 RF xxxxxxxxxxxxxxxxx */
if (T1rho[A]=='y')
{dec2power(slNlvl);
dec2rgpulse(relaxTmax-relaxT, zero, 0.0, 0.0);
dec2power(pwNlvl);}
if (T2[A]=='y')
{ncyc = 8.0*100.0*(relaxTmax - relaxT);
if (BPpwrlimits > 0.5)
{
dec2power(pwNlvl-3.0); /* reduce for probe protection */
pwN=pwN*compN*1.4;
}
if (ncyc > 0)
{initval(ncyc,v1);
loop(v1,v2);
delay(0.625e-3 - pwN);
dec2rgpulse(2*pwN, zero, 0.0, 0.0);
delay(0.625e-3 - pwN);
endloop(v2);}
if (BPpwrlimits > 0.5)
{
dec2power(pwNlvl); /* restore normal value */
pwN=getval("pwN");
}
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
rcvroff();
if (TROSY[A]=='n')
dec2rgpulse(pwN, zero, 0.0, 0.0); /*destroy N15 magnetization*/
zgradpulse(gzlvl0, 0.5e-3);
delay(1.0e-4);
if (TROSY[A]=='n') dec2rgpulse(pwN, one, 0.0, 0.0);
zgradpulse(0.7*gzlvl0, 0.5e-3);
decpwrf(rfst);
txphase(t1);
delay(5.0e-4);
if ( dm3[B] == 'y' ) /* begins optional 2H decoupling */
{
lk_hold();
dec3rgpulse(1/dmf3,one,10.0e-6,2.0e-6);
dec3unblank();
dec3phase(zero);
delay(2.0e-6);
setstatus(DEC3ch, TRUE, 'w', FALSE, dmf3);
}
rgpulse(calH*pw,t1,0.0,0.0); /* 1H pulse excitation */
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0 - pwHH);
if(Hdecflg[0] != 'n')
{
obspower(tpwrs);
if (tpwrsf<4095.0) obspwrf(tpwrsf);
shaped_pulse("H2Osinc", pwHH, two, 5.0e-5, 0.0);
obspower(tpwr);
if (tpwrsf<4095.0) obspwrf(4095.0);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
obspower(tpwrs);
if (tpwrsf<4095.0) obspwrf(tpwrsf);
shaped_pulse("H2Osinc", pwHH, two, 5.0e-5, 0.0);
obspower(tpwr);
if (tpwrsf<4095.0) obspwrf(4095.0);
}
else
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
txphase(one);
zgradpulse(gzlvl0, gt0);
delay(lambda - gt0 - pwHH);
rgpulse(pw, one, 0.0, 0.0);
txphase(two);
obspower(tpwrs);
if (tpwrsf<4095.0) obspwrf(tpwrsf);
shaped_pulse("H2Osinc", pwHs, two, 5.0e-5, 0.0);
obspower(tpwr);
if (tpwrsf<4095.0) obspwrf(4095.0);
if (TROSY[A]=='y')
zgradpulse(ihh*gzlvl3, gt3);
else
zgradpulse(-ihh*gzlvl3, gt3);
dec2phase(t3);
delay(2.0e-4);
dec2rgpulse(calN*pwN, t3, 0.0, 0.0);
txphase(zero);
decphase(zero);
/* xxxxxxxxxxxxxxxxxx OPTIONS FOR N15 RELAXATION xxxxxxxxxxxxxxxxxxxx */
if ( (T1[A]=='y') || (T1rho[A]=='y') || (T2[A]=='y') )
{
dec2phase(one);
zgradpulse(gzlvl4, gt4); /* 2.0*GRADIENT_DELAY */
delay(tNH - gt4 - 2.0*GRADIENT_DELAY);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, one, 0.0, 0.0);
zgradpulse(gzlvl4, gt4); /* 2.0*GRADIENT_DELAY */
delay(tNH - gt4 - 2.0*GRADIENT_DELAY);
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
if (T1[A]=='y')
{
dec2rgpulse(pwN, one, 0.0, 0.0);
dec2phase(three);
zgradpulse(gzlvl0, gt0); /* 2.0*GRADIENT_DELAY */
delay(2.5e-3 - gt0 - 2.0*GRADIENT_DELAY - pw);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(2.5e-3 - pw);
ncyc = (100.0*relaxT);
initval(ncyc,v4);
if (ncyc > 0)
{loop(v4,v5);
delay(2.5e-3 - pw);
rgpulse(2.0*pw, two, 0.0, 0.0);
delay(2.5e-3 - pw);
delay(2.5e-3 - pw);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(2.5e-3 - pw);
endloop(v5);}
dec2rgpulse(pwN, three, 0.0, 0.0);
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
/* Theory suggests 8.0 is better than 2PI as RF */
/* field multiplier and experiment confirms this.*/
if (T1rho[A]=='y') /* Shift evolution of 2.0*pwN/PI for one pulse */
{ /* at end left unrefocused as for normal sequence*/
delay(1.0/(8.0*slNrf) - pwN);
decrgpulse(pwN, zero, 0.0, 0.0);
dec2power(slNlvl);
/* minimum 5ms spinlock to dephase */
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0); /* spins not locked */
sim3pulse(2.0*pw, 0.0, 2.0*pw, zero, zero, zero, 0.0, 0.0);
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0);
ncyc = 100.0*relaxT;
initval(ncyc,v4); if (ncyc > 0)
{loop(v4,v5);
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0);
sim3pulse(2.0*pw, 0.0, 2.0*pw, two, zero, zero, 0.0, 0.0);
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0);
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0);
sim3pulse(2.0*pw, 0.0, 2.0*pw, zero, zero, zero, 0.0, 0.0);
dec2rgpulse((2.5e-3-pw), zero, 0.0, 0.0);
endloop(v5);}
dec2power(pwNlvl);
decrgpulse(pwN, zero, 0.0, 0.0);
delay(1.0/(8.0*slNrf) + 2.0*pwN/PI - pwN);
}
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
if (T2[A]=='y')
{
dec2phase(zero);
initval(0.0,v3); initval(180.0,v4);
if (BPpwrlimits > 0.5)
{
dec2power(pwNlvl-3.0); /* reduce for probe protection */
pwN=pwN*compN*1.4;
}
ncyc = 100.0*relaxT;
initval(ncyc,v5);
loop(v5,v6);
initval(3.0,v7);
loop(v7,v8);
delay(0.625e-3 - pwN);
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(0.625e-3 - pwN);
endloop(v8);
delay(0.625e-3 - pwN - SAPS_DELAY);
add(v4,v3,v3); obsstepsize(1.0); xmtrphase(v3); /* SAPS_DELAY */
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(0.625e-3 - pwN - pw);
rgpulse(2*pw, zero, 0.0, 0.0);
delay(0.625e-3 - pwN - pw );
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
xmtrphase(zero); /* SAPS_DELAY */
delay(0.625e-3 - pwN - SAPS_DELAY);
initval(3.0,v9);
loop(v9,v10);
delay(0.625e-3 - pwN);
dec2rgpulse(2.0*pwN, zero, 0.0, 0.0);
delay(0.625e-3 - pwN);
endloop(v10);
endloop(v6);
if (BPpwrlimits > 0.5)
{
dec2power(pwNlvl); /* restore normal value */
pwN=getval("pwN");
}
}
/* xxxxxxxxxxxxxxxxxx OPTIONS FOR N15 EVOLUTION xxxxxxxxxxxxxxxxxxxxx */
txphase(zero);
dec2phase(t9);
if ( (NH2only[A]=='y') || (T1[A]=='y') || (T1rho[A]=='y') || (T2[A]=='y') )
{
delay(tau1);
/* optional sech/tanh pulse in middle of t1 */
if (C13refoc[A]=='y') /* WFG_START_DELAY */
{decshaped_pulse("stC200", 1.0e-3, zero, 0.0, 0.0);
delay(tNH - 1.0e-3 - WFG_START_DELAY - 2.0*pw);}
else
{delay(tNH - 2.0*pw);}
rgpulse(2.0*pw, zero, 0.0, 0.0);
if (tNH < gt1 + 1.99e-4) delay(gt1 + 1.99e-4 - tNH);
delay(tau1);
dec2rgpulse(2.0*pwN, t9, 0.0, 0.0);
if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
txphase(t4);
dec2phase(t10);
if (tNH > gt1 + 1.99e-4) delay(tNH - gt1 - 2.0*GRADIENT_DELAY);
else delay(1.99e-4 - 2.0*GRADIENT_DELAY);
}
else if (TROSY[A]=='y')
{
if ( (C13refoc[A]=='y') && (tau1 > 0.5e-3 + WFG2_START_DELAY) )
{delay(tau1 - 0.5e-3 - WFG2_START_DELAY); /* WFG2_START_DELAY */
decshaped_pulse("stC200", 1.0e-3, zero, 0.0, 0.0);
delay(tau1 - 0.5e-3);}
else delay(2.0*tau1);
if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
delay(2.0e-4 - 2.0*GRADIENT_DELAY);
dec2rgpulse(2.0*pwN, t9, 0.0, 0.0);
txphase(three);
delay(gt1 + 2.0e-4 - pwHs - 1.0e-4 - 2.0*pwr_dly);
obspower(tpwrs);
if (tpwrsf<4095.0) obspwrf(tpwrsf);
shaped_pulse("H2Osinc", pwHs, three, 5.0e-5, 0.0);
obspower(tpwr);
if (tpwrsf<4095.0) obspwrf(4095.0);
txphase(t4);
delay(5.0e-5);
}
else
{ /* fully-coupled spectrum */
if (dm2[C]=='n') {rgpulse(2.0*pw, zero, 0.0, 0.0); pw=0.0;}
if ( (C13refoc[A]=='y') && (tau1 > 0.5e-3 + WFG2_START_DELAY) )
{delay(tau1 - 0.5e-3 - WFG2_START_DELAY); /* WFG2_START_DELAY */
simshaped_pulse("", "stC200", 2.0*pw, 1.0e-3, zero, zero, 0.0, 0.0);
delay(tau1 - 0.5e-3);
delay(gt1 + 2.0e-4);}
else
{delay(tau1);
rgpulse(2.0*pw, zero, 0.0, 0.0);
delay(gt1 + 2.0e-4 - 2.0*pw);
delay(tau1);}
pw=getval("pw");
dec2rgpulse(2.0*pwN, t9, 0.0, 0.0);
if (mag_flg[A] == 'y') magradpulse(gzcal*gzlvl1, gt1);
else zgradpulse(gzlvl1, gt1); /* 2.0*GRADIENT_DELAY */
txphase(t4);
dec2phase(t10);
delay(2.0e-4 - 2.0*GRADIENT_DELAY);
}
if (T1rho[A]=='y') delay(POWER_DELAY);
/* xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx */
if (TROSY[A]=='y') rgpulse(pw, t4, 0.0, 0.0);
else sim3pulse(pw, 0.0, pwN, t4, zero, t10, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(gzlvl5, gt5);
if (TROSY[A]=='y') delay(lambda - 0.65*(pw + pwN) - gt5);
else delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
zgradpulse(gzlvl5, gt5);
txphase(one);
dec2phase(t11);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(pw, 0.0, pwN, one, zero, t11, 0.0, 0.0);
txphase(zero);
dec2phase(zero);
zgradpulse(1.5*gzlvl5, gt5);
delay(lambda - 1.3*pwN - gt5);
sim3pulse(2.0*pw, 0.0, 2.0*pwN, zero, zero, zero, 0.0, 0.0);
dec2phase(t10);
zgradpulse(1.5*gzlvl5, gt5);
if (TROSY[A]=='y') delay(lambda - 1.6*pwN - gt5);
else delay(lambda - 0.65*pwN - gt5);
if (TROSY[A]=='y') dec2rgpulse(pwN, t10, 0.0, 0.0);
else rgpulse(pw, zero, 0.0, 0.0);
delay((gt1/10.0) + 1.0e-4 +gstab - 0.65*pw + 2.0*GRADIENT_DELAY + POWER_DELAY);
if ( dm3[B] == 'y' ) /* turns off 2H decoupling */
{
setstatus(DEC3ch, FALSE, 'c', FALSE, dmf3);
dec3rgpulse(1/dmf3,three,2.0e-6,2.0e-6);
dec3blank();
lk_autotrig(); /* resumes lock pulsing */
}
rgpulse(2.0*pw, zero, 0.0, 0.0);
dec2power(dpwr2); /* POWER_DELAY */
if (mag_flg[A] == 'y') magradpulse(icosel*gzcal*gzlvl2, 0.1*gt1);
else zgradpulse(icosel*gzlvl2, 0.1*gt1); /* 2.0*GRADIENT_DELAY */
if(Cdecflg[0] == 'y')
{
delay(gstab-2.0*POWER_DELAY-PRG_START_DELAY+rof2);
rcvron();
statusdelay(C,1.0e-4);
if (dm3[B] == 'y')
{
delay(1/dmf3);
lk_sample();
}
setreceiver(t12);
pbox_decon(&Cdseq);
if(Hdecflg[0] == 'y')
homodec(&HHdseq);
}
else
{
delay(gstab+rof2);
rcvron();
statusdelay(C,1.0e-4);
if (dm3[B] == 'y')
{
delay(1/dmf3);
lk_sample();
}
setreceiver(t12);
if(Hdecflg[0] == 'y')
homodec(&HHdseq);
}
}
int main(int argc, char *argv[])
{
SDL_Joystick *joy = NULL;
int t1, t0;
if (!fs_init(argv[0]))
{
fprintf(stderr, "Failure to initialize virtual file system (%s)\n",
fs_error());
return 1;
}
opt_parse(argc, argv);
config_paths(opt_data);
log_init("Neverball", "neverball.log");
make_dirs_and_migrate();
/* Initialize SDL. */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_JOYSTICK) == -1)
{
log_printf("Failure to initialize SDL (%s)\n", SDL_GetError());
return 1;
}
/* Intitialize configuration. */
config_init();
config_load();
/* Initialize localization. */
lang_init();
/* Initialize joystick. */
if (config_get_d(CONFIG_JOYSTICK) && SDL_NumJoysticks() > 0)
{
joy = SDL_JoystickOpen(config_get_d(CONFIG_JOYSTICK_DEVICE));
if (joy)
SDL_JoystickEventState(SDL_ENABLE);
}
/* Initialize audio. */
audio_init();
tilt_init();
/* Initialize video. */
if (!video_init())
return 1;
/* Material system. */
mtrl_init();
/* Screen states. */
init_state(&st_null);
/* Initialize demo playback or load the level. */
if (opt_replay &&
fs_add_path(dir_name(opt_replay)) &&
progress_replay(base_name(opt_replay)))
{
demo_play_goto(1);
goto_state(&st_demo_play);
}
else if (opt_level)
{
const char *path = fs_resolve(opt_level);
int loaded = 0;
if (path)
{
/* HACK: must be around for the duration of the game. */
static struct level level;
if (level_load(path, &level))
{
progress_init(MODE_STANDALONE);
if (progress_play(&level))
{
goto_state(&st_level);
loaded = 1;
}
}
}
else log_printf("File %s is not in game path\n", opt_level);
if (!loaded)
goto_state(&st_title);
}
else
goto_state(&st_title);
/* Run the main game loop. */
t0 = SDL_GetTicks();
while (loop())
{
if ((t1 = SDL_GetTicks()) > t0)
{
/* Step the game state. */
st_timer(0.001f * (t1 - t0));
t0 = t1;
/* Render. */
hmd_step();
st_paint(0.001f * t0);
video_swap();
if (config_get_d(CONFIG_NICE))
SDL_Delay(1);
}
}
config_save();
mtrl_quit();
if (joy)
SDL_JoystickClose(joy);
tilt_free();
hmd_free();
SDL_Quit();
return 0;
}
