开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
readmidi.cpp
资源名称：readmidi.rar　[点击查看]
上传用户：mengshanjx
上传日期：2013-09-13
资源大小：10k
文件大小：33k
源码类别：

midi

开发平台：

Visual C++

readmidi.cpp：源码内容
  1. /*
  3.   $Id: readmidi.c,v 1.6 2005/04/20 22:33:36 pkot Exp $
  5.   G N O K I I
  7.   A Linux/Unix toolset and driver for the mobile phones.
  9.   This file is part of gnokii.
  11.   Gnokii is free software; you can redistribute it and/or modify
  12.   it under the terms of the GNU General Public License as published by
  13.   the Free Software Foundation; either version 2 of the License, or
  14.   (at your option) any later version.
  16.   Gnokii is distributed in the hope that it will be useful,
  17.   but WITHOUT ANY WARRANTY; without even the implied warranty of
  18.   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19.   GNU General Public License for more details.
  21.   You should have received a copy of the GNU General Public License
  22.   along with gnokii; if not, write to the Free Software
  23.   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25.   Copyright (C) 1999-2000 Hugh Blemings & Pavel Jank ml.
  26.   Copyright (C) 2003      Tomi Ollila, BORBELY Zoltan
  28.   Functions to read and write common file types.
  30. */
  32. /*
  33.  * This file was downloaded from http://www.guru-group.fi/~too/sw/xring/
  34.  * The page states this is a GPL'd program, so I added an explicit GPL
  35.  * header (required by savannah). -- bozo
  36.  */
  38. /* embedding modified midifile.h and midifile.c into this file */
  40. /***** midifile.h ******/
  42. struct MF {
  43. /* definitions for MIDI file parsing code */
  44. int (*Mf_getc) (struct MF *);
  45. void (*Mf_header) (struct MF *, int, int, int);
  46. void (*Mf_trackstart) (struct MF *);
  47. void (*Mf_trackend) (struct MF *);
  48. void (*Mf_noteon) (struct MF *, int, int, int);
  49. void (*Mf_noteoff) (struct MF *, int, int, int);
  50. void (*Mf_pressure) (struct MF *, int, int, int);
  51. void (*Mf_parameter) (struct MF *, int, int, int);
  52. void (*Mf_pitchbend) (struct MF *, int, int, int);
  53. void (*Mf_program) (struct MF *, int, int);
  54. void (*Mf_chanpressure) (struct MF *, int, int);
  55. void (*Mf_sysex) (struct MF *, int, char *);
  56. void (*Mf_metamisc) (struct MF *, int, int, char *);
  57. void (*Mf_seqspecific) (struct MF *, int, int, char *);
  58. void (*Mf_seqnum) (struct MF *, int);
  59. void (*Mf_text) (struct MF *, int, int, char *);
  60. void (*Mf_eot) (struct MF *);
  61. void (*Mf_timesig) (struct MF *, int, int, int, int);
  62. void (*Mf_smpte) (struct MF *, int, int, int, int, int);
  63. void (*Mf_tempo) (struct MF *, long);
  64. void (*Mf_keysig) (struct MF *, int, int);
  65. void (*Mf_arbitrary) (struct MF *, int, char *);
  66. void (*Mf_error) (struct MF *, char *);
  67. /* definitions for MIDI file writing code */
  68. int (*Mf_putc) (struct MF *, int);
  69. long (*Mf_getpos) (struct MF *);
  70. int (*Mf_setpos) (struct MF *, long);
  71. void (*Mf_writetrack) (struct MF *, int);
  72. void (*Mf_writetempotrack) (struct MF *);
  73. /* variables */
  74. int Mf_nomerge; /* 1 => continue'ed system exclusives are */
  75. /* not collapsed. */
  76. long Mf_currtime; /* current time in delta-time units */
  78. /* private stuff */
  79. long Mf_toberead;
  80. long Mf_numbyteswritten;
  82. char *Msgbuff; /* message buffer */
  83. int Msgsize; /* Size of currently allocated Msg */
  84. int Msgindex; /* index of next available location in Msg */
  86. };
  88. float mf_ticks2sec(unsigned long ticks, int division, unsigned int tempo);
  89. unsigned long mf_sec2ticks(float secs, int division, unsigned int tempo);
  91. void mferror(struct MF *mf, char *s);
  93. /*void mfwrite(); */
  96. /* MIDI status commands most significant bit is 1 */
  97. #define note_off          0x80
  98. #define note_on           0x90
  99. #define poly_aftertouch   0xa0
  100. #define control_change     0xb0
  101. #define program_chng      0xc0
  102. #define channel_aftertouch      0xd0
  103. #define pitch_wheel       0xe0
  104. #define system_exclusive       0xf0
  105. #define delay_packet   (1111)
  107. /* 7 bit controllers */
  108. #define damper_pedal            0x40
  109. #define portamento         0x41
  110. #define sostenuto         0x42
  111. #define soft_pedal         0x43
  112. #define general_4               0x44
  113. #define hold_2         0x45
  114. #define general_5         0x50
  115. #define general_6         0x51
  116. #define general_7         0x52
  117. #define general_8         0x53
  118. #define tremolo_depth         0x5c
  119. #define chorus_depth         0x5d
  120. #define detune         0x5e
  121. #define phaser_depth         0x5f
  123. /* parameter values */
  124. #define data_inc         0x60
  125. #define data_dec         0x61
  127. /* parameter selection */
  128. #define non_reg_lsb         0x62
  129. #define non_reg_msb         0x63
  130. #define reg_lsb         0x64
  131. #define reg_msb         0x65
  133. /* Standard MIDI Files meta event definitions */
  134. #define meta_event 0xFF
  135. #define sequence_number  0x00
  136. #define text_event 0x01
  137. #define copyright_notice  0x02
  138. #define sequence_name     0x03
  139. #define instrument_name  0x04
  140. #define lyric          0x05
  141. #define marker 0x06
  142. #define cue_point 0x07
  143. #define channel_prefix 0x20
  144. #define end_of_track 0x2f
  145. #define set_tempo 0x51
  146. #define smpte_offset 0x54
  147. #define time_signature 0x58
  148. #define key_signature 0x59
  149. #define sequencer_specific 0x74
  151. /* Manufacturer's ID number */
  152. #define Seq_Circuits (0x01) /* Sequential Circuits Inc. */
  153. #define Big_Briar    (0x02) /* Big Briar Inc.           */
  154. #define Octave       (0x03) /* Octave/Plateau           */
  155. #define Moog         (0x04) /* Moog Music               */
  156. #define Passport     (0x05) /* Passport Designs         */
  157. #define Lexicon      (0x06) /* Lexicon                  */
  158. #define Tempi        (0x20) /* Bon Tempi                */
  159. #define Siel         (0x21) /* S.I.E.L.                 */
  160. #define Kawai        (0x41)
  161. #define Roland       (0x42)
  162. #define Korg         (0x42)
  163. #define Yamaha       (0x43)
  165. /* miscellaneous definitions */
  166. #define MThd 0x4d546864
  167. #define MTrk 0x4d54726b
  168. #define lowerbyte(x) ((unsigned char)(x & 0xff))
  169. #define upperbyte(x) ((unsigned char)((x & 0xff00)>>8))
  171. /* the midifile interface */
  172. void midifile(struct MF *mf);
  174. /***** midifile.c ******/
  176. /*
  177.  * midifile 1.11
  178.  * 
  179.  * Read and write a MIDI file.  Externally-assigned function pointers are 
  180.  * called upon recognizing things in the file.
  181.  *
  182.  * Original release ?
  183.  * June 1989 - Added writing capability, M. Czeiszperger.
  184.  *
  185.  *          The file format implemented here is called
  186.  *          Standard MIDI Files, and is part of the Musical
  187.  *          instrument Digital Interface specification.
  188.  *          The spec is avaiable from:
  189.  *
  190.  *               International MIDI Association
  191.  *               5316 West 57th Street
  192.  *               Los Angeles, CA 90056
  193.  *
  194.  *          An in-depth description of the spec can also be found
  195.  *          in the article "Introducing Standard MIDI Files", published
  196.  *          in Electronic Musician magazine, April, 1989.
  197.  * 
  198.  */
  200. #include "config.h"
  201. #include "misc.h"
  202. #include "gnokii.h"
  203. #include <stdio.h>
  204. #include <stdlib.h>
  205. #include <string.h>
  207. #define NULLFUNC NULL
  209. static void readheader(struct MF *mf);
  210. static int readtrack(struct MF *mf);
  211. static void chanmessage(struct MF *mf, int status, int c1, int c2);
  212. static void msginit(struct MF *mf);
  213. static void msgadd(struct MF *mf, int c);
  214. static void metaevent(struct MF *mf, int type);
  215. static void sysex(struct MF *mf);
  216. static int msgleng(struct MF *mf);
  217. static void badbyte(struct MF *mf, int c);
  218. static void biggermsg(struct MF *mf);
  219. static void mf_write_track_chunk(struct MF *mf, int which_track);
  220. static void mf_write_header_chunk(struct MF *mf, int format, int ntracks, int division);
  223. static long readvarinum(struct MF *mf);
  224. static long read32bit(struct MF *mf);
  225. static long to32bit(int, int, int, int);
  226. static int read16bit(struct MF *mf);
  227. static int to16bit(int, int);
  228. static char *msg(struct MF *mf);
  229. static void write32bit(struct MF *mf, unsigned long data);
  230. static void write16bit(struct MF *mf, int data);
  231. static int eputc(struct MF *mf, unsigned char c);
  232. static void WriteVarLen(struct MF *mf, unsigned long value);
  234. /* The only non-static function in this file. */
  235. void mfread(struct MF *mf)
  236. {
  237. if (mf->Mf_getc == NULLFUNC)
  238. mferror(mf, "mfread() called without setting Mf_getc");
  240. readheader(mf);
  241. while (readtrack(mf))
  242. ;
  243. }
  245. /* for backward compatibility with the original lib */
  246. void midifile(struct MF *mf)
  247. {
  248. mfread(mf);
  249. }
  251. /* read through the "MThd" or "MTrk" header string */
  252. static int readmt(struct MF *mf, char *s)
  253. {
  254. int n = 0;
  255. char *p = s;
  256. int c;
  258. while (n++ < 4 && (c = mf->Mf_getc(mf)) != EOF) {
  259. if (c != *p++) {
  260. char buff[32];
  261. (void) strcpy(buff, "expecting ");
  262. (void) strcat(buff, s);
  263. mferror(mf, buff);
  264. }
  265. }
  266. return c;
  267. }
  269. /* read a single character and abort on EOF */
  270. static int egetc(struct MF *mf)
  271. {
  272. int c = mf->Mf_getc(mf);
  274. if (c == EOF)
  275. mferror(mf, "premature EOF");
  276. mf->Mf_toberead--;
  277. return c;
  278. }
  280. /* read a header chunk */
  281. static void readheader(struct MF *mf)
  282. {
  283. int format, ntrks, division;
  285. if (readmt(mf, "MThd") == EOF)
  286. return;
  288. mf->Mf_toberead = read32bit(mf);
  289. format = read16bit(mf);
  290. ntrks = read16bit(mf);
  291. division = read16bit(mf);
  293. if (mf->Mf_header)
  294. (*mf->Mf_header) (mf, format, ntrks, division);
  296. /* flush any extra stuff, in case the length of header is not 6 */
  297. while (mf->Mf_toberead > 0)
  298. (void) egetc(mf);
  299. }
  301. static int readtrack(struct MF *mf)
  302. { /* read a track chunk */
  303. /* This array is indexed by the high half of a status byte.  It's */
  304. /* value is either the number of bytes needed (1 or 2) for a channel */
  305. /* message, or 0 (meaning it's not  a channel message). */
  306. static int chantype[] = {
  307. 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 through 0x70 */
  308. 2, 2, 2, 2, 1, 1, 2, 0 /* 0x80 through 0xf0 */
  309. };
  310. long lookfor;
  311. int c, c1, type;
  312. int sysexcontinue = 0; /* 1 if last message was an unfinished sysex */
  313. int running = 0;               /* 1 when running status used */
  314. int status = 0;        /* status value (e.g. 0x90==note-on) */
  315. int needed;
  317. if (readmt(mf, "MTrk") == EOF)
  318. return (0);
  320. mf->Mf_toberead = read32bit(mf);
  321. mf->Mf_currtime = 0;
  323. if (mf->Mf_trackstart)
  324. (*mf->Mf_trackstart) (mf);
  326. while (mf->Mf_toberead > 0) {
  328. mf->Mf_currtime += readvarinum(mf); /* delta time */
  330. c = egetc(mf);
  332. if (sysexcontinue && c != 0xf7)
  333. mferror(mf, "didn't find expected continuation of a sysex");
  335. if ((c & 0x80) == 0)
  336. { /* running status? */
  337. if (status == 0)
  338. mferror(mf, "unexpected running status");
  339. running = 1;
  340. }
  341. else
  342. {
  343. status = c;
  344. running = 0;
  345. }
  347. needed = chantype[(status >> 4) & 0xf];
  349. if (needed) { /* ie. is it a channel message? */
  351. if (running)
  352. c1 = c;
  353. else
  354. c1 = egetc(mf);
  355. chanmessage(mf, status, c1, (needed > 1) ? egetc(mf) : 0);
  356. continue;;
  357. }
  359. switch (c) {
  361. case 0xff: /* meta event */
  363. type = egetc(mf);
  364. lookfor = mf->Mf_toberead - readvarinum(mf);
  365. msginit(mf);
  367. while (mf->Mf_toberead > lookfor)
  368. msgadd(mf, egetc(mf));
  370. metaevent(mf, type);
  371. break;
  373. case 0xf0: /* start of system exclusive */
  375. lookfor = mf->Mf_toberead - readvarinum(mf);
  376. msginit(mf);
  377. msgadd(mf, 0xf0);
  379. while (mf->Mf_toberead > lookfor)
  380. msgadd(mf, c = egetc(mf));
  382. if (c == 0xf7 || mf->Mf_nomerge == 0)
  383. sysex(mf);
  384. else
  385. sysexcontinue = 1; /* merge into next msg */
  386. break;
  388. case 0xf7: /* sysex continuation or arbitrary stuff */
  390. lookfor = mf->Mf_toberead - readvarinum(mf);
  392. if (!sysexcontinue)
  393. msginit(mf);
  395. while (mf->Mf_toberead > lookfor)
  396. msgadd(mf, c = egetc(mf));
  398. if (!sysexcontinue) {
  399. if (mf->Mf_arbitrary)
  400. (*mf->Mf_arbitrary) (mf, msgleng(mf), msg(mf));
  401. } else if (c == 0xf7) {
  402. sysex(mf);
  403. sysexcontinue = 0;
  404. }
  405. break;
  406. default:
  407. badbyte(mf, c);
  408. break;
  409. }
  410. }
  411. if (mf->Mf_trackend)
  412. (*mf->Mf_trackend) (mf);
  413. return (1);
  414. }
  416. static void badbyte(struct MF *mf, int c)
  417. {
  418. char buff[32];
  420. (void) sprintf(buff, "unexpected byte: 0x%02x", c);
  421. mferror(mf, buff);
  422. }
  424. static void metaevent(struct MF *mf, int type)
  425. {
  426. int leng = msgleng(mf);
  427. char *m = msg(mf);
  429. switch (type) {
  430. case 0x00:
  431. if (mf->Mf_seqnum)
  432. (*mf->Mf_seqnum) (mf, to16bit(m[0], m[1]));
  433. break;
  434. case 0x01: /* Text event */
  435. case 0x02: /* Copyright notice */
  436. case 0x03: /* Sequence/Track name */
  437. case 0x04: /* Instrument name */
  438. case 0x05: /* Lyric */
  439. case 0x06: /* Marker */
  440. case 0x07: /* Cue point */
  441. case 0x08:
  442. case 0x09:
  443. case 0x0a:
  444. case 0x0b:
  445. case 0x0c:
  446. case 0x0d:
  447. case 0x0e:
  448. case 0x0f:
  449. /* These are all text events */
  450. if (mf->Mf_text)
  451. (*mf->Mf_text) (mf, type, leng, m);
  452. break;
  453. case 0x2f: /* End of Track */
  454. if (mf->Mf_eot)
  455. (*mf->Mf_eot) (mf);
  456. break;
  457. case 0x51: /* Set tempo */
  458. if (mf->Mf_tempo)
  459. (*mf->Mf_tempo) (mf, to32bit(0, m[0], m[1], m[2]));
  460. break;
  461. case 0x54:
  462. if (mf->Mf_smpte)
  463. (*mf->Mf_smpte) (mf, m[0], m[1], m[2], m[3], m[4]);
  464. break;
  465. case 0x58:
  466. if (mf->Mf_timesig)
  467. (*mf->Mf_timesig) (mf, m[0], m[1], m[2], m[3]);
  468. break;
  469. case 0x59:
  470. if (mf->Mf_keysig)
  471. (*mf->Mf_keysig) (mf, m[0], m[1]);
  472. break;
  473. case 0x7f:
  474. if (mf->Mf_seqspecific)
  475. (*mf->Mf_seqspecific) (mf, type, leng, m);
  476. break;
  477. default:
  478. if (mf->Mf_metamisc)
  479. (*mf->Mf_metamisc) (mf, type, leng, m);
  480. }
  481. }
  483. static void sysex(struct MF *mf)
  484. {
  485. if (mf->Mf_sysex)
  486. (*mf->Mf_sysex) (mf, msgleng(mf), msg(mf));
  487. }
  489. static void chanmessage(struct MF *mf, int status, int c1, int c2)
  490. {
  491. int chan = status & 0xf;
  493. switch (status & 0xf0) {
  494. case 0x80:
  495. if (mf->Mf_noteoff)
  496. (*mf->Mf_noteoff) (mf, chan, c1, c2);
  497. break;
  498. case 0x90:
  499. if (mf->Mf_noteon)
  500. (*mf->Mf_noteon) (mf, chan, c1, c2);
  501. break;
  502. case 0xa0:
  503. if (mf->Mf_pressure)
  504. (*mf->Mf_pressure) (mf, chan, c1, c2);
  505. break;
  506. case 0xb0:
  507. if (mf->Mf_parameter)
  508. (*mf->Mf_parameter) (mf, chan, c1, c2);
  509. break;
  510. case 0xe0:
  511. if (mf->Mf_pitchbend)
  512. (*mf->Mf_pitchbend) (mf, chan, c1, c2);
  513. break;
  514. case 0xc0:
  515. if (mf->Mf_program)
  516. (*mf->Mf_program) (mf, chan, c1);
  517. break;
  518. case 0xd0:
  519. if (mf->Mf_chanpressure)
  520. (*mf->Mf_chanpressure) (mf, chan, c1);
  521. break;
  522. }
  523. }
  525. /* readvarinum - read a varying-length number, and return the */
  526. /* number of characters it took. */
  528. static long readvarinum(struct MF *mf)
  529. {
  530. long value;
  531. int c;
  533. c = egetc(mf);
  534. value = c;
  535. if (c & 0x80) {
  536. value &= 0x7f;
  537. do {
  538. c = egetc(mf);
  539. value = (value << 7) + (c & 0x7f);
  540. } while (c & 0x80);
  541. }
  542. return (value);
  543. }
  545. static long to32bit(int c1, int c2, int c3, int c4)
  546. {
  547. long value = 0L;
  549. value = (c1 & 0xff);
  550. value = (value << 8) + (c2 & 0xff);
  551. value = (value << 8) + (c3 & 0xff);
  552. value = (value << 8) + (c4 & 0xff);
  553. return (value);
  554. }
  556. static int to16bit(int c1, int c2)
  557. {
  558. return ((c1 & 0xff) << 8) + (c2 & 0xff);
  559. }
  561. static long read32bit(struct MF *mf)
  562. {
  563. int c1, c2, c3, c4;
  565. c1 = egetc(mf);
  566. c2 = egetc(mf);
  567. c3 = egetc(mf);
  568. c4 = egetc(mf);
  569. return to32bit(c1, c2, c3, c4);
  570. }
  572. static int read16bit(struct MF *mf)
  573. {
  574. int c1, c2;
  575. c1 = egetc(mf);
  576. c2 = egetc(mf);
  577. return to16bit(c1, c2);
  578. }
  580. /* static */
  581. void mferror(struct MF *mf, char *s)
  582. {
  583. if (mf->Mf_error)
  584. (*mf->Mf_error) (mf, s);
  585. exit(1);
  586. }
  588. /* The code below allows collection of a system exclusive message of */
  589. /* arbitrary length.  The Msgbuff is expanded as necessary.  The only */
  590. /* visible data/routines are msginit(), msgadd(), msg(), msgleng(). */
  592. #define MSGINCREMENT 128
  594. static void msginit(struct MF *mf)
  595. {
  596. mf->Msgindex = 0;
  597. }
  599. static char *msg(struct MF *mf)
  600. {
  601. return (mf->Msgbuff);
  602. }
  604. static int msgleng(struct MF *mf)
  605. {
  606. return (mf->Msgindex);
  607. }
  609. static void msgadd(struct MF *mf, int c)
  610. {
  611. /* If necessary, allocate larger message buffer. */
  612. if (mf->Msgindex >= mf->Msgsize)
  613. biggermsg(mf);
  614. mf->Msgbuff[mf->Msgindex++] = c;
  615. }
  617. static void biggermsg(struct MF *mf)
  618. {
  619. char *newmess;
  620. char *oldmess = mf->Msgbuff;
  621. int oldleng = mf->Msgsize;
  623. mf->Msgsize += MSGINCREMENT;
  624. newmess = (char *) malloc((unsigned) (sizeof(char) * mf->Msgsize));
  626. if (newmess == NULL)
  627. mferror(mf, "malloc error!");
  629. /* copy old message into larger new one */
  630. if (oldmess != NULL) {
  631. register char *p = newmess;
  632. register char *q = oldmess;
  633. register char *endq = &oldmess[oldleng];
  635. for (; q != endq; p++, q++)
  636. *p = *q;
  637. free(oldmess);
  638. }
  639. mf->Msgbuff = newmess;
  640. }
  642. /*
  643.  * mfwrite() - The only fuction you'll need to call to write out
  644.  *             a midi file.
  645.  *
  646.  * format      0 - Single multi-channel track
  647.  *             1 - Multiple simultaneous tracks
  648.  *             2 - One or more sequentially independent
  649.  *                 single track patterns                
  650.  * ntracks     The number of tracks in the file.
  651.  * division    This is kind of tricky, it can represent two
  652.  *             things, depending on whether it is positive or negative
  653.  *             (bit 15 set or not).  If  bit  15  of division  is zero,
  654.  *             bits 14 through 0 represent the number of delta-time
  655.  *             "ticks" which make up a quarter note.  If bit  15 of
  656.  *             division  is  a one, delta-times in a file correspond to
  657.  *             subdivisions of a second similiar to  SMPTE  and  MIDI
  658.  *             time code.  In  this format bits 14 through 8 contain
  659.  *             one of four values - 24, -25, -29, or -30,
  660.  *             corresponding  to  the  four standard  SMPTE and MIDI
  661.  *             time code frame per second formats, where  -29
  662.  *             represents  30  drop  frame.   The  second  byte
  663.  *             consisting  of  bits 7 through 0 corresponds the the
  664.  *             resolution within a frame.  Refer the Standard MIDI
  665.  *             Files 1.0 spec for more details.
  666.  * fp          This should be the open file pointer to the file you
  667.  *             want to write.  It will have be a global in order
  668.  *             to work with Mf_putc.  
  669.  */
  670. void mfwrite(struct MF *mf, int format, int ntracks, int division)
  671. {
  672. int i;
  674. if (mf->Mf_putc == NULLFUNC)
  675. mferror(mf, "mfmf_write() called without setting Mf_putc");
  677. if (mf->Mf_writetrack == NULLFUNC)
  678. mferror(mf, "mfmf_write() called without setting Mf_writetrack");
  680. if (mf->Mf_getpos == NULLFUNC)
  681. mferror(mf, "mfmf_write() called without setting Mf_getpos");
  683. if (mf->Mf_setpos == NULLFUNC)
  684. mferror(mf, "mfmf_write() called without setting Mf_setpos");
  686. /* every MIDI file starts with a header */
  687. mf_write_header_chunk(mf, format, ntracks, division);
  689. /* In format 1 files, the first track is a tempo map */
  690. if (format == 1 && (mf->Mf_writetempotrack)) {
  691. (*mf->Mf_writetempotrack) (mf);
  692. }
  694. /* The rest of the file is a series of tracks */
  695. for (i = 0; i < ntracks; i++)
  696. mf_write_track_chunk(mf, i);
  697. }
  699. static void mf_write_track_chunk(struct MF *mf, int which_track)
  700. {
  701. unsigned long trkhdr, trklength;
  702. long offset, place_marker;
  705. trkhdr = MTrk;
  706. trklength = 0;
  708. /* Remember where the length was written, because we don't
  709.    know how long it will be until we've finished writing */
  710. offset = (*mf->Mf_getpos) (mf);
  712. #ifdef DEBUG
  713. printf("offset = %dn", (int) offset);
  714. #endif
  716. /* Write the track chunk header */
  717. write32bit(mf, trkhdr);
  718. write32bit(mf, trklength);
  720. mf->Mf_numbyteswritten = 0L; /* the header's length doesn't count */
  722. if (mf->Mf_writetrack) {
  723. (*mf->Mf_writetrack) (mf, which_track);
  724. }
  726. /* mf_write End of track meta event */
  727. eputc(mf, 0);
  728. eputc(mf, meta_event);
  729. eputc(mf, end_of_track);
  731. eputc(mf, 0);
  733. /* It's impossible to know how long the track chunk will be beforehand,
  734.    so the position of the track length data is kept so that it can
  735.    be written after the chunk has been generated */
  736. place_marker = (*mf->Mf_getpos) (mf);
  738. /* This method turned out not to be portable because the
  739.    parameter returned from ftell is not guaranteed to be
  740.    in bytes on every machine */
  741. /* track.length = place_marker - offset - (long) sizeof(track); */
  743. #ifdef DEBUG
  744. printf("length = %dn", (int) trklength);
  745. #endif
  747. if (mf->Mf_setpos(mf, offset) < 0)
  748. mferror(mf, "error seeking during final stage of write");
  750. trklength = mf->Mf_numbyteswritten;
  752. /* Re-mf_write the track chunk header with right length */
  753. write32bit(mf, trkhdr);
  754. write32bit(mf, trklength);
  756. mf->Mf_setpos(mf, place_marker);
  757. } /* End gen_track_chunk() */
  760. static void mf_write_header_chunk(struct MF *mf, int format, int ntracks, int division)
  761. {
  762. unsigned long ident, length;
  764. ident = MThd; /* Head chunk identifier                    */
  765. length = 6; /* Chunk length                             */
  767. /* individual bytes of the header must be written separately
  768.    to preserve byte order across cpu types :-( */
  769. write32bit(mf, ident);
  770. write32bit(mf, length);
  771. write16bit(mf, format);
  772. write16bit(mf, ntracks);
  773. write16bit(mf, division);
  774. } /* end gen_header_chunk() */
  777. /*
  778.  * mf_write_midi_event()
  779.  * 
  780.  * Library routine to mf_write a single MIDI track event in the standard MIDI
  781.  * file format. The format is:
  782.  *
  783.  *                    <delta-time><event>
  784.  *
  785.  * In this case, event can be any multi-byte midi message, such as
  786.  * "note on", "note off", etc.      
  787.  *
  788.  * delta_time - the time in ticks since the last event.
  789.  * type - the type of meta event.
  790.  * chan - The midi channel.
  791.  * data - A pointer to a block of chars containing the META EVENT,
  792.  *        data.
  793.  * size - The length of the meta-event data.
  794.  */
  795. int mf_write_midi_event(struct MF *mf, unsigned long delta_time, unsigned int type, unsigned int chan, unsigned char *data, unsigned long size)
  796. {
  797. int i;
  798. unsigned char c;
  800. WriteVarLen(mf, delta_time);
  802. /* all MIDI events start with the type in the first four bits,
  803.    and the channel in the lower four bits */
  804. c = type | chan;
  806. if (chan > 15)
  807. mferror(mf, "error: MIDI channel greater than 16n");
  809. eputc(mf, c);
  811. /* write out the data bytes */
  812. for (i = 0; i < size; i++)
  813. eputc(mf, data[i]);
  815. return (size);
  816. } /* end mf_write MIDI event */
  818. /*
  819.  * mf_write_meta_event()
  820.  *
  821.  * Library routine to mf_write a single meta event in the standard MIDI
  822.  * file format. The format of a meta event is:
  823.  *
  824.  *          <delta-time><FF><type><length><bytes>
  825.  *
  826.  * delta_time - the time in ticks since the last event.
  827.  * type - the type of meta event.
  828.  * data - A pointer to a block of chars containing the META EVENT,
  829.  *        data.
  830.  * size - The length of the meta-event data.
  831.  */
  832. int mf_write_meta_event(struct MF *mf, unsigned long delta_time, unsigned char type, unsigned char *data, unsigned long size)
  833. {
  834. int i;
  836. WriteVarLen(mf, delta_time);
  838. /* This marks the fact we're writing a meta-event */
  839. eputc(mf, meta_event);
  841. /* The type of meta event */
  842. eputc(mf, type);
  844. /* The length of the data bytes to follow */
  845. WriteVarLen(mf, size);
  847. for (i = 0; i < size; i++) {
  848. if (eputc(mf, data[i]) != data[i])
  849. return (-1);
  850. }
  851. return (size);
  852. } /* end mf_write_meta_event */
  854. void mf_write_tempo(struct MF *mf, unsigned long tempo)
  855. {
  856. /* Write tempo */
  857. /* all tempos are written as 120 beats/minute, */
  858. /* expressed in microseconds/quarter note     */
  859. eputc(mf, 0);
  860. eputc(mf, meta_event);
  861. eputc(mf, set_tempo);
  863. eputc(mf, 3);
  864. eputc(mf, (unsigned) (0xff & (tempo >> 16)));
  865. eputc(mf, (unsigned) (0xff & (tempo >> 8)));
  866. eputc(mf, (unsigned) (0xff & tempo));
  867. }
  869. /*
  870.  * Write multi-length bytes to MIDI format files
  871.  */
  872. static void WriteVarLen(struct MF *mf, unsigned long value)
  873. {
  874. unsigned long buffer;
  876. buffer = value & 0x7f;
  877. while ((value >>= 7) > 0) {
  878. buffer <<= 8;
  879. buffer |= 0x80;
  880. buffer += (value & 0x7f);
  881. }
  882. while (1) {
  883. eputc(mf, (unsigned) (buffer & 0xff));
  885. if (buffer & 0x80)
  886. buffer >>= 8;
  887. else
  888. return;
  889. }
  890. } /* end of WriteVarLen */
  893. /*
  894.  * write32bit()
  895.  * write16bit()
  896.  *
  897.  * These routines are used to make sure that the byte order of
  898.  * the various data types remains constant between machines. This
  899.  * helps make sure that the code will be portable from one system
  900.  * to the next.  It is slightly dangerous that it assumes that longs
  901.  * have at least 32 bits and ints have at least 16 bits, but this
  902.  * has been true at least on PCs, UNIX machines, and Macintosh's.
  903.  *
  904.  */
  905. static void write32bit(struct MF *mf, unsigned long data)
  906. {
  907. eputc(mf, (unsigned) ((data >> 24) & 0xff));
  908. eputc(mf, (unsigned) ((data >> 16) & 0xff));
  909. eputc(mf, (unsigned) ((data >> 8) & 0xff));
  910. eputc(mf, (unsigned) (data & 0xff));
  911. }
  913. static void write16bit(struct MF *mf, int data)
  914. {
  915. eputc(mf, (unsigned) ((data & 0xff00) >> 8));
  916. eputc(mf, (unsigned) (data & 0xff));
  917. }
  919. /* write a single character and abort on error */
  920. static int eputc(struct MF *mf, unsigned char c)
  921. {
  922. int return_val;
  924. if ((mf->Mf_putc) == NULLFUNC) {
  925. mferror(mf, "Mf_putc undefined");
  926. return (-1);
  927. }
  929. return_val = (mf->Mf_putc) (mf, c);
  931. if (return_val == EOF)
  932. mferror(mf, "error writing");
  934. mf->Mf_numbyteswritten++;
  935. return (return_val);
  936. }
  939. unsigned long mf_sec2ticks(float secs, int division, unsigned int tempo)
  940. {
  941. return (long) (((secs * 1000.0) / 4.0 * division) / tempo);
  942. }
  945. /* 
  946.  * This routine converts delta times in ticks into seconds. The
  947.  * else statement is needed because the formula is different for tracks
  948.  * based on notes and tracks based on SMPTE times.
  949.  *
  950.  */
  951. float mf_ticks2sec(unsigned long ticks, int division, unsigned int tempo)
  952. {
  953. float smpte_format, smpte_resolution;
  955. if (division > 0)
  956. return ((float)
  957. (((float) (ticks) * (float) (tempo)) /
  958.  ((float) (division) * 1000000.0)));
  959. else {
  960. smpte_format = upperbyte(division);
  961. smpte_resolution = lowerbyte(division);
  962. return (float) ((float) ticks /
  963. (smpte_format * smpte_resolution *
  964.  1000000.0));
  965. }
  966. } /* end of ticks2sec() */
  968. /* code to utilize the interface */
  970. #define TRACE(x, y) do { if (x) printf y; } while (0)
  973. typedef unsigned long ulg;
  974. typedef unsigned char uch;
  975. typedef unsigned int ui;
  977. struct MFX {
  978. struct MF mfi;
  980. int division;
  981. int trackstate;
  983. int prevnoteonpitch; /* -1, nothing, 0 pause, 1-x note. */
  984. ulg prevnoteontime;
  986. gn_ringtone *ringtone;
  987. FILE *istream;
  988. gn_error err;
  989. };
  991. enum { TRK_NONE, TRK_READING, TRK_FINISHED };
  994. static void lm_error(struct MF *mf, char *s);
  996. static int lm_getc(struct MF *mf);
  997. static void lm_header(struct MF *mf, int, int, int);
  998. static void lm_trackstart(struct MF *mf);
  999. static void lm_trackend(struct MF *mf);
  1000. static void lm_tempo(struct MF *, long);
  1001. static void lm_noteon(struct MF *, int, int, int);
  1002. static void lm_noteoff(struct MF *, int, int, int);
  1006. static void lm_error(struct MF *mf, char *s)
  1007. {
  1008. struct MFX *mfx = (struct MFX *) mf;
  1010. if (mfx->err == GN_ERR_NONE)
  1011. mfx->err = GN_ERR_WRONGDATAFORMAT;
  1012. fprintf(stderr, "%sn", s);
  1013. }
  1015. static int lm_getc(struct MF *mf)
  1016. {
  1017. struct MFX *mfx = (struct MFX *) mf;
  1018. int ch;
  1020. if ((ch = fgetc(mfx->istream)) == EOF)
  1021. return -1;
  1022. return ch;
  1023. }
  1025. static void lm_header(struct MF *mf, int format, int ntrks, int division)
  1026. {
  1027. struct MFX *mfx = (struct MFX *) mf;
  1029. TRACE(0, ("lm_header(%p, %d, %d, %d)n", mf, format, ntrks, division));
  1031. mfx->division = division;
  1032. }
  1034. /* this is just a quess */
  1035. static void lm_tempo(struct MF *mf, long tempo)
  1036. {
  1037. struct MFX *mfx = (struct MFX *) mf;
  1039. TRACE(0, ("lm_tempo(%p, %ld)n", mf, tempo));
  1041. if (mfx->trackstate != TRK_FINISHED)
  1042. mfx->ringtone->tempo = 60000000 / tempo;
  1043. }
  1046. static void addnote(struct MFX *mfx, int pitch, int duration, int special)
  1047. {
  1048. gn_ringtone_note *note;
  1049. int scale;
  1050. int lengths[] = { 4, 8, 16, 32, 64, 128 };
  1051.             /*  c, c#,  d, d#,  e,  f, f#,  g, g#,  a, a#,  h */
  1052. int notes[] = { 0,  1,  2,  3,  4,  6,  7,  8,  9, 10, 11, 12 };
  1054. /* truncate the ringtone if it's too long */
  1055. if (mfx->ringtone->notes_count == GN_RINGTONE_MAX_NOTES-1)
  1056. return;
  1058. note = mfx->ringtone->notes + mfx->ringtone->notes_count;
  1059. mfx->ringtone->notes_count++;
  1061. if (pitch == 0) {
  1062. /* pause */
  1063. note->note = 255;
  1064. } else {
  1065. pitch--;
  1066. scale = pitch / 12;
  1067. if (scale < 4)
  1068. scale = 0;
  1069. else if (scale > 7)
  1070. scale = 3;
  1071. else
  1072. scale -= 4;
  1073. note->note = 14 * (pitch / 12 - 4) + notes[pitch % 12];
  1074. }
  1076. if (duration < sizeof(lengths) / sizeof(lengths[0]))
  1077. note->duration = lengths[duration];
  1078. else
  1079. note->duration = 4;
  1080. if (special)
  1081. note->duration *= 1.5;
  1082. }
  1084. /* currently supported */
  1085. static /*  N  32  32. 16  16.   8    8.   4    4.   2    2.   1     1.  */
  1086. int vals[] = { 15, 38, 54, 78, 109, 156, 218, 312, 437, 625, 875, 1250 };
  1088. static void writenote(struct MFX *mfx, int delta)
  1089. {
  1090. ulg millinotetime = delta * 250 / mfx->division;
  1091. int i;
  1092. int duration;
  1093. int special;
  1095. for (i = 0; i < sizeof vals / sizeof vals[0]; i++) {
  1096. if (millinotetime < vals[i])
  1097. break;
  1098. }
  1100. if (i == 0)
  1101. return;
  1103. i--;
  1104. duration = i / 2;
  1105. special = i & 1;
  1107. addnote(mfx, mfx->prevnoteonpitch, duration, special); /* XXX think this */
  1108. }
  1111. static void lm_trackstart(struct MF *mf)
  1112. {
  1113. struct MFX *mfx = (struct MFX *) mf;
  1115. TRACE(0, ("lm_trackstart(%p)n", mf));
  1117. if (mfx->trackstate == TRK_NONE)
  1118. mfx->trackstate = TRK_READING;
  1120. mfx->prevnoteonpitch = -1;
  1121. }
  1123. static void lm_trackend(struct MF *mf)
  1124. {
  1125. struct MFX *mfx = (struct MFX *) mf;
  1126. long time = mf->Mf_currtime;
  1128. TRACE(0, ("lm_trackend(%p)n", mf));
  1130. if (mfx->trackstate == TRK_READING && mfx->ringtone->notes_count > 0)
  1131. mfx->trackstate = TRK_FINISHED;
  1133. if (mfx->prevnoteonpitch >= 0)
  1134. writenote(mfx, time - mfx->prevnoteontime);
  1136. mfx->prevnoteonpitch = -1;
  1137. }
  1139. static void lm_noteon(struct MF *mf, int chan, int pitch, int vol)
  1140. {
  1141. struct MFX *mfx = (struct MFX *) mf;
  1142. long time = mf->Mf_currtime;
  1144. TRACE(0, ("lm_noteon(%p, %d, %d, %d)n", mf, chan, pitch, vol));
  1146. if (vol == 0) /* kludge? to handle some (format 1? midi files) */
  1147. return;
  1149. if (mfx->trackstate != TRK_READING)
  1150. return;
  1152. if (mfx->prevnoteonpitch >= 0)
  1153. writenote(mfx, time - mfx->prevnoteontime);
  1155. if (vol == 0)
  1156. mfx->prevnoteonpitch = 0;
  1157. else
  1158. mfx->prevnoteonpitch = pitch + 1;
  1160. mfx->prevnoteontime = time;
  1161. }
  1163. static void lm_noteoff(struct MF *mf, int chan, int pitch, int vol)
  1164. {
  1165. struct MFX *mfx = (struct MFX *) mf;
  1166. long time = mf->Mf_currtime;
  1168. TRACE(0, ("lm_noteoff(%p, %d, %d, %d)n", mf, chan, pitch, vol));
  1170. if (mfx->prevnoteonpitch >= 0) {
  1171. writenote(mfx, time - mfx->prevnoteontime);
  1172. mfx->prevnoteonpitch = -1;
  1173. }
  1174. mfx->prevnoteonpitch = 0;
  1175. mfx->prevnoteontime = time;
  1176. }
  1178. static int lm_putc(struct MF *mf, int c)
  1179. {
  1180. struct MFX *mfx = (struct MFX *) mf;
  1182. return fputc(c, mfx->istream);
  1183. }
  1185. static long lm_getpos(struct MF *mf)
  1186. {
  1187. struct MFX *mfx = (struct MFX *) mf;
  1189. return ftell(mfx->istream);
  1190. }
  1192. static int lm_setpos(struct MF *mf, long pos)
  1193. {
  1194. struct MFX *mfx = (struct MFX *) mf;
  1196. return fseek(mfx->istream, pos, SEEK_SET);
  1197. }
  1199. static void lm_writetrack(struct MF *mf, int track)
  1200. {
  1201. struct MFX *mfx = (struct MFX *) mf;
  1202. gn_ringtone_note *note;
  1203. int i, delta;
  1204. int volume = 100;
  1205. char data[2];
  1206. int notes[] = {0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9, 10, 11, 11};
  1208. mf_write_tempo(mf, 60000000 / mfx->ringtone->tempo);
  1210. for (i = 0; i < mfx->ringtone->notes_count; i++) {
  1211. note = mfx->ringtone->notes + i;
  1212. delta = note->duration * mfx->division / 32;
  1213. if (note->note == 0xff) {
  1214. data[0] = 0;
  1215. data[1] = 0;
  1216. mf_write_midi_event(mf, delta, note_off, 1, data, 2);
  1217. } else {
  1218. data[0] = 12 * (4 + note->note / 14) + notes[note->note % 14];
  1219. data[1] = volume;
  1220. mf_write_midi_event(mf, 1, note_on, 1, data, 2);
  1221. data[1] = 0;
  1222. mf_write_midi_event(mf, delta, note_off, 1, data, 2);
  1223. }
  1224. }
  1225. }
  1227. gn_error file_midi_load(FILE * file, gn_ringtone * ringtone)
  1228. {
  1229. struct MFX mfxi;
  1230. struct MF *mf;
  1232. ringtone->location = 0;
  1233. strcpy(ringtone->name, "GNOKII");
  1234. ringtone->tempo = 120;
  1235. ringtone->notes_count = 0;
  1237. memset(&mfxi, 0, sizeof(struct MFX));
  1238. mf = &mfxi.mfi;
  1240. mfxi.ringtone = ringtone;
  1241. mfxi.istream = file;
  1242. mfxi.err = GN_ERR_NONE;
  1244. /* set variables to their initial values */
  1245. mfxi.division = 0;
  1246. mfxi.trackstate = TRK_NONE;
  1247. mfxi.prevnoteonpitch = -1;
  1249. mf->Mf_getc = lm_getc;
  1251. mf->Mf_header = lm_header;
  1252. mf->Mf_tempo = lm_tempo;
  1253. mf->Mf_trackstart = lm_trackstart;
  1254. mf->Mf_trackend = lm_trackend;
  1255. mf->Mf_noteon = lm_noteon;
  1256. mf->Mf_noteoff = lm_noteoff;
  1258. mf->Mf_error = lm_error;
  1260. midifile(mf);
  1262. return mfxi.err;
  1263. }
  1265. gn_error file_midi_save(FILE * file, gn_ringtone * ringtone)
  1266. {
  1267. struct MFX mfxi;
  1268. struct MF *mf;
  1270. memset(&mfxi, 0, sizeof(struct MFX));
  1271. mf = &mfxi.mfi;
  1273. mfxi.ringtone = ringtone;
  1274. mfxi.istream = file;
  1275. mfxi.err = GN_ERR_NONE;
  1277. /* set variables to their initial values */
  1278. mfxi.division = 480;
  1280. mf->Mf_putc = lm_putc;
  1281. mf->Mf_getpos = lm_getpos;
  1282. mf->Mf_setpos = lm_setpos;
  1283. mf->Mf_writetrack = lm_writetrack;
  1284. mf->Mf_writetempotrack = NULLFUNC;
  1286. mf->Mf_error = lm_error;
  1288. mfwrite(mf, 0, 1, mfxi.division);
  1290. return mfxi.err;
  1291. }