00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "qwrk.h"
00021 #include <cmath>
00022 #include <QDataStream>
00023 #include <QFile>
00024 #include <QIODevice>
00025 #include <QTextStream>
00026 #include <QTextCodec>
00027 #include <QStringList>
00028
00034 namespace drumstick {
00035
00048 class QWrk::QWrkPrivate {
00049 public:
00050 QWrkPrivate():
00051 m_Now(0),
00052 m_From(0),
00053 m_Thru(11930),
00054 m_KeySig(0),
00055 m_Clock(0),
00056 m_AutoSave(0),
00057 m_PlayDelay(0),
00058 m_ZeroCtrls(false),
00059 m_SendSPP(true),
00060 m_SendCont(true),
00061 m_PatchSearch(false),
00062 m_AutoStop(false),
00063 m_StopTime(4294967295U),
00064 m_AutoRewind(false),
00065 m_RewindTime(0),
00066 m_MetroPlay(false),
00067 m_MetroRecord(true),
00068 m_MetroAccent(false),
00069 m_CountIn(1),
00070 m_ThruOn(true),
00071 m_AutoRestart(false),
00072 m_CurTempoOfs(1),
00073 m_TempoOfs1(32),
00074 m_TempoOfs2(64),
00075 m_TempoOfs3(128),
00076 m_PunchEnabled(false),
00077 m_PunchInTime(0),
00078 m_PunchOutTime(0),
00079 m_EndAllTime(0),
00080 m_division(120),
00081 m_codec(0),
00082 m_IOStream(0)
00083 { }
00084
00085 quint32 m_Now;
00086 quint32 m_From;
00087 quint32 m_Thru;
00088 quint8 m_KeySig;
00089 quint8 m_Clock;
00090 quint8 m_AutoSave;
00091 quint8 m_PlayDelay;
00092 bool m_ZeroCtrls;
00093 bool m_SendSPP;
00094 bool m_SendCont;
00095 bool m_PatchSearch;
00096 bool m_AutoStop;
00097 quint32 m_StopTime;
00098 bool m_AutoRewind;
00099 quint32 m_RewindTime;
00100 bool m_MetroPlay;
00101 bool m_MetroRecord;
00102 bool m_MetroAccent;
00103 quint8 m_CountIn;
00104 bool m_ThruOn;
00105 bool m_AutoRestart;
00106 quint8 m_CurTempoOfs;
00107 quint8 m_TempoOfs1;
00108 quint8 m_TempoOfs2;
00109 quint8 m_TempoOfs3;
00110 bool m_PunchEnabled;
00111 quint32 m_PunchInTime;
00112 quint32 m_PunchOutTime;
00113 quint32 m_EndAllTime;
00114
00115 int m_division;
00116 QTextCodec *m_codec;
00117 QDataStream *m_IOStream;
00118 QByteArray m_lastChunkData;
00119 QList<RecTempo> m_tempos;
00120 };
00121
00122 QWrk::QWrk(QObject * parent) :
00123 QObject(parent),
00124 d(new QWrkPrivate)
00125 { }
00126
00127 QWrk::~QWrk()
00128 {
00129 delete d;
00130 }
00131
00136 QTextCodec* QWrk::getTextCodec()
00137 {
00138 return d->m_codec;
00139 }
00140
00147 void QWrk::setTextCodec(QTextCodec *codec)
00148 {
00149 d->m_codec = codec;
00150 }
00151
00157 QByteArray QWrk::getLastChunkRawData() const
00158 {
00159 return d->m_lastChunkData;
00160 }
00161
00165 void QWrk::readRawData(int size)
00166 {
00167 d->m_lastChunkData = d->m_IOStream->device()->read(size);
00168 }
00169
00174 int QWrk::getNow() const
00175 {
00176 return d->m_Now;
00177 }
00178
00183 int QWrk::getFrom() const
00184 {
00185 return d->m_From;
00186 }
00187
00192 int QWrk::getThru() const
00193 {
00194 return d->m_Thru;
00195 }
00196
00201 int QWrk::getKeySig() const
00202 {
00203 return d->m_KeySig;
00204 }
00205
00210 int QWrk::getClock() const
00211 {
00212 return d->m_Clock;
00213 }
00214
00219 int QWrk::getAutoSave() const
00220 {
00221 return d->m_AutoSave;
00222 }
00223
00228 int QWrk::getPlayDelay() const
00229 {
00230 return d->m_PlayDelay;
00231 }
00232
00237 bool QWrk::getZeroCtrls() const
00238 {
00239 return d->m_ZeroCtrls;
00240 }
00241
00246 bool QWrk::getSendSPP() const
00247 {
00248 return d->m_SendSPP;
00249 }
00250
00255 bool QWrk::getSendCont() const
00256 {
00257 return d->m_SendCont;
00258 }
00259
00264 bool QWrk::getPatchSearch() const
00265 {
00266 return d->m_PatchSearch;
00267 }
00268
00273 bool QWrk::getAutoStop() const
00274 {
00275 return d->m_AutoStop;
00276 }
00277
00282 unsigned int QWrk::getStopTime() const
00283 {
00284 return d->m_StopTime;
00285 }
00286
00291 bool QWrk::getAutoRewind() const
00292 {
00293 return d->m_AutoRewind;
00294 }
00295
00300 int QWrk::getRewindTime() const
00301 {
00302 return d->m_RewindTime;
00303 }
00304
00309 bool QWrk::getMetroPlay() const
00310 {
00311 return d->m_MetroPlay;
00312 }
00313
00318 bool QWrk::getMetroRecord() const
00319 {
00320 return d->m_MetroRecord;
00321 }
00322
00327 bool QWrk::getMetroAccent() const
00328 {
00329 return d->m_MetroAccent;
00330 }
00331
00336 int QWrk::getCountIn() const
00337 {
00338 return d->m_CountIn;
00339 }
00340
00345 bool QWrk::getThruOn() const
00346 {
00347 return d->m_ThruOn;
00348 }
00349
00354 bool QWrk::getAutoRestart() const
00355 {
00356 return d->m_AutoRestart;
00357 }
00358
00363 int QWrk::getCurTempoOfs() const
00364 {
00365 return d->m_CurTempoOfs;
00366 }
00367
00382 int QWrk::getTempoOfs1() const
00383 {
00384 return d->m_TempoOfs1;
00385 }
00386
00401 int QWrk::getTempoOfs2() const
00402 {
00403 return d->m_TempoOfs2;
00404 }
00405
00420 int QWrk::getTempoOfs3() const
00421 {
00422 return d->m_TempoOfs3;
00423 }
00424
00429 bool QWrk::getPunchEnabled() const
00430 {
00431 return d->m_PunchEnabled;
00432 }
00433
00438 int QWrk::getPunchInTime() const
00439 {
00440 return d->m_PunchInTime;
00441 }
00442
00447 int QWrk::getPunchOutTime() const
00448 {
00449 return d->m_PunchOutTime;
00450 }
00451
00456 int QWrk::getEndAllTime() const
00457 {
00458 return d->m_EndAllTime;
00459 }
00460
00465 quint8 QWrk::readByte()
00466 {
00467 quint8 b = 0xff;
00468 if (!d->m_IOStream->atEnd())
00469 *d->m_IOStream >> b;
00470 return b;
00471 }
00472
00479 quint16 QWrk::to16bit(quint8 c1, quint8 c2)
00480 {
00481 quint16 value = (c1 << 8);
00482 value += c2;
00483 return value;
00484 }
00485
00494 quint32 QWrk::to32bit(quint8 c1, quint8 c2, quint8 c3, quint8 c4)
00495 {
00496 quint32 value = (c1 << 24);
00497 value += (c2 << 16);
00498 value += (c3 << 8);
00499 value += c4;
00500 return value;
00501 }
00502
00507 quint16 QWrk::read16bit()
00508 {
00509 quint8 c1, c2;
00510 c1 = readByte();
00511 c2 = readByte();
00512 return to16bit(c2, c1);
00513 }
00514
00519 quint32 QWrk::read24bit()
00520 {
00521 quint8 c1, c2, c3;
00522 c1 = readByte();
00523 c2 = readByte();
00524 c3 = readByte();
00525 return to32bit(0, c3, c2, c1);
00526 }
00527
00532 quint32 QWrk::read32bit()
00533 {
00534 quint8 c1, c2, c3, c4;
00535 c1 = readByte();
00536 c2 = readByte();
00537 c3 = readByte();
00538 c4 = readByte();
00539 return to32bit(c4, c3, c2, c1);
00540 }
00541
00546 QString QWrk::readString(int len)
00547 {
00548 QString s;
00549 if ( len > 0 ) {
00550 quint8 c = 0xff;
00551 QByteArray data;
00552 for ( int i = 0; i < len && c != 0; ++i ) {
00553 c = readByte();
00554 if ( c != 0)
00555 data += c;
00556 }
00557 if (d->m_codec == NULL)
00558 s = QString(data);
00559 else
00560 s = d->m_codec->toUnicode(data);
00561 }
00562 return s;
00563 }
00564
00569 QString QWrk::readVarString()
00570 {
00571 QString s;
00572 QByteArray data;
00573 quint8 b;
00574 do {
00575 b = readByte();
00576 if (b != 0)
00577 data += b;
00578 } while (b != 0);
00579 if (d->m_codec == NULL)
00580 s = QString(data);
00581 else
00582 s = d->m_codec->toUnicode(data);
00583 return s;
00584 }
00585
00590 long QWrk::getFilePos()
00591 {
00592 return d->m_IOStream->device()->pos();
00593 }
00594
00599 void QWrk::seek(qint64 pos)
00600 {
00601 d->m_IOStream->device()->seek(pos);
00602 }
00603
00608 bool QWrk::atEnd()
00609 {
00610 return d->m_IOStream->atEnd();
00611 }
00612
00617 void QWrk::readGap(int size)
00618 {
00619 if ( size > 0)
00620 seek( getFilePos() + size );
00621 }
00622
00627 void QWrk::readFromStream(QDataStream *stream)
00628 {
00629 d->m_IOStream = stream;
00630 wrkRead();
00631 }
00632
00637 void QWrk::readFromFile(const QString& fileName)
00638 {
00639 QFile file(fileName);
00640 file.open(QIODevice::ReadOnly);
00641 QDataStream ds(&file);
00642 readFromStream(&ds);
00643 file.close();
00644 }
00645
00646 void QWrk::processTrackChunk()
00647 {
00648 int namelen;
00649 QString name[2];
00650 int trackno;
00651 int channel;
00652 int pitch;
00653 int velocity;
00654 int port;
00655 bool selected;
00656 bool muted;
00657 bool loop;
00658
00659 trackno = read16bit();
00660 for(int i=0; i<2; ++i) {
00661 namelen = readByte();
00662 name[i] = readString(namelen);
00663 }
00664 channel = (qint8) readByte();
00665 pitch = readByte();
00666 velocity = readByte();
00667 port = readByte();
00668 quint8 flags = readByte();
00669 selected = ((flags & 1) != 0);
00670 muted = ((flags & 2) != 0);
00671 loop = ((flags & 4) != 0);
00672 Q_EMIT signalWRKTrack( name[0], name[1],
00673 trackno, channel, pitch,
00674 velocity, port, selected,
00675 muted, loop );
00676 }
00677
00678 void QWrk::processVarsChunk()
00679 {
00680 d->m_Now = read32bit();
00681 d->m_From = read32bit();
00682 d->m_Thru = read32bit();
00683 d->m_KeySig = readByte();
00684 d->m_Clock = readByte();
00685 d->m_AutoSave = readByte();
00686 d->m_PlayDelay = readByte();
00687 readGap(1);
00688 d->m_ZeroCtrls = (readByte() != 0);
00689 d->m_SendSPP = (readByte() != 0);
00690 d->m_SendCont = (readByte() != 0);
00691 d->m_PatchSearch = (readByte() != 0);
00692 d->m_AutoStop = (readByte() != 0);
00693 d->m_StopTime = read32bit();
00694 d->m_AutoRewind = (readByte() != 0);
00695 d->m_RewindTime = read32bit();
00696 d->m_MetroPlay = (readByte() != 0);
00697 d->m_MetroRecord = (readByte() != 0);
00698 d->m_MetroAccent = (readByte() != 0);
00699 d->m_CountIn = readByte();
00700 readGap(2);
00701 d->m_ThruOn = (readByte() != 0);
00702 readGap(19);
00703 d->m_AutoRestart = (readByte() != 0);
00704 d->m_CurTempoOfs = readByte();
00705 d->m_TempoOfs1 = readByte();
00706 d->m_TempoOfs2 = readByte();
00707 d->m_TempoOfs3 = readByte();
00708 readGap(2);
00709 d->m_PunchEnabled = (readByte() != 0);
00710 d->m_PunchInTime = read32bit();
00711 d->m_PunchOutTime = read32bit();
00712 d->m_EndAllTime = read32bit();
00713
00714 Q_EMIT signalWRKGlobalVars();
00715 }
00716
00717 void QWrk::processTimebaseChunk()
00718 {
00719 quint16 timebase = read16bit();
00720 d->m_division = timebase;
00721 Q_EMIT signalWRKTimeBase(timebase);
00722 }
00723
00724 void QWrk::processNoteArray(int track, int events)
00725 {
00726 quint32 time = 0;
00727 quint8 status = 0, data1 = 0, data2 = 0;
00728 quint16 dur = 0;
00729 int value = 0, type = 0, channel = 0, len = 0;
00730 QString text;
00731 QByteArray data;
00732 for ( int i = 0; i < events; ++i ) {
00733 time = read24bit();
00734 status = readByte();
00735 dur = 0;
00736 if (status >= 0x90) {
00737 type = status & 0xf0;
00738 channel = status & 0x0f;
00739 data1 = readByte();
00740 if (type == 0x90 || type == 0xA0 || type == 0xB0 || type == 0xE0)
00741 data2 = readByte();
00742 if (type == 0x90)
00743 dur = read16bit();
00744 switch (type) {
00745 case 0x90:
00746 Q_EMIT signalWRKNote(track, time, channel, data1, data2, dur);
00747 break;
00748 case 0xA0:
00749 Q_EMIT signalWRKKeyPress(track, time, channel, data1, data2);
00750 break;
00751 case 0xB0:
00752 Q_EMIT signalWRKCtlChange(track, time, channel, data1, data2);
00753 break;
00754 case 0xC0:
00755 Q_EMIT signalWRKProgram(track, time, channel, data1);
00756 break;
00757 case 0xD0:
00758 Q_EMIT signalWRKChanPress(track, time, channel, data1);
00759 break;
00760 case 0xE0:
00761 value = (data2 << 7) + data1 - 8192;
00762 Q_EMIT signalWRKPitchBend(track, time, channel, value);
00763 break;
00764 case 0xF0:
00765 Q_EMIT signalWRKSysexEvent(track, time, data1);
00766 break;
00767 }
00768 } else if (status == 5) {
00769 int code = read16bit();
00770 len = read32bit();
00771 text = readString(len);
00772 Q_EMIT signalWRKExpression(track, time, code, text);
00773 } else if (status == 6) {
00774 int code = read16bit();
00775 dur = read16bit();
00776 readGap(4);
00777 Q_EMIT signalWRKHairpin(track, time, code, dur);
00778 } else if (status == 7) {
00779 len = read32bit();
00780 text = readString(len);
00781 data.clear();
00782 for(int j=0; j<13; ++j) {
00783 int byte = readByte();
00784 data += byte;
00785 }
00786 Q_EMIT signalWRKChord(track, time, text, data);
00787 } else if (status == 8) {
00788 len = read16bit();
00789 data.clear();
00790 for(int j=0; j<len; ++j) {
00791 int byte = readByte();
00792 data += byte;
00793 }
00794 Q_EMIT signalWRKSysex(0, QString(), false, 0, data);
00795 } else {
00796 len = read32bit();
00797 text = readString(len);
00798 Q_EMIT signalWRKText(track, time, status, text);
00799 }
00800 }
00801 Q_EMIT signalWRKStreamEnd(time + dur);
00802 }
00803
00804 void QWrk::processStreamChunk()
00805 {
00806 long time = 0;
00807 int dur = 0, value = 0, type = 0, channel = 0;
00808 quint8 status = 0, data1 = 0, data2 = 0;
00809 quint16 track = read16bit();
00810 int events = read16bit();
00811 for ( int i = 0; i < events; ++i ) {
00812 time = read24bit();
00813 status = readByte();
00814 data1 = readByte();
00815 data2 = readByte();
00816 dur = read16bit();
00817 type = status & 0xf0;
00818 channel = status & 0x0f;
00819 switch (type) {
00820 case 0x90:
00821 Q_EMIT signalWRKNote(track, time, channel, data1, data2, dur);
00822 break;
00823 case 0xA0:
00824 Q_EMIT signalWRKKeyPress(track, time, channel, data1, data2);
00825 break;
00826 case 0xB0:
00827 Q_EMIT signalWRKCtlChange(track, time, channel, data1, data2);
00828 break;
00829 case 0xC0:
00830 Q_EMIT signalWRKProgram(track, time, channel, data1);
00831 break;
00832 case 0xD0:
00833 Q_EMIT signalWRKChanPress(track, time, channel, data1);
00834 break;
00835 case 0xE0:
00836 value = (data2 << 7) + data1 - 8192;
00837 Q_EMIT signalWRKPitchBend(track, time, channel, value);
00838 break;
00839 case 0xF0:
00840 Q_EMIT signalWRKSysexEvent(track, time, data1);
00841 break;
00842 }
00843 }
00844 Q_EMIT signalWRKStreamEnd(time + dur);
00845 }
00846
00847 void QWrk::processMeterChunk()
00848 {
00849 int count = read16bit();
00850 for (int i = 0; i < count; ++i) {
00851 readGap(4);
00852 int measure = read16bit();
00853 int num = readByte();
00854 int den = pow(2, readByte());
00855 readGap(4);
00856 Q_EMIT signalWRKTimeSig(measure, num, den);
00857 }
00858 }
00859
00860 void QWrk::processMeterKeyChunk()
00861 {
00862 int count = read16bit();
00863 for (int i = 0; i < count; ++i) {
00864 int measure = read16bit();
00865 int num = readByte();
00866 int den = pow(2, readByte());
00867 qint8 alt = readByte();
00868 Q_EMIT signalWRKTimeSig(measure, num, den);
00869 Q_EMIT signalWRKKeySig(measure, alt);
00870 }
00871 }
00872
00873 double QWrk::getRealTime(long ticks) const
00874 {
00875 double division = 1.0 * d->m_division;
00876 RecTempo last;
00877 last.time = 0;
00878 last.tempo = 100.0;
00879 last.seconds = 0.0;
00880 if (!d->m_tempos.isEmpty()) {
00881 foreach(const RecTempo& rec, d->m_tempos) {
00882 if (rec.time >= ticks)
00883 break;
00884 last = rec;
00885 }
00886 }
00887 return last.seconds + (((ticks - last.time) / division) * (60.0 / last.tempo));
00888 }
00889
00890 void QWrk::processTempoChunk(int factor)
00891 {
00892 double division = 1.0 * d->m_division;
00893 int count = read16bit();
00894 RecTempo last, next;
00895 for (int i = 0; i < count; ++i) {
00896
00897 long time = read32bit();
00898 readGap(4);
00899 long tempo = read16bit() * factor;
00900 readGap(8);
00901
00902 next.time = time;
00903 next.tempo = tempo / 100.0;
00904 next.seconds = 0.0;
00905 last.time = 0;
00906 last.tempo = next.tempo;
00907 last.seconds = 0.0;
00908 if (! d->m_tempos.isEmpty()) {
00909 foreach(const RecTempo& rec, d->m_tempos) {
00910 if (rec.time >= time)
00911 break;
00912 last = rec;
00913 }
00914 next.seconds = last.seconds +
00915 (((time - last.time) / division) * (60.0 / last.tempo));
00916 }
00917 d->m_tempos.append(next);
00918
00919 Q_EMIT signalWRKTempo(time, tempo);
00920 }
00921 }
00922
00923 void QWrk::processSysexChunk()
00924 {
00925 int j;
00926 QString name;
00927 QByteArray data;
00928 int bank = readByte();
00929 int length = read16bit();
00930 bool autosend = (readByte() != 0);
00931 int namelen = readByte();
00932 name = readString(namelen);
00933 for(j=0; j<length; ++j) {
00934 int byte = readByte();
00935 data += byte;
00936 }
00937 Q_EMIT signalWRKSysex(bank, name, autosend, 0, data);
00938 }
00939
00940 void QWrk::processSysex2Chunk()
00941 {
00942 int j;
00943 QString name;
00944 QByteArray data;
00945 int bank = read16bit();
00946 int length = read32bit();
00947 quint8 b = readByte();
00948 int port = ( b & 0xf0 ) >> 4;
00949 bool autosend = ( (b & 0x0f) != 0);
00950 int namelen = readByte();
00951 name = readString(namelen);
00952 for(j=0; j<length; ++j) {
00953 int byte = readByte();
00954 data += byte;
00955 }
00956 Q_EMIT signalWRKSysex(bank, name, autosend, port, data);
00957 }
00958
00959 void QWrk::processNewSysexChunk()
00960 {
00961 int j;
00962 QString name;
00963 QByteArray data;
00964 int bank = read16bit();
00965 int length = read32bit();
00966 int port = read16bit();
00967 bool autosend = (readByte() != 0);
00968 int namelen = readByte();
00969 name = readString(namelen);
00970 for(j=0; j<length; ++j) {
00971 int byte = readByte();
00972 data += byte;
00973 }
00974 Q_EMIT signalWRKSysex(bank, name, autosend, port, data);
00975 }
00976
00977 void QWrk::processThruChunk()
00978 {
00979 readGap(2);
00980 qint8 port = readByte();
00981 qint8 channel = readByte();
00982 qint8 keyPlus = readByte();
00983 qint8 velPlus = readByte();
00984 qint8 localPort = readByte();
00985 qint8 mode = readByte();
00986 Q_EMIT signalWRKThru(mode, port, channel, keyPlus, velPlus, localPort);
00987 }
00988
00989 void QWrk::processTrackOffset()
00990 {
00991 quint16 track = read16bit();
00992 qint16 offset = read16bit();
00993 Q_EMIT signalWRKTrackOffset(track, offset);
00994 }
00995
00996 void QWrk::processTrackReps()
00997 {
00998 quint16 track = read16bit();
00999 quint16 reps = read16bit();
01000 Q_EMIT signalWRKTrackReps(track, reps);
01001 }
01002
01003 void QWrk::processTrackPatch()
01004 {
01005 quint16 track = read16bit();
01006 qint8 patch = readByte();
01007 Q_EMIT signalWRKTrackPatch(track, patch);
01008 }
01009
01010 void QWrk::processTimeFormat()
01011 {
01012 quint16 fmt = read16bit();
01013 quint16 ofs = read16bit();
01014 Q_EMIT signalWRKTimeFormat(fmt, ofs);
01015 }
01016
01017 void QWrk::processComments()
01018 {
01019 int len = read16bit();
01020 QString text = readString(len);
01021 Q_EMIT signalWRKComments(text);
01022 }
01023
01024 void QWrk::processVariableRecord(int max)
01025 {
01026 int datalen = max - 32;
01027 QByteArray data;
01028 QString name = readVarString();
01029 readGap(31 - name.length());
01030 for ( int i = 0; i < datalen; ++i )
01031 data += readByte();
01032 Q_EMIT signalWRKVariableRecord(name, data);
01033 }
01034
01035 void QWrk::processUnknown(int id)
01036 {
01037 Q_EMIT signalWRKUnknownChunk(id, d->m_lastChunkData);
01038 }
01039
01040 void QWrk::processNewTrack()
01041 {
01042 qint16 bank = -1;
01043 qint16 patch = -1;
01044 qint16 vol = -1;
01045 qint16 pan = -1;
01046 qint8 key = -1;
01047 qint8 vel = 0;
01048 quint8 port = 0;
01049 qint8 channel = 0;
01050 bool selected = false;
01051 bool muted = false;
01052 bool loop = false;
01053 quint16 track = read16bit();
01054 quint8 len = readByte();
01055 QString name = readString(len);
01056 bank = read16bit();
01057 patch = read16bit();
01058 vol = read16bit();
01059 pan = read16bit();
01060 key = readByte();
01061 vel = readByte();
01062 readGap(7);
01063 port = readByte();
01064 channel = readByte();
01065 muted = (readByte() != 0);
01066 Q_EMIT signalWRKNewTrack(name, track, channel, key, vel, port, selected, muted, loop);
01067 if (bank > -1)
01068 Q_EMIT signalWRKTrackBank(track, bank);
01069 if (patch > -1) {
01070 if (channel > -1)
01071 Q_EMIT signalWRKProgram(track, 0, channel, patch);
01072 else
01073 Q_EMIT signalWRKTrackPatch(track, patch);
01074 }
01075 }
01076
01077 void QWrk::processSoftVer()
01078 {
01079 int len = readByte();
01080 QString vers = readString(len);
01081 Q_EMIT signalWRKSoftVer(vers);
01082 }
01083
01084 void QWrk::processTrackName()
01085 {
01086 int track = read16bit();
01087 int len = readByte();
01088 QString name = readString(len);
01089 Q_EMIT signalWRKTrackName(track, name);
01090 }
01091
01092 void QWrk::processStringTable()
01093 {
01094 QStringList table;
01095 int rows = read16bit();
01096 for (int i = 0; i < rows; ++i) {
01097 int len = readByte();
01098 QString name = readString(len);
01099 int idx = readByte();
01100 table.insert(idx, name);
01101 }
01102 Q_EMIT signalWRKStringTable(table);
01103 }
01104
01105 void QWrk::processLyricsStream()
01106 {
01107 quint16 track = read16bit();
01108 int events = read32bit();
01109 processNoteArray(track, events);
01110 }
01111
01112 void QWrk::processTrackVol()
01113 {
01114 quint16 track = read16bit();
01115 int vol = read16bit();
01116 Q_EMIT signalWRKTrackVol(track, vol);
01117 }
01118
01119 void QWrk::processNewTrackOffset()
01120 {
01121 quint16 track = read16bit();
01122 int offset = read32bit();
01123 Q_EMIT signalWRKTrackOffset(track, offset);
01124 }
01125
01126 void QWrk::processTrackBank()
01127 {
01128 quint16 track = read16bit();
01129 int bank = read16bit();
01130 Q_EMIT signalWRKTrackBank(track, bank);
01131 }
01132
01133 void QWrk::processSegmentChunk()
01134 {
01135 QString name;
01136 int track = read16bit();
01137 int offset = read32bit();
01138 readGap(8);
01139 int len = readByte();
01140 name = readString(len);
01141 readGap(20);
01142 Q_EMIT signalWRKSegment(track, offset, name);
01143 int events = read32bit();
01144 processNoteArray(track, events);
01145 }
01146
01147 void QWrk::processNewStream()
01148 {
01149 QString name;
01150 int track = read16bit();
01151 int len = readByte();
01152 name = readString(len);
01153 Q_EMIT signalWRKSegment(track, 0, name);
01154 int events = read32bit();
01155 processNoteArray(track, events);
01156 }
01157
01158 void QWrk::processEndChunk()
01159 {
01160 emit signalWRKEnd();
01161 }
01162
01163 int QWrk::readChunk()
01164 {
01165 long start_pos, final_pos;
01166 int ck_len, ck = readByte();
01167 if (ck != END_CHUNK) {
01168 ck_len = read32bit();
01169 start_pos = getFilePos();
01170 final_pos = start_pos + ck_len;
01171 readRawData(ck_len);
01172 seek(start_pos);
01173 switch (ck) {
01174 case TRACK_CHUNK:
01175 processTrackChunk();
01176 break;
01177 case VARS_CHUNK:
01178 processVarsChunk();
01179 break;
01180 case TIMEBASE_CHUNK:
01181 processTimebaseChunk();
01182 break;
01183 case STREAM_CHUNK:
01184 processStreamChunk();
01185 break;
01186 case METER_CHUNK:
01187 processMeterChunk();
01188 break;
01189 case TEMPO_CHUNK:
01190 processTempoChunk(100);
01191 break;
01192 case NTEMPO_CHUNK:
01193 processTempoChunk();
01194 break;
01195 case SYSEX_CHUNK:
01196 processSysexChunk();
01197 break;
01198 case THRU_CHUNK:
01199 processThruChunk();
01200 break;
01201 case TRKOFFS_CHUNK:
01202 processTrackOffset();
01203 break;
01204 case TRKREPS_CHUNK:
01205 processTrackReps();
01206 break;
01207 case TRKPATCH_CHUNK:
01208 processTrackPatch();
01209 break;
01210 case TIMEFMT_CHUNK:
01211 processTimeFormat();
01212 break;
01213 case COMMENTS_CHUNK:
01214 processComments();
01215 break;
01216 case VARIABLE_CHUNK:
01217 processVariableRecord(ck_len);
01218 break;
01219 case NTRACK_CHUNK:
01220 processNewTrack();
01221 break;
01222 case SOFTVER_CHUNK:
01223 processSoftVer();
01224 break;
01225 case TRKNAME_CHUNK:
01226 processTrackName();
01227 break;
01228 case STRTAB_CHUNK:
01229 processStringTable();
01230 break;
01231 case LYRICS_CHUNK:
01232 processLyricsStream();
01233 break;
01234 case TRKVOL_CHUNK:
01235 processTrackVol();
01236 break;
01237 case NTRKOFS_CHUNK:
01238 processNewTrackOffset();
01239 break;
01240 case TRKBANK_CHUNK:
01241 processTrackBank();
01242 break;
01243 case METERKEY_CHUNK:
01244 processMeterKeyChunk();
01245 break;
01246 case SYSEX2_CHUNK:
01247 processSysex2Chunk();
01248 break;
01249 case NSYSEX_CHUNK:
01250 processNewSysexChunk();
01251 break;
01252 case SGMNT_CHUNK:
01253 processSegmentChunk();
01254 break;
01255 case NSTREAM_CHUNK:
01256 processNewStream();
01257 break;
01258 default:
01259 processUnknown(ck);
01260 }
01261 seek(final_pos);
01262 }
01263 return ck;
01264 }
01265
01266 void QWrk::wrkRead()
01267 {
01268 int vma, vme;
01269 int ck_id;
01270 QByteArray hdr(HEADER.length(), ' ');
01271 d->m_tempos.clear();
01272 d->m_IOStream->device()->read(hdr.data(), HEADER.length());
01273 if (hdr == HEADER) {
01274 readGap(1);
01275 vme = readByte();
01276 vma = readByte();
01277 Q_EMIT signalWRKHeader(vma, vme);
01278 do {
01279 ck_id = readChunk();
01280 } while (ck_id != END_CHUNK);
01281 if (!atEnd())
01282 Q_EMIT signalWRKError("Corrupted file");
01283 else
01284 processEndChunk();
01285 } else
01286 Q_EMIT signalWRKError("Invalid file format");
01287 }
01288
01289 }