【文件结构】MIDI文件的结构和完整的读取方法

0xAA55

原帖：http://www.0xaa55.com/thread-717-1-1.html
转载请注明出处。

MIDI文件是一种多媒体音乐文件。不同于别的音乐文件，MIDI文件只记录曲谱。播放的时候，软件会读取MIDI文件的内容，然后把曲谱发送给声卡，由声卡模拟发音。相对于留声机原理的音乐文件（MP3、OGG、AMR、WAV、FLAC、AAC等），这种记录曲谱的文件更小，更容易创作。缺点是因为声音是软件模拟发出的，音质不能得到保证，而且不同的声卡有不同的发音效果，因此MIDI文件的播放效果不能得到保证。不过为此，微软提供了软波表合成器，使用微软的软波表可以实现MIDI文件效果的统一。

著名的游戏《恶魔之星III》（俗称“雷电3”）的背景音乐就是用MIDI音乐播放的效果。微软DirectX的组件DirectMusic就能用于播放MIDI音乐。

MIDI文件大体上分两个部分：文件头和音轨。
文件头由14个字节组成。开头是文件标识“MThd”，之后是一个Big-Endian存储的DWORD，值通常为6。这个值的意义是“文件头的信息所占字节数”，也就是文件头接下来6个字节的字节数（就是6了嘛）。之后的6个字节，其实是3个Big-Endian存储的WORD，分别是类型字，音轨数，每四分音符的Tick数。类型字有三个值：0表示这个文件只有一个音轨，1表示这个文件有多个音轨，播放的时候要同步播放所有音轨，2表示这个文件虽然有多个音轨，但是播放的时候必须一个音轨一个音轨的播放。
用一个结构体来描述MIDI文件头的结构：

1. typedef struct
   
2. {
   
3.     DWORD   dwFlag;             //MThd标识
   
4.     DWORD   dwRestLen;          //剩余部分长度
   
5.     WORD    wType;              //类型
   
6.     WORD    wNbTracks;          //音轨数
   
7.     WORD    wTicksPerCrotchet;  //每四分音符的Tick数
   
8. }MIDIHeader;

复制代码

以上就是文件头了。然后就是文件的重要部分：文件内容了。
文件内容由多个音轨组成，每个音轨的开头都是这样的结构：4字节的音轨标识"MTrk"，4字节以Big-Endian存储的音轨字节数。如下所示：

1. typedef struct
   
2. {
   
3.     DWORD   dwFlag;     //为0x6B72544D，即"MTrk"
   
4.     DWORD   dwTrackLen; //音轨长度（除去音轨头部以外的字节数）(Big-Endian)
   
5. }MIDITrack;

复制代码

其中dwTrackLen的值，是整个音轨的字节数减去音轨头部的8个字节。
每个音轨，除去音轨头部以外，剩下的就是主要的文件内容了。在介绍文件内容以前，我觉得有必要科普一下MIDI文件所用的“动态字节”是怎么回事。
首先这个动态字节存在的意义是为了减少一个数字的存储空间。1个字节是8位，我们拿出其中的低7位存储数字，那么我们能存储的范围是0-127，如果我们要存储的数字在这个范围内的话，我们就把最高位设置为0。而如果我们要存储的数字超出了0-127这个范围，那么我们就把最高位设置为1，然后记录下高7位，剩下的留给下一个字节。假设我们要存储111这个数字，因为它的值在0-127范围内，我们可以只用一个字节存储：01101111b。而假设我要存储333这个数字，把它转换成二进制的时候是101001101b，超出了7位能存储的范围，那么我们先提取出它的高7位和低7位：0000010和1001101.然后我们用这样的两个字节存储：10000010b和01001101b.当我们读取动态字节的时候，我们先读取一个字节，记录它的低7位，然后判断它的最高位来判断是否需要继续读取下一个字节。
以下VB代码用于展示读取动态字节的方法。调用的时候，以文件号1打开文件，然后用Seek #1定位文件指针，最后调用它来读取动态字节。

1. '读取动态字节
   
2. Function ReadDynamicBytes(ValueOut As Long) As Long '返回读取的字节数
   
3. Dim OneByte As Byte
   
4. ValueOut = 0
   
5. For ReadDynamicBytes = 1 To 4 '最多读取4个字节
   
6.     Get #1, , OneByte '读取一个字节
   
7.     ValueOut = (ValueOut * &H80&) Or (OneByte And &H7F) '记录这个字节的低7位，同时左移以读取的数据让出位置。
   
8.     If (OneByte And &H80) = 0 Then Exit For '这个字节的最高位是0，没有后续字节，停止读取。
   
9. Next
   
10. End Function

复制代码

理论上动态字节可用于存储大数，不过特别大的数在MIDI文件里用不着。我们顶多读取4字节（28位整数）

讲完了动态字节，接下来就应该讲文件内容了。文件的内容都是“事件”，这些“事件”是一个接一个存储的。一个事件都有固定的结构：延迟，事件号，事件参数。
其中“延迟”是动态字节，用于表示上一个事件到这一个事件之间的延迟量。这个延迟量的单位是Tick。一个Tick有多长时间取决于MIDI文件的曲速。
事件号的值在0x80到0xFF之间的时候表示的是具体的值，若读取到的这个值在0到0x7F之间，则表示这个事件的事件号和上一个事件相同，而读取到的值是它的参数。
有关事件号的资料在网络上查找也大同小异。但是都讲得不够清楚。我专门写了一个C语言程序用于解释事件号。看源码便知。

1. //=============================================================================
   
2. //作者：0xAA55
   
3. //论坛：http://www.0xaa55.com/
   
4. //版权所有(C) 2013-2014 技术宅的结界
   
5. //请保留原作者信息，否则视为侵权。
   
6. //-----------------------------------------------------------------------------
   
7. #include<stdio.h>
   
8. #include<malloc.h>
   
9. 
   
10. //统一类型长度
    
11. typedef signed int      MIDIInt,*MIDIIntP;
    
12. typedef signed char     MIDIInt8,*MIDIInt8P;
    
13. typedef signed short    MIDIInt16,*MIDIInt16P;
    
14. typedef signed long     MIDIInt32,*MIDIInt32P;
    
15. typedef unsigned int    MIDIUInt,*MIDIUIntP;
    
16. typedef unsigned char   MIDIUInt8,*MIDIUInt8P;
    
17. typedef unsigned short  MIDIUInt16,*MIDIUInt16P;
    
18. typedef unsigned long   MIDIUInt32,*MIDIUInt32P;
    
19. 
    
20. typedef MIDIUInt8       BYTE;
    
21. typedef MIDIUInt16      WORD;
    
22. typedef MIDIUInt32      DWORD;
    
23. 
    
24. //MIDI文件头的结构体
    
25. typedef struct
    
26. {
    
27.     DWORD   dwFlag;             //MThd标识
    
28.     DWORD   dwRestLen;          //剩余部分长度
    
29.     WORD    wType;              //类型
    
30.     WORD    wNbTracks;          //音轨数
    
31.     WORD    wTicksPerCrotchet;  //每四分音符的Tick数
    
32. }MIDIHeader,*MIDIHeaderP;
    
33. 
    
34. //MIDI文件中出现过的标识
    
35. #define MIDI_MThd   0x6468544D
    
36. #define MIDI_MTrk   0x6B72544D
    
37. 
    
38. //MIDI文件头的“类型”
    
39. #define MIDIT_SingleTrack   0   /*单音轨*/
    
40. #define MIDIT_MultiSync     1   /*同步多音轨*/
    
41. #define MIDIT_MultiAsync    2   /*异步多音轨*/
    
42. 
    
43. //各种长度的Big-Endian到Little-Endian的转换
    
44. #define BSwapW(x)   ((((x) & 0xFF)<<8)|(((x) & 0xFF00)>>8))
    
45. #define BSwap24(x)  ((((x) & 0xFF)<<16)|((x) & 0xFF00)|(((x) & 0xFF0000)>>16))
    
46. #define BSwapD(x)   ((((x) & 0xFF)<<24)|(((x) & 0xFF00)<<8)|(((x) & 0xFF0000)>>8)|(((x) & 0xFF000000)>>24))
    
47. 
    
48. //将音符字节转换成字符串的函数
    
49. char*NoteToString(BYTE bNote);
    
50. 
    
51. //读取字符串然后打印
    
52. size_t ReadStringAndPrint(FILE*,size_t);
    
53. 
    
54. //=============================================================================
    
55. //ReadDynamicBytes:
    
56. //读取动态字节，最多读取4字节。返回读取的字节数
    
57. //-----------------------------------------------------------------------------
    
58. size_t ReadDynamicBytes(FILE*fp,DWORD*pOut)
    
59. {
    
60.     size_t bBytesRead;//已读取的字节数
    
61.     *pOut=0;
    
62.     for(bBytesRead=1;bBytesRead<=4;bBytesRead++)//最多读取4字节
    
63.     {
    
64.         int iValue=fgetc(fp);
    
65.         if(iValue==EOF)
    
66.             return 0;
    
67.         *pOut=(*pOut<<7)|(iValue & 0x7F);//新读入的是低位
    
68.         if(!(iValue & 0x80))//如果没有后续字节
    
69.             break;//就停止读取。
    
70.     }
    
71.     return bBytesRead;//返回读取的字节数
    
72. }
    
73. 
    
74. //=============================================================================
    
75. //ParseMIDI:
    
76. //分析MIDI文件。失败返回零，成功返回非零
    
77. //-----------------------------------------------------------------------------
    
78. int ParseMIDI(char*pszFileName)
    
79. {
    
80. #   define READERR {fprintf(stderr,"读取文件%s遇到错误\n",pszFileName);goto BadReturn;}
    
81. #   define FMTERR {fprintf(stderr,"%s不是一个正常的MIDI文件\n",pszFileName);goto BadReturn;}
    
82. #   define READ(x) if(fread(&(x),1,sizeof(x),fp)!=sizeof(x))READERR
    
83. 
    
84.     FILE*fp;
    
85.     MIDIHeader midiHeader;
    
86.     size_t i;
    
87. 
    
88.     //打开文件
    
89.     fp=fopen(pszFileName,"rb");
    
90.     if(!fp)
    
91.         READERR;
    
92. 
    
93.     //MIDI文件头就是一个MIDIHeader结构体。
    
94.     //但是要注意其中的数值都是Big-Endian存储的
    
95.     //需要进行转换
    
96. 
    
97.     //读取MIDI文件头
    
98.     READ(midiHeader);
    
99.    
    
100.     //检查文件格式
     
101.     if(midiHeader.dwFlag!=MIDI_MThd)//标识必须是"MThd"
     
102.         FMTERR;
     
103. 
     
104.     //转换为Little-Endian
     
105.     midiHeader.dwRestLen=           BSwapD(midiHeader.dwRestLen);
     
106.     midiHeader.wType=               BSwapW(midiHeader.wType);
     
107.     midiHeader.wNbTracks=           BSwapW(midiHeader.wNbTracks);
     
108.     midiHeader.wTicksPerCrotchet=   BSwapW(midiHeader.wTicksPerCrotchet);
     
109. 
     
110.     //分析文件头
     
111.     switch(midiHeader.wType)
     
112.     {
     
113.     case MIDIT_SingleTrack:
     
114.         fputs("类型:单音轨\n",stdout);
     
115.         break;
     
116.     case MIDIT_MultiSync:
     
117.         fputs("类型:同步多音轨\n",stdout);
     
118.         break;
     
119.     case MIDIT_MultiAsync:
     
120.         fputs("类型:异步多音轨\n",stdout);
     
121.         break;
     
122.     default:
     
123.         fprintf(stdout,"类型:未知(0x%04X)\n",midiHeader.wType);
     
124.         break;
     
125.     }
     
126. 
     
127.     //打印音轨数等信息
     
128.     fprintf(stdout,
     
129.         "音轨数:%u\n"
     
130.         "每四分音符时钟数:%u\n",
     
131.         midiHeader.wNbTracks,
     
132.         midiHeader.wTicksPerCrotchet);
     
133. 
     
134.     //正确跳转到MIDI音轨的位置，体现midiHeader.dwRestLen的作用……
     
135.     fseek(fp,8+midiHeader.dwRestLen,SEEK_SET);
     
136. 
     
137.     //准备读取各个音轨
     
138.     for(i=0;i<midiHeader.wNbTracks;i++)
     
139.     {
     
140.         DWORD dwTrackFlag;
     
141.         DWORD dwTrackLen;
     
142. 
     
143.         //每个音轨的开头都是一个dwTrackFlag和一个dwTrackLen
     
144.         //dwTrackFlag的值必须是MIDI_MTrk
     
145.         //dwTrackLen标记了下一个音轨的位置
     
146. 
     
147.         size_t TrackStartPos;
     
148. 
     
149.         fputs("读取音轨\n",stdout);
     
150. 
     
151.         READ(dwTrackFlag);  if(dwTrackFlag!=MIDI_MTrk)FMTERR;//检查文件格式
     
152.         READ(dwTrackLen);   TrackStartPos=ftell(fp);//记录当前位置
     
153. 
     
154.         //转换Big-Endian
     
155.         dwTrackLen=BSwapD(dwTrackLen);
     
156. 
     
157.         //显示每个音轨的字节数
     
158.         fprintf(stdout,"音轨大小:%u 字节\n",dwTrackLen);
     
159. 
     
160.         //音轨的重要内容是事件数据
     
161.         for(;;)//循环读取事件
     
162.         {
     
163.             DWORD dwDelay;
     
164.             BYTE bEvent;
     
165. 
     
166.             //每个事件的构成都是：
     
167.             //延时，事件号，参数
     
168.             //其中的延时是动态字节，参数大小随事件号而定
     
169. 
     
170.             //上一个事件号
     
171.             BYTE bLastEvent;
     
172. 
     
173.             //读取延时
     
174.             if(!ReadDynamicBytes(fp,&dwDelay))
     
175.                 READERR;
     
176. 
     
177.             //读取事件号
     
178.             READ(bEvent);
     
179. 
     
180.             //每读取一个事件，打印这个事件的时间
     
181.             fprintf(stdout,"时间:%u,",dwDelay);
     
182. 
     
183.             //分析事件
     
184. ProcEvent:  if(bEvent <= 0x7F)
     
185.             {//0到0x7F:和上一个事件的事件号相同，而读取的这个字节就是上一个事件号的参数的第一个字节
     
186.                 fseek(fp,-1,SEEK_CUR);//回退一个字节
     
187.                 bEvent=bLastEvent;
     
188.                 goto ProcEvent;
     
189.             }
     
190.             else if(bEvent <= 0x8F)
     
191.             {//0x80到0x8F:松开音符
     
192.                 BYTE bNote,bVel;
     
193. 
     
194.                 READ(bNote);//音符
     
195.                 READ(bVel); //力度
     
196. 
     
197.                 fprintf(stdout,"(通道%u)松开音符:%s, 力度:%u\n",
     
198.                     bEvent & 0xF,//低4位表示通道数
     
199.                     NoteToString(bNote),//音高
     
200.                     bVel);//力度
     
201.             }
     
202.             else if(bEvent <= 0x9F)
     
203.             {//0x90到0x9F:按下音符
     
204.                 BYTE bNote,bVel;
     
205. 
     
206.                 READ(bNote);//音符
     
207.                 READ(bVel); //力度
     
208. 
     
209.                 fprintf(stdout,"(通道%u)按下音符:%s, 力度:%u\n",
     
210.                     bEvent & 0xF,//低4位表示通道数
     
211.                     NoteToString(bNote),//音高
     
212.                     bVel);//力度
     
213.             }
     
214.             else if(bEvent <= 0xAF)
     
215.             {//0xA0到0xAF:触后音符
     
216.                 BYTE bNote,bVel;
     
217. 
     
218.                 READ(bNote);//音符
     
219.                 READ(bVel); //力度
     
220. 
     
221.                 fprintf(stdout,"(通道%u)触后音符:%s, 力度:%u\n",
     
222.                     bEvent & 0xF,//低4位表示通道数
     
223.                     NoteToString(bNote),//音高
     
224.                     bVel);//力度
     
225.             }
     
226.             else if(bEvent <= 0xBF)
     
227.             {//0xB0到0xBF:控制器
     
228.                 BYTE bReg,bVal;
     
229. 
     
230.                 READ(bReg);//寄存器号
     
231.                 READ(bVal);//寄存器值
     
232. 
     
233.                 fprintf(stdout,"(通道%u)控制器:%u,值=%u\n",
     
234.                     bEvent & 0xF,//低4位表示通道数
     
235.                     bReg,//寄存器
     
236.                     bVal);//值
     
237.             }
     
238.             else if(bEvent <= 0xCF)
     
239.             {//0xC0到0xCF:改变乐器
     
240.                 BYTE bInstrument;
     
241. 
     
242.                 READ(bInstrument);//乐器号
     
243.                
     
244.                 fprintf(stdout,"(通道%u)改变乐器:%u\n",
     
245.                     bEvent & 0xF,//低4位表示通道数
     
246.                     bInstrument);//乐器号
     
247.             }
     
248.             else if(bEvent <= 0xDF)
     
249.             {//0xD0到0xDF:触后通道
     
250.                 BYTE bChannel;
     
251. 
     
252.                 READ(bChannel);//通道号
     
253.                
     
254.                 fprintf(stdout,"(通道%u)触后通道:%u\n",
     
255.                     bEvent & 0xF,//低4位表示通道数
     
256.                     bChannel);//通道号
     
257.             }
     
258.             else if(bEvent <= 0xEF)
     
259.             {//0xE0到0xEF:滑音
     
260.                 WORD wPitch;//滑音参数是Little-Endian的WORD
     
261. 
     
262.                 READ(wPitch);
     
263.                
     
264.                 fprintf(stdout,"(通道%u)滑音:%u\n",
     
265.                     bEvent & 0xF,//低4位表示通道数
     
266.                     wPitch);//滑音
     
267.             }
     
268.             else if(bEvent == 0xF0)
     
269.             {//0xF0:系统码
     
270.                 BYTE bSysCode=0;
     
271. 
     
272.                 fputs("系统码:",stdout);
     
273.                 for(;;)
     
274.                 {
     
275.                     READ(bSysCode);
     
276.                     if(bSysCode!=0xF7)
     
277.                         fprintf(stdout,"0x%02X,",bSysCode);
     
278.                     else
     
279.                     {
     
280.                         fprintf(stdout,"0x%02X\n",bSysCode);
     
281.                         break;//读取到0xF7结束
     
282.                     }
     
283.                 }
     
284.             }
     
285.             else if(bEvent == 0xFF)
     
286.             {//元事件
     
287.                 BYTE bType,bBytes;
     
288.                 size_t CurrentPos;
     
289.                
     
290.                 READ(bType);//元数据类型
     
291.                 READ(bBytes);//元数据字节数
     
292. 
     
293.                 CurrentPos=ftell(fp);//记录元数据读取的位置
     
294. 
     
295.                 fputs("元数据 - ",stdout);
     
296. 
     
297.                 switch(bType)
     
298.                 {
     
299.                 case 0x00://设置轨道音序
     
300.                     {
     
301.                         WORD wTrackSeq;
     
302.                         READ(wTrackSeq);
     
303.                         wTrackSeq=BSwapW(wTrackSeq);
     
304.                         fprintf(stdout,"设置轨道音序:0x%04X\n",wTrackSeq);
     
305.                     }
     
306.                     break;
     
307.                 case 0x01://歌曲备注
     
308.                     fputs("备注:",stdout);
     
309.                     ReadStringAndPrint(fp,bBytes);
     
310.                     fputc('\n',stdout);
     
311.                     break;
     
312.                 case 0x02://版权
     
313.                     fputs("版权:",stdout);
     
314.                     ReadStringAndPrint(fp,bBytes);
     
315.                     fputc('\n',stdout);
     
316.                     break;
     
317.                 case 0x03://歌曲标题
     
318.                     fputs("标题:",stdout);
     
319.                     ReadStringAndPrint(fp,bBytes);
     
320.                     fputc('\n',stdout);
     
321.                     break;
     
322.                 case 0x04://乐器名称
     
323.                     fputs("乐器名:",stdout);
     
324.                     ReadStringAndPrint(fp,bBytes);
     
325.                     fputc('\n',stdout);
     
326.                     break;
     
327.                 case 0x05://歌词
     
328.                     fputs("歌词:",stdout);
     
329.                     ReadStringAndPrint(fp,bBytes);
     
330.                     fputc('\n',stdout);
     
331.                     break;
     
332.                 case 0x06://标记
     
333.                     fputs("标记:",stdout);
     
334.                     ReadStringAndPrint(fp,bBytes);
     
335.                     fputc('\n',stdout);
     
336.                     break;
     
337.                 case 0x07://开始点
     
338.                     fputs("开始点:",stdout);
     
339.                     ReadStringAndPrint(fp,bBytes);
     
340.                     fputc('\n',stdout);
     
341.                     break;
     
342.                 case 0x21://音轨开始标识
     
343.                     fputs("音轨开始标识.\n",stdout);
     
344.                     break;
     
345.                 case 0x2F://音轨结束标识
     
346.                     fputs("音轨结束标识.\n",stdout);
     
347.                     goto EndOfTrack;
     
348.                 case 0x51://速度
     
349.                     {
     
350.                         BYTE bVelocity1,bVelocity2,bVelocity3;
     
351. 
     
352.                         //速度是24位整数，一个四分音符的微秒数。
     
353.                         READ(bVelocity1);
     
354.                         READ(bVelocity2);
     
355.                         READ(bVelocity3);
     
356. 
     
357.                         //而且是Big-Endian
     
358.                         fprintf(stdout,"速度: 每四分音符%u微秒.\n",
     
359.                             bVelocity3|(bVelocity2<<8)|(bVelocity1<<16));
     
360.                     }
     
361.                     break;
     
362.                 case 0x58://节拍
     
363.                     {
     
364.                         BYTE bBeatNumerator,bBeatDenominator,bMetronomeTimer,bNb32ndNotesInCrotchet;
     
365. 
     
366.                         READ(bBeatNumerator);//分子
     
367.                         READ(bBeatDenominator);//分母
     
368.                         READ(bMetronomeTimer);//节拍器时钟
     
369.                         READ(bNb32ndNotesInCrotchet);//每四分音符有多少三十二分音符
     
370. 
     
371.                         fprintf(stdout,"节拍:%u/%u. 节拍器时钟:%u. 每四分音符有%u个三十二分音符.\n",
     
372.                             bBeatNumerator,bBeatDenominator,bMetronomeTimer,bNb32ndNotesInCrotchet);
     
373.                     }
     
374.                     break;
     
375.                 case 0x59://调号
     
376.                     {
     
377.                         MIDIInt8 bTunePitch;
     
378.                         BYTE bTuneType;
     
379. 
     
380.                         READ(bTunePitch);//升降号
     
381.                         READ(bTuneType);//大调、小调
     
382. 
     
383.                         fprintf(stdout,"升降号:%d, ",bTunePitch);
     
384.                         switch(bTuneType)
     
385.                         {
     
386.                         case 0://大调
     
387.                             fputs("大调\n",stdout);
     
388.                             break;
     
389.                         case 1://小调
     
390.                             fputs("小调\n",stdout);
     
391.                             break;
     
392.                         default://不知道
     
393.                             fprintf(stdout,"未知调(0x%02X).\n",bTuneType);
     
394.                             break;
     
395.                         }
     
396.                     }
     
397.                     break;
     
398.                 case 0x7F://音序特定信息
     
399.                     fputs("音序特定信息:",stdout);
     
400.                     ReadStringAndPrint(fp,bBytes);
     
401.                     fputc('\n',stdout);
     
402.                     break;
     
403.                 default:
     
404.                     fprintf(stdout,"未知元数据类型(0x%02X)\n",bType);
     
405.                     break;
     
406.                 }
     
407. 
     
408.                 fseek(fp,CurrentPos+bBytes,SEEK_SET);//读取完成后正确跳到下一个事件的位置。
     
409.             }
     
410.             else//其它事件，未知事件
     
411.             {
     
412.                 fprintf(stdout,"未知事件:0x%08X. 停止当前音轨的分析。\n",bEvent);
     
413.                 break;
     
414.             }
     
415. 
     
416.             //记录上一个事件号
     
417.             bLastEvent=bEvent;
     
418.         }//回去继续读取事件。
     
419. 
     
420. EndOfTrack:
     
421.         fseek(fp,TrackStartPos+dwTrackLen,SEEK_SET);//转到下一个音轨
     
422.     }
     
423. 
     
424.     fputs("MIDI文件读取结束。\n",stdout);
     
425. 
     
426.     fclose(fp);
     
427.     return 1;
     
428. BadReturn:
     
429.     fclose(fp);
     
430.     return 0;
     
431. 
     
432. #   undef READ
     
433. #   undef READERR
     
434. }
     
435. 
     
436. //=============================================================================
     
437. //NoteToString:
     
438. //将音符音高转换为字符串
     
439. //其实每次返回的都是同一缓冲区，只是每次都改写了缓冲区的值。
     
440. //-----------------------------------------------------------------------------
     
441. char*NoteToString(BYTE bNote)
     
442. {
     
443.     static char szBuf[5];//顶多5字符
     
444.     switch(bNote % 12)
     
445.     {
     
446.     case 0:
     
447.         sprintf(szBuf,"C%d",(int)(bNote / 12)-2);
     
448.         break;
     
449.     case 1:
     
450.         sprintf(szBuf,"C%d#",(int)(bNote / 12)-2);
     
451.         break;
     
452.     case 2:
     
453.         sprintf(szBuf,"D%d",(int)(bNote / 12)-2);
     
454.         break;
     
455.     case 3:
     
456.         sprintf(szBuf,"D%d#",(int)(bNote / 12)-2);
     
457.         break;
     
458.     case 4:
     
459.         sprintf(szBuf,"E%d",(int)(bNote / 12)-2);
     
460.         break;
     
461.     case 5:
     
462.         sprintf(szBuf,"F%d",(int)(bNote / 12)-2);
     
463.         break;
     
464.     case 6:
     
465.         sprintf(szBuf,"F%d#",(int)(bNote / 12)-2);
     
466.         break;
     
467.     case 7:
     
468.         sprintf(szBuf,"G%d",(int)(bNote / 12)-2);
     
469.         break;
     
470.     case 8:
     
471.         sprintf(szBuf,"G%d#",(int)(bNote / 12)-2);
     
472.         break;
     
473.     case 9:
     
474.         sprintf(szBuf,"A%d",(int)(bNote / 12)-2);
     
475.         break;
     
476.     case 10:
     
477.         sprintf(szBuf,"A%d#",(int)(bNote / 12)-2);
     
478.         break;
     
479.     case 11:
     
480.         sprintf(szBuf,"B%d",(int)(bNote / 12)-2);
     
481.         break;
     
482.     }
     
483.     return szBuf;
     
484. }
     
485. 
     
486. //=============================================================================
     
487. //ReadStringAndPrint
     
488. //读取字符串然后打印。返回读取的字节数
     
489. //-----------------------------------------------------------------------------
     
490. size_t ReadStringAndPrint(FILE*fp,size_t szLength)
     
491. {
     
492.     char*pBuf;
     
493.     pBuf=(char*)malloc(szLength+1);
     
494.     if(pBuf)//分配内存一次读取
     
495.     {
     
496.         size_t Ret=fread(pBuf,1,szLength,fp);
     
497.         pBuf[szLength]=0;//结尾的\0
     
498.         fputs(pBuf,stdout);
     
499.         free(pBuf);
     
500.         return Ret;
     
501.     }
     
502.     else
     
503.     {
     
504.         fputs("无法将字符串读入内存。\n",stderr);
     
505.         return 0;
     
506.     }
     
507. }
     
508. 
     
509. //=============================================================================
     
510. //main:
     
511. //入口
     
512. //-----------------------------------------------------------------------------
     
513. int main(int argc,char**argv)
     
514. {
     
515.     if(argc<2)
     
516.     {
     
517.         fprintf(stderr,
     
518.             "Usage:\n"
     
519.             "%s midifile.mid\n",argv[0]?argv[0]:"MIDIFile");
     
520.         return 1;
     
521.     }
     
522. 
     
523.     ParseMIDI(argv[1]);
     
524.     return 0;
     
525. }

复制代码

BIN: MIDIFile.exe (48 KB, 下载次数: 65, 售价: 1 个宅币)

2014-7-19 22:55 上传

点击文件名下载附件

SRC: MIDIFile.7z (21.83 KB, 下载次数: 41, 售价: 10 个宅币)

2014-7-19 22:55 上传

点击文件名下载附件

曦。风起

好东西，好好学习

tx7790

这个资料在十几年前应该很有用。。。

0xAA55

tx7790 发表于 2017-2-22 10:51
这个资料在十几年前应该很有用。。。

现在依然有用，尤其是嵌入式开发，这个技术根本就没过时

KAKA

谢谢楼主分享！！

ABC

学习了…感谢楼主!

白天

谢谢楼主分享

白天

正好在写这方面的程序

断念兰

挺好的，这个文件挺有用的

(⊙o⊙)

感谢源代码。收藏

yang

在做音乐方面的,希望可以用到

yang

mac上跑的有问题,

再见肥仔扑

挺好的，这个文件挺有用的

jay

谢谢楼主分享

qqss335

跑这个程序应该出什么结果？文件名应该在什么地方修改？

8421

你这个程序有问题，元事件长度用ReadDynamicBytes函数读取的

PrincessSnow

谢谢大佬的教程 收藏起来观摩一波

aceansha

搞嵌入式开发入门，对这个完全不懂

imr2013

学习一下，给小孩编个小程序