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

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

多媒体编程

开发平台：

DOS

instrum.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.    instrum.c 
  21.    
  22.    Code to load and unload GUS-compatible instrument patches.
  24. */
  26. #include <stdio.h>
  27. #include <string.h>
  28. #include <stdlib.h>
  30. #include "config.h"
  31. #include "common.h"
  32. #include "instrum.h"
  33. #include "playmidi.h"
  34. #include "output.h"
  35. #include "ctrlmode.h"
  36. #include "resample.h"
  37. #include "tables.h"
  38. #include "filter.h"
  40. /* Some functions get aggravated if not even the standard banks are 
  41.    available. */
  42. static ToneBank standard_tonebank, standard_drumset;
  43. ToneBank 
  44.   *tonebank[MAXBANK]={&standard_tonebank},
  45.   *drumset[MAXBANK]={&standard_drumset};
  47. /* This is a special instrument, used for all melodic programs */
  48. InstrumentLayer *default_instrument=0;
  50. /* This is only used for tracks that don't specify a program */
  51. int default_program=DEFAULT_PROGRAM;
  53. int antialiasing_allowed=0;
  54. #ifdef FAST_DECAY
  55. int fast_decay=1;
  56. #else
  57. int fast_decay=0;
  58. #endif
  61. int current_tune_number = 0;
  62. int last_tune_purged = 0;
  63. int current_patch_memory = 0;
  64. int max_patch_memory = 60000000;
  66. static void purge_as_required(void);
  68. static void free_instrument(Instrument *ip)
  69. {
  70.   Sample *sp;
  71.   int i;
  72.   if (!ip) return;
  74.   if (!ip->contents)
  75.   for (i=0; i<ip->samples; i++)
  76.     {
  77.       sp=&(ip->sample[i]);
  78.       if (sp->data) free(sp->data);
  79.     }
  80.   free(ip->sample);
  82.   if (!ip->contents)
  83.   for (i=0; i<ip->right_samples; i++)
  84.     {
  85.       sp=&(ip->right_sample[i]);
  86.       if (sp->data) free(sp->data);
  87.     }
  88.   if (ip->right_sample)
  89.     free(ip->right_sample);
  90.   free(ip);
  91. }
  94. static void free_layer(InstrumentLayer *lp)
  95. {
  96.   InstrumentLayer *next;
  98.   current_patch_memory -= lp->size;
  100.   for (; lp; lp = next)
  101.    {
  102.      next = lp->next;
  103.      free_instrument(lp->instrument);
  104.      free(lp);
  105.    }
  106. }
  108. static void free_bank(int dr, int b)
  109. {
  110.   int i;
  111.   ToneBank *bank=((dr) ? drumset[b] : tonebank[b]);
  112.   for (i=0; i<MAXPROG; i++)
  113.   {
  114.     if (bank->tone[i].layer)
  115.     {
  116.   /* Not that this could ever happen, of course */
  117.   if (bank->tone[i].layer != MAGIC_LOAD_INSTRUMENT)
  118.   {
  119.     free_layer(bank->tone[i].layer);
  120.     bank->tone[i].layer=NULL;
  121.     bank->tone[i].last_used=-1;
  122.   }
  123.     }
  124.     if (bank->tone[i].name)
  125.     {
  126.       free(bank->tone[i].name);
  127.       bank->tone[i].name = NULL;
  128.     }
  129.   }
  130. }
  133. static void free_old_bank(int dr, int b, int how_old)
  134. {
  135.   int i;
  136.   ToneBank *bank=((dr) ? drumset[b] : tonebank[b]);
  137.   for (i=0; i<MAXPROG; i++)
  138.     if (bank->tone[i].layer && bank->tone[i].last_used < how_old)
  139.       {
  140. if (bank->tone[i].layer != MAGIC_LOAD_INSTRUMENT)
  141.   {
  142.     ctl->cmsg(CMSG_INFO, VERB_DEBUG,
  143. "Unloading %s %s[%d,%d] - last used %d.",
  144. (dr)? "drum" : "inst", bank->tone[i].name,
  145. i, b, bank->tone[i].last_used);
  146.     free_layer(bank->tone[i].layer);
  147.     bank->tone[i].layer=NULL;
  148.     bank->tone[i].last_used=-1;
  149.   }
  150.       }
  151. }
  154. int32 convert_envelope_rate_attack(uint8 rate, uint8 fastness)
  155. {
  156.   int32 r;
  158.   r=3-((rate>>6) & 0x3);
  159.   r*=3;
  160.   r = (int32)(rate & 0x3f) << r; /* 6.9 fixed point */
  162.   /* 15.15 fixed point. */
  163.   return (((r * 44100) / play_mode->rate) * control_ratio) 
  164.     << 10;
  165. }
  167. int32 convert_envelope_rate(uint8 rate)
  168. {
  169.   int32 r;
  171.   r=3-((rate>>6) & 0x3);
  172.   r*=3;
  173.   r = (int32)(rate & 0x3f) << r; /* 6.9 fixed point */
  175.   /* 15.15 fixed point. */
  176.   return (((r * 44100) / play_mode->rate) * control_ratio) 
  177.     << ((fast_decay) ? 10 : 9);
  178. }
  180. int32 convert_envelope_offset(uint8 offset)
  181. {
  182.   /* This is not too good... Can anyone tell me what these values mean?
  183.      Are they GUS-style "exponential" volumes? And what does that mean? */
  185.   /* 15.15 fixed point */
  186.   return offset << (7+15);
  187. }
  189. int32 convert_tremolo_sweep(uint8 sweep)
  190. {
  191.   if (!sweep)
  192.     return 0;
  194.   return
  195.     ((control_ratio * SWEEP_TUNING) << SWEEP_SHIFT) /
  196.       (play_mode->rate * sweep);
  197. }
  199. int32 convert_vibrato_sweep(uint8 sweep, int32 vib_control_ratio)
  200. {
  201.   if (!sweep)
  202.     return 0;
  204.   return
  205.     (int32) (FSCALE((double) (vib_control_ratio) * SWEEP_TUNING, SWEEP_SHIFT)
  206.      / (double)(play_mode->rate * sweep));
  208.   /* this was overflowing with seashore.pat
  210.       ((vib_control_ratio * SWEEP_TUNING) << SWEEP_SHIFT) /
  211.       (play_mode->rate * sweep); */
  212. }
  214. int32 convert_tremolo_rate(uint8 rate)
  215. {
  216.   return
  217.     ((SINE_CYCLE_LENGTH * control_ratio * rate) << RATE_SHIFT) /
  218.       (TREMOLO_RATE_TUNING * play_mode->rate);
  219. }
  221. int32 convert_vibrato_rate(uint8 rate)
  222. {
  223.   /* Return a suitable vibrato_control_ratio value */
  224.   return
  225.     (VIBRATO_RATE_TUNING * play_mode->rate) / 
  226.       (rate * 2 * VIBRATO_SAMPLE_INCREMENTS);
  227. }
  229. static void reverse_data(int16 *sp, int32 ls, int32 le)
  230. {
  231.   int16 s, *ep=sp+le;
  232.   sp+=ls;
  233.   le-=ls;
  234.   le/=2;
  235.   while (le--)
  236.     {
  237.       s=*sp;
  238.       *sp++=*ep;
  239.       *ep--=s;
  240.     }
  241. }
  243. /* 
  244.    If panning or note_to_use != -1, it will be used for all samples,
  245.    instead of the sample-specific values in the instrument file. 
  247.    For note_to_use, any value <0 or >127 will be forced to 0.
  248.  
  249.    For other parameters, 1 means yes, 0 means no, other values are
  250.    undefined.
  252.    TODO: do reverse loops right */
  253. static InstrumentLayer *load_instrument(const char *name, int font_type, int percussion,
  254.    int panning, int amp, int cfg_tuning, int note_to_use,
  255.    int strip_loop, int strip_envelope,
  256.    int strip_tail, int bank, int gm_num, int sf_ix)
  257. {
  258.   InstrumentLayer *lp, *lastlp, *headlp = 0;
  259.   Instrument *ip;
  260.   FILE *fp;
  261.   uint8 tmp[1024];
  262.   int i,j,noluck=0;
  263. #ifdef PATCH_EXT_LIST
  264.   static char *patch_ext[] = PATCH_EXT_LIST;
  265. #endif
  266.   int sf2flag = 0;
  267.   int right_samples = 0;
  268.   int stereo_channels = 1, stereo_layer;
  269.   int vlayer_list[19][4], vlayer, vlayer_count = 0;
  271.   if (!name) return 0;
  272.   
  273.   /* Open patch file */
  274.   if ((fp=open_file(name, 1, OF_NORMAL)) == NULL)
  275.     {
  276.       noluck=1;
  277. #ifdef PATCH_EXT_LIST
  278.       /* Try with various extensions */
  279.       for (i=0; patch_ext[i]; i++)
  280. {
  281.   if (strlen(name)+strlen(patch_ext[i])<PATH_MAX)
  282.     {
  283.               char path[PATH_MAX];
  284.       strcpy(path, name);
  285.       strcat(path, patch_ext[i]);
  286.       if ((fp=open_file(path, 1, OF_NORMAL)) != NULL)
  287. {
  288.   noluck=0;
  289.   break;
  290. }
  291.     }
  292. }
  293. #endif
  294.     }
  295.   
  296.   if (noluck)
  297.     {
  298.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  299. "Instrument `%s' can't be found.", name);
  300.       return 0;
  301.     }
  302.       
  303.   /*ctl->cmsg(CMSG_INFO, VERB_NOISY, "Loading instrument %s", current_filename);*/
  304.   
  305.   /* Read some headers and do cursory sanity checks. There are loads
  306.      of magic offsets. This could be rewritten... */
  308.   if ((239 != fread(tmp, 1, 239, fp)) ||
  309.       (memcmp(tmp, "GF1PATCH110ID#000002", 22) &&
  310.        memcmp(tmp, "GF1PATCH100ID#000002", 22))) /* don't know what the
  311.       differences are */
  312.     {
  313.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: not an instrument", name);
  314.       return 0;
  315.     }
  317. /* patch layout:
  318.  * bytes:  info: starts at offset:
  319.  * 22 id (see above) 0
  320.  * 60 copyright 22
  321.  *  1 instruments 82
  322.  *  1 voices 83
  323.  *  1 channels 84
  324.  *  2 number of waveforms 85
  325.  *  2 master volume 87
  326.  *  4 datasize 89
  327.  * 36   reserved, but now: 93
  328.  *  7 "SF2EXT" id 93
  329.  *  1 right samples        100
  330.  *     28 reserved        101
  331.  *  2 instrument number 129
  332.  * 16 instrument name 131
  333.  *  4 instrument size 147
  334.  *  1 number of layers 151
  335.  * 40 reserved 152
  336.  *  1 layer duplicate 192
  337.  *  1 layer number 193
  338.  *  4 layer size 194
  339.  *  1 number of samples 198
  340.  * 40 reserved 199
  341.  *  239
  342.  * THEN, for each sample, see below
  343.  */
  345.   if (!memcmp(tmp + 93, "SF2EXT", 6))
  346.     {
  347.     sf2flag = 1;
  348.     vlayer_count = tmp[152];
  349.     }
  351.   if (tmp[82] != 1 && tmp[82] != 0) /* instruments. To some patch makers, 
  352.        0 means 1 */
  353.     {
  354.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  355.    "Can't handle patches with %d instruments", tmp[82]);
  356.       return 0;
  357.     }
  359.   if (tmp[151] != 1 && tmp[151] != 0) /* layers. What's a layer? */
  360.     {
  361.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  362.    "Can't handle instruments with %d layers", tmp[151]);
  363.       return 0;
  364.     }
  365.   
  367.   if (sf2flag && vlayer_count > 0) {
  368. for (i = 0; i < 9; i++)
  369.   for (j = 0; j < 4; j++)
  370.     vlayer_list[i][j] = tmp[153+i*4+j];
  371. for (i = 9; i < 19; i++)
  372.   for (j = 0; j < 4; j++)
  373.     vlayer_list[i][j] = tmp[199+(i-9)*4+j];
  374.   }
  375.   else {
  376. for (i = 0; i < 19; i++)
  377.   for (j = 0; j < 4; j++)
  378.     vlayer_list[i][j] = 0;
  379. vlayer_list[0][0] = 0;
  380. vlayer_list[0][1] = 127;
  381. vlayer_list[0][2] = tmp[198];
  382. vlayer_list[0][3] = 0;
  383. vlayer_count = 1;
  384.   }
  386.   lastlp = 0;
  388.   for (vlayer = 0; vlayer < vlayer_count; vlayer++) {
  390.   lp=(InstrumentLayer *)safe_malloc(sizeof(InstrumentLayer));
  391.   lp->size = sizeof(InstrumentLayer);
  392.   lp->lo = vlayer_list[vlayer][0];
  393.   lp->hi = vlayer_list[vlayer][1];
  394.   ip=(Instrument *)safe_malloc(sizeof(Instrument));
  395.   lp->size += sizeof(Instrument);
  396.   lp->instrument = ip;
  397.   lp->next = 0;
  399.   if (lastlp) lastlp->next = lp;
  400.   else headlp = lp;
  402.   lastlp = lp;
  404.   if (sf2flag) ip->type = INST_SF2;
  405.   else ip->type = INST_GUS;
  406.   ip->samples = vlayer_list[vlayer][2];
  407.   ip->sample = (Sample *)safe_malloc(sizeof(Sample) * ip->samples);
  408.   lp->size += sizeof(Sample) * ip->samples;
  409.   ip->left_samples = ip->samples;
  410.   ip->left_sample = ip->sample;
  411.   right_samples = vlayer_list[vlayer][3];
  412.   ip->right_samples = right_samples;
  413.   if (right_samples)
  414.     {
  415.       ip->right_sample = (Sample *)safe_malloc(sizeof(Sample) * right_samples);
  416.       lp->size += sizeof(Sample) * right_samples;
  417.       stereo_channels = 2;
  418.     }
  419.   else ip->right_sample = 0;
  420.   ip->contents = 0;
  422.   ctl->cmsg(CMSG_INFO, VERB_NOISY, "%s%s[%d,%d] %s(%d-%d layer %d of %d)",
  423. (percussion)? "   ":"", name,
  424. (percussion)? note_to_use : gm_num, bank,
  425. (right_samples)? "(2) " : "",
  426. lp->lo, lp->hi, vlayer+1, vlayer_count);
  428.  for (stereo_layer = 0; stereo_layer < stereo_channels; stereo_layer++)
  429.  {
  430.   int sample_count = 0;
  432.   if (stereo_layer == 0) sample_count = ip->left_samples;
  433.   else if (stereo_layer == 1) sample_count = ip->right_samples;
  435.   for (i=0; i < sample_count; i++)
  436.     {
  437.       uint8 fractions;
  438.       int32 tmplong;
  439.       uint16 tmpshort;
  440.       uint16 sample_volume = 0;
  441.       uint8 tmpchar;
  442.       Sample *sp = 0;
  443.       uint8 sf2delay = 0;
  445. #define READ_CHAR(thing) 
  446.       if (1 != fread(&tmpchar, 1, 1, fp)) goto fail; 
  447.       thing = tmpchar;
  448. #define READ_SHORT(thing) 
  449.       if (1 != fread(&tmpshort, 2, 1, fp)) goto fail; 
  450.       thing = LE_SHORT(tmpshort);
  451. #define READ_LONG(thing) 
  452.       if (1 != fread(&tmplong, 4, 1, fp)) goto fail; 
  453.       thing = LE_LONG(tmplong);
  455. /*
  456.  *  7 sample name
  457.  *  1 fractions
  458.  *  4 length
  459.  *  4 loop start
  460.  *  4 loop end
  461.  *  2 sample rate
  462.  *  4 low frequency
  463.  *  4 high frequency
  464.  *  2 finetune
  465.  *  1 panning
  466.  *  6 envelope rates |
  467.  *  6 envelope offsets |  18 bytes
  468.  *  3 tremolo sweep, rate, depth |
  469.  *  3 vibrato sweep, rate, depth |
  470.  *  1 sample mode
  471.  *  2 scale frequency
  472.  *  2 scale factor
  473.  *  2 sample volume (??)
  474.  * 34 reserved
  475.  * Now: 1 delay
  476.  *  33 reserved
  477.  */
  478.       skip(fp, 7); /* Skip the wave name */
  480.       if (1 != fread(&fractions, 1, 1, fp))
  481. {
  482. fail:
  483.   ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "Error reading sample %d", i);
  484.   if (stereo_layer == 1)
  485.      {
  486.        for (j=0; j<i; j++)
  487.          free(ip->right_sample[j].data);
  488.        free(ip->right_sample);
  489.        i = ip->left_samples;
  490.      }
  491.   for (j=0; j<i; j++)
  492.     free(ip->left_sample[j].data);
  493.   free(ip->left_sample);
  494.   free(ip);
  495.   free(lp);
  496.   return 0;
  497. }
  499.       if (stereo_layer == 0) sp=&(ip->left_sample[i]);
  500.       else if (stereo_layer == 1) sp=&(ip->right_sample[i]);
  502.       READ_LONG(sp->data_length);
  503.       READ_LONG(sp->loop_start);
  504.       READ_LONG(sp->loop_end);
  505.       READ_SHORT(sp->sample_rate);
  506.       READ_LONG(sp->low_freq);
  507.       READ_LONG(sp->high_freq);
  508.       READ_LONG(sp->root_freq);
  509.       skip(fp, 2); /* Why have a "root frequency" and then "tuning"?? */
  510.       
  511.       READ_CHAR(tmp[0]);
  513.       if (panning==-1)
  514. sp->panning = (tmp[0] * 8 + 4) & 0x7f;
  515.       else
  516. sp->panning=(uint8)(panning & 0x7F);
  518.       sp->resonance=0;
  519.       sp->cutoff_freq=0;
  520.       sp->reverberation=0;
  521.       sp->chorusdepth=0;
  522.       sp->exclusiveClass=0;
  523.       sp->keyToModEnvHold=0;
  524.       sp->keyToModEnvDecay=0;
  525.       sp->keyToVolEnvHold=0;
  526.       sp->keyToVolEnvDecay=0;
  528.       if (cfg_tuning)
  529. {
  530.   double tune_factor = (double)(cfg_tuning)/1200.0;
  531.   tune_factor = pow(2.0, tune_factor);
  532.   sp->root_freq = (uint32)( tune_factor * (double)sp->root_freq );
  533. }
  535.       /* envelope, tremolo, and vibrato */
  536.       if (18 != fread(tmp, 1, 18, fp)) goto fail; 
  538.       if (!tmp[13] || !tmp[14])
  539. {
  540.   sp->tremolo_sweep_increment=
  541.     sp->tremolo_phase_increment=sp->tremolo_depth=0;
  542.   ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * no tremolo");
  543. }
  544.       else
  545. {
  546.   sp->tremolo_sweep_increment=convert_tremolo_sweep(tmp[12]);
  547.   sp->tremolo_phase_increment=convert_tremolo_rate(tmp[13]);
  548.   sp->tremolo_depth=tmp[14];
  549.   ctl->cmsg(CMSG_INFO, VERB_DEBUG,
  550.        " * tremolo: sweep %d, phase %d, depth %d",
  551.        sp->tremolo_sweep_increment, sp->tremolo_phase_increment,
  552.        sp->tremolo_depth);
  553. }
  555.       if (!tmp[16] || !tmp[17])
  556. {
  557.   sp->vibrato_sweep_increment=
  558.     sp->vibrato_control_ratio=sp->vibrato_depth=0;
  559.   ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * no vibrato");
  560. }
  561.       else
  562. {
  563.   sp->vibrato_control_ratio=convert_vibrato_rate(tmp[16]);
  564.   sp->vibrato_sweep_increment=
  565.     convert_vibrato_sweep(tmp[15], sp->vibrato_control_ratio);
  566.   sp->vibrato_depth=tmp[17];
  567.   ctl->cmsg(CMSG_INFO, VERB_DEBUG,
  568.        " * vibrato: sweep %d, ctl %d, depth %d",
  569.        sp->vibrato_sweep_increment, sp->vibrato_control_ratio,
  570.        sp->vibrato_depth);
  572. }
  574.       READ_CHAR(sp->modes);
  575.       READ_SHORT(sp->freq_center);
  576.       READ_SHORT(sp->freq_scale);
  578.       if (sf2flag)
  579.         {
  580.           READ_SHORT(sample_volume);
  581.   READ_CHAR(sf2delay);
  582.           READ_CHAR(sp->exclusiveClass);
  583.           skip(fp, 32);
  584. }
  585.       else
  586.         {
  587.           skip(fp, 36);
  588.         }
  590.       /* Mark this as a fixed-pitch instrument if such a deed is desired. */
  591.       if (note_to_use!=-1)
  592. sp->note_to_use=(uint8)(note_to_use);
  593.       else
  594. sp->note_to_use=0;
  595.       
  596.       /* seashore.pat in the Midia patch set has no Sustain. I don't
  597.          understand why, and fixing it by adding the Sustain flag to
  598.          all looped patches probably breaks something else. We do it
  599.          anyway. */
  600.  
  601.       if (sp->modes & MODES_LOOPING) 
  602. sp->modes |= MODES_SUSTAIN;
  604.       /* Strip any loops and envelopes we're permitted to */
  605.       if ((strip_loop==1) && 
  606.   (sp->modes & (MODES_SUSTAIN | MODES_LOOPING | 
  607. MODES_PINGPONG | MODES_REVERSE)))
  608. {
  609.   ctl->cmsg(CMSG_INFO, VERB_DEBUG, " - Removing loop and/or sustain");
  610.   sp->modes &=~(MODES_SUSTAIN | MODES_LOOPING | 
  611. MODES_PINGPONG | MODES_REVERSE);
  612. }
  614.       if (strip_envelope==1)
  615. {
  616.   if (sp->modes & MODES_ENVELOPE)
  617.     ctl->cmsg(CMSG_INFO, VERB_DEBUG, " - Removing envelope");
  618.   sp->modes &= ~MODES_ENVELOPE;
  619. }
  620.       else if (strip_envelope != 0)
  621. {
  622.   /* Have to make a guess. */
  623.   if (!(sp->modes & (MODES_LOOPING | MODES_PINGPONG | MODES_REVERSE)))
  624.     {
  625.       /* No loop? Then what's there to sustain? No envelope needed
  626.  either... */
  627.       sp->modes &= ~(MODES_SUSTAIN|MODES_ENVELOPE);
  628.       ctl->cmsg(CMSG_INFO, VERB_DEBUG, 
  629. " - No loop, removing sustain and envelope");
  630.     }
  631.   else if (!memcmp(tmp, "??????", 6) || tmp[11] >= 100) 
  632.     {
  633.       /* Envelope rates all maxed out? Envelope end at a high "offset"?
  634.  That's a weird envelope. Take it out. */
  635.       sp->modes &= ~MODES_ENVELOPE;
  636.       ctl->cmsg(CMSG_INFO, VERB_DEBUG, 
  637. " - Weirdness, removing envelope");
  638.     }
  639.   else if (!(sp->modes & MODES_SUSTAIN))
  640.     {
  641.       /* No sustain? Then no envelope.  I don't know if this is
  642.  justified, but patches without sustain usually don't need the
  643.  envelope either... at least the Gravis ones. They're mostly
  644.  drums.  I think. */
  645.       sp->modes &= ~MODES_ENVELOPE;
  646.       ctl->cmsg(CMSG_INFO, VERB_DEBUG, 
  647. " - No sustain, removing envelope");
  648.     }
  649. }
  651.       sp->attenuation = 0;
  653.       for (j=ATTACK; j<DELAY; j++)
  654. {
  655.   sp->envelope_rate[j]=
  656.     (j<3)? convert_envelope_rate_attack(tmp[j], 11) : convert_envelope_rate(tmp[j]);
  657.   sp->envelope_offset[j]= 
  658.     convert_envelope_offset(tmp[6+j]);
  659. }
  660.       if (sf2flag)
  661. {
  662.   if (sf2delay > 5) sf2delay = 5;
  663.   sp->envelope_rate[DELAY] = (int32)( (sf2delay*play_mode->rate) / 1000 );
  664. }
  665.       else
  666. {
  667.           sp->envelope_rate[DELAY]=0;
  668. }
  669.       sp->envelope_offset[DELAY]=0;
  671.       for (j=ATTACK; j<DELAY; j++)
  672. {
  673.   sp->modulation_rate[j]=sp->envelope_rate[j];
  674.   sp->modulation_offset[j]=sp->envelope_offset[j];
  675. }
  676.       sp->modulation_rate[DELAY] = sp->modulation_offset[DELAY] = 0;
  677.       sp->modEnvToFilterFc=0;
  678.       sp->modEnvToPitch=0;
  679.       sp->lfo_sweep_increment = 0;
  680.       sp->lfo_phase_increment = 0;
  681.       sp->modLfoToFilterFc = 0;
  682.       sp->vibrato_delay = 0;
  684.       /* Then read the sample data */
  685.       if (sp->data_length/2 > MAX_SAMPLE_SIZE)
  686.         {
  687.   goto fail;
  688. }
  689.       sp->data = safe_malloc(sp->data_length + 1);
  690.       lp->size += sp->data_length + 1;
  692.       if (1 != fread(sp->data, sp->data_length, 1, fp))
  693. goto fail;
  694.       
  695.       if (!(sp->modes & MODES_16BIT)) /* convert to 16-bit data */
  696. {
  697.   int32 i=sp->data_length;
  698.   uint8 *cp=(uint8 *)(sp->data);
  699.   uint16 *tmp,*newdta;
  700.   tmp=newdta=safe_malloc(sp->data_length*2 + 2);
  701.   while (i--)
  702.     *tmp++ = (uint16)(*cp++) << 8;
  703.   cp=(uint8 *)(sp->data);
  704.   sp->data = (sample_t *)newdta;
  705.   free(cp);
  706.   sp->data_length *= 2;
  707.   sp->loop_start *= 2;
  708.   sp->loop_end *= 2;
  709. }
  710. #if SDL_BYTEORDER == SDL_BIG_ENDIAN
  711.       else
  712. /* convert to machine byte order */
  713. {
  714.   int32 i=sp->data_length/2;
  715.   int16 *tmp=(int16 *)sp->data,s;
  716.   while (i--)
  717.     { 
  718.       s=LE_SHORT(*tmp);
  719.       *tmp++=s;
  720.     }
  721. }
  722. #endif
  723.       
  724.       if (sp->modes & MODES_UNSIGNED) /* convert to signed data */
  725. {
  726.   int32 i=sp->data_length/2;
  727.   int16 *tmp=(int16 *)sp->data;
  728.   while (i--)
  729.     *tmp++ ^= 0x8000;
  730. }
  732.       /* Reverse reverse loops and pass them off as normal loops */
  733.       if (sp->modes & MODES_REVERSE)
  734. {
  735.   int32 t;
  736.   /* The GUS apparently plays reverse loops by reversing the
  737.      whole sample. We do the same because the GUS does not SUCK. */
  739.   ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "Reverse loop in %s", name);
  740.   reverse_data((int16 *)sp->data, 0, sp->data_length/2);
  742.   t=sp->loop_start;
  743.   sp->loop_start=sp->data_length - sp->loop_end;
  744.   sp->loop_end=sp->data_length - t;
  746.   sp->modes &= ~MODES_REVERSE;
  747.   sp->modes |= MODES_LOOPING; /* just in case */
  748. }
  750.       /* If necessary do some anti-aliasing filtering  */
  752.       if (antialiasing_allowed)
  753.   antialiasing(sp,play_mode->rate);
  755. #ifdef ADJUST_SAMPLE_VOLUMES
  756.       if (amp!=-1)
  757. sp->volume=(FLOAT_T)((amp) / 100.0);
  758.       else if (sf2flag)
  759. sp->volume=(FLOAT_T)((sample_volume) / 255.0);
  760.       else
  761. {
  762.   /* Try to determine a volume scaling factor for the sample.
  763.      This is a very crude adjustment, but things sound more
  764.      balanced with it. Still, this should be a runtime option. */
  765.   uint32 i, numsamps=sp->data_length/2;
  766.   uint32 higher=0, highcount=0;
  767.   int16 maxamp=0,a;
  768.   int16 *tmp=(int16 *)sp->data;
  769.   i = numsamps;
  770.   while (i--)
  771.     {
  772.       a=*tmp++;
  773.       if (a<0) a=-a;
  774.       if (a>maxamp)
  775. maxamp=a;
  776.     }
  777.   tmp=(int16 *)sp->data;
  778.   i = numsamps;
  779.   while (i--)
  780.     {
  781.       a=*tmp++;
  782.       if (a<0) a=-a;
  783.       if (a > 3*maxamp/4)
  784. {
  785.    higher += a;
  786.    highcount++;
  787. }
  788.     }
  789.   if (highcount) higher /= highcount;
  790.   else higher = 10000;
  791.   sp->volume = (32768.0 * 0.875) /  (double)higher ;
  792.   ctl->cmsg(CMSG_INFO, VERB_DEBUG, " * volume comp: %f", sp->volume);
  793. }
  794. #else
  795.       if (amp!=-1)
  796. sp->volume=(double)(amp) / 100.0;
  797.       else
  798. sp->volume=1.0;
  799. #endif
  801.       sp->data_length /= 2; /* These are in bytes. Convert into samples. */
  803.       sp->loop_start /= 2;
  804.       sp->loop_end /= 2;
  805.       sp->data[sp->data_length] = sp->data[sp->data_length-1];
  807.       /* Then fractional samples */
  808.       sp->data_length <<= FRACTION_BITS;
  809.       sp->loop_start <<= FRACTION_BITS;
  810.       sp->loop_end <<= FRACTION_BITS;
  812.     /* trim off zero data at end */
  813.     {
  814. int ls = sp->loop_start>>FRACTION_BITS;
  815. int le = sp->loop_end>>FRACTION_BITS;
  816. int se = sp->data_length>>FRACTION_BITS;
  817. while (se > 1 && !sp->data[se-1]) se--;
  818. if (le > se) le = se;
  819. if (ls >= le) sp->modes &= ~MODES_LOOPING;
  820. sp->loop_end = le<<FRACTION_BITS;
  821. sp->data_length = se<<FRACTION_BITS;
  822.     }
  824.       /* Adjust for fractional loop points. This is a guess. Does anyone
  825.  know what "fractions" really stands for? */
  826.       sp->loop_start |=
  827. (fractions & 0x0F) << (FRACTION_BITS-4);
  828.       sp->loop_end |=
  829. ((fractions>>4) & 0x0F) << (FRACTION_BITS-4);
  831.       /* If this instrument will always be played on the same note,
  832.  and it's not looped, we can resample it now. */
  833.       if (sp->note_to_use && !(sp->modes & MODES_LOOPING))
  834. pre_resample(sp);
  836. #ifdef LOOKUP_HACK
  837.       /* Squash the 16-bit data into 8 bits. */
  838.       {
  839. uint8 *gulp,*ulp;
  840. int16 *swp;
  841. int l=sp->data_length >> FRACTION_BITS;
  842. gulp=ulp=safe_malloc(l+1);
  843. swp=(int16 *)sp->data;
  844. while(l--)
  845.   *ulp++ = (*swp++ >> 8) & 0xFF;
  846. free(sp->data);
  847. sp->data=(sample_t *)gulp;
  848.       }
  849. #endif
  850.       
  851.       if (strip_tail==1)
  852. {
  853.   /* Let's not really, just say we did. */
  854.   ctl->cmsg(CMSG_INFO, VERB_DEBUG, " - Stripping tail");
  855.   sp->data_length = sp->loop_end;
  856. }
  857.     } /* end of sample loop */
  858.  } /* end of stereo layer loop */
  859.  } /* end of vlayer loop */
  862.   close_file(fp);
  863.   return headlp;
  864. }
  866. static int fill_bank(int dr, int b)
  867. {
  868.   int i, errors=0;
  869.   ToneBank *bank=((dr) ? drumset[b] : tonebank[b]);
  870.   if (!bank)
  871.     {
  872.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  873.    "Huh. Tried to load instruments in non-existent %s %d",
  874.    (dr) ? "drumset" : "tone bank", b);
  875.       return 0;
  876.     }
  877.   for (i=0; i<MAXPROG; i++)
  878.     {
  879.       if (bank->tone[i].layer==MAGIC_LOAD_INSTRUMENT)
  880. {
  881.   if (!(bank->tone[i].name))
  882.     {
  883.       ctl->cmsg(CMSG_WARNING, (b!=0) ? VERB_VERBOSE : VERB_NORMAL,
  884.    "No instrument mapped to %s %d, program %d%s",
  885.    (dr)? "drum set" : "tone bank", b, i, 
  886.    (b!=0) ? "" : " - this instrument will not be heard");
  887.       if (b!=0)
  888. {
  889.   /* Mark the corresponding instrument in the default
  890.      bank / drumset for loading (if it isn't already) */
  891.   if (!dr)
  892.     {
  893.       if (!(standard_tonebank.tone[i].layer))
  894. standard_tonebank.tone[i].layer=
  895.   MAGIC_LOAD_INSTRUMENT;
  896.     }
  897.   else
  898.     {
  899.       if (!(standard_drumset.tone[i].layer))
  900. standard_drumset.tone[i].layer=
  901.   MAGIC_LOAD_INSTRUMENT;
  902.     }
  903. }
  904.       bank->tone[i].layer=0;
  905.       errors++;
  906.     }
  907.   else if (!(bank->tone[i].layer=
  908.      load_instrument(bank->tone[i].name, 
  909.            bank->tone[i].font_type,
  910.      (dr) ? 1 : 0,
  911.      bank->tone[i].pan,
  912.      bank->tone[i].amp,
  913.      bank->tone[i].tuning,
  914.      (bank->tone[i].note!=-1) ? 
  915.        bank->tone[i].note :
  916.        ((dr) ? i : -1),
  917.      (bank->tone[i].strip_loop!=-1) ?
  918.      bank->tone[i].strip_loop :
  919.      ((dr) ? 1 : -1),
  920.      (bank->tone[i].strip_envelope != -1) ? 
  921.      bank->tone[i].strip_envelope :
  922.      ((dr) ? 1 : -1),
  923.      bank->tone[i].strip_tail,
  924.      b,
  925.      ((dr) ? i + 128 : i),
  926.      bank->tone[i].sf_ix
  927.       )))
  928.     {
  929.       ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  930.    "Couldn't load instrument %s (%s %d, program %d)",
  931.    bank->tone[i].name,
  932.    (dr)? "drum set" : "tone bank", b, i);
  933.       errors++;
  934.     }
  935.   else
  936.     { /* it's loaded now */
  937. bank->tone[i].last_used = current_tune_number;
  938. current_patch_memory += bank->tone[i].layer->size;
  939. purge_as_required();
  940. if (current_patch_memory > max_patch_memory) {
  941.        ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 
  942.     "Not enough memory to load instrument %s (%s %d, program %d)",
  943.     bank->tone[i].name,
  944.     (dr)? "drum set" : "tone bank", b, i);
  945.        errors++;
  946.      free_layer(bank->tone[i].layer);
  947.      bank->tone[i].layer=0;
  948.      bank->tone[i].last_used=-1;
  949. }
  950. #if 0
  951.            if (check_for_rc()) {
  952.      free_layer(bank->tone[i].layer);
  953.      bank->tone[i].layer=0;
  954.      bank->tone[i].last_used=-1;
  955. return 0;
  956. }
  957. #endif
  958.     }
  959. }
  960.     }
  961.   return errors;
  962. }
  964. static void free_old_instruments(int how_old)
  965. {
  966.   int i=MAXBANK;
  967.   while(i--)
  968.     {
  969.       if (tonebank[i])
  970. free_old_bank(0, i, how_old);
  971.       if (drumset[i])
  972. free_old_bank(1, i, how_old);
  973.     }
  974. }
  976. static void purge_as_required(void)
  977. {
  978.   if (!max_patch_memory) return;
  980.   while (last_tune_purged < current_tune_number
  981. && current_patch_memory > max_patch_memory)
  982.     {
  983. last_tune_purged++;
  984. free_old_instruments(last_tune_purged);
  985.     }
  986. }
  989. int load_missing_instruments(void)
  990. {
  991.   int i=MAXBANK,errors=0;
  992.   while (i--)
  993.     {
  994.       if (tonebank[i])
  995. errors+=fill_bank(0,i);
  996.       if (drumset[i])
  997. errors+=fill_bank(1,i);
  998.     }
  999.   current_tune_number++;
  1000.   return errors;
  1001. }
  1003. void free_instruments(void)
  1004. {
  1005.   int i=128;
  1006.   while(i--)
  1007.     {
  1008.       if (tonebank[i])
  1009. free_bank(0,i);
  1010.       if (drumset[i])
  1011. free_bank(1,i);
  1012.     }
  1013. }
  1015. int set_default_instrument(const char *name)
  1016. {
  1017.   InstrumentLayer *lp;
  1018. /*  if (!(lp=load_instrument(name, 0, -1, -1, -1, 0, 0, 0))) */
  1019.   if (!(lp=load_instrument(name, FONT_NORMAL, 0, -1, -1, 0, -1, -1, -1, -1, 0, -1, -1)))
  1020.     return -1;
  1021.   if (default_instrument)
  1022.     free_layer(default_instrument);
  1023.   default_instrument=lp;
  1024.   default_program=SPECIAL_PROGRAM;
  1025.   return 0;
  1026. }