This source file includes following definitions.
- midibuf_message_length
- midibuf_is_empty
- midibuf_is_full
- line6_midibuf_reset
- line6_midibuf_init
- line6_midibuf_bytes_free
- line6_midibuf_bytes_used
- line6_midibuf_write
- line6_midibuf_read
- line6_midibuf_ignore
- line6_midibuf_destroy
1
2
3
4
5
6
7
8 #include <linux/slab.h>
9
10 #include "midibuf.h"
11
12 static int midibuf_message_length(unsigned char code)
13 {
14 int message_length;
15
16 if (code < 0x80)
17 message_length = -1;
18 else if (code < 0xf0) {
19 static const int length[] = { 3, 3, 3, 3, 2, 2, 3 };
20
21 message_length = length[(code >> 4) - 8];
22 } else {
23
24
25
26
27
28 static const int length[] = { -1, 2, -1, 2, -1, -1, 1, 1, 1, 1,
29 1, 1, 1, -1, 1, 1
30 };
31 message_length = length[code & 0x0f];
32 }
33
34 return message_length;
35 }
36
37 static int midibuf_is_empty(struct midi_buffer *this)
38 {
39 return (this->pos_read == this->pos_write) && !this->full;
40 }
41
42 static int midibuf_is_full(struct midi_buffer *this)
43 {
44 return this->full;
45 }
46
47 void line6_midibuf_reset(struct midi_buffer *this)
48 {
49 this->pos_read = this->pos_write = this->full = 0;
50 this->command_prev = -1;
51 }
52
53 int line6_midibuf_init(struct midi_buffer *this, int size, int split)
54 {
55 this->buf = kmalloc(size, GFP_KERNEL);
56
57 if (this->buf == NULL)
58 return -ENOMEM;
59
60 this->size = size;
61 this->split = split;
62 line6_midibuf_reset(this);
63 return 0;
64 }
65
66 int line6_midibuf_bytes_free(struct midi_buffer *this)
67 {
68 return
69 midibuf_is_full(this) ?
70 0 :
71 (this->pos_read - this->pos_write + this->size - 1) % this->size +
72 1;
73 }
74
75 int line6_midibuf_bytes_used(struct midi_buffer *this)
76 {
77 return
78 midibuf_is_empty(this) ?
79 0 :
80 (this->pos_write - this->pos_read + this->size - 1) % this->size +
81 1;
82 }
83
84 int line6_midibuf_write(struct midi_buffer *this, unsigned char *data,
85 int length)
86 {
87 int bytes_free;
88 int length1, length2;
89 int skip_active_sense = 0;
90
91 if (midibuf_is_full(this) || (length <= 0))
92 return 0;
93
94
95 if (data[length - 1] == 0xfe) {
96 --length;
97 skip_active_sense = 1;
98 }
99
100 bytes_free = line6_midibuf_bytes_free(this);
101
102 if (length > bytes_free)
103 length = bytes_free;
104
105 if (length > 0) {
106 length1 = this->size - this->pos_write;
107
108 if (length < length1) {
109
110 memcpy(this->buf + this->pos_write, data, length);
111 this->pos_write += length;
112 } else {
113
114 length2 = length - length1;
115 memcpy(this->buf + this->pos_write, data, length1);
116 memcpy(this->buf, data + length1, length2);
117 this->pos_write = length2;
118 }
119
120 if (this->pos_write == this->pos_read)
121 this->full = 1;
122 }
123
124 return length + skip_active_sense;
125 }
126
127 int line6_midibuf_read(struct midi_buffer *this, unsigned char *data,
128 int length)
129 {
130 int bytes_used;
131 int length1, length2;
132 int command;
133 int midi_length;
134 int repeat = 0;
135 int i;
136
137
138 if (length < 3)
139 return -EINVAL;
140
141 if (midibuf_is_empty(this))
142 return 0;
143
144 bytes_used = line6_midibuf_bytes_used(this);
145
146 if (length > bytes_used)
147 length = bytes_used;
148
149 length1 = this->size - this->pos_read;
150
151
152 command = this->buf[this->pos_read];
153
154 if (command & 0x80) {
155 midi_length = midibuf_message_length(command);
156 this->command_prev = command;
157 } else {
158 if (this->command_prev > 0) {
159 int midi_length_prev =
160 midibuf_message_length(this->command_prev);
161
162 if (midi_length_prev > 1) {
163 midi_length = midi_length_prev - 1;
164 repeat = 1;
165 } else
166 midi_length = -1;
167 } else
168 midi_length = -1;
169 }
170
171 if (midi_length < 0) {
172
173 if (length < length1) {
174
175 for (i = 1; i < length; ++i)
176 if (this->buf[this->pos_read + i] & 0x80)
177 break;
178
179 midi_length = i;
180 } else {
181
182 length2 = length - length1;
183
184 for (i = 1; i < length1; ++i)
185 if (this->buf[this->pos_read + i] & 0x80)
186 break;
187
188 if (i < length1)
189 midi_length = i;
190 else {
191 for (i = 0; i < length2; ++i)
192 if (this->buf[i] & 0x80)
193 break;
194
195 midi_length = length1 + i;
196 }
197 }
198
199 if (midi_length == length)
200 midi_length = -1;
201 }
202
203 if (midi_length < 0) {
204 if (!this->split)
205 return 0;
206 } else {
207 if (length < midi_length)
208 return 0;
209
210 length = midi_length;
211 }
212
213 if (length < length1) {
214
215 memcpy(data + repeat, this->buf + this->pos_read, length);
216 this->pos_read += length;
217 } else {
218
219 length2 = length - length1;
220 memcpy(data + repeat, this->buf + this->pos_read, length1);
221 memcpy(data + repeat + length1, this->buf, length2);
222 this->pos_read = length2;
223 }
224
225 if (repeat)
226 data[0] = this->command_prev;
227
228 this->full = 0;
229 return length + repeat;
230 }
231
232 int line6_midibuf_ignore(struct midi_buffer *this, int length)
233 {
234 int bytes_used = line6_midibuf_bytes_used(this);
235
236 if (length > bytes_used)
237 length = bytes_used;
238
239 this->pos_read = (this->pos_read + length) % this->size;
240 this->full = 0;
241 return length;
242 }
243
244 void line6_midibuf_destroy(struct midi_buffer *this)
245 {
246 kfree(this->buf);
247 this->buf = NULL;
248 }