[BACK]Return to midiout.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2 / sound / vermouth

Diff for /np2/sound/vermouth/midiout.c between versions 1.16 and 1.17

version 1.16, 2006/12/16 12:11:07 version 1.17, 2006/12/16 22:23:24
Line 15  static const int gaintbl[24+1] = Line 15  static const int gaintbl[24+1] =
   
 // ---- voice  // ---- voice
   
   #define VOICEHDLPTR(hdl)        ((hdl)->voice)
   #define VOICEHDLEND(hdl)        (VOICE)((hdl) + 1)
   
 static void VERMOUTHCL voice_volupdate(VOICE v) {  static void VERMOUTHCL voice_volupdate(VOICE v) {
   
         CHANNEL ch;          CHANNEL ch;
Line 134  static void VERMOUTHCL freq_update(VOICE Line 137  static void VERMOUTHCL freq_update(VOICE
         v->sampstep = (int)step;          v->sampstep = (int)step;
 }  }
   
 static void VERMOUTHCL voice_on(MIDIHDL midi, CHANNEL ch, VOICE v, int key,  static void VERMOUTHCL voice_on(MIDIHDL hdl, CHANNEL ch, VOICE v, int key,
                                                                                                                                         int vel) {                                                                                                                                          int vel) {
   
         INSTRUMENT      inst;          INSTRUMENT      inst;
Line 159  static void VERMOUTHCL voice_on(MIDIHDL  Line 162  static void VERMOUTHCL voice_on(MIDIHDL 
 #if !defined(MIDI_GMONLY)  #if !defined(MIDI_GMONLY)
                 inst = ch->rhythm[key];                  inst = ch->rhythm[key];
                 if (inst == NULL) {                  if (inst == NULL) {
                         inst = midi->bank0[1][key];                          inst = hdl->bank0[1][key];
                 }                  }
 #else  #else
                 inst = midi->bank0[1][key];                  inst = hdl->bank0[1][key];
 #endif  #endif
                 if (inst == NULL) {                  if (inst == NULL) {
                         return;                          return;
Line 238  static void VERMOUTHCL voice_on(MIDIHDL  Line 241  static void VERMOUTHCL voice_on(MIDIHDL 
                 v->flag |= VOICE_FIXPITCH;                  v->flag |= VOICE_FIXPITCH;
         }          }
         else {          else {
                 v->freq = (float)layer->samprate / (float)midi->samprate *                  v->freq = (float)layer->samprate / (float)hdl->samprate *
                                         (float)v->frequency / (float)layer->freqroot;                                          (float)v->frequency / (float)layer->freqroot;
         }          }
         voice_setphase(v, VOICE_ON);          voice_setphase(v, VOICE_ON);
Line 266  static void VERMOUTHCL voice_off(VOICE v Line 269  static void VERMOUTHCL voice_off(VOICE v
         }          }
 }  }
   
 static void VERMOUTHCL allresetvoices(MIDIHDL midi) {  static void VERMOUTHCL allresetvoices(MIDIHDL hdl) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 voice_setfree(v);                  voice_setfree(v);
                 v++;                  v++;
Line 282  static void VERMOUTHCL allresetvoices(MI Line 285  static void VERMOUTHCL allresetvoices(MI
   
 // ---- key  // ---- key
   
 static void VERMOUTHCL key_on(MIDIHDL midi, CHANNEL ch, int key, int vel) {  static void VERMOUTHCL key_on(MIDIHDL hdl, CHANNEL ch, int key, int vel) {
   
         VOICE   v;          VOICE   v;
         VOICE   v1;          VOICE   v1;
Line 291  static void VERMOUTHCL key_on(MIDIHDL mi Line 294  static void VERMOUTHCL key_on(MIDIHDL mi
         int             volmin;          int             volmin;
   
         v = NULL;          v = NULL;
         v1 = midi->voice;          v1 = VOICEHDLPTR(hdl);
         v2 = v1 + VOICE_MAX;          v2 = VOICEHDLEND(hdl);
         do {          do {
                 v2--;                  v2--;
                 if (v2->phase == VOICE_FREE) {                  if (v2->phase == VOICE_FREE) {
Line 306  static void VERMOUTHCL key_on(MIDIHDL mi Line 309  static void VERMOUTHCL key_on(MIDIHDL mi
         } while(v1 < v2);          } while(v1 < v2);
   
         if (v != NULL) {          if (v != NULL) {
                 voice_on(midi, ch, v, key, vel);                  voice_on(hdl, ch, v, key, vel);
                 return;                  return;
         }          }
   
         volmin = 0x7fffffff;          volmin = 0x7fffffff;
         v2 = v1 + VOICE_MAX;          v2 = VOICEHDLEND(hdl);
         do {          do {
                 v2--;                  v2--;
                 if (!(v2->phase & (VOICE_ON | VOICE_REL))) {                  if (!(v2->phase & (VOICE_ON | VOICE_REL))) {
Line 328  static void VERMOUTHCL key_on(MIDIHDL mi Line 331  static void VERMOUTHCL key_on(MIDIHDL mi
   
         if (v != NULL) {          if (v != NULL) {
                 voice_setfree(v);                  voice_setfree(v);
                 voice_on(midi, ch, v, key, vel);                  voice_on(hdl, ch, v, key, vel);
         }          }
 }  }
   
 static void VERMOUTHCL key_off(MIDIHDL midi, CHANNEL ch, int key) {  static void VERMOUTHCL key_off(MIDIHDL hdl, CHANNEL ch, int key) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase & VOICE_ON) &&                  if ((v->phase & VOICE_ON) &&
                         (v->channel == ch) && (v->note == key)) {                          (v->channel == ch) && (v->note == key)) {
Line 354  static void VERMOUTHCL key_off(MIDIHDL m Line 357  static void VERMOUTHCL key_off(MIDIHDL m
         } while(v < vterm);          } while(v < vterm);
 }  }
   
 static void VERMOUTHCL key_pressure(MIDIHDL midi, CHANNEL ch, int key,  static void VERMOUTHCL key_pressure(MIDIHDL hdl, CHANNEL ch, int key,
                                                                                                                                         int vel) {                                                                                                                                          int vel) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase & VOICE_ON) &&                  if ((v->phase & VOICE_ON) &&
                         (v->channel == ch) && (v->note == key)) {                          (v->channel == ch) && (v->note == key)) {
Line 377  static void VERMOUTHCL key_pressure(MIDI Line 380  static void VERMOUTHCL key_pressure(MIDI
   
 // ---- control  // ---- control
   
 static void VERMOUTHCL volumeupdate(MIDIHDL midi, CHANNEL ch) {  static void VERMOUTHCL volumeupdate(MIDIHDL hdl, CHANNEL ch) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
 #if defined(VOLUME_ACURVE)  #if defined(VOLUME_ACURVE)
         ch->level = (midi->level * acurve[ch->volume] * ch->expression) >> 15;          ch->level = (hdl->level * acurve[ch->volume] * ch->expression) >> 15;
 #else  #else
         ch->level = (midi->level * ch->volume * ch->expression) >> 14;          ch->level = (hdl->level * ch->volume * ch->expression) >> 14;
 #endif  #endif
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase & (VOICE_ON | VOICE_SUSTAIN)) && (v->channel == ch)) {                  if ((v->phase & (VOICE_ON | VOICE_SUSTAIN)) && (v->channel == ch)) {
                         voice_volupdate(v);                          voice_volupdate(v);
Line 398  static void VERMOUTHCL volumeupdate(MIDI Line 401  static void VERMOUTHCL volumeupdate(MIDI
         } while(v < vterm);          } while(v < vterm);
 }  }
   
 static void VERMOUTHCL pedaloff(MIDIHDL midi, CHANNEL ch) {  static void VERMOUTHCL pedaloff(MIDIHDL hdl, CHANNEL ch) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase & VOICE_SUSTAIN) && (v->channel == ch)) {                  if ((v->phase & VOICE_SUSTAIN) && (v->channel == ch)) {
                         voice_off(v);                          voice_off(v);
Line 413  static void VERMOUTHCL pedaloff(MIDIHDL  Line 416  static void VERMOUTHCL pedaloff(MIDIHDL 
         } while(v < vterm);          } while(v < vterm);
 }  }
   
 static void VERMOUTHCL allsoundsoff(MIDIHDL midi, CHANNEL ch) {  static void VERMOUTHCL allsoundsoff(MIDIHDL hdl, CHANNEL ch) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase != VOICE_FREE) && (v->channel == ch)) {                  if ((v->phase != VOICE_FREE) && (v->channel == ch)) {
                         voice_setphase(v, VOICE_REL);                          voice_setphase(v, VOICE_REL);
Line 441  static void VERMOUTHCL resetallcontrolle Line 444  static void VERMOUTHCL resetallcontrolle
         ch->pitchfactor = 1.0;          ch->pitchfactor = 1.0;
 }  }
   
 static void VERMOUTHCL allnotesoff(MIDIHDL midi, CHANNEL ch) {  static void VERMOUTHCL allnotesoff(MIDIHDL hdl, CHANNEL ch) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
 #if 1  #if 1
                 if ((v->phase & (VOICE_ON | VOICE_SUSTAIN)) && (v->channel == ch)) {                  if ((v->phase & (VOICE_ON | VOICE_SUSTAIN)) && (v->channel == ch)) {
Line 467  static void VERMOUTHCL allnotesoff(MIDIH Line 470  static void VERMOUTHCL allnotesoff(MIDIH
         } while(v < vterm);          } while(v < vterm);
 }  }
   
 static void VERMOUTHCL ctrlchange(MIDIHDL midi, CHANNEL ch, int ctrl,  static void VERMOUTHCL ctrlchange(MIDIHDL hdl, CHANNEL ch, int ctrl,
                                                                                                                                         int val) {                                                                                                                                          int val) {
   
         val &= 0x7f;          val &= 0x7f;
Line 495  static void VERMOUTHCL ctrlchange(MIDIHD Line 498  static void VERMOUTHCL ctrlchange(MIDIHD
   
                 case CTRL_VOLUME:                  case CTRL_VOLUME:
                         ch->volume = val;                          ch->volume = val;
                         volumeupdate(midi, ch);                          volumeupdate(hdl, ch);
                         break;                          break;
   
                 case CTRL_PANPOT:                  case CTRL_PANPOT:
Line 504  static void VERMOUTHCL ctrlchange(MIDIHD Line 507  static void VERMOUTHCL ctrlchange(MIDIHD
   
                 case CTRL_EXPRESS:                  case CTRL_EXPRESS:
                         ch->expression = val;                          ch->expression = val;
                         volumeupdate(midi, ch);                          volumeupdate(hdl, ch);
                         break;                          break;
   
                 case CTRL_PEDAL:                  case CTRL_PEDAL:
                         if (val == 0) {                          if (val == 0) {
                                 ch->flag &= ~CHANNEL_SUSTAIN;                                  ch->flag &= ~CHANNEL_SUSTAIN;
                                 pedaloff(midi, ch);                                  pedaloff(hdl, ch);
                         }                          }
                         else {                          else {
                                 ch->flag |= CHANNEL_SUSTAIN;                                  ch->flag |= CHANNEL_SUSTAIN;
Line 526  static void VERMOUTHCL ctrlchange(MIDIHD Line 529  static void VERMOUTHCL ctrlchange(MIDIHD
                         break;                          break;
   
                 case CTRL_SOUNDOFF:                  case CTRL_SOUNDOFF:
                         allsoundsoff(midi, ch);                          allsoundsoff(hdl, ch);
                         break;                          break;
   
                 case CTRL_RESETCTRL:                  case CTRL_RESETCTRL:
Line 534  static void VERMOUTHCL ctrlchange(MIDIHD Line 537  static void VERMOUTHCL ctrlchange(MIDIHD
                         /*FALLTHROUGH*/                          /*FALLTHROUGH*/
   
                 case CTRL_NOTEOFF:                  case CTRL_NOTEOFF:
                         allnotesoff(midi, ch);                          allnotesoff(hdl, ch);
                         break;                          break;
   
                 case CTRL_MONOON:                  case CTRL_MONOON:
Line 551  static void VERMOUTHCL ctrlchange(MIDIHD Line 554  static void VERMOUTHCL ctrlchange(MIDIHD
         }          }
 }  }
   
 static void VERMOUTHCL progchange(MIDIHDL midi, CHANNEL ch, int val) {  static void VERMOUTHCL progchange(MIDIHDL hdl, CHANNEL ch, int val) {
   
 #if !defined(MIDI_GMONLY)  #if !defined(MIDI_GMONLY)
         MIDIMOD         module;          MIDIMOD         mod;
         INSTRUMENT      *bank;          INSTRUMENT      *bank;
         INSTRUMENT      inst;          INSTRUMENT      inst;
   
         module = midi->module;          mod = hdl->module;
         inst = NULL;          inst = NULL;
         if (ch->bank < MIDI_BANKS) {          if (ch->bank < MIDI_BANKS) {
                 bank = module->tone[ch->bank * 2];                  bank = mod->tone[ch->bank * 2];
                 if (bank) {                  if (bank) {
                         inst = bank[val];                          inst = bank[val];
                 }                  }
         }          }
         if (inst == NULL) {          if (inst == NULL) {
                 bank = midi->bank0[0];                  bank = hdl->bank0[0];
                 inst = bank[val];                  inst = bank[val];
         }          }
         ch->inst = inst;          ch->inst = inst;
   
         bank = NULL;          bank = NULL;
         if (ch->bank < MIDI_BANKS) {          if (ch->bank < MIDI_BANKS) {
                 bank = module->tone[ch->bank * 2 + 1];                  bank = mod->tone[ch->bank * 2 + 1];
         }          }
         if (bank == NULL) {          if (bank == NULL) {
                 bank = midi->bank0[1];                  bank = hdl->bank0[1];
         }          }
         ch->rhythm = bank;          ch->rhythm = bank;
 #else  #else
         ch->inst = midi->bank0[0][val];          ch->inst = hdl->bank0[0][val];
 #endif  #endif
         ch->program = val;          ch->program = val;
 }  }
   
 static void VERMOUTHCL chpressure(MIDIHDL midi, CHANNEL ch, int vel) {  static void VERMOUTHCL chpressure(MIDIHDL hdl, CHANNEL ch, int vel) {
   
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if ((v->phase & VOICE_ON) && (v->channel == ch)) {                  if ((v->phase & VOICE_ON) && (v->channel == ch)) {
                         v->velocity = vel;                          v->velocity = vel;
Line 604  static void VERMOUTHCL chpressure(MIDIHD Line 607  static void VERMOUTHCL chpressure(MIDIHD
         } while(v < vterm);          } while(v < vterm);
 }  }
   
 static void VERMOUTHCL pitchbendor(MIDIHDL midi, CHANNEL ch, int val1,  static void VERMOUTHCL pitchbendor(MIDIHDL hdl, CHANNEL ch, int val1,
                                                                                                                                 int val2) {                                                                                                                                  int val2) {
   
         VOICE   v;          VOICE   v;
Line 623  static void VERMOUTHCL pitchbendor(MIDIH Line 626  static void VERMOUTHCL pitchbendor(MIDIH
                         ch->pitchfactor = bendhtbl[(val1 >> (6 + 7)) + 24] *                          ch->pitchfactor = bendhtbl[(val1 >> (6 + 7)) + 24] *
                                                                                                 bendltbl[(val1 >> 7) & 0x3f];                                                                                                  bendltbl[(val1 >> 7) & 0x3f];
                 }                  }
                 v = midi->voice;                  v = VOICEHDLPTR(hdl);
                 vterm = v + VOICE_MAX;                  vterm = VOICEHDLEND(hdl);
                 do {                  do {
                         if ((v->phase != VOICE_FREE) && (v->channel == ch)) {                          if ((v->phase != VOICE_FREE) && (v->channel == ch)) {
                                 freq_update(v);                                  freq_update(v);
Line 634  static void VERMOUTHCL pitchbendor(MIDIH Line 637  static void VERMOUTHCL pitchbendor(MIDIH
         }          }
 }  }
   
 static void VERMOUTHCL allvolupdate(MIDIHDL midi) {  static void VERMOUTHCL allvolupdate(MIDIHDL hdl) {
   
         int             level;          int             level;
         CHANNEL ch;          CHANNEL ch;
Line 642  static void VERMOUTHCL allvolupdate(MIDI Line 645  static void VERMOUTHCL allvolupdate(MIDI
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
   
         level = gaintbl[midi->gain + 16] >> 1;          level = gaintbl[hdl->gain + 16] >> 1;
         level *= midi->master;          level *= hdl->master;
         midi->level = level;          hdl->level = level;
         ch = midi->channel;          ch = hdl->channel;
         chterm = ch + 16;          chterm = ch + CHANNEL_MAX;
         do {          do {
                 ch->level = (level * ch->volume * ch->expression) >> 14;                  ch->level = (level * ch->volume * ch->expression) >> 14;
                 ch++;                  ch++;
         } while(ch < chterm);          } while(ch < chterm);
         v = midi->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         do {          do {
                 if (v->phase & (VOICE_ON | VOICE_SUSTAIN)) {                  if (v->phase & (VOICE_ON | VOICE_SUSTAIN)) {
                         voice_volupdate(v);                          voice_volupdate(v);
Line 663  static void VERMOUTHCL allvolupdate(MIDI Line 666  static void VERMOUTHCL allvolupdate(MIDI
 }  }
   
 #if defined(ENABLE_GSRX)  #if defined(ENABLE_GSRX)
 static void VERMOUTHCL allresetmidi(MIDIHDL midi, BOOL gs)  static void VERMOUTHCL allresetmidi(MIDIHDL hdl, BOOL gs)
 #else  #else
 #define allresetmidi(m, g)              _allresetmidi(m)  #define allresetmidi(m, g)              _allresetmidi(m)
 static void VERMOUTHCL _allresetmidi(MIDIHDL midi)  static void VERMOUTHCL _allresetmidi(MIDIHDL hdl)
 #endif  #endif
 {  {
         CHANNEL ch;          CHANNEL ch;
         CHANNEL chterm;          CHANNEL chterm;
         UINT    flag;          UINT    flag;
   
         midi->master = 127;          hdl->master = 127;
         ch = midi->channel;          ch = hdl->channel;
         chterm = ch + 16;          chterm = ch + CHANNEL_MAX;
         ZeroMemory(ch, sizeof(_CHANNEL) * 16);          ZeroMemory(ch, sizeof(_CHANNEL) * CHANNEL_MAX);
         flag = 0;          flag = 0;
         do {          do {
                 ch->flag = flag++;                  ch->flag = flag++;
Line 685  static void VERMOUTHCL _allresetmidi(MID Line 688  static void VERMOUTHCL _allresetmidi(MID
                 ch->bank = 0;                  ch->bank = 0;
 #endif  #endif
                 ch->panpot = 64;                  ch->panpot = 64;
                 progchange(midi, ch, 0);                  progchange(hdl, ch, 0);
                 resetallcontrollers(ch);                  resetallcontrollers(ch);
 #if defined(ENABLE_GSRX)  #if defined(ENABLE_GSRX)
                 ch->keyshift = 0x40;                  ch->keyshift = 0x40;
Line 704  static void VERMOUTHCL _allresetmidi(MID Line 707  static void VERMOUTHCL _allresetmidi(MID
 #endif  #endif
                 ch++;                  ch++;
         } while(ch < chterm);          } while(ch < chterm);
         allresetvoices(midi);          allresetvoices(hdl);
         allvolupdate(midi);          allvolupdate(hdl);
 }  }
   
   
Line 718  VEXTERN UINT VEXPORT midiout_getver(char Line 721  VEXTERN UINT VEXPORT midiout_getver(char
         return((MIDIOUT_VERSION << 8) | 0x00);          return((MIDIOUT_VERSION << 8) | 0x00);
 }  }
   
 VEXTERN MIDIHDL VEXPORT midiout_create(MIDIMOD module, UINT worksize) {  VEXTERN MIDIHDL VEXPORT midiout_create(MIDIMOD mod, UINT worksize) {
   
         UINT    size;          UINT    size;
         MIDIHDL ret;          MIDIHDL ret;
   
         if (module == NULL) {          if (mod == NULL) {
                 return(NULL);                  return(NULL);
         }          }
         worksize = min(worksize, 512);          worksize = min(worksize, 512);
Line 733  VEXTERN MIDIHDL VEXPORT midiout_create(M Line 736  VEXTERN MIDIHDL VEXPORT midiout_create(M
         size += sizeof(_SAMPLE) * worksize;          size += sizeof(_SAMPLE) * worksize;
         ret = (MIDIHDL)_MALLOC(size, "MIDIHDL");          ret = (MIDIHDL)_MALLOC(size, "MIDIHDL");
         if (ret) {          if (ret) {
                 midimod_lock(module);                  midimod_lock(mod);
                 ZeroMemory(ret, size);                  ZeroMemory(ret, size);
                 ret->samprate = module->samprate;                  ret->samprate = mod->samprate;
                 ret->worksize = worksize;                  ret->worksize = worksize;
                 ret->module = module;                  ret->module = mod;
         //      ret->master = 127;          //      ret->master = 127;
                 ret->bank0[0] = module->tone[0];                  ret->bank0[0] = mod->tone[0];
                 ret->bank0[1] = module->tone[1];                  ret->bank0[1] = mod->tone[1];
                 ret->sampbuf = (SINT32 *)(ret + 1);                  ret->sampbuf = (SINT32 *)(ret + 1);
                 ret->resampbuf = (SAMPLE)(ret->sampbuf + worksize * 2);                  ret->resampbuf = (SAMPLE)(ret->sampbuf + worksize * 2);
                 allresetmidi(ret, FALSE);                  allresetmidi(ret, FALSE);
Line 750  VEXTERN MIDIHDL VEXPORT midiout_create(M Line 753  VEXTERN MIDIHDL VEXPORT midiout_create(M
   
 VEXTERN void VEXPORT midiout_destroy(MIDIHDL hdl) {  VEXTERN void VEXPORT midiout_destroy(MIDIHDL hdl) {
   
         MIDIMOD module;          MIDIMOD mod;
   
         if (hdl) {          if (hdl) {
                 module = hdl->module;                  mod = hdl->module;
                 _MFREE(hdl);                  _MFREE(hdl);
                 midimod_lock(module);                  midimod_lock(mod);
         }          }
 }  }
   
Line 1085  VEXTERN const SINT32 * VEXPORT midiout_g Line 1088  VEXTERN const SINT32 * VEXPORT midiout_g
         }          }
         buf = hdl->sampbuf;          buf = hdl->sampbuf;
         ZeroMemory(buf, size * 2 * sizeof(SINT32));          ZeroMemory(buf, size * 2 * sizeof(SINT32));
         v = hdl->voice;          v = VOICEHDLPTR(hdl);
         vterm = v + VOICE_MAX;          vterm = VOICEHDLEND(hdl);
         playing = FALSE;          playing = FALSE;
         do {          do {
                 if (v->phase != VOICE_FREE) {                  if (v->phase != VOICE_FREE) {
Line 1136  moget_err: Line 1139  moget_err:
         return(NULL);          return(NULL);
 }  }
   
   static UINT     VERMOUTHCL preparepcm(MIDIHDL hdl, UINT size)
   {
           UINT    step;
           VOICE   v;
           VOICE   vterm;
           SINT32  *buf;
           SAMPLE  src;
           SAMPLE  srcterm;
           UINT    cnt;
           UINT    pos;
           UINT    rem;
   
           step = min(size, hdl->worksize);
           buf = hdl->sampbuf;
           ZeroMemory(buf, step * 2 * sizeof(SINT32));
           v = VOICEHDLPTR(hdl);
           vterm = VOICEHDLEND(hdl);
           do {
                   if (v->phase != VOICE_FREE) {
                           cnt = step;
                           if (v->phase & VOICE_REL) {
                                   voice_setfree(v);
                                   if (cnt > REL_COUNT) {
                                           cnt = REL_COUNT;
                                   }
                           }
                           if (v->flag & VOICE_FIXPITCH) {
                                   pos = v->samppos >> FREQ_SHIFT;
                                   src = v->sample->data + pos;
                                   rem = (v->sample->datasize >> FREQ_SHIFT) - pos;
                                   if (cnt < rem) {
                                           v->samppos += cnt << FREQ_SHIFT;
                                           srcterm = src + cnt;
                                   }
                                   else {
                                           voice_setfree(v);
                                           srcterm = src + rem;
                                   }
                           }
                           else {
                                   src = hdl->resampbuf;
                                   srcterm = v->resamp(v, src, src + cnt);
                           }
                           if (src != srcterm) {
                                   v->mix(v, buf, src, srcterm);
                           }
                   }
                   v++;
           } while(v < vterm);
           return(step);
   }
   
 VEXTERN UINT VEXPORT midiout_get16(MIDIHDL hdl, SINT16 *pcm, UINT size) {  VEXTERN UINT VEXPORT midiout_get16(MIDIHDL hdl, SINT16 *pcm, UINT size) {
   
         UINT    step;          UINT    step;
Line 1156  VEXTERN UINT VEXPORT midiout_get16(MIDIH Line 1211  VEXTERN UINT VEXPORT midiout_get16(MIDIH
                         size -= step;                          size -= step;
                         buf = hdl->sampbuf;                          buf = hdl->sampbuf;
                         ZeroMemory(buf, step * 2 * sizeof(SINT32));                          ZeroMemory(buf, step * 2 * sizeof(SINT32));
                         v = hdl->voice;                          v = VOICEHDLPTR(hdl);
                         vterm = v + VOICE_MAX;                          vterm = VOICEHDLEND(hdl);
                         do {                          do {
                                 if (v->phase != VOICE_FREE) {                                  if (v->phase != VOICE_FREE) {
                                         cnt = step;                                          cnt = step;
Line 1230  VEXTERN UINT VEXPORT midiout_get32(MIDIH Line 1285  VEXTERN UINT VEXPORT midiout_get32(MIDIH
   
         if ((hdl != NULL) && (size)) {          if ((hdl != NULL) && (size)) {
                 do {                  do {
   
                         step = min(size, hdl->worksize);                          step = min(size, hdl->worksize);
                         size -= step;                          size -= step;
                         buf = hdl->sampbuf;                          buf = hdl->sampbuf;
                         ZeroMemory(buf, step * 2 * sizeof(SINT32));                          ZeroMemory(buf, step * 2 * sizeof(SINT32));
                         v = hdl->voice;                          v = VOICEHDLPTR(hdl);
                         vterm = v + VOICE_MAX;                          vterm = VOICEHDLEND(hdl);
                         do {                          do {
                                 if (v->phase != VOICE_FREE) {                                  if (v->phase != VOICE_FREE) {
                                         cnt = step;                                          cnt = step;
Line 1268  VEXTERN UINT VEXPORT midiout_get32(MIDIH Line 1324  VEXTERN UINT VEXPORT midiout_get32(MIDIH
                                 }                                  }
                                 v++;                                  v++;
                         } while(v < vterm);                          } while(v < vterm);
   
                         do {                          do {
                                 pcm[0] += buf[0] >> (SAMP_SHIFT + 1);                                  pcm[0] += buf[0] >> (SAMP_SHIFT + 1);
                                 pcm[1] += buf[1] >> (SAMP_SHIFT + 1);                                  pcm[1] += buf[1] >> (SAMP_SHIFT + 1);
Removed from v.1.16  
changed lines
  Added in v.1.17

RetroPC.NET-CVS <cvs@retropc.net>