source: spip-zone/_core_/plugins/medias/lib/getid3/module.audio.midi.php @ 113161

Last change on this file since 113161 was 113161, checked in by spip.franck@…, 5 months ago

Mise à jour de la lib getid en 1.9.16, nous étions en 1.9.14
https://github.com/JamesHeinrich/getID3/blob/master/changelog.txt

File size: 18.7 KB
Line 
1<?php
2
3/////////////////////////////////////////////////////////////////
4/// getID3() by James Heinrich <info@getid3.org>               //
5//  available at https://github.com/JamesHeinrich/getID3       //
6//            or https://www.getid3.org                        //
7//            or http://getid3.sourceforge.net                 //
8//  see readme.txt for more details                            //
9/////////////////////////////////////////////////////////////////
10//                                                             //
11// module.audio.midi.php                                       //
12// module for Midi Audio files                                 //
13// dependencies: NONE                                          //
14//                                                            ///
15/////////////////////////////////////////////////////////////////
16
17define('GETID3_MIDI_MAGIC_MTHD', 'MThd'); // MIDI file header magic
18define('GETID3_MIDI_MAGIC_MTRK', 'MTrk'); // MIDI track header magic
19
20class getid3_midi extends getid3_handler
21{
22        /**
23         * @var bool
24         */
25        public $scanwholefile = true;
26
27        /**
28         * @return bool
29         */
30        public function Analyze() {
31                $info = &$this->getid3->info;
32
33                // shortcut
34                $info['midi']['raw'] = array();
35                $thisfile_midi               = &$info['midi'];
36                $thisfile_midi_raw           = &$thisfile_midi['raw'];
37
38                $info['fileformat']          = 'midi';
39                $info['audio']['dataformat'] = 'midi';
40
41                $this->fseek($info['avdataoffset']);
42                $MIDIdata = $this->fread($this->getid3->fread_buffer_size());
43                $offset = 0;
44                $MIDIheaderID = substr($MIDIdata, $offset, 4); // 'MThd'
45                if ($MIDIheaderID != GETID3_MIDI_MAGIC_MTHD) {
46                        $this->error('Expecting "'.getid3_lib::PrintHexBytes(GETID3_MIDI_MAGIC_MTHD).'" at offset '.$info['avdataoffset'].', found "'.getid3_lib::PrintHexBytes($MIDIheaderID).'"');
47                        unset($info['fileformat']);
48                        return false;
49                }
50                $offset += 4;
51                $thisfile_midi_raw['headersize']    = getid3_lib::BigEndian2Int(substr($MIDIdata, $offset, 4));
52                $offset += 4;
53                $thisfile_midi_raw['fileformat']    = getid3_lib::BigEndian2Int(substr($MIDIdata, $offset, 2));
54                $offset += 2;
55                $thisfile_midi_raw['tracks']        = getid3_lib::BigEndian2Int(substr($MIDIdata, $offset, 2));
56                $offset += 2;
57                $thisfile_midi_raw['ticksperqnote'] = getid3_lib::BigEndian2Int(substr($MIDIdata, $offset, 2));
58                $offset += 2;
59
60                for ($i = 0; $i < $thisfile_midi_raw['tracks']; $i++) {
61                        while ((strlen($MIDIdata) - $offset) < 8) {
62                                if ($buffer = $this->fread($this->getid3->fread_buffer_size())) {
63                                        $MIDIdata .= $buffer;
64                                } else {
65                                        $this->warning('only processed '.($i - 1).' of '.$thisfile_midi_raw['tracks'].' tracks');
66                                        $this->error('Unabled to read more file data at '.$this->ftell().' (trying to seek to : '.$offset.'), was expecting at least 8 more bytes');
67                                        return false;
68                                }
69                        }
70                        $trackID = substr($MIDIdata, $offset, 4);
71                        $offset += 4;
72                        if ($trackID == GETID3_MIDI_MAGIC_MTRK) {
73                                $tracksize = getid3_lib::BigEndian2Int(substr($MIDIdata, $offset, 4));
74                                $offset += 4;
75                                //$thisfile_midi['tracks'][$i]['size'] = $tracksize;
76                                $trackdataarray[$i] = substr($MIDIdata, $offset, $tracksize);
77                                $offset += $tracksize;
78                        } else {
79                                $this->error('Expecting "'.getid3_lib::PrintHexBytes(GETID3_MIDI_MAGIC_MTRK).'" at '.($offset - 4).', found "'.getid3_lib::PrintHexBytes($trackID).'" instead');
80                                return false;
81                        }
82                }
83
84                if (!isset($trackdataarray) || !is_array($trackdataarray)) {
85                        $this->error('Cannot find MIDI track information');
86                        unset($thisfile_midi);
87                        unset($info['fileformat']);
88                        return false;
89                }
90
91                if ($this->scanwholefile) { // this can take quite a long time, so have the option to bypass it if speed is very important
92                        $thisfile_midi['totalticks']      = 0;
93                        $info['playtime_seconds'] = 0;
94                        $CurrentMicroSecondsPerBeat       = 500000; // 120 beats per minute;  60,000,000 microseconds per minute -> 500,000 microseconds per beat
95                        $CurrentBeatsPerMinute            = 120;    // 120 beats per minute;  60,000,000 microseconds per minute -> 500,000 microseconds per beat
96                        $MicroSecondsPerQuarterNoteAfter  = array ();
97                        $MIDIevents                       = array();
98
99                        foreach ($trackdataarray as $tracknumber => $trackdata) {
100
101                                $eventsoffset               = 0;
102                                $LastIssuedMIDIcommand      = 0;
103                                $LastIssuedMIDIchannel      = 0;
104                                $CumulativeDeltaTime        = 0;
105                                $TicksAtCurrentBPM = 0;
106                                while ($eventsoffset < strlen($trackdata)) {
107                                        $eventid = 0;
108                                        if (isset($MIDIevents[$tracknumber]) && is_array($MIDIevents[$tracknumber])) {
109                                                $eventid = count($MIDIevents[$tracknumber]);
110                                        }
111                                        $deltatime = 0;
112                                        for ($i = 0; $i < 4; $i++) {
113                                                $deltatimebyte = ord(substr($trackdata, $eventsoffset++, 1));
114                                                $deltatime = ($deltatime << 7) + ($deltatimebyte & 0x7F);
115                                                if ($deltatimebyte & 0x80) {
116                                                        // another byte follows
117                                                } else {
118                                                        break;
119                                                }
120                                        }
121                                        $CumulativeDeltaTime += $deltatime;
122                                        $TicksAtCurrentBPM   += $deltatime;
123                                        $MIDIevents[$tracknumber][$eventid]['deltatime'] = $deltatime;
124                                        $MIDI_event_channel                                  = ord(substr($trackdata, $eventsoffset++, 1));
125                                        if ($MIDI_event_channel & 0x80) {
126                                                // OK, normal event - MIDI command has MSB set
127                                                $LastIssuedMIDIcommand = $MIDI_event_channel >> 4;
128                                                $LastIssuedMIDIchannel = $MIDI_event_channel & 0x0F;
129                                        } else {
130                                                // running event - assume last command
131                                                $eventsoffset--;
132                                        }
133                                        $MIDIevents[$tracknumber][$eventid]['eventid']   = $LastIssuedMIDIcommand;
134                                        $MIDIevents[$tracknumber][$eventid]['channel']   = $LastIssuedMIDIchannel;
135                                        if ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x08) { // Note off (key is released)
136
137                                                $notenumber = ord(substr($trackdata, $eventsoffset++, 1));
138                                                $velocity   = ord(substr($trackdata, $eventsoffset++, 1));
139
140                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x09) { // Note on (key is pressed)
141
142                                                $notenumber = ord(substr($trackdata, $eventsoffset++, 1));
143                                                $velocity   = ord(substr($trackdata, $eventsoffset++, 1));
144
145                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0A) { // Key after-touch
146
147                                                $notenumber = ord(substr($trackdata, $eventsoffset++, 1));
148                                                $velocity   = ord(substr($trackdata, $eventsoffset++, 1));
149
150                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0B) { // Control Change
151
152                                                $controllernum = ord(substr($trackdata, $eventsoffset++, 1));
153                                                $newvalue      = ord(substr($trackdata, $eventsoffset++, 1));
154
155                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0C) { // Program (patch) change
156
157                                                $newprogramnum = ord(substr($trackdata, $eventsoffset++, 1));
158
159                                                $thisfile_midi_raw['track'][$tracknumber]['instrumentid'] = $newprogramnum;
160                                                if ($tracknumber == 10) {
161                                                        $thisfile_midi_raw['track'][$tracknumber]['instrument'] = $this->GeneralMIDIpercussionLookup($newprogramnum);
162                                                } else {
163                                                        $thisfile_midi_raw['track'][$tracknumber]['instrument'] = $this->GeneralMIDIinstrumentLookup($newprogramnum);
164                                                }
165
166                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0D) { // Channel after-touch
167
168                                                $channelnumber = ord(substr($trackdata, $eventsoffset++, 1));
169
170                                        } elseif ($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0E) { // Pitch wheel change (2000H is normal or no change)
171
172                                                $changeLSB = ord(substr($trackdata, $eventsoffset++, 1));
173                                                $changeMSB = ord(substr($trackdata, $eventsoffset++, 1));
174                                                $pitchwheelchange = (($changeMSB & 0x7F) << 7) & ($changeLSB & 0x7F);
175
176                                        } elseif (($MIDIevents[$tracknumber][$eventid]['eventid'] == 0x0F) && ($MIDIevents[$tracknumber][$eventid]['channel'] == 0x0F)) {
177
178                                                $METAeventCommand = ord(substr($trackdata, $eventsoffset++, 1));
179                                                $METAeventLength  = ord(substr($trackdata, $eventsoffset++, 1));
180                                                $METAeventData    = substr($trackdata, $eventsoffset, $METAeventLength);
181                                                $eventsoffset += $METAeventLength;
182                                                switch ($METAeventCommand) {
183                                                        case 0x00: // Set track sequence number
184                                                                $track_sequence_number = getid3_lib::BigEndian2Int(substr($METAeventData, 0, $METAeventLength));
185                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['seqno'] = $track_sequence_number;
186                                                                break;
187
188                                                        case 0x01: // Text: generic
189                                                                $text_generic = substr($METAeventData, 0, $METAeventLength);
190                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['text'] = $text_generic;
191                                                                $thisfile_midi['comments']['comment'][] = $text_generic;
192                                                                break;
193
194                                                        case 0x02: // Text: copyright
195                                                                $text_copyright = substr($METAeventData, 0, $METAeventLength);
196                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['copyright'] = $text_copyright;
197                                                                $thisfile_midi['comments']['copyright'][] = $text_copyright;
198                                                                break;
199
200                                                        case 0x03: // Text: track name
201                                                                $text_trackname = substr($METAeventData, 0, $METAeventLength);
202                                                                $thisfile_midi_raw['track'][$tracknumber]['name'] = $text_trackname;
203                                                                break;
204
205                                                        case 0x04: // Text: track instrument name
206                                                                $text_instrument = substr($METAeventData, 0, $METAeventLength);
207                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['instrument'] = $text_instrument;
208                                                                break;
209
210                                                        case 0x05: // Text: lyrics
211                                                                $text_lyrics  = substr($METAeventData, 0, $METAeventLength);
212                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['lyrics'] = $text_lyrics;
213                                                                if (!isset($thisfile_midi['lyrics'])) {
214                                                                        $thisfile_midi['lyrics'] = '';
215                                                                }
216                                                                $thisfile_midi['lyrics'] .= $text_lyrics."\n";
217                                                                break;
218
219                                                        case 0x06: // Text: marker
220                                                                $text_marker = substr($METAeventData, 0, $METAeventLength);
221                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['marker'] = $text_marker;
222                                                                break;
223
224                                                        case 0x07: // Text: cue point
225                                                                $text_cuepoint = substr($METAeventData, 0, $METAeventLength);
226                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['cuepoint'] = $text_cuepoint;
227                                                                break;
228
229                                                        case 0x2F: // End Of Track
230                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['EOT'] = $CumulativeDeltaTime;
231                                                                break;
232
233                                                        case 0x51: // Tempo: microseconds / quarter note
234                                                                $CurrentMicroSecondsPerBeat = getid3_lib::BigEndian2Int(substr($METAeventData, 0, $METAeventLength));
235                                                                if ($CurrentMicroSecondsPerBeat == 0) {
236                                                                        $this->error('Corrupt MIDI file: CurrentMicroSecondsPerBeat == zero');
237                                                                        return false;
238                                                                }
239                                                                $thisfile_midi_raw['events'][$tracknumber][$CumulativeDeltaTime]['us_qnote'] = $CurrentMicroSecondsPerBeat;
240                                                                $CurrentBeatsPerMinute = (1000000 / $CurrentMicroSecondsPerBeat) * 60;
241                                                                $MicroSecondsPerQuarterNoteAfter[$CumulativeDeltaTime] = $CurrentMicroSecondsPerBeat;
242                                                                $TicksAtCurrentBPM = 0;
243                                                                break;
244
245                                                        case 0x58: // Time signature
246                                                                $timesig_numerator   = getid3_lib::BigEndian2Int($METAeventData{0});
247                                                                $timesig_denominator = pow(2, getid3_lib::BigEndian2Int($METAeventData{1})); // $02 -> x/4, $03 -> x/8, etc
248                                                                $timesig_32inqnote   = getid3_lib::BigEndian2Int($METAeventData{2});         // number of 32nd notes to the quarter note
249                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['timesig_32inqnote']   = $timesig_32inqnote;
250                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['timesig_numerator']   = $timesig_numerator;
251                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['timesig_denominator'] = $timesig_denominator;
252                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['timesig_text']        = $timesig_numerator.'/'.$timesig_denominator;
253                                                                $thisfile_midi['timesignature'][] = $timesig_numerator.'/'.$timesig_denominator;
254                                                                break;
255
256                                                        case 0x59: // Keysignature
257                                                                $keysig_sharpsflats = getid3_lib::BigEndian2Int($METAeventData{0});
258                                                                if ($keysig_sharpsflats & 0x80) {
259                                                                        // (-7 -> 7 flats, 0 ->key of C, 7 -> 7 sharps)
260                                                                        $keysig_sharpsflats -= 256;
261                                                                }
262
263                                                                $keysig_majorminor  = getid3_lib::BigEndian2Int($METAeventData{1}); // 0 -> major, 1 -> minor
264                                                                $keysigs = array(-7=>'Cb', -6=>'Gb', -5=>'Db', -4=>'Ab', -3=>'Eb', -2=>'Bb', -1=>'F', 0=>'C', 1=>'G', 2=>'D', 3=>'A', 4=>'E', 5=>'B', 6=>'F#', 7=>'C#');
265                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['keysig_sharps'] = (($keysig_sharpsflats > 0) ? abs($keysig_sharpsflats) : 0);
266                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['keysig_flats']  = (($keysig_sharpsflats < 0) ? abs($keysig_sharpsflats) : 0);
267                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['keysig_minor']  = (bool) $keysig_majorminor;
268                                                                //$thisfile_midi_raw['events'][$tracknumber][$eventid]['keysig_text']   = $keysigs[$keysig_sharpsflats].' '.($thisfile_midi_raw['events'][$tracknumber][$eventid]['keysig_minor'] ? 'minor' : 'major');
269
270                                                                // $keysigs[$keysig_sharpsflats] gets an int key (correct) - $keysigs["$keysig_sharpsflats"] gets a string key (incorrect)
271                                                                $thisfile_midi['keysignature'][] = $keysigs[$keysig_sharpsflats].' '.((bool) $keysig_majorminor ? 'minor' : 'major');
272                                                                break;
273
274                                                        case 0x7F: // Sequencer specific information
275                                                                $custom_data = substr($METAeventData, 0, $METAeventLength);
276                                                                break;
277
278                                                        default:
279                                                                $this->warning('Unhandled META Event Command: '.$METAeventCommand);
280                                                                break;
281                                                }
282
283                                        } else {
284
285                                                $this->warning('Unhandled MIDI Event ID: '.$MIDIevents[$tracknumber][$eventid]['eventid'].' + Channel ID: '.$MIDIevents[$tracknumber][$eventid]['channel']);
286
287                                        }
288                                }
289                                if (($tracknumber > 0) || (count($trackdataarray) == 1)) {
290                                        $thisfile_midi['totalticks'] = max($thisfile_midi['totalticks'], $CumulativeDeltaTime);
291                                }
292                        }
293                        $previoustickoffset      = null;
294                        $prevmicrosecondsperbeat = null;
295
296                        ksort($MicroSecondsPerQuarterNoteAfter);
297                        foreach ($MicroSecondsPerQuarterNoteAfter as $tickoffset => $microsecondsperbeat) {
298                                if (is_null($previoustickoffset)) {
299                                        $prevmicrosecondsperbeat = $microsecondsperbeat;
300                                        $previoustickoffset = $tickoffset;
301                                        continue;
302                                }
303                                if ($thisfile_midi['totalticks'] > $tickoffset) {
304
305                                        if ($thisfile_midi_raw['ticksperqnote'] == 0) {
306                                                $this->error('Corrupt MIDI file: ticksperqnote == zero');
307                                                return false;
308                                        }
309
310                                        $info['playtime_seconds'] += (($tickoffset - $previoustickoffset) / $thisfile_midi_raw['ticksperqnote']) * ($prevmicrosecondsperbeat / 1000000);
311
312                                        $prevmicrosecondsperbeat = $microsecondsperbeat;
313                                        $previoustickoffset = $tickoffset;
314                                }
315                        }
316                        if ($thisfile_midi['totalticks'] > $previoustickoffset) {
317
318                                if ($thisfile_midi_raw['ticksperqnote'] == 0) {
319                                        $this->error('Corrupt MIDI file: ticksperqnote == zero');
320                                        return false;
321                                }
322
323                                $info['playtime_seconds'] += (($thisfile_midi['totalticks'] - $previoustickoffset) / $thisfile_midi_raw['ticksperqnote']) * ($prevmicrosecondsperbeat / 1000000);
324
325                        }
326                }
327
328
329                if (!empty($info['playtime_seconds'])) {
330                        $info['bitrate'] = (($info['avdataend'] - $info['avdataoffset']) * 8) / $info['playtime_seconds'];
331                }
332
333                if (!empty($thisfile_midi['lyrics'])) {
334                        $thisfile_midi['comments']['lyrics'][] = $thisfile_midi['lyrics'];
335                }
336
337                return true;
338        }
339
340        /**
341         * @param int $instrumentid
342         *
343         * @return string
344         */
345        public function GeneralMIDIinstrumentLookup($instrumentid) {
346
347                $begin = __LINE__;
348
349                /** This is not a comment!
350
351                        0       Acoustic Grand
352                        1       Bright Acoustic
353                        2       Electric Grand
354                        3       Honky-Tonk
355                        4       Electric Piano 1
356                        5       Electric Piano 2
357                        6       Harpsichord
358                        7       Clavier
359                        8       Celesta
360                        9       Glockenspiel
361                        10      Music Box
362                        11      Vibraphone
363                        12      Marimba
364                        13      Xylophone
365                        14      Tubular Bells
366                        15      Dulcimer
367                        16      Drawbar Organ
368                        17      Percussive Organ
369                        18      Rock Organ
370                        19      Church Organ
371                        20      Reed Organ
372                        21      Accordian
373                        22      Harmonica
374                        23      Tango Accordian
375                        24      Acoustic Guitar (nylon)
376                        25      Acoustic Guitar (steel)
377                        26      Electric Guitar (jazz)
378                        27      Electric Guitar (clean)
379                        28      Electric Guitar (muted)
380                        29      Overdriven Guitar
381                        30      Distortion Guitar
382                        31      Guitar Harmonics
383                        32      Acoustic Bass
384                        33      Electric Bass (finger)
385                        34      Electric Bass (pick)
386                        35      Fretless Bass
387                        36      Slap Bass 1
388                        37      Slap Bass 2
389                        38      Synth Bass 1
390                        39      Synth Bass 2
391                        40      Violin
392                        41      Viola
393                        42      Cello
394                        43      Contrabass
395                        44      Tremolo Strings
396                        45      Pizzicato Strings
397                        46      Orchestral Strings
398                        47      Timpani
399                        48      String Ensemble 1
400                        49      String Ensemble 2
401                        50      SynthStrings 1
402                        51      SynthStrings 2
403                        52      Choir Aahs
404                        53      Voice Oohs
405                        54      Synth Voice
406                        55      Orchestra Hit
407                        56      Trumpet
408                        57      Trombone
409                        58      Tuba
410                        59      Muted Trumpet
411                        60      French Horn
412                        61      Brass Section
413                        62      SynthBrass 1
414                        63      SynthBrass 2
415                        64      Soprano Sax
416                        65      Alto Sax
417                        66      Tenor Sax
418                        67      Baritone Sax
419                        68      Oboe
420                        69      English Horn
421                        70      Bassoon
422                        71      Clarinet
423                        72      Piccolo
424                        73      Flute
425                        74      Recorder
426                        75      Pan Flute
427                        76      Blown Bottle
428                        77      Shakuhachi
429                        78      Whistle
430                        79      Ocarina
431                        80      Lead 1 (square)
432                        81      Lead 2 (sawtooth)
433                        82      Lead 3 (calliope)
434                        83      Lead 4 (chiff)
435                        84      Lead 5 (charang)
436                        85      Lead 6 (voice)
437                        86      Lead 7 (fifths)
438                        87      Lead 8 (bass + lead)
439                        88      Pad 1 (new age)
440                        89      Pad 2 (warm)
441                        90      Pad 3 (polysynth)
442                        91      Pad 4 (choir)
443                        92      Pad 5 (bowed)
444                        93      Pad 6 (metallic)
445                        94      Pad 7 (halo)
446                        95      Pad 8 (sweep)
447                        96      FX 1 (rain)
448                        97      FX 2 (soundtrack)
449                        98      FX 3 (crystal)
450                        99      FX 4 (atmosphere)
451                        100     FX 5 (brightness)
452                        101     FX 6 (goblins)
453                        102     FX 7 (echoes)
454                        103     FX 8 (sci-fi)
455                        104     Sitar
456                        105     Banjo
457                        106     Shamisen
458                        107     Koto
459                        108     Kalimba
460                        109     Bagpipe
461                        110     Fiddle
462                        111     Shanai
463                        112     Tinkle Bell
464                        113     Agogo
465                        114     Steel Drums
466                        115     Woodblock
467                        116     Taiko Drum
468                        117     Melodic Tom
469                        118     Synth Drum
470                        119     Reverse Cymbal
471                        120     Guitar Fret Noise
472                        121     Breath Noise
473                        122     Seashore
474                        123     Bird Tweet
475                        124     Telephone Ring
476                        125     Helicopter
477                        126     Applause
478                        127     Gunshot
479
480                */
481
482                return getid3_lib::EmbeddedLookup($instrumentid, $begin, __LINE__, __FILE__, 'GeneralMIDIinstrument');
483        }
484
485        /**
486         * @param int $instrumentid
487         *
488         * @return string
489         */
490        public function GeneralMIDIpercussionLookup($instrumentid) {
491
492                $begin = __LINE__;
493
494                /** This is not a comment!
495
496                        35      Acoustic Bass Drum
497                        36      Bass Drum 1
498                        37      Side Stick
499                        38      Acoustic Snare
500                        39      Hand Clap
501                        40      Electric Snare
502                        41      Low Floor Tom
503                        42      Closed Hi-Hat
504                        43      High Floor Tom
505                        44      Pedal Hi-Hat
506                        45      Low Tom
507                        46      Open Hi-Hat
508                        47      Low-Mid Tom
509                        48      Hi-Mid Tom
510                        49      Crash Cymbal 1
511                        50      High Tom
512                        51      Ride Cymbal 1
513                        52      Chinese Cymbal
514                        53      Ride Bell
515                        54      Tambourine
516                        55      Splash Cymbal
517                        56      Cowbell
518                        57      Crash Cymbal 2
519                        59      Ride Cymbal 2
520                        60      Hi Bongo
521                        61      Low Bongo
522                        62      Mute Hi Conga
523                        63      Open Hi Conga
524                        64      Low Conga
525                        65      High Timbale
526                        66      Low Timbale
527                        67      High Agogo
528                        68      Low Agogo
529                        69      Cabasa
530                        70      Maracas
531                        71      Short Whistle
532                        72      Long Whistle
533                        73      Short Guiro
534                        74      Long Guiro
535                        75      Claves
536                        76      Hi Wood Block
537                        77      Low Wood Block
538                        78      Mute Cuica
539                        79      Open Cuica
540                        80      Mute Triangle
541                        81      Open Triangle
542
543                */
544
545                return getid3_lib::EmbeddedLookup($instrumentid, $begin, __LINE__, __FILE__, 'GeneralMIDIpercussion');
546        }
547
548}
Note: See TracBrowser for help on using the repository browser.