libcm is a C development framework with an emphasis on audio signal processing applications.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

cmMidiFile.h 10.0KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247
  1. #ifndef cmMidiFile_h
  2. #define cmMidiFile_h
  3. #ifdef __cplusplus
  4. extern "C" {
  5. #endif
  6. //( { file_desc:"MIDI file reader and writer." kw:[midi file]}
  7. // MIDI file timing:
  8. // Messages in the MIDI file are time tagged with a delta offset in 'ticks'
  9. // from the previous message in the same track.
  10. //
  11. // A 'tick' can be converted to microsends as follows:
  12. //
  13. // microsecond per tick = micros per quarter note / ticks per quarter note
  14. //
  15. // MpT = MpQN / TpQN
  16. //
  17. // TpQN is given as a constant in the MIDI file header.
  18. // MpQN is given as the value of the MIDI file tempo message.
  19. //
  20. // See cmMidiFileSeekUSecs() for an example of converting ticks to milliseconds.
  21. //
  22. // As part of the file reading process, the status byte of note-on messages
  23. // with velocity=0 are is changed to a note-off message. See _cmMidiFileReadChannelMsg().
  24. //)
  25. //(
  26. typedef cmHandle_t cmMidiFileH_t;
  27. typedef unsigned cmMfRC_t;
  28. typedef struct
  29. {
  30. cmMidiByte_t hr;
  31. cmMidiByte_t min;
  32. cmMidiByte_t sec;
  33. cmMidiByte_t frm;
  34. cmMidiByte_t sfr;
  35. } cmMidiSmpte_t;
  36. typedef struct
  37. {
  38. cmMidiByte_t num;
  39. cmMidiByte_t den;
  40. cmMidiByte_t metro;
  41. cmMidiByte_t th2s;
  42. } cmMidiTimeSig_t;
  43. typedef struct
  44. {
  45. cmMidiByte_t key;
  46. cmMidiByte_t scale;
  47. } cmMidiKeySig_t;
  48. struct cmMidiTrackMsg_str;
  49. typedef struct
  50. {
  51. cmMidiByte_t ch;
  52. cmMidiByte_t d0;
  53. cmMidiByte_t d1;
  54. unsigned durMicros; // note duration in microseconds (corrected for tempo changes)
  55. struct cmMidiTrackMsg_str* end; // note-off or pedal-up message
  56. } cmMidiChMsg_t;
  57. typedef struct cmMidiTrackMsg_str
  58. {
  59. unsigned uid; // uid's are unique among all msg's in the file
  60. unsigned dtick; // delta ticks between events on this track
  61. unsigned long long atick; // global (all tracks interleaved) accumulated ticks
  62. unsigned long long amicro; // global (all tracks interleaved) accumulated microseconds adjusted for tempo changes
  63. cmMidiByte_t status; // ch msg's have the channel value removed (it is stored in u.chMsgPtr->ch)
  64. cmMidiByte_t metaId; //
  65. unsigned short trkIdx; //
  66. unsigned byteCnt; // length of data pointed to by u.voidPtr (or any other pointer in the union)
  67. struct cmMidiTrackMsg_str* link; // link to next record in this track
  68. union
  69. {
  70. cmMidiByte_t bVal;
  71. unsigned iVal;
  72. unsigned short sVal;
  73. const char* text;
  74. const void* voidPtr;
  75. const cmMidiSmpte_t* smptePtr;
  76. const cmMidiTimeSig_t* timeSigPtr;
  77. const cmMidiKeySig_t* keySigPtr;
  78. const cmMidiChMsg_t* chMsgPtr;
  79. const cmMidiByte_t* sysExPtr;
  80. } u;
  81. } cmMidiTrackMsg_t;
  82. #define cmMidiFileIsNoteOn(m) (cmMidiIsNoteOn((m)->status) && (m)->u.chMsgPtr->d1>0)
  83. #define cmMidiFileIsNoteOff(m) (cmMidiIsNoteOff((m)->status,(m)->u.chMsgPtr->d1))
  84. #define cmMidiFileIsSustainPedalUp(m) (cmMidiIsSustainPedalUp( (m)->status,(m)->u.chMsgPtr->d0,(m)->u.chMsgPtr->d1))
  85. #define cmMidiFileIsSustainPedalDown(m) (cmMidiIsSustainPedalDown( (m)->status,(m)->u.chMsgPtr->d0,(m)->u.chMsgPtr->d1))
  86. #define cmMidiFileIsSostenutoPedalUp(m) (cmMidiIsSostenutoPedalUp( (m)->status,(m)->u.chMsgPtr->d0,(m)->u.chMsgPtr->d1))
  87. #define cmMidiFileIsSostenutoPedalDown(m) (cmMidiIsSostenutoPedalDown((m)->status,(m)->u.chMsgPtr->d0,(m)->u.chMsgPtr->d1))
  88. enum
  89. {
  90. kOkMfRC = cmOkRC, // 0
  91. kFileFailMfRC, // 1
  92. kNotAMidiFileMfRC, // 2
  93. kMemAllocFailMfRC, // 3
  94. kFileCorruptMfRC, // 4
  95. kMissingEoxMfRC, // 5
  96. kUnknownMetaIdMfRC, // 6
  97. kInvalidHandleMfRC, // 7
  98. kMissingNoteOffMfRC, // 8
  99. kInvalidStatusMfRC, // 9
  100. kSustainPedalMfRC, // 10
  101. kSostenutoPedalMfRC, // 11
  102. kLargeDeltaTickMfRC, // 12 (a large delta tick value was filtered)
  103. kUidNotFoundMfRC, // 13
  104. kUidNotANoteMsgMfRC, // 14
  105. kInvalidTrkIndexMfRC,// 15
  106. kSvgFailMfRC // 16
  107. };
  108. extern cmMidiFileH_t cmMidiFileNullHandle;
  109. cmMfRC_t cmMidiFileOpen( cmCtx_t* ctx, cmMidiFileH_t* h, const char* fn );
  110. cmMfRC_t cmMidiFileCreate( cmCtx_t* ctx, cmMidiFileH_t* hp, unsigned trkN, unsigned ticksPerQN );
  111. cmMfRC_t cmMidiFileClose( cmMidiFileH_t* hp );
  112. cmMfRC_t cmMidiFileWrite( cmMidiFileH_t h, const char* fn );
  113. bool cmMidiFileIsValid( cmMidiFileH_t h );
  114. // Returns track count or kInvalidCnt if 'h' is invalid.
  115. unsigned cmMidiFileTrackCount( cmMidiFileH_t h );
  116. // Return midi file format id (0,1,2) or kInvalidId if 'h' is invalid.
  117. unsigned cmMidiFileType( cmMidiFileH_t h );
  118. // Returns ticks per quarter note or kInvalidMidiByte if 'h' is
  119. // invalid or 0 if file uses SMPTE ticks per frame time base.
  120. unsigned cmMidiFileTicksPerQN( cmMidiFileH_t h );
  121. // The file name used in an earlier call to midiFileOpen() or NULL if this
  122. // midi file did not originate from an actual file.
  123. const char* cmMidiFileName( cmMidiFileH_t h );
  124. // Returns SMPTE ticks per frame or kInvalidMidiByte if 'h' is
  125. // invalid or 0 if file uses ticks per quarter note time base.
  126. cmMidiByte_t cmMidiFileTicksPerSmpteFrame( cmMidiFileH_t h );
  127. // Returns SMPTE format or kInvalidMidiByte if 'h' is invalid or 0
  128. // if file uses ticks per quarter note time base.
  129. cmMidiByte_t cmMidiFileSmpteFormatId( cmMidiFileH_t h );
  130. // Returns count of records in track 'trackIdx' or kInvalidCnt if 'h' is invalid.
  131. unsigned cmMidiFileTrackMsgCount( cmMidiFileH_t h, unsigned trackIdx );
  132. // Returns base of record chain from track 'trackIdx' or NULL if 'h' is invalid.
  133. const cmMidiTrackMsg_t* cmMidiFileTrackMsg( cmMidiFileH_t h, unsigned trackIdx );
  134. // Returns the total count of records in the midi file and the
  135. // number in the array returned by cmMidiFileMsgArray().
  136. // Return kInvalidCnt if 'h' is invalid.
  137. unsigned cmMidiFileMsgCount( cmMidiFileH_t h );
  138. // Returns a pointer to the base of an array of pointers to all records
  139. // in the file sorted in ascending time order.
  140. // Returns NULL if 'h' is invalid.
  141. const cmMidiTrackMsg_t** cmMidiFileMsgArray( cmMidiFileH_t h );
  142. // Set the velocity of a note-on/off msg identified by 'uid'.
  143. cmMfRC_t cmMidiFileSetVelocity( cmMidiFileH_t h, unsigned uid, cmMidiByte_t vel );
  144. // Insert a MIDI message relative to the reference msg identified by 'uid'.
  145. // If dtick is positive/negative then the new msg is inserted after/before the reference msg.
  146. cmMfRC_t cmMidiFileInsertMsg( cmMidiFileH_t h, unsigned uid, int dtick, cmMidiByte_t ch, cmMidiByte_t status, cmMidiByte_t d0, cmMidiByte_t d1 );
  147. //
  148. // Insert a new cmMidiTrackMsg_t into the MIDI file on the specified track.
  149. //
  150. // Only the following fields need be set in 'msg'.
  151. // atick - used to position the msg in the track
  152. // status - this field is always set (Note that channel information must stripped from the status byte and included in the channel msg data)
  153. // metaId - this field is optional depending on the msg type
  154. // byteCnt - used to allocate storage for the data element in 'cmMidiTrackMsg_t.u'
  155. // u - the message data
  156. //
  157. cmMfRC_t cmMidiFileInsertTrackMsg( cmMidiFileH_t h, unsigned trkIdx, const cmMidiTrackMsg_t* msg );
  158. cmMfRC_t cmMidiFileInsertTrackChMsg( cmMidiFileH_t h, unsigned trkIdx, unsigned atick, cmMidiByte_t status, cmMidiByte_t d0, cmMidiByte_t d1 );
  159. cmMfRC_t cmMidFileInsertTrackTempoMsg( cmMidiFileH_t h, unsigned trkIdx, unsigned atick, unsigned bpm );
  160. // Return a pointer to the first msg at or after 'usecsOffs' or kInvalidIdx if no
  161. // msg exists after 'usecsOffs'. Note that 'usecOffs' is an offset from the beginning
  162. // of the file.
  163. // On return *'msgUsecsPtr' is set to the actual time of the msg.
  164. // (which will be equal to or greater than 'usecsOffs').
  165. unsigned cmMidiFileSeekUsecs( cmMidiFileH_t h, unsigned long long usecsOffs, unsigned* msgUsecsPtr, unsigned* newMicrosPerTickPtr );
  166. double cmMidiFileDurSecs( cmMidiFileH_t h );
  167. // Calculate Note Duration
  168. void cmMidiFileCalcNoteDurations( cmMidiFileH_t h );
  169. // Set the delay prior to the first non-zero msg.
  170. void cmMidiFileSetDelay( cmMidiFileH_t h, unsigned ticks );
  171. // This function packs a track msg into a single consecutive
  172. // block of memory buf[ bufByteCnt ]. Call cmMidiFilePackTracMsgBufByteCount()
  173. // to get the required buffer length for any given cmMidiTrackMsg_t instance.
  174. cmMidiTrackMsg_t* cmMidiFilePackTrackMsg( const cmMidiTrackMsg_t* m, void* buf, unsigned bufByteCnt );
  175. unsigned cmMidiFilePackTrackMsgBufByteCount( const cmMidiTrackMsg_t* m );
  176. void cmMidiFilePrintMsgs( cmMidiFileH_t h, cmRpt_t* rpt );
  177. void cmMidiFilePrintTrack( cmMidiFileH_t h, unsigned trkIdx, cmRpt_t* rpt );
  178. typedef struct
  179. {
  180. unsigned uid;
  181. unsigned long long amicro;
  182. unsigned density;
  183. } cmMidiFileDensity_t;
  184. // Generate the note onset density measure for each note in the MIDI file.
  185. // Delete the returned memory with a call to cmMemFree().
  186. cmMidiFileDensity_t* cmMidiFileNoteDensity( cmMidiFileH_t h, unsigned* cntRef );
  187. // Generate a piano-roll plot description file which can be displayed with cmXScore.m
  188. cmMfRC_t cmMidiFileGenPlotFile( cmCtx_t* ctx, const cmChar_t* midiFn, const cmChar_t* outFn );
  189. cmMfRC_t cmMidiFileGenSvgFile( cmCtx_t* ctx, const cmChar_t* midiFn, const cmChar_t* outSvgFn, const cmChar_t* cssFn );
  190. // Generate a text file reportusing cmMIdiFilePrintMsgs()
  191. cmMfRC_t cmMidiFileReport( cmCtx_t* ctx, const cmChar_t* midiFn, const cmChar_t* outTextFn );
  192. void cmMidiFileTest( const char* fn, cmCtx_t* ctx );
  193. //)
  194. #ifdef __cplusplus
  195. }
  196. #endif
  197. #endif