开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
resample.c
资源名称：SDL_mixer-1.2.11.tar.gz　[点击查看]
上传用户：nini_0081
上传日期：2022-07-21
资源大小：2628k
文件大小：16k
源码类别：

多媒体编程

开发平台：

DOS

resample.c：源码内容
  1. /*
  3.     TiMidity -- Experimental MIDI to WAVE converter
  4.     Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
  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.
  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.
  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., 675 Mass Ave, Cambridge, MA 02139, USA.
  20.     resample.c
  21. */
  23. #include <math.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  27. #include "config.h"
  28. #include "common.h"
  29. #include "instrum.h"
  30. #include "playmidi.h"
  31. #include "output.h"
  32. #include "ctrlmode.h"
  33. #include "tables.h"
  34. #include "resample.h"
  36. #ifdef LINEAR_INTERPOLATION
  37. # if defined(LOOKUP_HACK) && defined(LOOKUP_INTERPOLATION)
  38. #   define RESAMPLATION 
  39.        v1=src[ofs>>FRACTION_BITS];
  40.        v2=src[(ofs>>FRACTION_BITS)+1];
  41.        *dest++ = (resample_t)(v1 + (iplookup[(((v2-v1)<<5) & 0x03FE0) | 
  42.            ((ofs & FRACTION_MASK) >> (FRACTION_BITS-5))]));
  43. # else
  44. #   define RESAMPLATION 
  45.       v1=src[ofs>>FRACTION_BITS];
  46.       v2=src[(ofs>>FRACTION_BITS)+1];
  47.       *dest++ = (resample_t)(v1 + (((v2-v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS));
  48. # endif
  49. #  define INTERPVARS sample_t v1, v2
  50. #else
  51. /* Earplugs recommended for maximum listening enjoyment */
  52. #  define RESAMPLATION *dest++ = src[ofs>>FRACTION_BITS];
  53. #  define INTERPVARS
  54. #endif
  56. #define FINALINTERP if (ofs == le) *dest++=src[ofs>>FRACTION_BITS];
  57. /* So it isn't interpolation. At least it's final. */
  59. extern resample_t *resample_buffer;
  61. /*************** resampling with fixed increment *****************/
  63. static resample_t *rs_plain(int v, int32 *countptr)
  64. {
  66.   /* Play sample until end, then free the voice. */
  68.   INTERPVARS;
  69.   Voice 
  70.     *vp=&voice[v];
  71.   resample_t 
  72.     *dest=resample_buffer;
  73.   sample_t 
  74.     *src=vp->sample->data;
  75.   int32 
  76.     ofs=vp->sample_offset,
  77.     incr=vp->sample_increment,
  78.     le=vp->sample->data_length,
  79.     count=*countptr;
  81. #ifdef PRECALC_LOOPS
  82.   int32 i, j;
  84.   if (incr<0) incr = -incr; /* In case we're coming out of a bidir loop */
  86.   /* Precalc how many times we should go through the loop.
  87.      NOTE: Assumes that incr > 0 and that ofs <= le */
  88.   i = (le - ofs) / incr + 1;
  90.   if (i > count)
  91.     {
  92.       i = count;
  93.       count = 0;
  94.     } 
  95.   else count -= i;
  97.   for(j = 0; j < i; j++)
  98.     {
  99.       RESAMPLATION;
  100.       ofs += incr;
  101.     }
  103.   if (ofs >= le) 
  104.     {
  105.       FINALINTERP;
  106.       vp->status=VOICE_FREE;
  107.       ctl->note(v);
  108.       *countptr-=count+1;
  109.     }
  111. #else /* PRECALC_LOOPS */
  112.     while (count--)
  113.     {
  114.       RESAMPLATION;
  115.       ofs += incr;
  116.       if (ofs >= le)
  117. {
  118.   FINALINTERP;
  119.   vp->status=VOICE_FREE;
  120.     ctl->note(v);
  121.   *countptr-=count+1;
  122.   break;
  123. }
  124.     }
  125. #endif /* PRECALC_LOOPS */
  126.   
  127.   vp->sample_offset=ofs; /* Update offset */
  128.   return resample_buffer;
  129. }
  131. static resample_t *rs_loop(Voice *vp, int32 count)
  132. {
  134.   /* Play sample until end-of-loop, skip back and continue. */
  136.   INTERPVARS;
  137.   int32 
  138.     ofs=vp->sample_offset, 
  139.     incr=vp->sample_increment,
  140.     le=vp->sample->loop_end, 
  141.     ll=le - vp->sample->loop_start;
  142.   resample_t
  143.     *dest=resample_buffer;
  144.   sample_t
  145.     *src=vp->sample->data;
  147. #ifdef PRECALC_LOOPS
  148.   int32 i;
  149.  
  150.   if (ofs < 0 || le < 0) return resample_buffer;
  152.   while (count) 
  153.     {
  154.       if (ofs >= le)
  155. /* NOTE: Assumes that ll > incr and that incr > 0. */
  156. ofs -= ll;
  157.       /* Precalc how many times we should go through the loop */
  158.       i = (le - ofs) / incr + 1;
  159.       if (i > count) 
  160. {
  161.   i = count;
  162.   count = 0;
  163. } 
  164.       else count -= i;
  165.       if (i > 0)
  166.       while (i--) 
  167. {
  168.   RESAMPLATION;
  169.   ofs += incr;
  170. }
  171.     }
  172. #else
  173.   while (count--)
  174.     {
  175.       RESAMPLATION;
  176.       ofs += incr;
  177.       if (ofs>=le)
  178. ofs -= ll; /* Hopefully the loop is longer than an increment. */
  179.     }
  180. #endif
  182.   vp->sample_offset=ofs; /* Update offset */
  183.   return resample_buffer;
  184. }
  186. static resample_t *rs_bidir(Voice *vp, int32 count)
  187. {
  188.   INTERPVARS;
  189.   int32 
  190.     ofs=vp->sample_offset,
  191.     incr=vp->sample_increment,
  192.     le=vp->sample->loop_end,
  193.     ls=vp->sample->loop_start;
  194.   resample_t 
  195.     *dest=resample_buffer; 
  196.   sample_t 
  197.     *src=vp->sample->data;
  199. #ifdef PRECALC_LOOPS
  200.   int32
  201.     le2 = le<<1, 
  202.     ls2 = ls<<1,
  203.     i;
  204.   /* Play normally until inside the loop region */
  206.   if (ofs <= ls) 
  207.     {
  208.       /* NOTE: Assumes that incr > 0, which is NOT always the case
  209.  when doing bidirectional looping.  I have yet to see a case
  210.  where both ofs <= ls AND incr < 0, however. */
  211.       i = (ls - ofs) / incr + 1;
  212.       if (i > count) 
  213. {
  214.   i = count;
  215.   count = 0;
  216. } 
  217.       else count -= i;
  218.       while (i--) 
  219. {
  220.   RESAMPLATION;
  221.   ofs += incr;
  222. }
  223.     }
  225.   /* Then do the bidirectional looping */
  226.   
  227.   while(count) 
  228.     {
  229.       /* Precalc how many times we should go through the loop */
  230.       i = ((incr > 0 ? le : ls) - ofs) / incr + 1;
  231.       if (i > count) 
  232. {
  233.   i = count;
  234.   count = 0;
  235. } 
  236.       else count -= i;
  237.       while (i--) 
  238. {
  239.   RESAMPLATION;
  240.   ofs += incr;
  241. }
  242.       if (ofs>=le) 
  243. {
  244.   /* fold the overshoot back in */
  245.   ofs = le2 - ofs;
  246.   incr *= -1;
  247. } 
  248.       else if (ofs <= ls) 
  249. {
  250.   ofs = ls2 - ofs;
  251.   incr *= -1;
  252. }
  253.     }
  255. #else /* PRECALC_LOOPS */
  256.   /* Play normally until inside the loop region */
  258.   if (ofs < ls)
  259.     {
  260.       while (count--)
  261. {
  262.   RESAMPLATION;
  263.   ofs += incr;
  264.   if (ofs>=ls)
  265.     break;
  266. }
  267.     }
  269.   /* Then do the bidirectional looping */
  271.   if (count>0)
  272.     while (count--)
  273.       {
  274. RESAMPLATION;
  275. ofs += incr;
  276. if (ofs>=le)
  277.   {
  278.     /* fold the overshoot back in */
  279.     ofs = le - (ofs - le);
  280.     incr = -incr;
  281.   }
  282. else if (ofs <= ls)
  283.   {
  284.     ofs = ls + (ls - ofs);
  285.     incr = -incr;
  286.   }
  287.       }  
  288. #endif /* PRECALC_LOOPS */
  289.   vp->sample_increment=incr;
  290.   vp->sample_offset=ofs; /* Update offset */
  291.   return resample_buffer;
  292. }
  294. /*********************** vibrato versions ***************************/
  296. /* We only need to compute one half of the vibrato sine cycle */
  297. static int vib_phase_to_inc_ptr(int phase)
  298. {
  299.   if (phase < VIBRATO_SAMPLE_INCREMENTS/2)
  300.     return VIBRATO_SAMPLE_INCREMENTS/2-1-phase;
  301.   else if (phase >= 3*VIBRATO_SAMPLE_INCREMENTS/2)
  302.     return 5*VIBRATO_SAMPLE_INCREMENTS/2-1-phase;
  303.   else
  304.     return phase-VIBRATO_SAMPLE_INCREMENTS/2;
  305. }
  307. static int32 update_vibrato(Voice *vp, int sign)
  308. {
  309.   int32 depth;
  310.   int phase, pb;
  311.   double a;
  313.   if (vp->vibrato_phase++ >= 2*VIBRATO_SAMPLE_INCREMENTS-1)
  314.     vp->vibrato_phase=0;
  315.   phase=vib_phase_to_inc_ptr(vp->vibrato_phase);
  316.   
  317.   if (vp->vibrato_sample_increment[phase])
  318.     {
  319.       if (sign)
  320. return -vp->vibrato_sample_increment[phase];
  321.       else
  322. return vp->vibrato_sample_increment[phase];
  323.     }
  325.   /* Need to compute this sample increment. */
  326.     
  327.   depth=vp->sample->vibrato_depth<<7;
  329.   if (vp->vibrato_sweep)
  330.     {
  331.       /* Need to update sweep */
  332.       vp->vibrato_sweep_position += vp->vibrato_sweep;
  333.       if (vp->vibrato_sweep_position >= (1<<SWEEP_SHIFT))
  334. vp->vibrato_sweep=0;
  335.       else
  336. {
  337.   /* Adjust depth */
  338.   depth *= vp->vibrato_sweep_position;
  339.   depth >>= SWEEP_SHIFT;
  340. }
  341.     }
  343.   a = FSCALE(((double)(vp->sample->sample_rate) *
  344.       (double)(vp->frequency)) /
  345.      ((double)(vp->sample->root_freq) *
  346.       (double)(play_mode->rate)),
  347.      FRACTION_BITS);
  349.   pb=(int)((sine(vp->vibrato_phase * 
  350.  (SINE_CYCLE_LENGTH/(2*VIBRATO_SAMPLE_INCREMENTS)))
  351.     * (double)(depth) * VIBRATO_AMPLITUDE_TUNING));
  353.   if (pb<0)
  354.     {
  355.       pb=-pb;
  356.       a /= bend_fine[(pb>>5) & 0xFF] * bend_coarse[pb>>13];
  357.     }
  358.   else
  359.     a *= bend_fine[(pb>>5) & 0xFF] * bend_coarse[pb>>13];
  360.   
  361.   /* If the sweep's over, we can store the newly computed sample_increment */
  362.   if (!vp->vibrato_sweep)
  363.     vp->vibrato_sample_increment[phase]=(int32) a;
  365.   if (sign)
  366.     a = -a; /* need to preserve the loop direction */
  368.   return (int32) a;
  369. }
  371. static resample_t *rs_vib_plain(int v, int32 *countptr)
  372. {
  374.   /* Play sample until end, then free the voice. */
  376.   INTERPVARS;
  377.   Voice *vp=&voice[v];
  378.   resample_t 
  379.     *dest=resample_buffer; 
  380.   sample_t 
  381.     *src=vp->sample->data;
  382.   int32 
  383.     le=vp->sample->data_length,
  384.     ofs=vp->sample_offset, 
  385.     incr=vp->sample_increment, 
  386.     count=*countptr;
  387.   int 
  388.     cc=vp->vibrato_control_counter;
  390.   /* This has never been tested */
  392.   if (incr<0) incr = -incr; /* In case we're coming out of a bidir loop */
  394.   while (count--)
  395.     {
  396.       if (!cc--)
  397. {
  398.   cc=vp->vibrato_control_ratio;
  399.   incr=update_vibrato(vp, 0);
  400. }
  401.       RESAMPLATION;
  402.       ofs += incr;
  403.       if (ofs >= le)
  404. {
  405.   FINALINTERP;
  406.   vp->status=VOICE_FREE;
  407.     ctl->note(v);
  408.   *countptr-=count+1;
  409.   break;
  410. }
  411.     }
  412.   
  413.   vp->vibrato_control_counter=cc;
  414.   vp->sample_increment=incr;
  415.   vp->sample_offset=ofs; /* Update offset */
  416.   return resample_buffer;
  417. }
  419. static resample_t *rs_vib_loop(Voice *vp, int32 count)
  420. {
  422.   /* Play sample until end-of-loop, skip back and continue. */
  423.   
  424.   INTERPVARS;
  425.   int32 
  426.     ofs=vp->sample_offset, 
  427.     incr=vp->sample_increment, 
  428.     le=vp->sample->loop_end,
  429.     ll=le - vp->sample->loop_start;
  430.   resample_t 
  431.     *dest=resample_buffer; 
  432.   sample_t 
  433.     *src=vp->sample->data;
  434.   int 
  435.     cc=vp->vibrato_control_counter;
  437. #ifdef PRECALC_LOOPS
  438.   int32 i;
  439.   int
  440.     vibflag=0;
  442.   while (count) 
  443.     {
  444.       /* Hopefully the loop is longer than an increment */
  445.       if(ofs >= le)
  446. ofs -= ll;
  447.       /* Precalc how many times to go through the loop, taking
  448.  the vibrato control ratio into account this time. */
  449.       i = (le - ofs) / incr + 1;
  450.       if(i > count) i = count;
  451.       if(i > cc)
  452. {
  453.   i = cc;
  454.   vibflag = 1;
  455. } 
  456.       else cc -= i;
  457.       count -= i;
  458.       while(i--) 
  459. {
  460.   RESAMPLATION;
  461.   ofs += incr;
  462. }
  463.       if(vibflag) 
  464. {
  465.   cc = vp->vibrato_control_ratio;
  466.   incr = update_vibrato(vp, 0);
  467.   vibflag = 0;
  468. }
  469.     }
  471. #else /* PRECALC_LOOPS */
  472.   while (count--)
  473.     {
  474.       if (!cc--)
  475. {
  476.   cc=vp->vibrato_control_ratio;
  477.   incr=update_vibrato(vp, 0);
  478. }
  479.       RESAMPLATION;
  480.       ofs += incr;
  481.       if (ofs>=le)
  482. ofs -= ll; /* Hopefully the loop is longer than an increment. */
  483.     }
  484. #endif /* PRECALC_LOOPS */
  486.   vp->vibrato_control_counter=cc;
  487.   vp->sample_increment=incr;
  488.   vp->sample_offset=ofs; /* Update offset */
  489.   return resample_buffer;
  490. }
  492. static resample_t *rs_vib_bidir(Voice *vp, int32 count)
  493. {
  494.   INTERPVARS;
  495.   int32 
  496.     ofs=vp->sample_offset, 
  497.     incr=vp->sample_increment,
  498.     le=vp->sample->loop_end, 
  499.     ls=vp->sample->loop_start;
  500.   resample_t 
  501.     *dest=resample_buffer; 
  502.   sample_t 
  503.     *src=vp->sample->data;
  504.   int 
  505.     cc=vp->vibrato_control_counter;
  507. #ifdef PRECALC_LOOPS
  508.   int32
  509.     le2=le<<1,
  510.     ls2=ls<<1,
  511.     i;
  512.   int
  513.     vibflag = 0;
  515.   /* Play normally until inside the loop region */
  516.   while (count && (ofs <= ls)) 
  517.     {
  518.       i = (ls - ofs) / incr + 1;
  519.       if (i > count) i = count;
  520.       if (i > cc) 
  521. {
  522.   i = cc;
  523.   vibflag = 1;
  524. } 
  525.       else cc -= i;
  526.       count -= i;
  527.       while (i--) 
  528. {
  529.   RESAMPLATION;
  530.   ofs += incr;
  531. }
  532.       if (vibflag) 
  533. {
  534.   cc = vp->vibrato_control_ratio;
  535.   incr = update_vibrato(vp, 0);
  536.   vibflag = 0;
  537. }
  538.     }
  539.   
  540.   /* Then do the bidirectional looping */
  542.   while (count) 
  543.     {
  544.       /* Precalc how many times we should go through the loop */
  545.       i = ((incr > 0 ? le : ls) - ofs) / incr + 1;
  546.       if(i > count) i = count;
  547.       if(i > cc) 
  548. {
  549.   i = cc;
  550.   vibflag = 1;
  551. } 
  552.       else cc -= i;
  553.       count -= i;
  554.       while (i--) 
  555. {
  556.   RESAMPLATION;
  557.   ofs += incr;
  558. }
  559.       if (vibflag) 
  560. {
  561.   cc = vp->vibrato_control_ratio;
  562.   incr = update_vibrato(vp, (incr < 0));
  563.   vibflag = 0;
  564. }
  565.       if (ofs >= le) 
  566. {
  567.   /* fold the overshoot back in */
  568.   ofs = le2 - ofs;
  569.   incr *= -1;
  570. } 
  571.       else if (ofs <= ls) 
  572. {
  573.   ofs = ls2 - ofs;
  574.   incr *= -1;
  575. }
  576.     }
  578. #else /* PRECALC_LOOPS */
  579.   /* Play normally until inside the loop region */
  581.   if (ofs < ls)
  582.     {
  583.       while (count--)
  584. {
  585.   if (!cc--)
  586.     {
  587.       cc=vp->vibrato_control_ratio;
  588.       incr=update_vibrato(vp, 0);
  589.     }
  590.   RESAMPLATION;
  591.   ofs += incr;
  592.   if (ofs>=ls)
  593.     break;
  594. }
  595.     }
  597.   /* Then do the bidirectional looping */
  599.   if (count>0)
  600.     while (count--)
  601.       {
  602. if (!cc--)
  603.   {
  604.     cc=vp->vibrato_control_ratio;
  605.     incr=update_vibrato(vp, (incr < 0));
  606.   }
  607. RESAMPLATION;
  608. ofs += incr;
  609. if (ofs>=le)
  610.   {
  611.     /* fold the overshoot back in */
  612.     ofs = le - (ofs - le);
  613.     incr = -incr;
  614.   }
  615. else if (ofs <= ls)
  616.   {
  617.     ofs = ls + (ls - ofs);
  618.     incr = -incr;
  619.   }
  620.       }
  621. #endif /* PRECALC_LOOPS */
  623.   vp->vibrato_control_counter=cc;
  624.   vp->sample_increment=incr;
  625.   vp->sample_offset=ofs; /* Update offset */
  626.   return resample_buffer;
  627. }
  629. resample_t *resample_voice(int v, int32 *countptr)
  630. {
  631.   int32 ofs;
  632.   uint8 modes;
  633.   Voice *vp=&voice[v];
  634.   
  635.   if (!(vp->sample->sample_rate))
  636.     {
  637.       /* Pre-resampled data -- just update the offset and check if
  638.          we're out of data. */
  639.       ofs=vp->sample_offset >> FRACTION_BITS; /* Kind of silly to use
  640.  FRACTION_BITS here... */
  641.       if (*countptr >= (vp->sample->data_length>>FRACTION_BITS) - ofs)
  642. {
  643.   /* Note finished. Free the voice. */
  644.   vp->status = VOICE_FREE;
  645.   ctl->note(v);
  646.   
  647.   /* Let the caller know how much data we had left */
  648.   *countptr = (vp->sample->data_length>>FRACTION_BITS) - ofs;
  649. }
  650.       else
  651. vp->sample_offset += *countptr << FRACTION_BITS;
  652.       
  653.       return (resample_t *)vp->sample->data+ofs;
  654.     }
  656.   /* Need to resample. Use the proper function. */
  657.   modes=vp->sample->modes;
  659.   if (vp->vibrato_control_ratio)
  660.     {
  661.       if ((modes & MODES_LOOPING) &&
  662.   ((modes & MODES_ENVELOPE) ||
  663.    (vp->status==VOICE_ON || vp->status==VOICE_SUSTAINED)))
  664. {
  665.   if (modes & MODES_PINGPONG)
  666.     return rs_vib_bidir(vp, *countptr);
  667.   else
  668.     return rs_vib_loop(vp, *countptr);
  669. }
  670.       else
  671. return rs_vib_plain(v, countptr);
  672.     }
  673.   else
  674.     {
  675.       if ((modes & MODES_LOOPING) &&
  676.   ((modes & MODES_ENVELOPE) ||
  677.    (vp->status==VOICE_ON || vp->status==VOICE_SUSTAINED)))
  678. {
  679.   if (modes & MODES_PINGPONG)
  680.     return rs_bidir(vp, *countptr);
  681.   else
  682.     return rs_loop(vp, *countptr);
  683. }
  684.       else
  685. return rs_plain(v, countptr);
  686.     }
  687. }
  689. void pre_resample(Sample * sp)
  690. {
  691.   double a, xdiff;
  692.   int32 incr, ofs, newlen, count;
  693.   int16 *src = (int16 *) sp->data;
  694.   resample_t *newdata, *dest;
  695.   int16 v1, v2, v3, v4, *vptr;
  696.   static const char note_name[12][3] =
  697.   {
  698.     "C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"
  699.   };
  701.   ctl->cmsg(CMSG_INFO, VERB_NOISY, " * pre-resampling for note %d (%s%d)",
  702.     sp->note_to_use,
  703.     note_name[sp->note_to_use % 12], (sp->note_to_use & 0x7F) / 12);
  705.   a = ((double) (sp->sample_rate) * freq_table[(int) (sp->note_to_use)]) /
  706.     ((double) (sp->root_freq) * play_mode->rate);
  707.   if (a <= 0) return;
  708.   newlen = (int32)(sp->data_length / a);
  709.   if (newlen < 0 || (newlen >> FRACTION_BITS) > MAX_SAMPLE_SIZE) return;
  710.   dest = newdata = safe_malloc(newlen >> (FRACTION_BITS - 1));
  712.   count = (newlen >> FRACTION_BITS) - 1;
  713.   ofs = incr = (sp->data_length - (1 << FRACTION_BITS)) / count;
  715.   if (--count)
  716.     *dest++ = src[0];
  718.   /* Since we're pre-processing and this doesn't have to be done in
  719.      real-time, we go ahead and do the full sliding cubic interpolation. */
  720.   while (--count)
  721.     {
  722.       vptr = src + (ofs >> FRACTION_BITS);
  723.       v1 = (vptr == src) ? *vptr : *(vptr - 1);
  724.       v2 = *vptr;
  725.       v3 = *(vptr + 1);
  726.       v4 = *(vptr + 2);
  727.       xdiff = FSCALENEG(ofs & FRACTION_MASK, FRACTION_BITS);
  728.       *dest++ = (int16)(v2 + (xdiff / 6.0) * (-2 * v1 - 3 * v2 + 6 * v3 - v4 +
  729.       xdiff * (3 * (v1 - 2 * v2 + v3) + xdiff * (-v1 + 3 * (v2 - v3) + v4))));
  730.       ofs += incr;
  731.     }
  733.   if (ofs & FRACTION_MASK)
  734.     {
  735.       v1 = src[ofs >> FRACTION_BITS];
  736.       v2 = src[(ofs >> FRACTION_BITS) + 1];
  737.       *dest++ = (resample_t)(v1 + (((v2 - v1) * (ofs & FRACTION_MASK)) >> FRACTION_BITS));
  738.     }
  739.   else
  740.     *dest++ = src[ofs >> FRACTION_BITS];
  742.   sp->data_length = newlen;
  743.   sp->loop_start = (int32)(sp->loop_start / a);
  744.   sp->loop_end = (int32)(sp->loop_end / a);
  745.   free(sp->data);
  746.   sp->data = (sample_t *) newdata;
  747.   sp->sample_rate = 0;
  748. }