TDE
/
tdelibs
7
1
Fork 0
Code Issues 16 Pull Requests 8 Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '4f99f868f0'
${ noResults }
tdelibs/libtdemid/player.cpp

960 lines
22 KiB
Raw Blame History

/**************************************************************************
player.cpp - class MidiPlayer. Plays a set of tracks
This file is part of LibKMid 0.9.5
Copyright (C) 1997,98,99,2000 Antonio Larrosa Jimenez
LibKMid's homepage : http://www.arrakis.es/~rlarrosa/libtdemid.html
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
$Id$
Send comments and bug fixes to Antonio Larrosa <larrosa@kde.org>
***************************************************************************/
#include "player.h"
#include "sndcard.h"
#include "midispec.h"
#include <string.h>
#include <unistd.h>
#include <sys/time.h>
#include "midistat.h"
#include "mt32togm.h"
//#define PLAYERDEBUG
//#define GENERAL_DEBUG_MESSAGES
#define T2MS(ticks) (((double)ticks)*(double)60000L)/((double)tempoToMetronomeTempo(tempo)*(double)info->ticksPerCuarterNote)
#define MS2T(ms) (((ms)*(double)tempoToMetronomeTempo(tempo)*(double)info->ticksPerCuarterNote)/((double)60000L))
#define REMOVEDUPSTRINGS
MidiPlayer::MidiPlayer(DeviceManager *midi_,PlayerController *pctl)
{
midi=midi_;
info=NULL;
tracks=NULL;
songLoaded=0;
ctl=pctl;
spev=NULL;
na=NULL;
parsesong=true;
generatebeats=false;
}
MidiPlayer::~MidiPlayer()
{
removeSpecialEvents();
removeSong();
}
void MidiPlayer::removeSong(void)
{
if ((songLoaded)&&(tracks!=NULL))
{
#ifdef PLAYERDEBUG
printf("Removing song from memory\n");
#endif
int i=0;
while (i<info->ntracks)
{
if (tracks[i]!=NULL) delete tracks[i];
i++;
}
delete tracks;
tracks=NULL;
if (info!=NULL)
{
delete info;
info=NULL;
}
}
songLoaded=0;
}
int MidiPlayer::loadSong(const char *filename)
{
removeSong();
#ifdef PLAYERDEBUG
printf("Loading Song : %s\n",filename);
#endif
info=new MidiFileInfo;
int ok;
tracks=readMidiFile(filename,info,ok);
if (ok<0) return ok;
if (tracks==NULL) return -4;
parseInfoData(info,tracks,ctl->ratioTempo);
if (parsesong)
{
parseSpecialEvents();
if (generatebeats) generateBeats();
}
songLoaded=1;
return 0;
}
void MidiPlayer::insertBeat(SpecialEvent *ev,ulong ms,int num,int den)
{
SpecialEvent *beat=new SpecialEvent;
beat->next=ev->next;
ev->next=beat;
beat->id=1;
beat->type=7;
beat->absmilliseconds=ms;
beat->num=num;
beat->den=den;
}
void MidiPlayer::generateBeats(void)
{
#ifdef PLAYERDEBUG
printf("player::Generating Beats...\n");
#endif
if (spev==NULL) return;
SpecialEvent *ev=spev;
SpecialEvent *nextev=ev->next;
ulong tempo=(ulong)(500000 * ctl->ratioTempo);
int i=1;
int num=4;
int den=4;
// ulong beatstep=((double)tempo*4/(den*1000));
// ulong beatstep=T2MS(info->ticksPerCuarterNote*(4/den));
double ticksleft=(((double)info->ticksPerCuarterNote*4)/den);
double beatstep=T2MS(ticksleft);
double nextbeatms=0;
double lastbeatms=0;
double measurems=0;
while (nextev!=NULL)
{
switch (ev->type)
{
case (0): // End of list
{
};break;
case (1): // Text
case (2): // Lyrics
{
};break;
case (3): // Change Tempo
{
lastbeatms=ev->absmilliseconds;
ticksleft=MS2T(nextbeatms-lastbeatms);
tempo=ev->tempo;
nextbeatms=lastbeatms+T2MS(ticksleft);
// printf("Change at %lu to %d\n",ev->absmilliseconds,ev->tempo);
// beatstep=((double)tempo*4/(den*1000));
beatstep=T2MS(((static_cast<double>(info->ticksPerCuarterNote)*4)/den));
};break;
case (6): // Change number of beats per measure
{
num=ev->num;
i=1;
den=ev->den;
// printf("Change at %lu to %d/%d\n",ev->absmilliseconds,num,den);
// beatstep=((double)tempo*4/(den*1000));
// beatstep=T2MS(info->ticksPerCuarterNote*(4/den));
beatstep=T2MS((((double)info->ticksPerCuarterNote*4)/den));
nextbeatms=ev->absmilliseconds;
};break;
};
if (nextev->absmilliseconds>nextbeatms)
{
//printf("Adding %d,%d\n",num,tot);
//printf("beat at %g , %d/%d\n",nextbeatms,i,num);
//printf(" %ld %d\n",nextev->absmilliseconds,nextev->type);
if (i == 1) {
measurems=nextbeatms;
}
insertBeat(ev, static_cast<unsigned long>(nextbeatms), i++, num);
if (i > num) {
i=1;
}
lastbeatms=nextbeatms;
nextbeatms+=beatstep;
// nextbeatms=measurems+beatstep*i;
ticksleft = ( (static_cast<double>(info->ticksPerCuarterNote)*4) / den);
}
ev=ev->next;
nextev=ev->next;
}
/* ev==NULL doesn't indicate the end of the song, so continue generating beats */
if (ev!=NULL)
{
if (ev->type==0)
{
ev=spev;
/* Looking if ev->next is NULL is not needed because
we are sure that a ev->type == 0 exists, we just have
to assure that the first spev is not the only one */
if (ev->next!=NULL)
while (ev->next->type!=0) ev=ev->next;
}
while (nextbeatms<info->millisecsTotal)
{
// printf("beat2 at %g , %d/%d\n",nextbeatms,i,num);
if (i==1) measurems=nextbeatms;
insertBeat(ev, static_cast<unsigned long>(nextbeatms), i++, num);
if (i>num) i=1;
nextbeatms+=beatstep;
ev=ev->next;
}
}
/* Regenerate IDs */
ev=spev;
i=1;
while (ev!=NULL)
{
ev->id=i++;
ev=ev->next;
}
#ifdef PLAYERDEBUG
printf("player::Beats Generated\n");
#endif
}
void MidiPlayer::removeSpecialEvents(void)
{
SpecialEvent * ev=spev;
while (spev!=NULL)
{
ev=spev->next;
delete spev;
spev=ev;
}
delete na;
na=0;
}
void MidiPlayer::parseSpecialEvents(void)
{
#ifdef PLAYERDEBUG
printf("player::Parsing...\n");
#endif
removeSpecialEvents();
spev=new SpecialEvent;
if (spev==NULL) return;
SpecialEvent *pspev=spev;
pspev->type=0;
pspev->ticks=0;
if (na) delete na;
na=new NoteArray();
if (!na) { delete spev; spev=0L; return; };
int trk;
int minTrk;
double minTime=0;
double maxTime;
ulong tempo=(ulong)(500000 * (ctl->ratioTempo));
ulong firsttempo=0;
for (int i=0;i<info->ntracks;i++)
{
tracks[i]->init();
tracks[i]->changeTempo(tempo);
}
MidiEvent *ev=new MidiEvent;
//ulong mspass;
double prevms=0;
int spev_id=1;
int j;
int parsing=1;
#ifdef REMOVEDUPSTRINGS
char lasttext[1024];
ulong lasttexttime=0;
lasttext[0]=0;
int lasttexttype=0;
#endif
while (parsing)
{
prevms=minTime;
trk=0;
minTrk=0;
maxTime=minTime + 2 * 60000L;
minTime=maxTime;
parsing=0;
while (trk<info->ntracks)
{
if (tracks[trk]->absMsOfNextEvent()<minTime)
{
minTrk=trk;
minTime=tracks[minTrk]->absMsOfNextEvent();
parsing=1;
}
trk++;
}
// if ((minTime==maxTime))
if (parsing==0)
{
// parsing=0;
#ifdef PLAYERDEBUG
printf("END of parsing\n");
#endif
}
else
{
// mspass=(ulong)(minTime-prevms);
trk=0;
while (trk<info->ntracks)
{
tracks[trk]->currentMs(minTime);
trk++;
}
}
trk=minTrk;
tracks[trk]->readEvent(ev);
switch (ev->command)
{
case (MIDI_NOTEON) :
if (ev->vel==0) na->add((ulong)minTime,ev->chn,0, ev->note);
else na->add((ulong)minTime,ev->chn,1,ev->note);
break;
case (MIDI_NOTEOFF) :
na->add((ulong)minTime,ev->chn,0, ev->note);
break;
case (MIDI_PGM_CHANGE) :
na->add((ulong)minTime,ev->chn, 2,ev->patch);
break;
case (MIDI_SYSTEM_PREFIX) :
{
if ((ev->command|ev->chn)==META_EVENT)
{
switch (ev->d1)
{
case (1) :
case (5) :
{
if (pspev!=NULL)
{
pspev->absmilliseconds=(ulong)minTime;
pspev->type=ev->d1;
pspev->id=spev_id++;
#ifdef PLAYERDEBUG
printf("ev->length %ld\n",ev->length);
#endif
strncpy(pspev->text,(char *)ev->data,
(ev->length>= sizeof(lasttext))? sizeof(lasttext)-1 : (ev->length) );
pspev->text[(ev->length>= sizeof(lasttext))? sizeof(lasttext)-1:(ev->length)]=0;
#ifdef PLAYERDEBUG
printf("(%s)(%s)\n",pspev->text,lasttext);
#endif
#ifdef REMOVEDUPSTRINGS
if ((strcmp(pspev->text,lasttext)!=0)||(pspev->absmilliseconds!=lasttexttime)||(pspev->type!=lasttexttype))
{
lasttexttime=pspev->absmilliseconds;
lasttexttype=pspev->type;
strncpy(lasttext, pspev->text, 1024);
lasttext[sizeof(lasttext)-1] = 0;
#endif
pspev->next=new SpecialEvent;
#ifdef PLAYERDEBUG
if (pspev->next==NULL) printf("pspev->next=NULL\n");
#endif
pspev=pspev->next;
#ifdef REMOVEDUPSTRINGS
}
#endif
}
}
break;
case (ME_SET_TEMPO) :
{
if (pspev!=NULL)
{
pspev->absmilliseconds=(ulong)minTime;
pspev->type=3;
pspev->id=spev_id++;
tempo=(ulong)(((ev->data[0]<<16)|(ev->data[1]<<8)|(ev->data[2])) * ctl->ratioTempo);
pspev->tempo=tempo;
if (firsttempo==0) firsttempo=tempo;
for (j=0;j<info->ntracks;j++)
{
tracks[j]->changeTempo(tempo);
}
pspev->next=new SpecialEvent;
pspev=pspev->next;
}
}
break;
case (ME_TIME_SIGNATURE) :
{
if (pspev!=NULL)
{
pspev->absmilliseconds=(ulong)minTime;
pspev->type=6;
pspev->id=spev_id++;
pspev->num=ev->d2;
pspev->den=ev->d3;
pspev->next=new SpecialEvent;
pspev=pspev->next;
}
}
break;
}
}
}
break;
}
}
delete ev;
pspev->type=0;
pspev->absmilliseconds=(ulong)prevms;
pspev->next=NULL;
if (firsttempo==0) firsttempo=tempo;
ctl->tempo=firsttempo;
//writeSPEV();
for (int i=0;i<info->ntracks;i++)
{
tracks[i]->init();
}
}
/*
NoteArray *MidiPlayer::parseNotes(void)
{
#ifdef PLAYERDEBUG
printf("player::Parsing Notes...\n");
#endif
NoteArray *na=new NoteArray();
int trk;
int minTrk;
double minTime=0;
double maxTime;
for (int i=0;i<info->ntracks;i++)
{
tracks[i]->init();
};
ulong tempo=1000000;
ulong tmp;
Midi_event *ev=new Midi_event;
//ulong mspass;
double prevms=0;
int j;
int parsing=1;
while (parsing)
{
prevms=minTime;
trk=0;
minTrk=0;
maxTime=minTime + 2 * 60000L;
minTime=maxTime;
while (trk<info->ntracks)
{
if (tracks[trk]->absMsOfNextEvent()<minTime)
{
minTrk=trk;
minTime=tracks[minTrk]->absMsOfNextEvent();
};
trk++;
};
if ((minTime==maxTime))
{
parsing=0;
#ifdef PLAYERDEBUG
printf("END of parsing\n");
#endif
}
else
{
// mspass=(ulong)(minTime-prevms);
trk=0;
while (trk<info->ntracks)
{
tracks[trk]->currentMs(minTime);
trk++;
};
};
trk=minTrk;
tracks[trk]->readEvent(ev);
if (ev->command==MIDI_NOTEON)
{
if (ev->vel==0) {printf("note off at %g\n",minTime);na->add((ulong)minTime,ev->chn,0, ev->note);}
else {printf("note on at %g\n",minTime);na->add((ulong)minTime,ev->chn,1,ev->note);}
}
else
if (ev->command==MIDI_NOTEOFF) na->add((ulong)minTime,ev->chn,0, ev->note);
if (ev->command==MIDI_PGM_CHANGE) na->add((ulong)minTime,ev->chn, 2,ev->patch);
if (ev->command==MIDI_SYSTEM_PREFIX)
{
if (((ev->command|ev->chn)==META_EVENT)&&(ev->d1==ME_SET_TEMPO))
{
tempo=(ev->data[0]<<16)|(ev->data[1]<<8)|(ev->data[2]);
for (j=0;j<info->ntracks;j++)
{
tracks[j]->changeTempo(tempo);
};
};
};
};
delete ev;
for (int i=0;i<info->ntracks;i++)
{
tracks[i]->init();
};
return na;
};
*/
void MidiPlayer::play(bool calloutput,void output(void))
{
#ifdef PLAYERDEBUG
printf("Playing...\n");
#endif
if (midi->midiPorts()+midi->synthDevices()==0)
{
fprintf(stderr,"Player :: There are no midi ports !\n");
ctl->error=1;
return;
}
midi->openDev();
if (midi->ok()==0)
{
fprintf(stderr,"Player :: Couldn't play !\n");
ctl->error=1;
return;
}
midi->setVolumePercentage(ctl->volumepercentage);
midi->initDev();
// parsePatchesUsed(tracks,info,ctl->gm);
midi->setPatchesToUse(info->patchesUsed);
int trk;
int minTrk;
double minTime=0;
double maxTime;
int i;
ulong tempo=(ulong)(500000 * ctl->ratioTempo);
for (i=0;i<info->ntracks;i++)
{
tracks[i]->init();
tracks[i]->changeTempo(tempo);
}
midi->tmrStart(info->ticksPerCuarterNote);
MidiEvent *ev=new MidiEvent;
ctl->ev=ev;
ctl->ticksTotal=info->ticksTotal;
ctl->ticksPlayed=0;
//ctl->millisecsPlayed=0;
ulong ticksplayed=0;
double absTimeAtChangeTempo=0;
double absTime=0;
double diffTime=0;
MidiStatus *midistat;
//ulong mspass;
double prevms=0;
int j;
int halt=0;
ctl->tempo=tempo;
ctl->num=4;
ctl->den=4;
int playing;
ctl->paused=0;
if ((ctl->message!=0)&&(ctl->message & PLAYER_SETPOS))
{
ctl->moving=1;
ctl->message&=~PLAYER_SETPOS;
midi->sync(1);
midi->tmrStop();
midi->closeDev();
midistat = new MidiStatus();
setPos(ctl->gotomsec,midistat);
minTime=ctl->gotomsec;
prevms=(ulong)minTime;
midi->openDev();
midi->tmrStart(info->ticksPerCuarterNote);
diffTime=ctl->gotomsec;
midistat->sendData(midi,ctl->gm);
delete midistat;
midi->setPatchesToUse(info->patchesUsed);
ctl->moving=0;
} else
for (i=0;i<16;i++)
{
if (ctl->forcepgm[i])
{
midi->chnPatchChange(i, ctl->pgm[i]);
}
}
timeval begintv;
gettimeofday(&begintv, NULL);
ctl->beginmillisec=begintv.tv_sec*1000+begintv.tv_usec/1000;
ctl->OK=1;
ctl->playing=playing=1;
while (playing)
{
/*
if (ctl->message!=0)
{
if (ctl->message & PLAYER_DOPAUSE)
{
diffTime=minTime;
ctl->message&=~PLAYER_DOPAUSE;
midi->sync(1);
midi->tmrStop();
ctl->paused=1;
midi->closeDev();
while ((ctl->paused)&&(!(ctl->message&PLAYER_DOSTOP))
&&(!(ctl->message&PLAYER_HALT))) sleep(1);
midi->openDev();
midi->tmrStart();
ctl->OK=1;
printf("Continue playing ... \n");
};
if (ctl->message & PLAYER_DOSTOP)
{
ctl->message&=~PLAYER_DOSTOP;
playing=0;
};
if (ctl->message & PLAYER_HALT)
{
ctl->message&=~PLAYER_HALT;
playing=0;
halt=1;
};
if (ctl->message & PLAYER_SETPOS)
{
ctl->moving=1;
ctl->message&=~PLAYER_SETPOS;
midi->sync(1);
midi->tmrStop();
midi->closeDev();
midistat = new midiStat();
SetPos(ctl->gotomsec,midistat);
minTime=ctl->gotomsec;
prevms=(ulong)minTime;
midi->openDev();
midi->tmrStart();
diffTime=ctl->gotomsec;
ctl->moving=0;
midistat->sendData(midi,ctl->gm);
delete midistat;
ctl->OK=1;
while (ctl->OK==1) ;
ctl->moving=0;
};
};
*/
prevms=minTime;
// ctl->millisecsPlayed=minTime;
trk=0;
minTrk=0;
maxTime=minTime + 120000L /* milliseconds */;
minTime=maxTime;
playing=0;
while (trk<info->ntracks)
{
if (tracks[trk]->absMsOfNextEvent()<minTime)
{
minTrk=trk;
minTime=tracks[minTrk]->absMsOfNextEvent();
playing=1;
}
trk++;
}
#ifdef PLAYERDEBUG
printf("minTime %g\n",minTime);
#endif
// if ((minTime==maxTime)/* || (minTicks> 60000L)*/)
if (playing==0)
{
// playing=0;
#ifdef PLAYERDEBUG
printf("END of playing\n");
#endif
}
else
{
// mspass=(ulong)(minTime-prevms);
trk=0;
while (trk<info->ntracks)
{
tracks[trk]->currentMs(minTime);
trk++;
}
midi->wait(minTime-diffTime);
}
trk=minTrk;
tracks[trk]->readEvent(ev);
switch (ev->command)
{
case (MIDI_NOTEON) :
midi->noteOn(ev->chn, ev->note, ev->vel);break;
case (MIDI_NOTEOFF):
midi->noteOff(ev->chn, ev->note, ev->vel);break;
case (MIDI_KEY_PRESSURE) :
midi->keyPressure(ev->chn, ev->note,ev->vel);break;
case (MIDI_PGM_CHANGE) :
if (!ctl->forcepgm[ev->chn])
midi->chnPatchChange(ev->chn, (ctl->gm==1)?(ev->patch):(MT32toGM[ev->patch]));break;
case (MIDI_CHN_PRESSURE) :
midi->chnPressure(ev->chn, ev->vel);break;
case (MIDI_PITCH_BEND) :
midi->chnPitchBender(ev->chn, ev->d1,ev->d2);break;
case (MIDI_CTL_CHANGE) :
midi->chnController(ev->chn, ev->ctl,ev->d1);break;
case (MIDI_SYSTEM_PREFIX) :
if ((ev->command|ev->chn)==META_EVENT)
{
if ((ev->d1==5)||(ev->d1==1))
{
ctl->SPEVplayed++;
}
if (ev->d1==ME_SET_TEMPO)
{
absTimeAtChangeTempo=absTime;
ticksplayed=0;
ctl->SPEVplayed++;
tempo=(ulong)(((ev->data[0]<<16)|(ev->data[1]<<8)|(ev->data[2]))*ctl->ratioTempo);
#ifdef PLAYERDEBUG
printf("Tempo : %ld %g (ratio : %g)\n",tempo,tempoToMetronomeTempo(tempo),ctl->ratioTempo);
#endif
midi->tmrSetTempo((int)tempoToMetronomeTempo(tempo));
ctl->tempo=tempo;
for (j=0;j<info->ntracks;j++)
{
tracks[j]->changeTempo(tempo);
}
}
if (ev->d1==ME_TIME_SIGNATURE)
{
ctl->num=ev->d2;
ctl->den=ev->d3;
ctl->SPEVplayed++;
}
}
break;
}
if (calloutput)
{
midi->sync();
output();
}
}
ctl->ev=NULL;
delete ev;
#ifdef PLAYERDEBUG
printf("Syncronizing ...\n");
#endif
if (halt)
midi->sync(1);
else
midi->sync();
#ifdef PLAYERDEBUG
printf("Closing device ...\n");
#endif
midi->allNotesOff();
midi->closeDev();
ctl->playing=0;
#ifdef PLAYERDEBUG
printf("Bye...\n");
#endif
ctl->OK=1;
ctl->finished=1;
}
void MidiPlayer::setPos(ulong gotomsec,MidiStatus *midistat)
{
int trk,minTrk;
ulong tempo=(ulong)(500000 * ctl->ratioTempo);
double minTime=0,maxTime,prevms=0;
int i,j,likeplaying=1;
MidiEvent *ev=new MidiEvent;
ctl->SPEVplayed=0;
for (i=0;i<info->ntracks;i++)
{
tracks[i]->init();
tracks[i]->changeTempo(tempo);
}
for (i=0;i<16;i++)
{
if (ctl->forcepgm[i]) midistat->chnPatchChange(i, ctl->pgm[i]);
}
while (likeplaying)
{
trk=0;
minTrk=0;
maxTime=minTime + 120000L; /*milliseconds (2 minutes)*/
minTime=maxTime;
while (trk<info->ntracks)
{
if (tracks[trk]->absMsOfNextEvent()<minTime)
{
minTrk=trk;
minTime=tracks[minTrk]->absMsOfNextEvent();
}
trk++;
}
if (minTime==maxTime)
{
likeplaying=0;
#ifdef GENERAL_DEBUG_MESSAGES
printf("END of likeplaying\n");
#endif
}
else
{
if (minTime>=gotomsec)
{
prevms=gotomsec;
likeplaying=0;
#ifdef GENERAL_DEBUG_MESSAGES
printf("Position reached !! \n");
#endif
minTime=gotomsec;
}
else
{
prevms=minTime;
}
trk=0;
while (trk<info->ntracks)
{
tracks[trk]->currentMs(minTime);
trk++;
}
}
if (likeplaying)
{
trk=minTrk;
tracks[trk]->readEvent(ev);
switch (ev->command)
{
/* case (MIDI_NOTEON) :
midistat->noteOn(ev->chn, ev->note, ev->vel);break;
case (MIDI_NOTEOFF):
midistat->noteOff(ev->chn, ev->note, ev->vel);break;
case (MIDI_KEY_PRESSURE) :
midistat->keyPressure(ev->chn, ev->note,ev->vel);break;
*/
case (MIDI_PGM_CHANGE) :
if (!ctl->forcepgm[ev->chn]) midistat->chnPatchChange(ev->chn, ev->patch);break;
case (MIDI_CHN_PRESSURE) :
midistat->chnPressure(ev->chn, ev->vel);break;
case (MIDI_PITCH_BEND) :
midistat->chnPitchBender(ev->chn, ev->d1,ev->d2);break;
case (MIDI_CTL_CHANGE) :
midistat->chnController(ev->chn, ev->ctl,ev->d1);break;
case (MIDI_SYSTEM_PREFIX) :
if ((ev->command|ev->chn)==META_EVENT)
{
if ((ev->d1==5)||(ev->d1==1))
{
ctl->SPEVplayed++;
}
if (ev->d1==ME_SET_TEMPO)
{
ctl->SPEVplayed++;
tempo=(ulong)(((ev->data[0]<<16)|(ev->data[1]<<8)|(ev->data[2]))*ctl->ratioTempo);
midistat->tmrSetTempo((int)tempoToMetronomeTempo(tempo));
for (j=0;j<info->ntracks;j++)
{
tracks[j]->changeTempo(tempo);
}
}
if (ev->d1==ME_TIME_SIGNATURE)
{
ctl->num=ev->d2;
ctl->den=ev->d3;
ctl->SPEVplayed++;
}
}
break;
}
}
}
delete ev;
ctl->tempo=tempo;
}
void MidiPlayer::debugSpecialEvents(void)
{
SpecialEvent *pspev=spev;
printf("**************************************\n");
while ((pspev!=NULL)&&(pspev->type!=0))
{
printf("t:%d ticks:%d diff:%ld abs:%ld s:%s tempo:%ld\n",pspev->type,pspev->ticks,pspev->diffmilliseconds,pspev->absmilliseconds,pspev->text,pspev->tempo);
pspev=pspev->next;
}
}
void MidiPlayer::setParseSong(bool b)
{
parsesong=b;
}
void MidiPlayer::setGenerateBeats(bool b)
{
generatebeats=b;
}
void MidiPlayer::setTempoRatio(double ratio)
{
if (songLoaded)
{
ctl->ratioTempo=ratio;
parseInfoData(info,tracks,ctl->ratioTempo);
if (parsesong)
{
parseSpecialEvents();
if (generatebeats) generateBeats();
}
}
else
{
ctl->tempo=(ulong)((ctl->tempo*ctl->ratioTempo)/ratio);
ctl->ratioTempo=ratio;
}
}
#undef T2MS
#undef MS2T
Reference in new issue View Git Blame Copy Permalink