Android MIDI音乐播放/生成相关总结

这学期，笔者在制作一款音乐应用中需要用到多种乐器，纠结于程序包的大小后选择了MIDI音乐，查阅大量资料和博客后实现成功。讲制作过程中的理解分享如下，如有纰漏，望包涵并纠正。

一、Android平台音乐媒体以及MIDI音乐现状

目前Android平台使用的音乐媒体格式多为MP3、OGG、WAV等常用格式,，常用铃声格式为MP3、WMA格式音频文件。WAV为源声音文件，无损，音质高，文件大。MP3、OGG等均为压缩音频，需要特定的编解码器支持。

这是Android支持的媒体格式列表链接：

http://developer./guide/appendix/media-formats.html

虽然MP3、OGG等常用音乐格式可以满足大部分应用和游戏开发，但如果程序中涉及大量的音频文件，使用这些格式后的程序包文件肯定是非常大的，比如涉及多种乐器的音乐程序和大型游戏。其实还有另外一种更加常用、更加强大的音乐媒体格式，那就是MIDI音乐。关于MIDI音乐相关介绍，请各位看官自行搜索。个人觉得百度百科解释的非常好，链接如下: http://baike.baidu.com/view/7969.htm

MIDI仅仅是一个通信标准，它是由电子乐器制造商们建立起来的，用以确定电脑音乐程序、合成器和其他电子音响的设备互相交换信息与控制信号的方法。MIDI系统实际就是一个作曲、配器、电子模拟的演奏系统。从一个MIDI设备转送到另一个MIDI设备上去的数据就是MIDI信息。MIDI数据不是数字的音频波形，而是音乐代码或称电子乐谱。也就是说MIDI数据中没有声音数据，有的只是电子乐器的控制信息，需要借用电脑或者手机的声卡或者其他专业声卡来发声，音质肯定与声卡的质量相关。

MIDI音乐支持其实比MP3、OGG等更好，甚至Nokia仅能打电话和发短信不能播放MP3的低端机都支持MIDI，但像iPhone高端机却不支持。

Android平台对MIDI的支持情况其实也不好。具体请参考如下链接：

http://home./home.php?uid=5886&do=blog&id=15&mod=space

http://blog./index.php/2010/05/07/midi-on-android/

关于JetPlayer，平台下的Samples有个程序范例JetBoy。同时参考如下文章：

JetBoy游戏深入解析(中)--JetPlayer类解析：http://www.mo/?p=1333

二、MIDI文件格式分析

MIDI文件中不保存声音数据，只保存乐器和合成器等信息。

MIDI文件格式请参考下面几篇文章，在制作过程中肯定是要经常用到的。

MIDI音乐格式分析--理论篇：http://www./modulearticle-detailview-901.htm

MIDI音乐格式分析--实践篇：http://www./modulearticle-detailview-902.htm

MIDI音乐格式分析--附件篇：http://www./modulearticle-detailview-903.htm

或者可以参考MIDI的官方文档，会有详细介绍。

三、Android MIDI音乐播放与生成

从官方媒体格式列表中也可以看到Android的MediaPlayer支持MIDI文件的直接播放，具体播放过程与其他音乐文件无异，就不给出代码了。

但是有时候我们希望能对音频数据进行编辑合成，而MIDI音乐不保存音频数据，这时候就需要我们自己来写MIDI乐器与合成器的控制信息了，而且都是16进制数据。我们需要在程序中自己控制生成，当然你也可以自己用UltraEdit来编辑数据。

代码如下：

1. import java.io.FileOutputStream;
2. import java.io.IOException;
3. import java.util.Vector;
5. public class MidiFile
6. {
7. // Note lengths
8. // We are working with 32 ticks to the crotchet. So
9. // all the other note lengths can be derived from this
10. // basic figure. Note that the longest note we can
11. // represent with this code is one tick short of a
12. // two semibreves (i.e., 8 crotchets)
15. // Standard MIDI file header, for one-track file
16. // 4D, 54... are just magic numbers to identify the headers
17. // Note that because we're only writing one track, we
18. // can for simplicity combine the file and track headers
19. private int header[] = new int[]
20. {
21. 0x4d, 0x54, 0x68, 0x64, 0x00, 0x00, 0x00, 0x06,
22. 0x00, 0x01, // multi-track format synchronous
23. 0x00, 0x10, // two track
24. 0x00, 0x78, // 16 ticks per quarter
25. };
27. private int channelHeader[] = new int[]
28. {
29. 0x4d, 0x54, 0x72, 0x6B
30. };
32. // Standard footer
33. private int channelFooter[] = new int[]
34. {
35. 0x01, 0xFF, 0x2F, 0x00
36. };
38. // A MIDI event to set the tempo(速度)
39. private int tempoEvent[] = new int[]
40. {
41. 0x00, 0xFF, 0x51, 0x03,
42. 0x0F, 0x42, 0x40 // Default 1 million usec per crotchet
43. };
45. // A MIDI event to set the key signature. This is irrelent to
46. // playback, but necessary for editing applications(升降调)
47. private int keySigEvent[] = new int[]
48. {
49. 0x00, 0xFF, 0x59, 0x02,
50. 0x00, // C
51. 0x00 // major
52. };
54. // A MIDI event to set the time signature. This is irrelent to
55. // playback, but necessary for editing applications(节拍)
56. private int timeSigEvent[] = new int[]
57. {
58. 0x00, 0xFF, 0x58, 0x04,
59. 0x04, // numerator
60. 0x02, // denominator (2==4, because it's a power of 2)
61. 0x30, // ticks per click (not used)
62. 0x08 // 32nd notes per crotchet
63. };
65. private Vector<MidiChannel> mChannels = new Vector<MidiChannel>();
67. public MidiFile()
68. {}
70. /** Construct a new MidiFile with an empty playback event list */
71. public MidiFile(float tempo/*secPerCrotchet,default 1.0f*/,int keySig/*default 0, must between -7 to 7*/,
72. int timeSigNumerator/*default 4*/,int timeSigDenominator/*default 2, exponent of 2*/)
73. {
74. if (Math.abs(tempo-1.0f) > 0.001f)
75. {
76. int microSec = (int)(tempo * 1000000);
77. tempoEvent[6] = microSec % 0x100;
78. tempoEvent[5] = ((int)(microSec / 0x100)) % 0x100;
79. tempoEvent[4] = microSec / 0x10000;
80. }
82. keySigEvent[4] = keySig;
84. timeSigEvent[4] = timeSigNumerator;
85. timeSigEvent[5] = timeSigDenominator;
86. }
88. public void setBaseTicks(int ticks)
89. {
90. byte[] bytes = intToByteArray(ticks);
91. header[12] = bytes[2];
92. header[13] = bytes[3];
93. }
95. public int getBaseTicks()
96. {
97. return (header[12]* 0x100 + header[13]);
98. }
100. public void setTempo(float tempo)
101. {
102. int microSec = (int)(tempo * 1000000);
103. tempoEvent[6] = microSec % 0x100;
104. tempoEvent[5] = (microSec / 0x100) % 0x100;
105. tempoEvent[4] = microSec / 0x10000;
106. }
108. public float getTempo()
109. {
110. return (tempoEvent[4] * 0x10000 + tempoEvent[5] * 0x100 + tempoEvent[6]) / 1000000.0f;
111. }
113. public void setKeySig(int keySig)
114. {
115. keySigEvent[4] = keySig;
116. }
118. public int getKeySig()
119. {
120. return keySigEvent[4];
121. }
123. public void setTimeSig(int timeSigNumerator,int timeSigDenominator)
124. {
125. timeSigEvent[4] = timeSigNumerator;
126. timeSigEvent[5] = timeSigDenominator;
127. }
129. public int getTimeSig()
130. {
131. return timeSigEvent[4];
132. }
134. public void addChannel(MidiChannel channel)
135. {
136. mChannels.add(channel);
137. }
139. /** Write the stored MIDI events to a file */
140. public void writeToFile (String filename) throws IOException
141. {
142. FileOutputStream fos = new FileOutputStream (filename);
144. header[11] = mChannels.size() + 1;
146. fos.write (intArrayToByteArray (header));
148. fos.write(intArrayToByteArray(channelHeader));
150. // Calculate the amount of track data
151. // _Do_ include the footer but _do not_ include the track header
153. int size = tempoEvent.length + keySigEvent.length + timeSigEvent.length + channelFooter.length;
155. fos.write(intToByteArray(size));
157. // Write the standard metadata — tempo, etc
158. // At present, tempo is stuck at crotchet=60
159. fos.write (intArrayToByteArray (tempoEvent));
160. fos.write (intArrayToByteArray (keySigEvent));
161. fos.write (intArrayToByteArray (timeSigEvent));
163. //end global track
164. fos.write(intArrayToByteArray(channelFooter));
166. for (int i =0; i<mChannels.size();++i)
167. {
168. fos.write(intArrayToByteArray(channelHeader));
169. size = channelFooter.length;
170. MidiChannel channel = mChannels.elementAt(i);
171. for (int j = 0; j < channel.playEvents.size(); ++j)
172. size += channel.playEvents.elementAt(j).length;
174. fos.write(intToByteArray(size));
176. // Write out the note, etc., events
177. for (int j = 0; j < channel.playEvents.size();++j)
178. {
179. fos.write (intArrayToByteArray (channel.playEvents.elementAt(j)));
180. }
181. // Write the footer and close
182. fos.write (intArrayToByteArray (channelFooter));
183. }
185. fos.close();
186. }
188. public void release()
189. {
190. mChannels.clear();
191. }
193. /** Convert an array of integers which are assumed to contain
194. unsigned bytes into an array of bytes */
195. protected static byte[] intArrayToByteArray (int[] ints)
196. {
197. int l = ints.length;
198. byte[] out = new byte[ints.length];
199. for (int i = 0; i < l; i++)
200. {
201. out[i] = (byte) ints[i];
202. }
203. return out;
204. }
206. protected static byte[] intToByteArray(int i)
207. {
208. // Write out the track data size in big-endian format
209. // Note that this math is only valid for up to 64k of data
210. // (but that's a lot of notes)
211. byte[] out = new byte[4];
212. out[0] = 0;
213. out[1] = 0;
214. out[2] = (byte)(i / 256);
215. out[3] = (byte)(i - ((int)out[2] * 256));
216. return out;
217. }
218. }

import java.util.Vector;
public class MidiChannel
{	
	private int mChannelIndex = 1;
	// The collection of events to play, in time order
	public Vector<int[]> playEvents = new Vector<int[]>();   
	public MidiChannel()
	{}
	public MidiChannel(int channelIndex/*default 1, between 00 to FF*/)
	{		
		mChannelIndex = channelIndex;
	}
	public void setChannelIndex(int channelIndex)
	{
		mChannelIndex = channelIndex;
	}
	/** Store a program-change event at current position */
	public void progChange (int prog/*0x00-0x7f*/)
	{
		int[] data = new int[3];
		data[0] = 0;
		data[1] = 0xC0 + mChannelIndex;
		data[2] = prog;
		playEvents.add(data);
	}
	/** Store a note-on event */
	public void noteOn (int delta, int note, int velocity)
	{
		int[] data = new int[4];
		data[0] = delta;
		data[1] = 0x90 + mChannelIndex;
		data[2] = note;
		data[3] = velocity;
		playEvents.add (data);
	}
	/** Store a note-off event */
	public void noteOff (int delta, int note)
	{
		int[] data = new int[4];
		data[0] = delta;
		data[1] = 0x80 + mChannelIndex;
		data[2] = note;
		data[3] = 0;
		playEvents.add (data);
	}
	/** Store a note-on event followed by a note-off event a note length
	    later. There is no delta value — the note is assumed to
	    follow the previous one with no gap. */
	public void noteOnOffNow (int duration, int note, int velocity)
	{
		noteOn (0, note, velocity);
		noteOff (duration, note);
	}
	public void noteSequenceFixedVelocity (int[] sequence, int velocity)
	{
	    boolean lastWasRest = false;
	    int restDelta = 0;
	    for (int i = 0; i < sequence.length; i += 2)
	    {
	    	int note = sequence[i];
	    	int duration = sequence[i + 1];
	    	if (note < 0) 
	    	{
	    		// This is a rest
	    		restDelta += duration;
	    		lastWasRest = true;
	    	} 
	    	else
	    	{
	    		// A note, not a rest
	    		if (lastWasRest)
	    		{
	    			noteOn (restDelta, note, velocity);
	    			noteOff (duration, note);
	    		}
	    		else
	    		{
	    			noteOn (0, note, velocity);
	    			noteOff (duration, note);
	    		}
	    		restDelta = 0;
	    		lastWasRest = false;
	    	}
	    }
	}
}

下面是生成所有MIDI乐器的MIDI音乐示例：

public static void main (String[] args) throws Exception
  	{
  		String[] instruments = new String[]
  		{
			'Acoustic_Grand_Piano',
			'Bright_Acoustic_Piano',
			'Electric_Grand_Piano',
			'Honky_Tonk_Piano',
			'Rhodes_Piano',
			'Chorused_Piano',
			'Harpsichord',
			'Clavine',
			'Celesta',
			'Glockenspiel',
			'Music_Box',
			'Vibraphone',
			'Marimba',
			'Xylophone',
			'Tubular_Bells',
			'Dulcimer',
			'Hammond_Organ',
			'Percussive_Organ',
			'Rock_Organ',
			'Church_Organ',
			'Reed_Organ',
			'Accordion',
			'Harmonica',
			'Tango_Accordian',
			'Acoustic_Guitar_nylon',
			'Acoustic_Guitar_steel',
			'Electric_Guitar_jazz',
			'Electric_Guitar_clean',
			'Electric_Guitar_muted',
			'Overdriven_Guitar',
			'Distortion_Guitar',
			'Guitar_Harmonics',
			'Acoustic_Bass',
			'Electric_Bass_finger',
			'Electric_Bass_pick',
			'Fretless_Bass',
			'Slap_Bass_1',
			'Slap_Bass_2',
			'Synth_Bass_1',
			'Synth_Bass_2',
			'Violin',
			'Viola',
			'Cello',
			'Contrabass',
			'Tremolo_Strings',
			'Pizzicato_Strings',
			'Orchestral_Harp',
			'Timpani',
			'String_Ensemble_1',
			'String_Ensemble_2',
			'SynthStrings_1',
			'SynthStrings_2',
			'Choir_Aahs',
			'Voice_Oohs',
			'Synth_Voice',
			'Orchestra_Hit',
			'Trumpet',
			'Trombone',
			'Tuba',
			'Muted_Trumpet',
			'French_Horn',
			'Brass_Section',
			'Synth_Brass_1',
			'Synth_Brass_2',
			'Soprano_Sax',
			'Alto_Sax',
			'Tenor_Sax',
			'Baritone_Sax',
			'Oboe',
			'English_Horn',
			'Bassoon',
			'Clarinet',
			'Piccolo',
			'Flute',
			'Recorder',
			'Pan_Flute',
			'Bottle_Blow',
			'Skakuhachi',
			'Whistle',
			'Ocarina',
			'Synth_Lead_square',
			'Synth_Lead_sawtooth',
			'Synth_Lead_calliope',
			'Synth_Lead_chiff',
			'Synth_Lead_charang',
			'Synth_Lead_voice',
			'Synth_Lead_fifths',
			'Synth_Lead_bass_lead',
			'Synth_Pad_new_age',
			'Synth_Pad_warm',
			'Synth_Pad_polysynth',
			'Synth_Pad_choir',
			'Synth_Pad_bowed',
			'Synth_Pad_metallic',
			'Synth_Pad_halo',
			'Synth_Pad_sweep',
			'Synth_Effect_rain',
			'Synth_Effect_soundtrack',
			'Synth_Effect_crystal',
			'Synth_Effect_atmosphere',
			'Synth_Effect_brightness',
			'Synth_Effect_goblins',
			'Synth_Effect_echoes',
			'Synth_Effect_sci_fi',
			'Sitar',
			'Banjo',
			'Shamisen',
			'Koto',
			'Kalimba',
			'Bagpipe',
			'Fiddle',
			'Shanai',
			'Tinkle_Bell',
			'Agogo',
			'Steel_Drums',
			'Woodblock',
			'Taiko_Drum',
			'Melodic_Tom',
			'Synth_Drum',
			'Reverse_Cymbal',
			'Guitar_Fret_Noise',
			'Breath_Noise',
			'Seashore',
			'Bird_Tweet',
			'Telephone_Ring',
			'Helicopter',
			'Applause',
			'Gunshot'
  		};
  		int[] progs = new int[]
  		{
			0x00,
			0x18,
			0x28,
			0x29,
			0x2a,
			0x21,
			0x76,
			0x41
  		};
  		for (int i=0;i<=8;++i)
  		{
  			for (int j=0;j<=127;++j)
  			{
  				MidiFile mf = new MidiFile();
  				mf.progChange(progs[i]);
  				mf.noteOnOffNow(MINIM, j, 127);
  				mf.writeToFile (instruments[i]+'_'+String.valueOf(j)+'.mid');
  			}
  		}
  	}

以上文章仅供参考，如有纰漏烦请指正，交流请邮件:[e-mail]