1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
|
/*
---------------------------------------------------------------------------------------------
MIDI Sequencer - Final Year Project, A.J. Green
---------------------------------------------------------------------------------------------
File Name: File.h
Description: Type definitions and prototypes for MIDI file-handling.
Author: AJG
History:
Update Date Programmer Comments
====== ==== ========== ========
001 24/01/94 AJG File Created.
--------------------------------------------------------------------------------------------
*/
#ifndef _MIDI_FILE_H_
#define _MIDI_FILE_H_
#include <MidiEvent.h>
#include <netinet/in.h>
#include <stdio.h>
/*************************************************************/
/* Hack to provide constant definition for fseek that is not */
/* present when compiling under (for instance) SunOS. */
/*************************************************************/
#ifndef SEEK_CUR
#define SEEK_CUR 1
#endif
/*************************************************************/
/* Format enumeration - defines how the various track chunks */
/* in the MIDI file relate to each other. */
/*************************************************************/
typedef enum
{
MIDI_SINGLE_TRACK_FILE = 0x00,
MIDI_SIMULTANEOUS_TRACK_FILE = 0x01,
MIDI_SEQUENTIAL_TRACK_FILE = 0x02,
MIDI_NO_FILE_LOADED = 0xFF
}
MIDIFileFormatType;
#define MIDI_FILE_ERR_END_OF_CHUNK 257
#define MIDI_24_FPS -24
#define MIDI_25_FPS -25
#define MIDI_29_FPS -29
#define MIDI_30_FPS -30
typedef struct
{
byte FrameRate;
byte Resolution;
}
SMPTEGranularity;
typedef union
{
short Division;
SMPTEGranularity SMPTE;
}
MIDITimingData;
/*************************************/
/* MIDI header trunk data-structure. */
/*************************************/
typedef struct
{
MIDIFileFormatType Format;
short NumTracks;
MIDITimingData Timing;
}
MIDIHeaderChunk;
/*********************************************/
/* Mode to be used when opening a MIDI file. */
/*********************************************/
typedef enum
{
MIDI_READ,
MIDI_WRITE,
MIDI_READ_WRITE
}
MIDIFileMode;
/*****************************************************************/
/* MIDI file handle data structure. Contains a pointer to a file */
/* and a counter to help with efficient chunk skipping. */
/*****************************************************************/
#define BUFFER_INITIAL_SIZE 50 * 1024 /* 50Kb should be enough for most files */
#define HANDLE_FILE_NAME_SIZE 20
typedef struct
{
FILE *File;
long Count;
long MaxCount;
MIDIFileMode Mode;
char FileName[HANDLE_FILE_NAME_SIZE]; /* for err. msgs composition */
byte *Buffer;
byte *BufferIdx;
unsigned long BufferSize; /* Doesn't represents the actual malloc-ed
size in the case of files read from
stdin, but the actual size of MIDI data */
}
MIDIFileStruct;
#define BufferOffset(x) (x->BufferIdx - x->Buffer)
typedef MIDIFileStruct *MIDIFileHandle;
typedef char *MIDIChunkType;
#ifndef HAVE_NTOHL
#define ByteStreamTo32BitInt(PTR) ((((long)*(PTR)) << 24) | (((long)*(PTR + 1)) << 16) | \
(((long)*(PTR + 2)) << 8) | (long)*(PTR + 3))
#define ByteStreamTo16BitInt(PTR) ((((short)*(PTR)) << 8) | (((short)*(PTR + 1))))
#else
#define ByteStreamTo32BitInt(PTR) ntohl(*(long*)(PTR))
#define ByteStreamTo16BitInt(PTR) ntohs(*(long*)(PTR))
#endif
MIDIFileHandle Midi_FileOpen(char *FileName,
MIDIHeaderChunk *HeaderBuffer,
MIDIFileMode Mode);
MIDIFileHandle Midi_FileOpen2(char *FileName,
FILE *fp,
MIDIHeaderChunk *HeaderBuffer,
MIDIFileMode Mode);
#define Midi_FileOpen(filename, headerbuffer, mode) Midi_FileOpen2(filename, NULL, headerbuffer, mode)
#define Midi_FilePtrOpen(fp, headerbuffer, mode) Midi_FileOpen2(NULL, fp, headerbuffer, mode)
Boolean Midi_FileCheckHeaderChunk(MIDIFileHandle, MIDIHeaderChunk*);
void Midi_FileWriteHeaderChunk(MIDIFileHandle, MIDIHeaderChunk*);
void Midi_FileClose(MIDIFileHandle);
int Midi_FileSkipToNextChunk(MIDIFileHandle File,
MIDIChunkType ChunkIdentifier);
int Midi_FileReadByte(MIDIFileHandle File);
int Midi_FileReadBytes(MIDIFileHandle File, byte *Buffer, int NumBytes);
int Midi_FileRewindNBytes(MIDIFileHandle MidiFile, int Distance);
int Midi_FileFfwdNBytes(MIDIFileHandle MidiFile, int Distance);
#define Midi_FileBytesLeftInCurrentChunk(X) X->Count
int Midi_FileReadVarNum(MIDIFileHandle MidiFile, long *ReturnValue);
MIDIEvent Midi_FileReadNextEvent(MIDIFileHandle MidiFile);
EventList Midi_FileReadTrack(MIDIFileHandle MidiFile);
void Midi_FileWriteByte(MIDIFileHandle MidiFile, byte Byte);
void Midi_FileWriteBytes(MIDIFileHandle MidiFile, byte *Buffer, int NumBytes);
void Midi_FileWriteVarNum(MIDIFileHandle MidiFile, long Value);
void Midi_FileWriteNewChunkHeader(MIDIFileHandle MidiFile, MIDIChunkType ChunkIdentifier);
void Midi_FileWriteEvent(MIDIFileHandle MidiFile, MIDIEvent Event);
void Midi_FileWriteTrack(MIDIFileHandle MidiFile, EventList Track);
#endif
|
