1 /* 2 TiMidity++ -- MIDI to WAVE converter and player 3 Copyright (C) 1999-2002 Masanao Izumo <mo@goice.co.jp> 4 Copyright (C) 1995 Tuukka Toivonen <tt@cgs.fi> 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 2 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 19 20 resample.c 21 */ 22 23 #ifdef HAVE_CONFIG_H 24 #include "config.h" 25 #endif /* HAVE_CONFIG_H */ 26 #include <math.h> 27 #include <stdio.h> 28 #include <stdlib.h> 29 30 #ifndef NO_STRING_H 31 #include <string.h> 32 #else 33 #include <strings.h> 34 #endif 35 36 #include "timidity.h" 37 #include "common.h" 38 #include "instrum.h" 39 #include "playmidi.h" 40 #include "output.h" 41 #include "controls.h" 42 #include "tables.h" 43 #include "resample.h" 44 #include "recache.h" 45 46 47 /* for start/end of samples */ 48 static float newt_coeffs[58][58] = { 49 #include "newton_table.c" 50 }; 51 52 int sample_bounds_min, sample_bounds_max; /* min/max bounds for sample data */ 53 54 /* 4-point interpolation by cubic spline curve. */ 55 56 static resample_t resample_cspline(sample_t *src, splen_t ofs, resample_rec_t *rec) 57 { 58 int32 ofsi, ofsf, v0, v1, v2, v3, temp; 59 60 ofsi = ofs >> FRACTION_BITS; 61 v1 = src[ofsi]; 62 v2 = src[ofsi + 1]; 63 if((ofs<rec->loop_start+(1L<<FRACTION_BITS))|| 64 ((ofs+(2L<<FRACTION_BITS))>rec->loop_end)){ 65 return (v1 + ((resample_t)((v2 - v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS)); 66 } else { 67 v0 = src[ofsi - 1]; 68 v3 = src[ofsi + 2]; 69 ofsf = ofs & FRACTION_MASK; 70 temp = v2; 71 v2 = (6 * v2 + ((((5 * v3 - 11 * v2 + 7 * v1 - v0) >> 2) * 72 (ofsf + (1L << FRACTION_BITS)) >> FRACTION_BITS) * 73 (ofsf - (1L << FRACTION_BITS)) >> FRACTION_BITS)) 74 * ofsf; 75 v1 = (((6 * v1+((((5 * v0 - 11 * v1 + 7 * temp - v3) >> 2) * 76 ofsf >> FRACTION_BITS) * (ofsf - (2L << FRACTION_BITS)) 77 >> FRACTION_BITS)) * ((1L << FRACTION_BITS) - ofsf)) + v2) 78 / (6L << FRACTION_BITS); 79 return ((v1 > sample_bounds_max) ? sample_bounds_max : 80 ((v1 < sample_bounds_min) ? sample_bounds_min : v1)); 81 } 82 } 83 84 85 /* 4-point interpolation by Lagrange method. 86 Lagrange is now faster than C-spline. Both have about the same accuracy, 87 so choose Lagrange over C-spline, since it is faster. Technically, it is 88 really a 3rd order Newton polynomial (whereas the old Lagrange truely was 89 the Lagrange form of the polynomial). Both Newton and Lagrange forms 90 yield the same numerical results, but the Newton form is faster. Since 91 n'th order Newton interpolaiton is resample_newton(), it made sense to 92 just keep this labeled as resample_lagrange(), even if it really is the 93 Newton form of the polynomial. */ 94 95 static resample_t resample_lagrange(sample_t *src, splen_t ofs, resample_rec_t *rec) 96 { 97 int32 ofsi, ofsf, v0, v1, v2, v3; 98 99 ofsi = ofs >> FRACTION_BITS; 100 v1 = (int32)src[ofsi]; 101 v2 = (int32)src[ofsi + 1]; 102 if((ofs<rec->loop_start+(1L<<FRACTION_BITS))|| 103 ((ofs+(2L<<FRACTION_BITS))>rec->loop_end)) { 104 return (v1 + ((resample_t)((v2 - v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS)); 105 } else { 106 v0 = (int32)src[ofsi - 1]; 107 v3 = (int32)src[ofsi + 2]; 108 ofsf = (ofs & FRACTION_MASK) + (1<<FRACTION_BITS); 109 v3 += -3*v2 + 3*v1 - v0; 110 v3 *= (ofsf - (2<<FRACTION_BITS)) / 6; 111 v3 >>= FRACTION_BITS; 112 v3 += v2 - v1 - v1 + v0; 113 v3 *= (ofsf - (1<<FRACTION_BITS)) >> 1; 114 v3 >>= FRACTION_BITS; 115 v3 += v1 - v0; 116 v3 *= ofsf; 117 v3 >>= FRACTION_BITS; 118 v3 += v0; 119 return ((v3 > sample_bounds_max) ? sample_bounds_max : 120 ((v3 < sample_bounds_min) ? sample_bounds_min : v3)); 121 } 122 } 123 124 125 /* Very fast and accurate table based interpolation. Better speed and higher 126 accuracy than Newton. This isn't *quite* true Gauss interpolation; it's 127 more a slightly modified Gauss interpolation that I accidently stumbled 128 upon. Rather than normalize all x values in the window to be in the range 129 [0 to 2*PI], it simply divides them all by 2*PI instead. I don't know why 130 this works, but it does. Gauss should only work on periodic data with the 131 window spanning exactly one period, so it is no surprise that regular Gauss 132 interpolation doesn't work too well on general audio data. But dividing 133 the x values by 2*PI magically does. Any other scaling produces degraded 134 results or total garbage. If anyone can work out the theory behind why 135 this works so well (at first glance, it shouldn't ??), please contact me 136 (Eric A. Welsh, ewelsh@ccb.wustl.edu), as I would really like to have some 137 mathematical justification for doing this. Despite the lack of any sound 138 theoretical basis, this method DOES result in highly accurate interpolation 139 (or possibly approximaton, not sure yet if it truly interpolates, but it 140 looks like it does). -N 34 is as high as it can go before errors start 141 appearing. But even at -N 34, it is more accurate than Newton at -N 57. 142 -N 34 has no problem running in realtime on my system, but -N 25 is the 143 default, since that is the optimal compromise between speed and accuracy. 144 I strongly recommend using Gauss interpolation. It is the highest 145 quality interpolation option available, and is much faster than using 146 Newton polynomials. */ 147 148 #define DEFAULT_GAUSS_ORDER 25 149 static float *gauss_table[(1<<FRACTION_BITS)] = {0}; /* don't need doubles */ 150 static int gauss_n = DEFAULT_GAUSS_ORDER; 151 152 static resample_t resample_gauss(sample_t *src, splen_t ofs, resample_rec_t *rec) 153 { 154 sample_t *sptr; 155 int32 left, right, temp_n; 156 157 left = (ofs>>FRACTION_BITS); 158 right = (rec->data_length>>FRACTION_BITS) - left - 1; 159 temp_n = (right<<1)-1; 160 if (temp_n > (left<<1)+1) 161 temp_n = (left<<1)+1; 162 if (temp_n < gauss_n) { 163 int ii, jj; 164 float xd, y; 165 if (temp_n <= 0) 166 temp_n = 1; 167 xd = ofs & FRACTION_MASK; 168 xd /= (1L<<FRACTION_BITS); 169 xd += temp_n>>1; 170 y = 0; 171 sptr = src + (ofs>>FRACTION_BITS) - (temp_n>>1); 172 for (ii = temp_n; ii;) { 173 for (jj = 0; jj <= ii; jj++) 174 y += sptr[jj] * newt_coeffs[ii][jj]; 175 y *= xd - --ii; 176 } 177 y += *sptr; 178 return ((y > sample_bounds_max) ? sample_bounds_max : 179 ((y < sample_bounds_min) ? sample_bounds_min : y)); 180 } else { 181 float *gptr, *gend; 182 float y; 183 y = 0; 184 sptr = src + left - (gauss_n>>1); 185 gptr = gauss_table[ofs&FRACTION_MASK]; 186 if (gauss_n == DEFAULT_GAUSS_ORDER) { 187 /* expanding the loop for the default case. 188 * this will allow intensive optimization when compiled 189 * with SSE2 capability. 190 */ 191 #define do_gauss y += *(sptr++) * *(gptr++); 192 do_gauss; 193 do_gauss; 194 do_gauss; 195 do_gauss; 196 do_gauss; 197 do_gauss; 198 do_gauss; 199 do_gauss; 200 do_gauss; 201 do_gauss; 202 do_gauss; 203 do_gauss; 204 do_gauss; 205 do_gauss; 206 do_gauss; 207 do_gauss; 208 do_gauss; 209 do_gauss; 210 do_gauss; 211 do_gauss; 212 do_gauss; 213 do_gauss; 214 do_gauss; 215 do_gauss; 216 do_gauss; 217 y += *sptr * *gptr; 218 #undef do_gauss 219 } else { 220 gend = gptr + gauss_n; 221 do { 222 y += *(sptr++) * *(gptr++); 223 } while (gptr <= gend); 224 } 225 return ((y > sample_bounds_max) ? sample_bounds_max : 226 ((y < sample_bounds_min) ? sample_bounds_min : y)); 227 } 228 } 229 230 231 /* (at least) n+1 point interpolation using Newton polynomials. 232 n can be set with a command line option, and 233 must be an odd number from 1 to 57 (57 is as high as double precision 234 can go without precision errors). Default n = 11 is good for a 1.533 MHz 235 Athlon. Larger values for n require very fast processors for real time 236 playback. Some points will be interpolated at orders > n to both increase 237 accuracy and save CPU. */ 238 239 static int newt_n = 11; 240 static int32 newt_old_trunc_x = -1; 241 static int newt_grow = -1; 242 static int newt_max = 13; 243 static double newt_divd[60][60]; 244 static double newt_recip[60] = { 0, 1, 1.0/2, 1.0/3, 1.0/4, 1.0/5, 1.0/6, 1.0/7, 245 1.0/8, 1.0/9, 1.0/10, 1.0/11, 1.0/12, 1.0/13, 1.0/14, 246 1.0/15, 1.0/16, 1.0/17, 1.0/18, 1.0/19, 1.0/20, 1.0/21, 247 1.0/22, 1.0/23, 1.0/24, 1.0/25, 1.0/26, 1.0/27, 1.0/28, 248 1.0/29, 1.0/30, 1.0/31, 1.0/32, 1.0/33, 1.0/34, 1.0/35, 249 1.0/36, 1.0/37, 1.0/38, 1.0/39, 1.0/40, 1.0/41, 1.0/42, 250 1.0/43, 1.0/44, 1.0/45, 1.0/46, 1.0/47, 1.0/48, 1.0/49, 251 1.0/50, 1.0/51, 1.0/52, 1.0/53, 1.0/54, 1.0/55, 1.0/56, 252 1.0/57, 1.0/58, 1.0/59 }; 253 static sample_t *newt_old_src = NULL; 254 255 static resample_t resample_newton(sample_t *src, splen_t ofs, resample_rec_t *rec) 256 { 257 int n_new, n_old; 258 int32 v1, v2, diff = 0; 259 sample_t *sptr; 260 double y, xd; 261 int32 left, right, temp_n; 262 int ii, jj; 263 264 left = (ofs>>FRACTION_BITS); 265 right = (rec->data_length>>FRACTION_BITS)-(ofs>>FRACTION_BITS)-1; 266 temp_n = (right<<1)-1; 267 if (temp_n <= 0) 268 temp_n = 1; 269 if (temp_n > (left<<1)+1) 270 temp_n = (left<<1)+1; 271 if (temp_n < newt_n) { 272 xd = ofs & FRACTION_MASK; 273 xd /= (1L<<FRACTION_BITS); 274 xd += temp_n>>1; 275 y = 0; 276 sptr = src + (ofs>>FRACTION_BITS) - (temp_n>>1); 277 for (ii = temp_n; ii;) { 278 for (jj = 0; jj <= ii; jj++) 279 y += sptr[jj] * newt_coeffs[ii][jj]; 280 y *= xd - --ii; 281 } y += *sptr; 282 }else{ 283 if (newt_grow >= 0 && src == newt_old_src && 284 (diff = (ofs>>FRACTION_BITS) - newt_old_trunc_x) > 0){ 285 n_new = newt_n + ((newt_grow + diff)<<1); 286 if (n_new <= newt_max){ 287 n_old = newt_n + (newt_grow<<1); 288 newt_grow += diff; 289 for (v1=(ofs>>FRACTION_BITS)+(n_new>>1)+1,v2=n_new; 290 v2 > n_old; --v1, --v2){ 291 newt_divd[0][v2] = src[v1]; 292 }for (v1 = 1; v1 <= n_new; v1++) 293 for (v2 = n_new; v2 > n_old; --v2) 294 newt_divd[v1][v2] = (newt_divd[v1-1][v2] - 295 newt_divd[v1-1][v2-1]) * 296 newt_recip[v1]; 297 }else newt_grow = -1; 298 } 299 if (newt_grow < 0 || src != newt_old_src || diff < 0){ 300 newt_grow = 0; 301 for (v1=(ofs>>FRACTION_BITS)-(newt_n>>1),v2=0; 302 v2 <= newt_n; v1++, v2++){ 303 newt_divd[0][v2] = src[v1]; 304 }for (v1 = 1; v1 <= newt_n; v1++) 305 for (v2 = newt_n; v2 >= v1; --v2) 306 newt_divd[v1][v2] = (newt_divd[v1-1][v2] - 307 newt_divd[v1-1][v2-1]) * 308 newt_recip[v1]; 309 } 310 n_new = newt_n + (newt_grow<<1); 311 v2 = n_new; 312 y = newt_divd[v2][v2]; 313 xd = (double)(ofs&FRACTION_MASK) / (1L<<FRACTION_BITS) + 314 (newt_n>>1) + newt_grow; 315 for (--v2; v2; --v2){ 316 y *= xd - v2; 317 y += newt_divd[v2][v2]; 318 }y = y*xd + **newt_divd; 319 newt_old_src = src; 320 newt_old_trunc_x = (ofs>>FRACTION_BITS); 321 } 322 return ((y > sample_bounds_max) ? sample_bounds_max : 323 ((y < sample_bounds_min) ? sample_bounds_min : y)); 324 } 325 326 327 /* Simple linear interpolation */ 328 329 static resample_t resample_linear(sample_t *src, splen_t ofs, resample_rec_t *rec) 330 { 331 int32 v1, v2, ofsi; 332 333 ofsi = ofs >> FRACTION_BITS; 334 v1 = src[ofsi]; 335 v2 = src[ofsi + 1]; 336 #if defined(LOOKUP_HACK) && defined(LOOKUP_INTERPOLATION) 337 return (sample_t)(v1 + (iplookup[(((v2 - v1) << 5) & 0x03FE0) | 338 ((ofs & FRACTION_MASK) >> (FRACTION_BITS-5))])); 339 #else 340 return (v1 + ((resample_t)((v2 - v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS)); 341 #endif 342 } 343 344 345 /* No interpolation -- Earplugs recommended for maximum listening enjoyment */ 346 347 static resample_t resample_none(sample_t *src, splen_t ofs, resample_rec_t *rec) 348 { 349 return src[ofs >> FRACTION_BITS]; 350 } 351 352 353 /* 354 */ 355 356 typedef resample_t (*resampler_t)(sample_t*, splen_t, resample_rec_t *); 357 static resampler_t resamplers[] = { 358 resample_cspline, 359 resample_lagrange, 360 resample_gauss, 361 resample_newton, 362 resample_linear, 363 resample_none 364 }; 365 366 #ifdef FIXED_RESAMPLATION 367 /* don't allow to change the resamplation algorighm. 368 * accessing directly to the given function. 369 * hope the compiler will optimize the overhead of function calls in this case. 370 */ 371 #define cur_resample DEFAULT_RESAMPLATION 372 #else 373 static resampler_t cur_resample = DEFAULT_RESAMPLATION; 374 #endif 375 376 #define RESAMPLATION *dest++ = cur_resample(src, ofs, &resrc); 377 378 /* exported for recache.c */ 379 resample_t do_resamplation(sample_t *src, splen_t ofs, resample_rec_t *rec) 380 { 381 return cur_resample(src, ofs, rec); 382 } 383 384 /* return the current resampling algorithm */ 385 int get_current_resampler(void) 386 { 387 int i; 388 for (i = 0; i < (int)(sizeof(resamplers)/sizeof(resamplers[0])); i++) 389 if (resamplers[i] == cur_resample) 390 return i; 391 return 0; 392 } 393 394 /* set the current resampling algorithm */ 395 int set_current_resampler(int type) 396 { 397 #ifdef FIXED_RESAMPLATION 398 return -1; 399 #else 400 if (type < 0 || type > RESAMPLE_NONE) 401 return -1; 402 cur_resample = resamplers[type]; 403 return 0; 404 #endif 405 } 406 407 /* #define FINALINTERP if (ofs < le) *dest++=src[(ofs>>FRACTION_BITS)-1]/2; */ 408 #define FINALINTERP /* Nothing to do after TiMidity++ 2.9.0 */ 409 /* So it isn't interpolation. At least it's final. */ 410 411 static resample_t resample_buffer[AUDIO_BUFFER_SIZE]; 412 static int resample_buffer_offset; 413 static resample_t *vib_resample_voice(int, int32 *, int); 414 static resample_t *normal_resample_voice(int, int32 *, int); 415 416 #ifdef PRECALC_LOOPS 417 #if SAMPLE_LENGTH_BITS == 32 && TIMIDITY_HAVE_INT64 418 #define PRECALC_LOOP_COUNT(start, end, incr) (int32)(((int64)((end) - (start) + (incr) - 1)) / (incr)) 419 #else 420 #define PRECALC_LOOP_COUNT(start, end, incr) (int32)(((splen_t)((end) - (start) + (incr) - 1)) / (incr)) 421 #endif 422 #endif /* PRECALC_LOOPS */ 423 424 void initialize_gauss_table(int n) 425 { 426 int m, i, k, n_half = (n>>1); 427 double ck; 428 double x, x_inc, xz; 429 double z[35], zsin_[34 + 35], *zsin, xzsin[35]; 430 float *gptr; 431 432 for (i = 0; i <= n; i++) 433 z[i] = i / (4*M_PI); 434 zsin = &zsin_[34]; 435 for (i = -n; i <= n; i++) 436 zsin[i] = sin(i / (4*M_PI)); 437 438 x_inc = 1.0 / (1<<FRACTION_BITS); 439 gptr = safe_realloc(gauss_table[0], (n+1)*sizeof(float)*(1<<FRACTION_BITS)); 440 for (m = 0, x = 0.0; m < (1<<FRACTION_BITS); m++, x += x_inc) 441 { 442 xz = (x + n_half) / (4*M_PI); 443 for (i = 0; i <= n; i++) 444 xzsin[i] = sin(xz - z[i]); 445 gauss_table[m] = gptr; 446 447 for (k = 0; k <= n; k++) 448 { 449 ck = 1.0; 450 451 for (i = 0; i <= n; i++) 452 { 453 if (i == k) 454 continue; 455 456 ck *= xzsin[i] / zsin[k - i]; 457 } 458 459 *gptr++ = ck; 460 } 461 } 462 } 463 464 void free_gauss_table(void) 465 { 466 if(gauss_table[0] != 0) 467 free(gauss_table[0]); 468 gauss_table[0] = NULL; 469 } 470 471 #if 0 /* NOT USED */ 472 /* the was calculated statically in newton_table.c */ 473 static void initialize_newton_coeffs(void) 474 { 475 int i, j, n = 57; 476 int sign; 477 478 newt_coeffs[0][0] = 1; 479 for (i = 0; i <= n; i++) 480 { 481 newt_coeffs[i][0] = 1; 482 newt_coeffs[i][i] = 1; 483 484 if (i > 1) 485 { 486 newt_coeffs[i][0] = newt_coeffs[i-1][0] / i; 487 newt_coeffs[i][i] = newt_coeffs[i-1][0] / i; 488 } 489 490 for (j = 1; j < i; j++) 491 { 492 newt_coeffs[i][j] = newt_coeffs[i-1][j-1] + newt_coeffs[i-1][j]; 493 494 if (i > 1) 495 newt_coeffs[i][j] /= i; 496 } 497 } 498 for (i = 0; i <= n; i++) 499 for (j = 0, sign = pow(-1, i); j <= i; j++, sign *= -1) 500 newt_coeffs[i][j] *= sign; 501 } 502 #endif /* NOT USED */ 503 504 /* initialize the coefficients of the current resampling algorithm */ 505 void initialize_resampler_coeffs(void) 506 { 507 /* initialize_newton_coeffs(); */ 508 initialize_gauss_table(gauss_n); 509 /* we don't have to initialize newton table any more */ 510 511 /* bounds checking values for the appropriate sample types */ 512 /* this is as good a place as any to initialize them */ 513 if (play_mode->encoding & PE_24BIT) 514 { 515 sample_bounds_min = -8388608; 516 sample_bounds_max = 8388607; 517 } 518 else /* 16-bit */ 519 { 520 sample_bounds_min = -32768; 521 sample_bounds_max = 32767; 522 } 523 } 524 525 /* change the parameter for the current resampling algorithm */ 526 int set_resampler_parm(int val) 527 { 528 if (cur_resample == resample_gauss) { 529 if (val < 1 || val > 34) 530 return -1; 531 else 532 gauss_n = val; 533 } else if (cur_resample == resample_newton) { 534 if (val < 1 || val > 57) 535 return -1; 536 else if (val % 2 == 0) 537 return -1; 538 else { 539 newt_n = val; 540 /* set optimal value for newt_max */ 541 newt_max = newt_n * 1.57730263158 - 1.875328947; 542 if (newt_max < newt_n) 543 newt_max = newt_n; 544 if (newt_max > 57) 545 newt_max = 57; 546 } 547 } 548 return 0; 549 } 550 551 /*************** resampling with fixed increment *****************/ 552 553 static resample_t *rs_plain_c(int v, int32 *countptr) 554 { 555 Voice *vp = &voice[v]; 556 resample_t *dest = resample_buffer + resample_buffer_offset; 557 sample_t *src = vp->sample->data; 558 int32 ofs, count = *countptr, i, le; 559 560 le = (int32)(vp->sample->loop_end >> FRACTION_BITS); 561 ofs = (int32)(vp->sample_offset >> FRACTION_BITS); 562 563 i = ofs + count; 564 if(i > le) 565 i = le; 566 count = i - ofs; 567 568 for (i = 0; i < count; i++) { 569 dest[i] = src[i + ofs]; 570 } 571 572 ofs += count; 573 if(ofs == le) 574 { 575 vp->timeout = 1; 576 *countptr = count; 577 } 578 vp->sample_offset = ((splen_t)ofs << FRACTION_BITS); 579 return resample_buffer + resample_buffer_offset; 580 } 581 582 static resample_t *rs_plain(int v, int32 *countptr) 583 { 584 /* Play sample until end, then free the voice. */ 585 Voice *vp = &voice[v]; 586 resample_t *dest = resample_buffer + resample_buffer_offset; 587 sample_t *src = vp->sample->data; 588 splen_t 589 ofs = vp->sample_offset, 590 ls = 0, 591 le = vp->sample->data_length; 592 resample_rec_t resrc; 593 int32 count = *countptr, incr = vp->sample_increment; 594 #ifdef PRECALC_LOOPS 595 int32 i, j; 596 #endif 597 598 if(vp->cache && incr == (1 << FRACTION_BITS)) 599 return rs_plain_c(v, countptr); 600 601 resrc.loop_start = ls; 602 resrc.loop_end = le; 603 resrc.data_length = vp->sample->data_length; 604 #ifdef PRECALC_LOOPS 605 if (incr < 0) incr = -incr; /* In case we're coming out of a bidir loop */ 606 607 /* Precalc how many times we should go through the loop. 608 NOTE: Assumes that incr > 0 and that ofs <= le */ 609 i = PRECALC_LOOP_COUNT(ofs, le, incr); 610 611 if (i > count) 612 { 613 i = count; 614 count = 0; 615 } 616 else count -= i; 617 618 for(j = 0; j < i; j++) 619 { 620 RESAMPLATION; 621 ofs += incr; 622 } 623 624 if (ofs >= le) 625 { 626 FINALINTERP; 627 vp->timeout = 1; 628 *countptr -= count; 629 } 630 #else /* PRECALC_LOOPS */ 631 while (count--) 632 { 633 RESAMPLATION; 634 ofs += incr; 635 if (ofs >= le) 636 { 637 FINALINTERP; 638 vp->timeout = 1; 639 *countptr -= count; 640 break; 641 } 642 } 643 #endif /* PRECALC_LOOPS */ 644 645 vp->sample_offset = ofs; /* Update offset */ 646 return resample_buffer + resample_buffer_offset; 647 } 648 649 static resample_t *rs_loop_c(Voice *vp, int32 count) 650 { 651 int32 652 ofs = (int32)(vp->sample_offset >> FRACTION_BITS), 653 le = (int32)(vp->sample->loop_end >> FRACTION_BITS), 654 ll = le - (int32)(vp->sample->loop_start >> FRACTION_BITS); 655 resample_t *dest = resample_buffer + resample_buffer_offset; 656 sample_t *src = vp->sample->data; 657 int32 i, j; 658 659 while(count) 660 { 661 while(ofs >= le) 662 ofs -= ll; 663 /* Precalc how many times we should go through the loop */ 664 i = le - ofs; 665 if(i > count) 666 i = count; 667 count -= i; 668 for (j = 0; j < i; j++) { 669 dest[j] = src[j + ofs]; 670 } 671 dest += i; 672 ofs += i; 673 } 674 vp->sample_offset = ((splen_t)ofs << FRACTION_BITS); 675 return resample_buffer + resample_buffer_offset; 676 } 677 678 static resample_t *rs_loop(Voice *vp, int32 count) 679 { 680 /* Play sample until end-of-loop, skip back and continue. */ 681 splen_t 682 ofs = vp->sample_offset, 683 ls, le, ll; 684 resample_rec_t resrc; 685 resample_t *dest = resample_buffer + resample_buffer_offset; 686 sample_t *src = vp->sample->data; 687 #ifdef PRECALC_LOOPS 688 int32 i, j; 689 #endif 690 int32 incr = vp->sample_increment; 691 692 if(vp->cache && incr == (1 << FRACTION_BITS)) 693 return rs_loop_c(vp, count); 694 695 resrc.loop_start = ls = vp->sample->loop_start; 696 resrc.loop_end = le = vp->sample->loop_end; 697 ll = le - ls; 698 resrc.data_length = vp->sample->data_length; 699 700 #ifdef PRECALC_LOOPS 701 while (count) 702 { 703 while (ofs >= le) {ofs -= ll;} 704 /* Precalc how many times we should go through the loop */ 705 i = PRECALC_LOOP_COUNT(ofs, le, incr); 706 if (i > count) { 707 i = count; 708 count = 0; 709 } else {count -= i;} 710 for(j = 0; j < i; j++) { 711 RESAMPLATION; 712 ofs += incr; 713 } 714 } 715 #else 716 while (count--) 717 { 718 RESAMPLATION; 719 ofs += incr; 720 if (ofs >= le) 721 ofs -= ll; /* Hopefully the loop is longer than an increment. */ 722 } 723 #endif 724 725 vp->sample_offset = ofs; /* Update offset */ 726 return resample_buffer + resample_buffer_offset; 727 } 728 729 static resample_t *rs_bidir(Voice *vp, int32 count) 730 { 731 #if SAMPLE_LENGTH_BITS == 32 732 int32 733 #else 734 splen_t 735 #endif 736 ofs = vp->sample_offset, 737 le = vp->sample->loop_end, 738 ls = vp->sample->loop_start; 739 resample_t *dest = resample_buffer + resample_buffer_offset; 740 sample_t *src = vp->sample->data; 741 int32 incr = vp->sample_increment; 742 resample_rec_t resrc; 743 744 #ifdef PRECALC_LOOPS 745 #if SAMPLE_LENGTH_BITS == 32 746 int32 747 #else 748 splen_t 749 #endif 750 le2 = le << 1, 751 ls2 = ls << 1; 752 int32 i, j; 753 /* Play normally until inside the loop region */ 754 755 resrc.loop_start = ls; 756 resrc.loop_end = le; 757 resrc.data_length = vp->sample->data_length; 758 759 if (incr > 0 && ofs < ls) 760 { 761 /* NOTE: Assumes that incr > 0, which is NOT always the case 762 when doing bidirectional looping. I have yet to see a case 763 where both ofs <= ls AND incr < 0, however. */ 764 i = PRECALC_LOOP_COUNT(ofs, ls, incr); 765 if (i > count) 766 { 767 i = count; 768 count = 0; 769 } 770 else count -= i; 771 for(j = 0; j < i; j++) 772 { 773 RESAMPLATION; 774 ofs += incr; 775 } 776 } 777 778 /* Then do the bidirectional looping */ 779 780 while(count) 781 { 782 /* Precalc how many times we should go through the loop */ 783 i = PRECALC_LOOP_COUNT(ofs, incr > 0 ? le : ls, incr); 784 if (i > count) 785 { 786 i = count; 787 count = 0; 788 } 789 else count -= i; 790 for(j = 0; j < i; j++) 791 { 792 RESAMPLATION; 793 ofs += incr; 794 } 795 if(ofs >= 0 && ofs >= le) 796 { 797 /* fold the overshoot back in */ 798 ofs = le2 - ofs; 799 incr *= -1; 800 } 801 else if (ofs <= 0 || ofs <= ls) 802 { 803 ofs = ls2 - ofs; 804 incr *= -1; 805 } 806 } 807 808 #else /* PRECALC_LOOPS */ 809 /* Play normally until inside the loop region */ 810 811 if (ofs < ls) 812 { 813 while (count--) 814 { 815 RESAMPLATION; 816 ofs += incr; 817 if (ofs >= ls) 818 break; 819 } 820 } 821 822 /* Then do the bidirectional looping */ 823 824 if (count > 0) 825 while (count--) 826 { 827 RESAMPLATION; 828 ofs += incr; 829 if (ofs >= le) 830 { 831 /* fold the overshoot back in */ 832 ofs = le - (ofs - le); 833 incr = -incr; 834 } 835 else if (ofs <= ls) 836 { 837 ofs = ls + (ls - ofs); 838 incr = -incr; 839 } 840 } 841 #endif /* PRECALC_LOOPS */ 842 vp->sample_increment = incr; 843 vp->sample_offset = ofs; /* Update offset */ 844 return resample_buffer + resample_buffer_offset; 845 } 846 847 /*********************** vibrato versions ***************************/ 848 849 /* We only need to compute one half of the vibrato sine cycle */ 850 static int vib_phase_to_inc_ptr(int phase) 851 { 852 if (phase < VIBRATO_SAMPLE_INCREMENTS / 2) 853 return VIBRATO_SAMPLE_INCREMENTS / 2 - 1 - phase; 854 else if (phase >= 3 * VIBRATO_SAMPLE_INCREMENTS / 2) 855 return 5 * VIBRATO_SAMPLE_INCREMENTS / 2 - 1 - phase; 856 else 857 return phase - VIBRATO_SAMPLE_INCREMENTS / 2; 858 } 859 860 static int32 update_vibrato(Voice *vp, int sign) 861 { 862 int32 depth; 863 int phase, pb; 864 double a; 865 int ch = vp->channel; 866 867 if(vp->vibrato_delay > 0) 868 { 869 vp->vibrato_delay -= vp->vibrato_control_ratio; 870 if(vp->vibrato_delay > 0) 871 return vp->sample_increment; 872 } 873 874 if (vp->vibrato_phase++ >= 2 * VIBRATO_SAMPLE_INCREMENTS - 1) 875 vp->vibrato_phase = 0; 876 phase = vib_phase_to_inc_ptr(vp->vibrato_phase); 877 878 if (vp->vibrato_sample_increment[phase]) 879 { 880 if (sign) 881 return -vp->vibrato_sample_increment[phase]; 882 else 883 return vp->vibrato_sample_increment[phase]; 884 } 885 886 /* Need to compute this sample increment. */ 887 888 depth = vp->vibrato_depth; 889 depth <<= 7; 890 891 if (vp->vibrato_sweep && !channel[ch].mod.val) 892 { 893 /* Need to update sweep */ 894 vp->vibrato_sweep_position += vp->vibrato_sweep; 895 if (vp->vibrato_sweep_position >= (1 << SWEEP_SHIFT)) 896 vp->vibrato_sweep=0; 897 else 898 { 899 /* Adjust depth */ 900 depth *= vp->vibrato_sweep_position; 901 depth >>= SWEEP_SHIFT; 902 } 903 } 904 905 if(vp->sample->inst_type == INST_SF2) { 906 pb = (int)((lookup_triangular(vp->vibrato_phase * 907 (SINE_CYCLE_LENGTH / (2 * VIBRATO_SAMPLE_INCREMENTS))) 908 * (double)(depth) * VIBRATO_AMPLITUDE_TUNING)); 909 } else { 910 pb = (int)((lookup_sine(vp->vibrato_phase * 911 (SINE_CYCLE_LENGTH / (2 * VIBRATO_SAMPLE_INCREMENTS))) 912 * (double)(depth) * VIBRATO_AMPLITUDE_TUNING)); 913 } 914 915 a = TIM_FSCALE(((double)(vp->sample->sample_rate) * 916 (double)(vp->frequency)) / 917 ((double)(vp->sample->root_freq) * 918 (double)(play_mode->rate)), 919 FRACTION_BITS); 920 921 if(pb < 0) { 922 pb = -pb; 923 a /= bend_fine[(pb >> 5) & 0xFF] * bend_coarse[pb >> 13]; 924 pb = -pb; 925 } else { 926 a *= bend_fine[(pb >> 5) & 0xFF] * bend_coarse[pb >> 13]; 927 } 928 a += 0.5; 929 930 /* If the sweep's over, we can store the newly computed sample_increment */ 931 if (!vp->vibrato_sweep || channel[ch].mod.val) 932 vp->vibrato_sample_increment[phase] = (int32) a; 933 934 if (sign) 935 a = -a; /* need to preserve the loop direction */ 936 937 return (int32) a; 938 } 939 940 static resample_t *rs_vib_plain(int v, int32 *countptr) 941 { 942 /* Play sample until end, then free the voice. */ 943 Voice *vp = &voice[v]; 944 resample_t *dest = resample_buffer + resample_buffer_offset; 945 sample_t *src = vp->sample->data; 946 splen_t 947 ls = 0, 948 le = vp->sample->data_length, 949 ofs = vp->sample_offset; 950 resample_rec_t resrc; 951 952 int32 count = *countptr, incr = vp->sample_increment; 953 int cc = vp->vibrato_control_counter; 954 955 resrc.loop_start = ls; 956 resrc.loop_end = le; 957 resrc.data_length = vp->sample->data_length; 958 /* This has never been tested */ 959 960 if (incr < 0) incr = -incr; /* In case we're coming out of a bidir loop */ 961 962 while (count--) 963 { 964 if (!cc--) 965 { 966 cc = vp->vibrato_control_ratio; 967 incr = update_vibrato(vp, 0); 968 } 969 RESAMPLATION; 970 ofs += incr; 971 if (ofs >= le) 972 { 973 FINALINTERP; 974 vp->timeout = 1; 975 *countptr -= count; 976 break; 977 } 978 } 979 980 vp->vibrato_control_counter = cc; 981 vp->sample_increment = incr; 982 vp->sample_offset = ofs; /* Update offset */ 983 return resample_buffer + resample_buffer_offset; 984 } 985 986 static resample_t *rs_vib_loop(Voice *vp, int32 count) 987 { 988 /* Play sample until end-of-loop, skip back and continue. */ 989 splen_t 990 ofs = vp->sample_offset, 991 ls = vp->sample->loop_start, 992 le = vp->sample->loop_end, 993 ll = le - vp->sample->loop_start; 994 resample_t *dest = resample_buffer + resample_buffer_offset; 995 sample_t *src = vp->sample->data; 996 int cc = vp->vibrato_control_counter; 997 int32 incr = vp->sample_increment; 998 resample_rec_t resrc; 999 #ifdef PRECALC_LOOPS 1000 int32 i, j; 1001 int vibflag=0; 1002 #endif 1003 1004 resrc.loop_start = ls; 1005 resrc.loop_end = le; 1006 resrc.data_length =vp->sample->data_length; 1007 1008 #ifdef PRECALC_LOOPS 1009 while (count) 1010 { 1011 /* Hopefully the loop is longer than an increment */ 1012 while(ofs >= le) {ofs -= ll;} 1013 /* Precalc how many times to go through the loop, taking 1014 the vibrato control ratio into account this time. */ 1015 i = PRECALC_LOOP_COUNT(ofs, le, incr); 1016 if(i > count) { 1017 i = count; 1018 } 1019 if(i > cc) { 1020 i = cc; 1021 vibflag = 1; 1022 } else {cc -= i;} 1023 count -= i; 1024 if(vibflag) { 1025 cc = vp->vibrato_control_ratio; 1026 incr = update_vibrato(vp, 0); 1027 vibflag = 0; 1028 } 1029 for(j = 0; j < i; j++) { 1030 RESAMPLATION; 1031 ofs += incr; 1032 } 1033 } 1034 #else /* PRECALC_LOOPS */ 1035 while (count--) 1036 { 1037 if (!cc--) 1038 { 1039 cc=vp->vibrato_control_ratio; 1040 incr=update_vibrato(vp, 0); 1041 } 1042 RESAMPLATION; 1043 ofs += incr; 1044 if (ofs >= le) 1045 ofs -= ll; /* Hopefully the loop is longer than an increment. */ 1046 } 1047 #endif /* PRECALC_LOOPS */ 1048 1049 vp->vibrato_control_counter = cc; 1050 vp->sample_increment = incr; 1051 vp->sample_offset = ofs; /* Update offset */ 1052 return resample_buffer + resample_buffer_offset; 1053 } 1054 1055 static resample_t *rs_vib_bidir(Voice *vp, int32 count) 1056 { 1057 #if SAMPLE_LENGTH_BITS == 32 1058 int32 1059 #else 1060 splen_t 1061 #endif 1062 ofs = vp->sample_offset, 1063 le = vp->sample->loop_end, 1064 ls = vp->sample->loop_start; 1065 resample_t *dest = resample_buffer + resample_buffer_offset; 1066 sample_t *src = vp->sample->data; 1067 int cc=vp->vibrato_control_counter; 1068 int32 incr = vp->sample_increment; 1069 resample_rec_t resrc; 1070 1071 #if 0 /*def PRECALC_LOOPS*/ 1072 #if SAMPLE_LENGTH_BITS == 32 1073 int32 1074 #else 1075 splen_t 1076 #endif 1077 le2 = le << 1, 1078 ls2 = ls << 1; 1079 int32 i, j; 1080 int vibflag = 0; 1081 1082 resrc.loop_start = ls; 1083 resrc.loop_end = le; 1084 resrc.data_length = vp->sample->data_length; 1085 /* Play normally until inside the loop region */ 1086 while (count && incr > 0 && ofs < ls) 1087 { 1088 i = PRECALC_LOOP_COUNT(ofs, ls, incr); 1089 if (i > count) i = count; 1090 if (i > cc) 1091 { 1092 i = cc; 1093 vibflag = 1; 1094 } 1095 else cc -= i; 1096 count -= i; 1097 if (vibflag) 1098 { 1099 cc = vp->vibrato_control_ratio; 1100 incr = update_vibrato(vp, 0); 1101 vibflag = 0; 1102 } 1103 for(j = 0; j < i; j++) 1104 { 1105 RESAMPLATION; 1106 ofs += incr; 1107 } 1108 } 1109 1110 /* Then do the bidirectional looping */ 1111 1112 while (count) 1113 { 1114 /* Precalc how many times we should go through the loop */ 1115 i = PRECALC_LOOP_COUNT(ofs, incr > 0 ? le : ls, incr); 1116 if(i > count) i = count; 1117 if(i > cc) 1118 { 1119 i = cc; 1120 vibflag = 1; 1121 } 1122 else cc -= i; 1123 count -= i; 1124 if (vibflag) 1125 { 1126 cc = vp->vibrato_control_ratio; 1127 incr = update_vibrato(vp, (incr < 0)); 1128 vibflag = 0; 1129 } 1130 while (i--) 1131 { 1132 RESAMPLATION; 1133 ofs += incr; 1134 } 1135 if (ofs >= 0 && ofs >= le) 1136 { 1137 /* fold the overshoot back in */ 1138 ofs = le2 - ofs; 1139 incr *= -1; 1140 } 1141 else if (ofs <= 0 || ofs <= ls) 1142 { 1143 ofs = ls2 - ofs; 1144 incr *= -1; 1145 } 1146 } 1147 1148 #else /* PRECALC_LOOPS */ 1149 1150 resrc.loop_start = ls; 1151 resrc.loop_end = le; 1152 resrc.data_length = vp->sample->data_length; 1153 /* Play normally until inside the loop region */ 1154 1155 if (ofs < ls) 1156 { 1157 while (count--) 1158 { 1159 if (!cc--) 1160 { 1161 cc = vp->vibrato_control_ratio; 1162 incr = update_vibrato(vp, 0); 1163 } 1164 RESAMPLATION; 1165 ofs += incr; 1166 if (ofs >= ls) 1167 break; 1168 } 1169 } 1170 1171 /* Then do the bidirectional looping */ 1172 1173 if (count > 0) 1174 while (count--) 1175 { 1176 if (!cc--) 1177 { 1178 cc=vp->vibrato_control_ratio; 1179 incr=update_vibrato(vp, (incr < 0)); 1180 } 1181 RESAMPLATION; 1182 ofs += incr; 1183 if (ofs >= le) 1184 { 1185 /* fold the overshoot back in */ 1186 ofs = le - (ofs - le); 1187 incr = -incr; 1188 } 1189 else if (ofs <= ls) 1190 { 1191 ofs = ls + (ls - ofs); 1192 incr = -incr; 1193 } 1194 } 1195 #endif /* PRECALC_LOOPS */ 1196 1197 /* Update changed values */ 1198 vp->vibrato_control_counter = cc; 1199 vp->sample_increment = incr; 1200 vp->sample_offset = ofs; 1201 return resample_buffer + resample_buffer_offset; 1202 } 1203 1204 /*********************** portamento versions ***************************/ 1205 1206 static int rs_update_porta(int v) 1207 { 1208 Voice *vp = &voice[v]; 1209 int32 d; 1210 1211 d = vp->porta_dpb; 1212 if(vp->porta_pb < 0) 1213 { 1214 if(d > -vp->porta_pb) 1215 d = -vp->porta_pb; 1216 } 1217 else 1218 { 1219 if(d > vp->porta_pb) 1220 d = -vp->porta_pb; 1221 else 1222 d = -d; 1223 } 1224 1225 vp->porta_pb += d; 1226 if(vp->porta_pb == 0) 1227 { 1228 vp->porta_control_ratio = 0; 1229 vp->porta_pb = 0; 1230 } 1231 recompute_freq(v); 1232 return vp->porta_control_ratio; 1233 } 1234 1235 static resample_t *porta_resample_voice(int v, int32 *countptr, int mode) 1236 { 1237 Voice *vp = &voice[v]; 1238 int32 n = *countptr, i; 1239 resample_t *(* resampler)(int, int32 *, int); 1240 int cc = vp->porta_control_counter; 1241 int loop; 1242 1243 if(vp->vibrato_control_ratio) 1244 resampler = vib_resample_voice; 1245 else 1246 resampler = normal_resample_voice; 1247 if(mode != 1) 1248 loop = 1; 1249 else 1250 loop = 0; 1251 1252 vp->cache = NULL; 1253 resample_buffer_offset = 0; 1254 while(resample_buffer_offset < n) 1255 { 1256 if(cc == 0) 1257 { 1258 if((cc = rs_update_porta(v)) == 0) 1259 { 1260 i = n - resample_buffer_offset; 1261 resampler(v, &i, mode); 1262 resample_buffer_offset += i; 1263 break; 1264 } 1265 } 1266 1267 i = n - resample_buffer_offset; 1268 if(i > cc) 1269 i = cc; 1270 resampler(v, &i, mode); 1271 resample_buffer_offset += i; 1272 1273 if(!loop && (i == 0 || vp->status == VOICE_FREE)) 1274 break; 1275 cc -= i; 1276 } 1277 *countptr = resample_buffer_offset; 1278 resample_buffer_offset = 0; 1279 vp->porta_control_counter = cc; 1280 return resample_buffer; 1281 } 1282 1283 /* interface function */ 1284 static resample_t *vib_resample_voice(int v, int32 *countptr, int mode) 1285 { 1286 Voice *vp = &voice[v]; 1287 1288 vp->cache = NULL; 1289 if(mode == 0) 1290 return rs_vib_loop(vp, *countptr); 1291 if(mode == 1) 1292 return rs_vib_plain(v, countptr); 1293 return rs_vib_bidir(vp, *countptr); 1294 } 1295 1296 /* interface function */ 1297 static resample_t *normal_resample_voice(int v, int32 *countptr, int mode) 1298 { 1299 Voice *vp = &voice[v]; 1300 if(mode == 0) 1301 return rs_loop(vp, *countptr); 1302 if(mode == 1) 1303 return rs_plain(v, countptr); 1304 return rs_bidir(vp, *countptr); 1305 } 1306 1307 /* interface function */ 1308 resample_t *resample_voice(int v, int32 *countptr) 1309 { 1310 Voice *vp = &voice[v]; 1311 int mode; 1312 resample_t *result; 1313 resampler_t saved_resample; 1314 int32 i; 1315 1316 if(vp->sample->sample_rate == play_mode->rate && 1317 vp->sample->root_freq == get_note_freq(vp->sample, vp->sample->note_to_use) && 1318 vp->frequency == vp->orig_frequency) 1319 { 1320 int32 ofs; 1321 1322 /* Pre-resampled data -- just update the offset and check if 1323 we're out of data. */ 1324 ofs = (int32)(vp->sample_offset >> FRACTION_BITS); /* Kind of silly to use 1325 FRACTION_BITS here... */ 1326 if(*countptr >= (vp->sample->data_length >> FRACTION_BITS) - ofs) 1327 { 1328 /* Note finished. Free the voice. */ 1329 vp->timeout = 1; 1330 1331 /* Let the caller know how much data we had left */ 1332 *countptr = (int32)(vp->sample->data_length >> FRACTION_BITS) - ofs; 1333 } 1334 else 1335 vp->sample_offset += *countptr << FRACTION_BITS; 1336 1337 for (i = 0; i < *countptr; i++) { 1338 resample_buffer[i] = vp->sample->data[i + ofs]; 1339 } 1340 return resample_buffer; 1341 } 1342 1343 mode = vp->sample->modes; 1344 if((mode & MODES_LOOPING) && 1345 ((mode & MODES_ENVELOPE) || 1346 (vp->status & (VOICE_ON | VOICE_SUSTAINED)))) 1347 { 1348 if(mode & MODES_PINGPONG) 1349 { 1350 vp->cache = NULL; 1351 mode = 2; /* Bidir loop */ 1352 } 1353 else 1354 mode = 0; /* loop */ 1355 } 1356 else 1357 mode = 1; /* no loop */ 1358 1359 saved_resample = cur_resample; 1360 #ifndef FIXED_RESAMPLATION 1361 if (reduce_quality_flag && cur_resample != resample_none) 1362 cur_resample = resample_linear; 1363 #endif 1364 if(vp->porta_control_ratio) 1365 result = porta_resample_voice(v, countptr, mode); 1366 else if(vp->vibrato_control_ratio) 1367 result = vib_resample_voice(v, countptr, mode); 1368 else 1369 result = normal_resample_voice(v, countptr, mode); 1370 1371 #ifndef FIXED_RESAMPLATION 1372 cur_resample = saved_resample; /* get back */ 1373 #endif 1374 return result; 1375 } 1376 1377 void pre_resample(Sample * sp) 1378 { 1379 double a, b; 1380 splen_t ofs, newlen; 1381 sample_t *newdata, *dest, *src = (sample_t *)sp->data; 1382 int32 i, count, incr, f, x; 1383 resample_rec_t resrc; 1384 1385 ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * pre-resampling for note %d (%s%d)", 1386 sp->note_to_use, 1387 note_name[sp->note_to_use % 12], (sp->note_to_use & 0x7F) / 12); 1388 1389 f = get_note_freq(sp, sp->note_to_use); 1390 a = b = ((double) (sp->root_freq) * play_mode->rate) / 1391 ((double) (sp->sample_rate) * f); 1392 if((int64)sp->data_length * a >= 0x7fffffffL) 1393 { 1394 /* Too large to compute */ 1395 ctl->cmsg(CMSG_INFO, VERB_DEBUG, " *** Can't pre-resampling for note %d", 1396 sp->note_to_use); 1397 return; 1398 } 1399 newlen = (splen_t)(sp->data_length * a); 1400 count = (newlen >> FRACTION_BITS); 1401 ofs = incr = (sp->data_length - 1) / (count - 1); 1402 1403 if((double)newlen + incr >= 0x7fffffffL) 1404 { 1405 /* Too large to compute */ 1406 ctl->cmsg(CMSG_INFO, VERB_DEBUG, " *** Can't pre-resampling for note %d", 1407 sp->note_to_use); 1408 return; 1409 } 1410 1411 dest = newdata = (sample_t *)safe_malloc((int32)(newlen >> (FRACTION_BITS - 1)) + 2); 1412 dest[newlen >> FRACTION_BITS] = 0; 1413 1414 *dest++ = src[0]; 1415 1416 resrc.loop_start = 0; 1417 resrc.loop_end = sp->data_length; 1418 resrc.data_length = sp->data_length; 1419 1420 /* Since we're pre-processing and this doesn't have to be done in 1421 real-time, we go ahead and do the higher order interpolation. */ 1422 for(i = 1; i < count; i++) 1423 { 1424 x = cur_resample(src, ofs, &resrc); 1425 *dest++ = (int16)((x > 32767) ? 32767: ((x < -32768) ? -32768 : x)); 1426 ofs += incr; 1427 } 1428 1429 sp->data_length = newlen; 1430 sp->loop_start = (splen_t)(sp->loop_start * b); 1431 sp->loop_end = (splen_t)(sp->loop_end * b); 1432 free(sp->data); 1433 sp->data = (sample_t *) newdata; 1434 sp->root_freq = f; 1435 sp->sample_rate = play_mode->rate; 1436 sp->low_freq = freq_table[0]; 1437 sp->high_freq = freq_table[127]; 1438 } 1439