[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.17 and 1.18

version 1.17, 2006/12/16 22:23:24 version 1.18, 2006/12/17 17:53:24
Line 1066  VEXTERN void VEXPORT midiout_longmsg(MID Line 1066  VEXTERN void VEXPORT midiout_longmsg(MID
         }          }
 }  }
   
 VEXTERN const SINT32 * VEXPORT midiout_get(MIDIHDL hdl, UINT *samples) {  static UINT     VERMOUTHCL preparepcm(MIDIHDL hdl, UINT size) {
   
         UINT    size;          UINT    ret;
           SINT32  *buf;
         VOICE   v;          VOICE   v;
         VOICE   vterm;          VOICE   vterm;
         BOOL    playing;  
         SINT32  *buf;  
         SAMPLE  src;          SAMPLE  src;
         SAMPLE  srcterm;          SAMPLE  srcterm;
         UINT    cnt;          UINT    cnt;
         UINT    pos;          UINT    pos;
         UINT    rem;          UINT    rem;
   
         if ((hdl == NULL) || (samples == NULL)) {          ret = 0;
                 goto moget_err;          size = min(size, hdl->worksize);
         }  
         size = min(*samples, hdl->worksize);  
         if (size == 0) {  
                 goto moget_err;  
         }  
         buf = hdl->sampbuf;          buf = hdl->sampbuf;
         ZeroMemory(buf, size * 2 * sizeof(SINT32));          ZeroMemory(buf, size * 2 * sizeof(SINT32));
         v = VOICEHDLPTR(hdl);          v = VOICEHDLPTR(hdl);
         vterm = VOICEHDLEND(hdl);          vterm = VOICEHDLEND(hdl);
         playing = FALSE;  
         do {          do {
                 if (v->phase != VOICE_FREE) {                  if (v->phase != VOICE_FREE) {
                           ret = size;
                         cnt = size;                          cnt = size;
                         if (v->phase & VOICE_REL) {                          if (v->phase & VOICE_REL) {
                                 voice_setfree(v);                                  voice_setfree(v);
Line 1120  VEXTERN const SINT32 * VEXPORT midiout_g Line 1114  VEXTERN const SINT32 * VEXPORT midiout_g
                         if (src != srcterm) {                          if (src != srcterm) {
                                 v->mix(v, buf, src, srcterm);                                  v->mix(v, buf, src, srcterm);
                         }                          }
                         playing = TRUE;  
                 }                  }
                 v++;                  v++;
         } while(v < vterm);          } while(v < vterm);
           return(ret);
         if (playing) {  
                 *samples = size;  
                 pos = 0;  
                 do {  
                         buf[pos*2+0] >>= (SAMP_SHIFT + 1);  
                         buf[pos*2+1] >>= (SAMP_SHIFT + 1);  
                 } while(++pos < size);  
                 return(buf);  
         }  
   
 moget_err:  
         return(NULL);  
 }  }
   
 static UINT     VERMOUTHCL preparepcm(MIDIHDL hdl, UINT size)  VEXTERN const SINT32 * VEXPORT midiout_get(MIDIHDL hdl, UINT *samples) {
 {  
         UINT    step;          UINT    size;
         VOICE   v;  
         VOICE   vterm;  
         SINT32  *buf;          SINT32  *buf;
         SAMPLE  src;          SINT32  *bufterm;
         SAMPLE  srcterm;  
         UINT    cnt;          if ((hdl == NULL) || (samples == NULL)) {
         UINT    pos;                  goto moget_err;
         UINT    rem;          }
           size = *samples;
           if (size == 0) {
                   goto moget_err;
           }
           size = preparepcm(hdl, size);
           if (size == 0) {
                   goto moget_err;
           }
   
         step = min(size, hdl->worksize);          *samples = size;
         buf = hdl->sampbuf;          buf = hdl->sampbuf;
         ZeroMemory(buf, step * 2 * sizeof(SINT32));          bufterm = buf + (size * 2);
         v = VOICEHDLPTR(hdl);  
         vterm = VOICEHDLEND(hdl);  
         do {          do {
                 if (v->phase != VOICE_FREE) {                  buf[0] >>= (SAMP_SHIFT + 1);
                         cnt = step;                  buf[1] >>= (SAMP_SHIFT + 1);
                         if (v->phase & VOICE_REL) {                  buf += 2;
                                 voice_setfree(v);          } while(buf < bufterm);
                                 if (cnt > REL_COUNT) {          return(hdl->sampbuf);
                                         cnt = REL_COUNT;  
                                 }  moget_err:
                         }          return(NULL);
                         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;
         VOICE   v;  
         VOICE   vterm;  
         SINT32  *buf;          SINT32  *buf;
         SAMPLE  src;  
         SAMPLE  srcterm;  
         UINT    cnt;  
         UINT    pos;  
         UINT    rem;  
         SINT32  l;          SINT32  l;
         SINT32  r;          SINT32  r;
   
         if ((hdl != NULL) && (size)) {          if (hdl != NULL) {
                 do {                  while(size) {
                         step = min(size, hdl->worksize);                          step = preparepcm(hdl, size);
                           if (step == 0) {
                                   break;
                           }
                         size -= step;                          size -= step;
                         buf = hdl->sampbuf;                          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);  
                         do {                          do {
                                 l = pcm[0];                                  l = pcm[0];
                                 r = pcm[1];                                  r = pcm[1];
Line 1267  VEXTERN UINT VEXPORT midiout_get16(MIDIH Line 1189  VEXTERN UINT VEXPORT midiout_get16(MIDIH
                                 buf += 2;                                  buf += 2;
                                 pcm += 2;                                  pcm += 2;
                         } while(--step);                          } while(--step);
                 } while(size);                  }
         }          }
         return(0);}          return(0);
   }
   
 VEXTERN UINT VEXPORT midiout_get32(MIDIHDL hdl, SINT32 *pcm, UINT size) {  VEXTERN UINT VEXPORT midiout_get32(MIDIHDL hdl, SINT32 *pcm, UINT size) {
   
         UINT    step;          UINT    step;
         VOICE   v;  
         VOICE   vterm;  
         SINT32  *buf;          SINT32  *buf;
         SAMPLE  src;  
         SAMPLE  srcterm;  
         UINT    cnt;  
         UINT    pos;  
         UINT    rem;  
   
         if ((hdl != NULL) && (size)) {          if (hdl != NULL) {
                 do {                  while(size) {
                           step = preparepcm(hdl, size);
                         step = min(size, hdl->worksize);                          if (step == 0) {
                                   break;
                           }
                         size -= step;                          size -= step;
                         buf = hdl->sampbuf;                          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);  
   
                         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);
                                 buf += 2;                                  buf += 2;
                                 pcm += 2;                                  pcm += 2;
                         } while(--step);                          } while(--step);
                 } while(size);                  }
         }          }
         return(0);          return(0);
 }  }
Removed from v.1.17  
changed lines
  Added in v.1.18

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