int PokemonInfo::Stat(int poke, int stat, int level, quint8 dv, quint8 ev) { quint8 basestat = PokemonInfo::BaseStats(poke).baseStat(stat); if (stat == Hp) { /* Shedinja */ if (poke == Pokemon::Shedinja) return 1; else return calc_stat(basestat, level, dv, ev) + level + 5; } else return calc_stat(basestat, level, dv, ev); }
void normalize (enum WINDOWTYPE wt, float *gclookup, float *gclookup_x, float *max, float *max_x, float *min, float *min_x){ int i; for (i=0; i<num_chrom; i++) norm_wins(i, wt, gclookup, gclookup_x); calc_stat(wt, gclookup, gclookup_x, 0, max, max_x, min, min_x); }
//type=0 regular=old, type=1 start isfirst pos,type=2 is from pos0. kstring_t do_stat_main(perChr &pc,int step,int win,int nChr,int type){ int pS,pE;//physical start,physical end int begI,endI;//position in array for pS, pE; kstring_t str; str.l=str.m=0; str.s=NULL; if(step==0&&win==0){ //assuming whole chromosome as window begI=0; endI=pc.nSites-1; pS=0; pE=pc.posi[endI]; ksprintf(&str,"(%d,%d)(%d,%d)(%d,%d)\t%s\t%d\t",begI,endI,pc.posi[begI],pc.posi[endI],pS,pE,pc.chr,pS+(pE-pS)/2); calc_stat(begI,endI,pc,str,nChr); ksprintf(&str,"\t%d\n",endI-begI); return str; } if(type==0) pS = (pc.posi[0]/step)*step +step; else if(type==1) pS = pc.posi[0]; else if(type==2) pS = 1; pE = pS+win; begI=endI=0; if(pE>pc.posi[pc.nSites-1]){ fprintf(stderr,"end of dataset is before end of window: end of window:%d last position in chr:%d\n",pE,pc.posi[pc.nSites-1]); return str; } while(pc.posi[begI]<pS) begI++; endI=begI; while(pc.posi[endI]<pE) endI++; while(1){ // fprintf(estpgF,"(%d,%d)(%d,%d)\t%s\t%d\t",begI,endI,the[begI].pos,the[endI].pos,chrCur,the[begI].pos+(the[endI].pos-the[begI].pos)/2); ksprintf(&str,"(%d,%d)(%d,%d)(%d,%d)\t%s\t%d\t",begI,endI,pc.posi[begI],pc.posi[endI],pS,pE,pc.chr,pS+(pE-pS)/2); calc_stat(begI,endI,pc,str,nChr); ksprintf(&str,"\t%d\n",endI-begI); //str.l=0; pS += step; pE =pS+win; if(pE>pc.posi[pc.nSites-1]) break; while(pc.posi[begI]<pS) begI++; while(pc.posi[endI]<pE) endI++; } return str; }
void set_lpc_mode(float * signal_ptr, /* I Input signal */ float * a_fwd, /* I Forward LPC filter */ float * a_bwd, /* I Backward LPC filter */ int *mode, /* O Backward / forward Indication */ float * lsp_new, /* I LSP vector current frame */ float * lsp_old, /* I LSP vector previous frame */ int *bwd_dominant, /* O Bwd dominant mode indication */ int prev_mode, /* I previous frame Backward / forward Indication */ float * prev_filter, /* I previous frame filter */ float * C_int, /*I/O filter interpolation parameter */ int16_t * glob_stat, /* I/O Mre of global stationnarity */ int16_t * stat_bwd, /* I/O Number of consecutive backward frames */ int16_t * val_stat_bwd /* I/O Value associated with stat_bwd */ ) { int i; float res[L_FRAME]; float *pa_bwd; float gap; float gpred_f, gpred_b, gpred_bint; float tmp; float thresh_lpc; float dist_lsp, energy; pa_bwd = a_bwd + M_BWDP1; /* Backward filter prediction gain (no interpolation ) */ /* --------------------------------------------------- */ residue(M_BWD, pa_bwd, signal_ptr, res, L_FRAME); gpred_b = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* Interpolated LPC filter for transition forward -> backward */ /* (used during 10 frames) ( for the second sub-frame ) */ /* Interpolated backward filter for the first sub-frame */ /* ---------------------------------------------------------- */ int_bwd(a_bwd, prev_filter, C_int); /* Interpolated backward filter prediction gain */ /* -------------------------------------------- */ residue(M_BWD, a_bwd, signal_ptr, res, L_SUBFR); residue(M_BWD, pa_bwd, &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR); gpred_bint = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* Forward filter prediction gain */ /* ------------------------------ */ residue(M, a_fwd, signal_ptr, res, L_SUBFR); residue(M, &a_fwd[MP1], &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR); gpred_f = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* -------------------------------------------------------------- */ /* BACKWARD / FORWARD DECISION */ /* */ /* The Main criterion is based on the prediction gains : */ /* The global stationnarity index is used to adapt the threshold */ /* value " GAP ". */ /* This adaptation is used to favour one mode according to the */ /* stationnarity of the input signal (backward for music and */ /* forward for speech) which avoids too many switches. */ /* */ /* A second criterion based on the LSPs is used to avoid switches */ /* if the successive LPC forward filters are very stationnary */ /* (which is measured a Euclidean distance on LSPs). */ /* */ /* -------------------------------------------------------------- */ /* 1st criterion with prediction gains */ /* ----------------------------------- */ /* Threshold adaptation according to the global stationnarity indicator */ gap = (float) (*glob_stat) * GAP_FACT; gap += (float) 1.; if ((gpred_bint > gpred_f - gap) && (gpred_b > gpred_f - gap) && (gpred_b > (float) 0.) && (gpred_bint > (float) 0.)) *mode = 1; else *mode = 0; if (*glob_stat < 13000) *mode = 0; /* => Forward mode imposed */ /* 2nd criterion with a distance between 2 successive LSP vectors */ /* -------------------------------------------------------------- */ /* Computation of the LPC distance */ dist_lsp = 0; for (i = 0; i < M; i++) { tmp = lsp_old[i] - lsp_new[i]; dist_lsp += tmp * tmp; } /* Adaptation of the LSPs thresholds */ if (*glob_stat < 32000) { thresh_lpc = (float) 0.; } else { thresh_lpc = (float) 0.03; } /* Switching backward -> forward forbidden in case of a LPC stationnary */ if ((dist_lsp < thresh_lpc) && (*mode == 0) && (prev_mode == 1) && (gpred_b > (float) 0.) && (gpred_bint > (float) 0.)) { *mode = 1; } /* Low energy frame => Forward mode chosen */ /* --------------------------------------- */ energy = ener_dB(signal_ptr, L_FRAME); if (energy < THRES_ENERGY) { *mode = 0; if (*glob_stat > 13000) *glob_stat = 13000; } else tst_bwd_dominant(bwd_dominant, *mode); /* Adaptation of the global stationnarity indicator */ /* ------------------------------------------------ */ if (energy >= THRES_ENERGY) calc_stat(gpred_b, gpred_f, *mode, prev_mode, glob_stat, stat_bwd, val_stat_bwd); if (*mode == 0) *C_int = (float) 1.1; return; }
static int64_t bitfury_scanHash(struct thr_info *thr) { static struct bitfury_device *devices; // TODO Move somewhere to appropriate place int chip_n; int chip; uint64_t hashes = 0; struct timeval now; unsigned char line[2048]; int short_stat = 10; static time_t short_out_t; int long_stat = 1800; static time_t long_out_t; int long_long_stat = 60 * 30; static time_t long_long_out_t; static first = 0; //TODO Move to detect() int i; devices = thr->cgpu->devices; chip_n = thr->cgpu->chip_n; if (!first) { for (i = 0; i < chip_n; i++) { devices[i].osc6_bits = 54; } for (i = 0; i < chip_n; i++) { send_reinit(devices[i].slot, devices[i].fasync, devices[i].osc6_bits); } } first = 1; for (chip = 0; chip < chip_n; chip++) { devices[chip].job_switched = 0; if(!devices[chip].work) { devices[chip].work = get_queued(thr->cgpu); if (devices[chip].work == NULL) { return 0; } work_to_payload(&(devices[chip].payload), devices[chip].work); } } libbitfury_sendHashData(devices, chip_n); nmsleep(5); cgtime(&now); chip = 0; for (;chip < chip_n; chip++) { if (devices[chip].job_switched) { int i,j; int *res = devices[chip].results; struct work *work = devices[chip].work; struct work *owork = devices[chip].owork; struct work *o2work = devices[chip].o2work; i = devices[chip].results_n; for (j = i - 1; j >= 0; j--) { if (owork) { submit_nonce(thr, owork, bswap_32(res[j])); devices[chip].stat_ts[devices[chip].stat_counter++] = now.tv_sec; if (devices[chip].stat_counter == BITFURY_STAT_N) { devices[chip].stat_counter = 0; } } if (o2work) { // TEST //submit_nonce(thr, owork, bswap_32(res[j])); } } devices[chip].results_n = 0; devices[chip].job_switched = 0; if (devices[chip].old_nonce && o2work) { submit_nonce(thr, o2work, bswap_32(devices[chip].old_nonce)); i++; } if (devices[chip].future_nonce) { submit_nonce(thr, work, bswap_32(devices[chip].future_nonce)); i++; } if (o2work) work_completed(thr->cgpu, o2work); devices[chip].o2work = devices[chip].owork; devices[chip].owork = devices[chip].work; devices[chip].work = NULL; hashes += 0xffffffffull * i; } } if (now.tv_sec - short_out_t > short_stat) { int shares_first = 0, shares_last = 0, shares_total = 0; char stat_lines[32][256] = {0}; int len, k; double gh[32][8] = {0}; double ghsum = 0, gh1h = 0, gh2h = 0; unsigned strange_counter = 0; for (chip = 0; chip < chip_n; chip++) { int shares_found = calc_stat(devices[chip].stat_ts, short_stat, now); double ghash; len = strlen(stat_lines[devices[chip].slot]); ghash = shares_to_ghashes(shares_found, short_stat); gh[devices[chip].slot][chip & 0x07] = ghash; snprintf(stat_lines[devices[chip].slot] + len, 256 - len, "%.1f-%3.0f ", ghash, devices[chip].mhz); if(short_out_t && ghash < 0.5) { applog(LOG_WARNING, "Chip_id %d FREQ CHANGE\n", chip); send_freq(devices[chip].slot, devices[chip].fasync, devices[chip].osc6_bits - 1); nmsleep(1); send_freq(devices[chip].slot, devices[chip].fasync, devices[chip].osc6_bits); } shares_total += shares_found; shares_first += chip < 4 ? shares_found : 0; shares_last += chip > 3 ? shares_found : 0; strange_counter += devices[chip].strange_counter; devices[chip].strange_counter = 0; } sprintf(line, "vvvvwww SHORT stat %ds: wwwvvvv", short_stat); applog(LOG_WARNING, line); sprintf(line, "stranges: %u", strange_counter); applog(LOG_WARNING, line); for(i = 0; i < 32; i++) if(strlen(stat_lines[i])) { len = strlen(stat_lines[i]); ghsum = 0; gh1h = 0; gh2h = 0; for(k = 0; k < 4; k++) { gh1h += gh[i][k]; gh2h += gh[i][k+4]; ghsum += gh[i][k] + gh[i][k+4]; } snprintf(stat_lines[i] + len, 256 - len, "- %2.1f + %2.1f = %2.1f slot %i ", gh1h, gh2h, ghsum, i); applog(LOG_WARNING, stat_lines[i]); } short_out_t = now.tv_sec; } if (now.tv_sec - long_out_t > long_stat) { int shares_first = 0, shares_last = 0, shares_total = 0; char stat_lines[32][256] = {0}; int len, k; double gh[32][8] = {0}; double ghsum = 0, gh1h = 0, gh2h = 0; for (chip = 0; chip < chip_n; chip++) { int shares_found = calc_stat(devices[chip].stat_ts, long_stat, now); double ghash; len = strlen(stat_lines[devices[chip].slot]); ghash = shares_to_ghashes(shares_found, long_stat); gh[devices[chip].slot][chip & 0x07] = ghash; snprintf(stat_lines[devices[chip].slot] + len, 256 - len, "%.1f-%3.0f ", ghash, devices[chip].mhz); shares_total += shares_found; shares_first += chip < 4 ? shares_found : 0; shares_last += chip > 3 ? shares_found : 0; } sprintf(line, "!!!_________ LONG stat %ds: ___________!!!", long_stat); applog(LOG_WARNING, line); for(i = 0; i < 32; i++) if(strlen(stat_lines[i])) { len = strlen(stat_lines[i]); ghsum = 0; gh1h = 0; gh2h = 0; for(k = 0; k < 4; k++) { gh1h += gh[i][k]; gh2h += gh[i][k+4]; ghsum += gh[i][k] + gh[i][k+4]; } snprintf(stat_lines[i] + len, 256 - len, "- %2.1f + %2.1f = %2.1f slot %i ", gh1h, gh2h, ghsum, i); applog(LOG_WARNING, stat_lines[i]); } long_out_t = now.tv_sec; } return hashes; }
int norm_until_converges (enum WINDOWTYPE wt, float *gclookup, float *gclookup_x){ float max; float max_x; float min; float min_x; float p_max; float p_max_x; float p_min; float p_min_x; int i, j; float mean = 0.0; float mean_x = 0.0; float stdev = 0.0; float stdev_x = 0.0; int iter; float maxcut; float maxcut_x; float mincut; float mincut_x; iter = 1; calc_stat(wt, gclookup, gclookup_x, 0, &max, &max_x, &min, &min_x); switch(wt){ case LW: mean = LW_MEAN; mean_x = LW_MEAN_X; break; case SW: mean = SW_MEAN; mean_x = SW_MEAN_X; break; case CW: mean = CW_MEAN; mean_x = CW_MEAN_X; break; } if (GENDER == AUTODETECT){ if (VERBOSE) fprintf(stdout, "MEAN: %f\tMEAN_X: %f\n", mean, mean_x); if (mean_x / mean < 0.75){ // magical ratio GENDER = MALE; if (VERBOSE) fprintf(stdout, "Autodetect Gender: Male\n"); i = findChrom("chrX", "", -1); if (i==-1) i = findChrom("X", "", -1); if (i != -1){ switch(wt){ case CW: for (j=0; j<chromosomes[i]->cw_cnt; j++) if (chromosomes[i]->cw[j].depth > (float) CW_MEAN_X * 2 || chromosomes[i]->cw[j].depth < (float) CW_MEAN_X / 10.0) chromosomes[i]->cw[j].isControl = 0; break; case LW: for (j=0; j<chromosomes[i]->lw_cnt; j++) if (chromosomes[i]->lw[j].depth > (float) LW_MEAN_X * 2 || chromosomes[i]->lw[j].depth < (float) LW_MEAN_X / 10.0) chromosomes[i]->lw[j].isControl = 0; break; case SW: for (j=0; j<chromosomes[i]->sw_cnt; j++) if (chromosomes[i]->sw[j].depth > (float) SW_MEAN_X * 2 || chromosomes[i]->sw[j].depth < (float) SW_MEAN_X / 10.0) chromosomes[i]->sw[j].isControl = 0; break; } } } else{ GENDER = FEMALE; if (VERBOSE) fprintf(stdout, "Autodetect Gender: Female\n"); } } if (!ISNORMALIZED) normalize(wt, gclookup, gclookup_x, &max, &max_x, &min, &min_x); do{ if (VERBOSE){ fprintf(stdout, "Control regions %s iteration %d ", (wt == LW ? "LW" : (wt == SW ? "SW" : "CW")), iter); fflush(stdout); } p_min = min; p_max = max; p_min_x = min_x; p_max_x = max_x; calc_stat(wt, gclookup, gclookup_x, 1, &max, &max_x, &min, &min_x); switch(wt){ case LW: mean = LW_MEAN; stdev = LW_STD; mean_x = LW_MEAN_X; stdev_x = LW_STD_X; break; case SW: mean = SW_MEAN; stdev = SW_STD; mean_x = SW_MEAN_X; stdev_x = SW_STD_X; break; case CW: mean = CW_MEAN; stdev = CW_STD; mean_x = CW_MEAN_X; stdev_x = CW_STD_X; break; } if (GENDER == FEMALE){ max_x = max; mean_x = mean; stdev_x = stdev; min_x = min; } iter++; maxcut = mean + STDMULT * stdev; mincut = mean - STDMULT * stdev; maxcut_x = mean_x + STDMULT * stdev_x; mincut_x = mean_x - STDMULT * stdev_x; /* maxcut = mean * 2.5;// + STDMULT * stdev; mincut = mean / 2.5; //- STDMULT * stdev; maxcut_x = mean_x * 1.5;//+ STDMULT * stdev_x; mincut_x = mean_x / 1.5; //- STDMULT * stdev_x; */ /* if (GENDER != FEMALE){ maxcut_x = mean_x + STDMULT * stdev_x; mincut_x = mean_x - STDMULT * stdev_x; }*/ if (mincut < 0.0) mincut = mean / 10.0; if (mincut_x < 0.0) mincut_x = mean_x / 10.0; /* if (maxcut - mean > mean - mincut) maxcut = mean + (mean - mincut); if (GENDER != FEMALE){ if (maxcut_x - mean_x > mean_x - mincut_x) maxcut_x = mean_x + (mean_x - mincut_x); }*/ if (VERBOSE){ fprintf(stdout, "mean: %f\tstdev: %f\tmax: %f (cut: %f)\tmin: %f (cut: %f) \n", mean, stdev, max, maxcut, min, mincut); if (GENDER != FEMALE) fprintf(stdout, "mean_x: %f\tstdev_x: %f\tmax_x: %f (cut: %f)\tmin_x: %f (cut: %f)\n", mean_x, stdev_x, max_x, maxcut_x, min_x, mincut_x); } if (p_min == min && p_max == max && p_min_x == min_x && p_max_x == max_x) break; // } while (max >= maxcut || max_x >= maxcut_x || min <= mincut || min_x <= mincut_x); } while (stdev > 0.25 * mean); fprintf(stdout, "%s Normalization completed.\n", (wt == LW ? "LW" : (wt == SW ? "SW" : "CW"))); return 1; }
void set_lpc_modeg ( Word16 *signal_ptr, /* I Input signal */ Word16 *a_fwd, /* I Forward LPC filter */ Word16 *a_bwd, /* I Backward LPC filter */ Word16 *mode, /* O Backward / forward Indication */ Word16 *lsp_new, /* I LSP vector current frame */ Word16 *lsp_old, /* I LSP vector previous frame */ Word16 *bwd_dominant,/* O Bwd dominant mode indication */ Word16 prev_mode, /* I previous frame Backward / forward Indication */ Word16 *prev_filter, /* I previous frame filter */ Word16 *C_int, /*I/O filter interpolation parameter */ Word16 *glob_stat, /* I/O Mre of global stationnarity Q8 */ Word16 *stat_bwd, /* I/O Number of consecutive backward frames */ Word16 *val_stat_bwd/* I/O Value associated with stat_bwd */ ) { Word16 i; Word16 res[L_FRAME]; Word16 *pa_bwd; Word16 gap; Word16 gpred_f, gpred_b, gpred_bint; Word16 tmp; Word32 thresh_lpc_L; Word32 tmp_L; Word32 dist_lsp, energy; pa_bwd = a_bwd + M_BWDP1; /* Backward filter prediction gain (no interpolation ) */ /* --------------------------------------------------- */ Residue(M_BWD,pa_bwd, signal_ptr, res, L_FRAME); gpred_b = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* Interpolated LPC filter for transition forward -> backward */ /* (used during 10 frames) ( for the second sub-frame ) */ /* Interpolated backward filter for the first sub-frame */ /* ---------------------------------------------------------- */ Int_bwd(a_bwd, prev_filter, C_int); /* Interpolated backward filter prediction gain */ /* -------------------------------------------- */ Residue(M_BWD,a_bwd, signal_ptr, res, L_SUBFR); Residue(M_BWD,pa_bwd, &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR); gpred_bint = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* Forward filter prediction gain */ /* ------------------------------ */ Residue(M, a_fwd, signal_ptr, res, L_SUBFR); Residue(M, &a_fwd[MP1], &signal_ptr[L_SUBFR], &res[L_SUBFR], L_SUBFR); gpred_f = ener_dB(signal_ptr, L_FRAME) - ener_dB(res, L_FRAME); /* -------------------------------------------------------------- */ /* BACKWARD / FORWARD DECISION */ /* */ /* The Main criterion is based on the prediction gains : */ /* The global stationnarity index is used to adapt the threshold */ /* value " GAP ". */ /* This adaptation is used to favour one mode according to the */ /* stationnarity of the input signal (backward for music and */ /* forward for speech) which avoids too many switches. */ /* */ /* A second criterion based on the LSPs is used to avoid switches */ /* if the successive LPC forward filters are very stationnary */ /* (which is measured a Euclidean distance on LSPs). */ /* */ /* -------------------------------------------------------------- */ /* 1st criterion with prediction gains */ /* ----------------------------------- */ /* Threshold adaptation according to the global stationnarity indicator */ tmp = shr(*glob_stat, 7); tmp_L = L_mult(tmp, 3); tmp_L = L_shr(tmp_L, 1); tmp = extract_l(tmp_L); gap = add(tmp, 205); if ( (gpred_bint > gpred_f - gap)&& (gpred_b > gpred_f - gap)&& (gpred_b > 0)&& (gpred_bint > 0) ) *mode = 1; else *mode = 0; if (*glob_stat < 13000) *mode = 0; /* => Forward mode imposed */ /* 2nd criterion with a distance between 2 successive LSP vectors */ /* -------------------------------------------------------------- */ /* Computation of the LPC distance */ dist_lsp = 0; for(i=0; i<M; i++){ tmp = sub(lsp_old[i],lsp_new[i]); dist_lsp = L_mac(dist_lsp, tmp, tmp); } /* Adaptation of the LSPs thresholds */ if (*glob_stat < 32000) { thresh_lpc_L = 0L; } else { thresh_lpc_L = 64424509L; } /* Switching backward -> forward forbidden in case of a LPC stationnary */ if ((dist_lsp < thresh_lpc_L)&&(*mode == 0)&&(prev_mode == 1)&&(gpred_b > 0)&&(gpred_bint > 0)) { *mode = 1; } /* Low energy frame => Forward mode chosen */ /* --------------------------------------- */ energy = ener_dB(signal_ptr, L_FRAME); if (energy < 8192) { *mode = 0; if (*glob_stat > 13000) *glob_stat = 13000; } else tst_bwd_dominant(bwd_dominant, *mode); /* Adaptation of the global stationnarity indicator */ /* ------------------------------------------------ */ if (energy >= 8192) calc_stat(gpred_b, gpred_f, *mode, prev_mode, glob_stat, stat_bwd, val_stat_bwd); if(*mode == 0) *C_int = 4506; return; }
void job_controller(int ops, _main_data *main_data) { static int cur_type = -1; static int wav_cur_track = -1; static int mp3_cur_track = -1; static int mp3_nxt_track = -1; static pid_t wav_pg_pid = -1; static pid_t mp3_pg_pid = -1; static pid_t wav_pi_pid = -1; static pid_t mp3_pi_pid = -1; static int wav_read_fd; static int mp3_read_fd; static _stat stat; static _main_data *saved_main_data; static char *wav_file_path, *enc_file_path; unsigned wav_current = 0; unsigned mp3_current = 0; double wav_progress; double mp3_progress; char msg[ MAX_PLUGIN_OUTPUT_LENGTH ]; char *str; int temp, temp_track; switch(ops) { case JC_START : /* called once when the go button is clicked. */ saved_main_data = main_data; if(wav_cur_track != -1) { err_handler(JOB_IN_PROGRESS_ERR, NULL); job_finisher(main_data); return; } if(find_next_job(main_data, wav_cur_track, WAV, &wav_cur_track, &cur_type) < 0) { /* ok, no more wavs to rip, try looking for mp3s */ if(find_next_job(main_data, mp3_cur_track, MP3, &mp3_cur_track, &cur_type) < 0) { /* nothing at all found */ err_handler(NOTHING_TO_DO_ERR, NULL); job_finisher(main_data); return; } create_file_names_for_track(main_data, mp3_cur_track, &wav_file_path, &enc_file_path); calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_START_SESSION); calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_START); /* start encoding */ if(start_ripping_encoding(MP3, main_data->track[ mp3_cur_track ].begin, main_data->track[ mp3_cur_track ].length, mp3_cur_track, wav_file_path, enc_file_path, &mp3_pg_pid, &mp3_pi_pid, &mp3_read_fd) < 0) { job_finisher(main_data); return; } stat.encoding = TRUE; } else { /* found the first wav to rip */ create_file_names_for_track(main_data, wav_cur_track, &wav_file_path, &enc_file_path); calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_START_SESSION); calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_START); /* start ripping */ if(start_ripping_encoding(WAV, main_data->track[ wav_cur_track ].begin, main_data->track[ wav_cur_track ].length, wav_cur_track, wav_file_path, enc_file_path, &wav_pg_pid, &wav_pi_pid, &wav_read_fd) < 0) { job_finisher(main_data); return; } stat.ripping = TRUE; /* Find the next track to encode if any */ if(find_next_job(main_data, mp3_cur_track, MP3, &mp3_nxt_track, &cur_type) < 0 || !main_data->track[ mp3_nxt_track ].make_mp3) { mp3_nxt_track = -1; } } /* Create wav/mp3 status frame */ wm_status_frame_handler(WIDGET_CREATE, cur_type, &stat, NULL); job_controller_timeout_start(); return; case JC_UPDATE : main_data = saved_main_data; /* Part 1: check progress on the rip */ if(stat.ripping == TRUE) { temp = read_and_process_plugin_output(wav_read_fd, &wav_progress, msg); wav_current = main_data->track[ wav_cur_track ].length * wav_progress; switch(temp) { case PLUGIN_MSG_PARSE_ERR : /* Nothing to do. Let's wait more */ break; case PLUGIN_PROGRESS_MSG : /* progress report, update status display */ calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_UPDATE); /* Update status widget */ if(msg[ 0 ] == '\0') { str = NULL; } else { str = msg; } wm_status_frame_handler(WIDGET_UPDATE, WAV, &stat, str); break; case PLUGIN_NO_MSG_AVAILABLE : /* Check if the plugin has exited It only happens when ripperX failed to execute the plugin */ if(wav_pi_pid >= 0) if(waitpid(wav_pi_pid, NULL, WNOHANG) == wav_pi_pid) { err_handler(PLUGIN_NOT_PRESENT_ERR, _("Maybe ripperX has failed to execute the plugin")); wav_pi_pid = -1; job_controller_timeout_stop(); job_controller(JC_ABORT_ALL_DELETE, main_data); return; } /* Check if the job is finished */ if(waitpid(wav_pg_pid, NULL, WNOHANG) == wav_pg_pid) { /* One job finished, go for next one */ /* kill the plugin */ if(waitpid(wav_pi_pid, NULL, WNOHANG) != wav_pi_pid) { kill(-wav_pi_pid, SIGTERM); waitpid(wav_pi_pid, NULL, 0); } /* Close the fd */ close(wav_read_fd); /* stop calculating stats */ calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_STOP); /* Mark that it exists */ main_data->track[ wav_cur_track ].wav_exist = TRUE; /* find next track to rip */ temp_track = wav_cur_track; if(find_next_job(main_data, wav_cur_track, WAV, &wav_cur_track, &cur_type) < 0) { /* All finished - no more rips */ wav_pg_pid = -1; wav_pi_pid = -1; wav_cur_track = -1; cur_type = -1; stat.ripping = FALSE; /* if we are only ripping, finish up for good */ if(!main_data->track[ temp_track ].make_mp3) { calc_stat(main_data, &stat, wav_current, temp_track, WAV, CALC_STOP_SESSION); job_controller_timeout_stop(); job_finisher(main_data); return; } } else { /* if we are only ripping, update the stats */ if(!main_data->track[ temp_track ].make_mp3) { stat.tracks_done++; stat.tracks_remain--; } /* start ripping the next track */ create_file_names_for_track(main_data, wav_cur_track, &wav_file_path, &enc_file_path); calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_START); if(start_ripping_encoding(WAV, main_data->track[ wav_cur_track ].begin, main_data->track[ wav_cur_track ].length, wav_cur_track, wav_file_path, enc_file_path, &wav_pg_pid, &wav_pi_pid, &wav_read_fd) < 0) { calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_STOP_SESSION); job_controller_timeout_stop(); job_finisher(main_data); return; } } } /* end if job is finished section */ break; } /* end rip switch */ } /* end rip progress check */ /* Part 2: check progress on the encode */ if(stat.encoding == TRUE) { temp = read_and_process_plugin_output(mp3_read_fd, &mp3_progress, msg); mp3_current = main_data->track[ mp3_cur_track ].length * mp3_progress; switch(temp) { case PLUGIN_MSG_PARSE_ERR : /* Nothing to do. Let's wait more */ break; case PLUGIN_PROGRESS_MSG : /* progress report, update status display */ calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_UPDATE); /* Update status widget */ if(msg[ 0 ] == '\0') { str = NULL; } else { str = msg; } wm_status_frame_handler(WIDGET_UPDATE, MP3, &stat, str); break; case PLUGIN_NO_MSG_AVAILABLE : /* Check if the plugin has exited It only happens when ripperX failed to execute the plugin */ if(mp3_pi_pid >= 0) if(waitpid(mp3_pi_pid, NULL, WNOHANG) == mp3_pi_pid) { err_handler(PLUGIN_NOT_PRESENT_ERR, _("Maybe ripperX has failed to execute the plugin")); mp3_pi_pid = -1; job_controller_timeout_stop(); job_controller(JC_ABORT_ALL_DELETE, main_data); return; } /* Check if the job is finished */ if(waitpid(mp3_pg_pid, NULL, WNOHANG) == mp3_pg_pid) { /* One job finished, go for next one */ /* kill the plugin */ if(waitpid(mp3_pi_pid, NULL, WNOHANG) != mp3_pi_pid) { kill(-mp3_pi_pid, SIGTERM); waitpid(mp3_pi_pid, NULL, 0); } /* Close the fd */ close(mp3_read_fd); /* stop calculating stats */ calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_STOP); main_data->track[ mp3_cur_track ].mp3_exist = TRUE; /* Delete WAV file if he/she doesn't want it */ if(!config.keep_wav) { create_file_names_for_track(main_data, mp3_cur_track, &wav_file_path, &enc_file_path); if(unlink(wav_file_path) < 0) { err_handler(FILE_DELETE_ERR, wav_file_path); } /* Mark that it has been deleted */ main_data->track[ mp3_cur_track ].wav_exist = FALSE; /* Delete WAV work directory if this was the last WAV file, and the mp3 work dir is different */ if(stat.tracks_remain <= 1) if(strcmp(config.wav_path,config.mp3_path) != 0) { rmdir(file_path_without_name(wav_file_path)); } } /* find next track to encode */ temp_track = mp3_cur_track; if(find_next_job(main_data, mp3_cur_track, MP3, &mp3_nxt_track, &cur_type) < 0) { /* All finished - no more encoding - done for good! */ mp3_pg_pid = -1; mp3_pi_pid = -1; mp3_cur_track = mp3_nxt_track = -1; cur_type = -1; calc_stat(main_data, &stat, mp3_current, temp_track, MP3, CALC_STOP_SESSION); job_controller_timeout_stop(); stat.encoding = FALSE; job_finisher(main_data); return; } mp3_cur_track = -1; stat.tracks_done++; stat.tracks_remain--; stat.encoding = FALSE; } /* end if job is finished section */ break; } /* end encode switch */ } /* end encode progress check */ if(!stat.encoding && mp3_nxt_track != -1 && main_data->track[ mp3_nxt_track ].wav_exist) { /* start encoding */ mp3_cur_track = mp3_nxt_track; mp3_nxt_track = -1; create_file_names_for_track(main_data, mp3_cur_track, &wav_file_path, &enc_file_path); calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_START); if(start_ripping_encoding(MP3, main_data->track[ mp3_cur_track ].begin, main_data->track[ mp3_cur_track ].length, mp3_cur_track, wav_file_path, enc_file_path, &mp3_pg_pid, &mp3_pi_pid, &mp3_read_fd) < 0) { calc_stat(main_data, &stat, mp3_current, mp3_cur_track, MP3, CALC_STOP_SESSION); job_controller_timeout_stop(); job_finisher(main_data); } stat.encoding = TRUE; } /* end of JC_UPDATE */ return; case JC_PAUSE : main_data = saved_main_data; if(wav_pg_pid >= 0) if(waitpid(wav_pg_pid, NULL, WNOHANG) != wav_pg_pid) { kill(wav_pg_pid, SIGTSTP); } if(wav_pi_pid >= 0) if(waitpid(wav_pi_pid, NULL, WNOHANG) != wav_pi_pid) { kill(wav_pi_pid, SIGTSTP); } if(mp3_pg_pid >= 0) if(waitpid(mp3_pg_pid, NULL, WNOHANG) != mp3_pg_pid) { kill(mp3_pg_pid, SIGTSTP); } if(mp3_pi_pid >= 0) if(waitpid(mp3_pi_pid, NULL, WNOHANG) != mp3_pi_pid) { kill(mp3_pi_pid, SIGTSTP); } calc_stat(main_data, &stat, wav_current, wav_cur_track, WAV, CALC_PAUSE); job_controller_timeout_stop(); return; case JC_CONT : main_data = saved_main_data; if(wav_pg_pid >= 0) if(waitpid(wav_pg_pid, NULL, WNOHANG) != wav_pg_pid) { kill(wav_pg_pid, SIGCONT); } if(wav_pi_pid >= 0) if(waitpid(wav_pi_pid, NULL, WNOHANG) != wav_pi_pid) { kill(wav_pi_pid, SIGCONT); } if(mp3_pg_pid >= 0) if(waitpid(mp3_pg_pid, NULL, WNOHANG) != mp3_pg_pid) { kill(mp3_pg_pid, SIGCONT); } if(mp3_pi_pid >= 0) if(waitpid(mp3_pi_pid, NULL, WNOHANG) != mp3_pi_pid) { kill(mp3_pi_pid, SIGCONT); } calc_stat(main_data, &stat, wav_current, wav_cur_track, cur_type, CALC_CONT); job_controller_timeout_start(); return; case JC_ABORT : case JC_ABORT_DELETE : case JC_ABORT_ALL : case JC_ABORT_ALL_DELETE : main_data = saved_main_data; if(wav_pg_pid >= 0) if(waitpid(wav_pg_pid, NULL, WNOHANG) != wav_pg_pid) { job_controller(JC_CONT, NULL); kill(-wav_pg_pid, SIGTERM); waitpid(wav_pg_pid, NULL, 0); } if(wav_pi_pid >= 0) if(waitpid(wav_pi_pid, NULL, WNOHANG) != wav_pi_pid) { kill(-wav_pi_pid, SIGTERM); waitpid(wav_pi_pid, NULL, 0); } if(mp3_pg_pid >= 0) if(waitpid(mp3_pg_pid, NULL, WNOHANG) != mp3_pg_pid) { job_controller(JC_CONT, NULL); kill(-mp3_pg_pid, SIGTERM); waitpid(mp3_pg_pid, NULL, 0); } if(mp3_pi_pid >= 0) if(waitpid(mp3_pi_pid, NULL, WNOHANG) != mp3_pi_pid) { kill(-mp3_pi_pid, SIGTERM); waitpid(mp3_pi_pid, NULL, 0); } /* Close the pipe or pty */ close(wav_read_fd); close(mp3_read_fd); calc_stat(main_data, &stat, wav_current, wav_cur_track, cur_type, CALC_STOP_SESSION); /* Destroy status widget */ wm_status_frame_handler(WIDGET_DESTROY, WAV, &stat, msg); if((ops == JC_ABORT_ALL_DELETE) || (ops == JC_ABORT_DELETE)) { create_file_names_for_track(main_data, wav_cur_track, &wav_file_path, NULL); if(wav_cur_track != -1) { create_file_names_for_track(main_data, wav_cur_track, &wav_file_path, &enc_file_path); if(unlink(wav_file_path) < 0) { err_handler(FILE_DELETE_ERR, wav_file_path); } } if(mp3_cur_track != -1) { create_file_names_for_track(main_data, mp3_cur_track, NULL, &enc_file_path); if(unlink(enc_file_path) < 0) { err_handler(FILE_DELETE_ERR, enc_file_path); } } } else { /* Mark that it exists */ if(wav_cur_track != -1) { main_data->track[ wav_cur_track ].wav_exist = TRUE; } if(mp3_cur_track != -1) { main_data->track[ mp3_cur_track ].mp3_exist = TRUE; } } wav_cur_track = -1; mp3_cur_track = -1; cur_type = -1; calc_stat(main_data, &stat, wav_current, wav_cur_track, cur_type, CALC_STOP_SESSION); job_controller_timeout_stop(); job_finisher(main_data); return; } }
int main(int argc, char **argv) { #if DEBUG feenableexcept(FE_DIVBYZERO| FE_INVALID|FE_OVERFLOW); // enable exceptions #endif if(argc ^ 2){ printf("Usage: ./sa sa.config\n"); exit(1); } if(read_config(argv[1])){ // read config printf("READDATA: Can't process %s \n", argv[1]); return 1; } T = T+SKIP; // increase T by SKIP to go from 0 to T all the way in time units // precomputing I_Gamma = 1.0/Gamma; I_Alpha = 1.0/Alpha; Bo = B; X0_Be = pow(X0, Beta); GaBe = Gamma * Beta; // event probabilites scaling by G; PE[0] = PE[0]*(double)G; PE[1] = PE[1]*(double)G; PE[2] = PE[2]*(double)G; initrand(Seed); init(); // note: method is in init.c // allocate memory at initial int i, j, ev, k = 0; // m; unsigned long seed; double dt, ct, tt; // tt: time of simulation; dt: delta time after which next event occurs; ct: counter time to check with skip time for stat calculation time_t now; for( i = 0; i < Runs; i++){ tt = 0.0, ct = 0.0; k = 0; //m = 0; if(Seed == 0){ now = time(0); seed = ((unsigned long)now); seed = 1454011037; initrand(seed); printf("\n run: %d rand seed: %lu\n",i+1, seed); } set_init_xrvpi(); // sets initial strategies vector, roles, valuations and payoffs calc_stat(0, i); for( j = 0; j < N; j++) printf("%.4lf ", V[0][j]); printf("\n"); // Gillespie's stochastic simulation while(tt < T){ // calc lambda; lambda = summation of P[j]s for(Lambda = 0, j = EVENTS; j--;) Lambda += PE[j]; // select time for next event dt = randexp(Lambda); //printf("dt: %.4lf\n", dt); // select next event ev = select_event(); // play the event play_event(ev); // update time tt += dt; // calc stat ct += dt; if(ct >= SKIP){ calc_stat(++k, i); // calculates all the stats ct = 0.0; } // update events associated probabilites if necessary } #if ALLDATAFILE calc_stat(-1, -1); // free file pointers for individual run data files #if !CLUSTER plotallIndividualRun(i, 0); // note: method is in dataplot.c #if GRAPHS plotallIndividualRun(i, 1); // note: method is in dataplot.c #endif #endif // write traits of final state { int m, n; char tstr[200], str[100]; sprintf(str, "traits%d.dat", i); sprintf(str, "traits%d.dat", i); prep_file(tstr, str); FILE *fp = fopen(tstr, "w"); for(m = 0; m < G; m++){ for( n = 0; n < GS[m]; n++){ fprintf(fp, "%.4lf %.4lf ", dxi[m][n], dsi[m][n]); } fprintf(fp, "\n"); } fclose(fp); } #if PUNISH #if DISP_MATRIX plotTraits(i, 0); // note: method is in dataplot.c #endif #if GRAPHS plotTraits(i, 1); // note: method is in dataplot.c #endif #endif #endif } // write effort and payoff data writefile_effort_fertility(); // note: method is in dataplot.c writefile_threshold_aggressiveness(); // note: method is in dataplot.c // plot data with graphics using gnuplot if(!CLUSTER){ plotall(0); // note: method is in dataplot.c #if GRAPHS plotall(1); // note: method is in dataplot.c #endif } #if PUNISH #if DISP_MATRIX displayMatrix(); #endif #endif cleanup(); // note: method is in init.c return 0; }