Subversion Repositories svn.mios32

Rev

Rev 1422 | Rev 2159 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
134 tk 1
// $Id: seq_par.c 1794 2013-05-31 19:25:43Z tk $
2
/*
3
 * Parameter Layer Routines
4
 *
5
 * ==========================================================================
6
 *
7
 *  Copyright (C) 2008 Thorsten Klose (tk@midibox.org)
8
 *  Licensed for personal non-commercial use only.
9
 *  All other rights reserved.
10
 *
11
 * ==========================================================================
12
 */
13
 
14
/////////////////////////////////////////////////////////////////////////////
15
// Include files
16
/////////////////////////////////////////////////////////////////////////////
17
 
18
#include <mios32.h>
318 tk 19
#include <string.h>
134 tk 20
 
21
#include "seq_par.h"
333 tk 22
#include "seq_cc.h"
134 tk 23
#include "seq_core.h"
24
 
25
 
26
/////////////////////////////////////////////////////////////////////////////
248 tk 27
// Global variables
134 tk 28
/////////////////////////////////////////////////////////////////////////////
29
 
248 tk 30
// should only be directly accessed by SEQ_FILE_B, remaining functions should
31
// use SEQ_PAR_Get/Set
1261 tk 32
#ifndef AHB_SECTION
33
#define AHB_SECTION
34
#endif
1234 tk 35
u8 AHB_SECTION seq_par_layer_value[SEQ_CORE_NUM_TRACKS][SEQ_PAR_MAX_BYTES];
134 tk 36
 
37
 
38
/////////////////////////////////////////////////////////////////////////////
318 tk 39
// Local variables
40
/////////////////////////////////////////////////////////////////////////////
41
 
42
static u16 par_layer_num_steps[SEQ_CORE_NUM_TRACKS];
43
static u8 par_layer_num_layers[SEQ_CORE_NUM_TRACKS];
328 tk 44
static u8 par_layer_num_instruments[SEQ_CORE_NUM_TRACKS];
318 tk 45
 
333 tk 46
static const char seq_par_type_names[SEQ_PAR_NUM_TYPES][6] = {
47
  "None ", // 0
48
  "Note ", // 1
49
  "Chord", // 2
50
  "Vel. ", // 3
51
  "Len. ", // 4
52
  " CC  ", // 5
53
  "Pitch", // 6
54
  "Prob.", // 7
55
  "Delay", // 8
56
  "Roll ", // 9
1024 tk 57
  "Roll2", // 10
1422 tk 58
  "PrgCh", // 11
333 tk 59
};
318 tk 60
 
333 tk 61
static const u8 seq_par_default_value[SEQ_PAR_NUM_TYPES] = {
62
  0x00, // None
63
  0x3c, // Note: C-3
64
  0x40, // Chord: 0
65
  100,  // Velocity
66
  71,   // Length
1794 tk 67
  64,   // CC // NEW: overruled via seq_core_options.INIT_CC !!!
333 tk 68
  64,   // PitchBender
69
  0,    // Probability (reversed: 100%)
70
  0,    // Delay
71
  0,    // Roll
1024 tk 72
  0,    // Roll2
1422 tk 73
  0,    // PrgCh
333 tk 74
};
75
 
76
 
318 tk 77
/////////////////////////////////////////////////////////////////////////////
134 tk 78
// Initialisation
79
/////////////////////////////////////////////////////////////////////////////
80
s32 SEQ_PAR_Init(u32 mode)
81
{
1316 tk 82
#ifndef MBSEQV4L
318 tk 83
  // init parameter layer values
84
  u8 track;
85
  for(track=0; track<SEQ_CORE_NUM_TRACKS; ++track)
961 tk 86
    SEQ_PAR_TrackInit(track, 256, 4, 1); // track, steps, parameter layers, instruments
1316 tk 87
#else
88
  // extra for MBSEQ V4L:
89
  // G1T1/2/3 and G3T1/2/3 use 64 steps and 16 layers (for Notes)
90
  // remaining tracks use 256 steps and 4 layers (Pitchbender/CC) with 4 times speed
91
  u8 track;
92
  for(track=0; track<SEQ_CORE_NUM_TRACKS; ++track) {
93
    if( (track >= 0 && track <= 2) || (track >= 8 && track <= 10) )
94
      SEQ_PAR_TrackInit(track, 64, 16, 1); // track, steps, parameter layers, instruments
95
    else
96
      SEQ_PAR_TrackInit(track, 256, 4, 1); // track, steps, parameter layers, instruments
97
  }
98
#endif
134 tk 99
 
318 tk 100
  return 0; // no error
101
}
102
 
103
 
104
/////////////////////////////////////////////////////////////////////////////
105
// Inits all parameter layers of the given track with the given constraints
106
/////////////////////////////////////////////////////////////////////////////
328 tk 107
s32 SEQ_PAR_TrackInit(u8 track, u16 steps, u8 par_layers, u8 instruments)
318 tk 108
{
328 tk 109
  if( (instruments * par_layers * steps) > SEQ_PAR_MAX_BYTES )
318 tk 110
    return -1; // invalid configuration
111
 
112
  par_layer_num_layers[track] = par_layers;
113
  par_layer_num_steps[track] = steps;
328 tk 114
  par_layer_num_instruments[track] = instruments;
318 tk 115
 
134 tk 116
  // init parameter layer values
318 tk 117
  memset((u8 *)&seq_par_layer_value[track], 0, SEQ_PAR_MAX_BYTES);
134 tk 118
 
119
  return 0; // no error
120
}
174 tk 121
 
122
 
123
/////////////////////////////////////////////////////////////////////////////
328 tk 124
// Returns number of instruments for a given track
125
/////////////////////////////////////////////////////////////////////////////
126
s32 SEQ_PAR_NumInstrumentsGet(u8 track)
127
{
128
  return par_layer_num_instruments[track];
129
}
130
 
131
 
132
/////////////////////////////////////////////////////////////////////////////
318 tk 133
// Returns number of trigger layers for a given track
134
/////////////////////////////////////////////////////////////////////////////
135
s32 SEQ_PAR_NumLayersGet(u8 track)
136
{
137
  return par_layer_num_layers[track];
138
}
139
 
140
 
141
/////////////////////////////////////////////////////////////////////////////
142
// Returns number of steps for a given track
143
/////////////////////////////////////////////////////////////////////////////
144
s32 SEQ_PAR_NumStepsGet(u8 track)
145
{
146
  return par_layer_num_steps[track];
147
}
148
 
149
 
150
/////////////////////////////////////////////////////////////////////////////
333 tk 151
// returns the assignment of a certain parameter layer
152
/////////////////////////////////////////////////////////////////////////////
153
seq_par_layer_type_t SEQ_PAR_AssignmentGet(u8 track, u8 par_layer)
154
{
155
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
156
 
157
  if( tcc->event_mode == SEQ_EVENT_MODE_Drum )
158
    return (par_layer >= 2) ? SEQ_PAR_Type_None : tcc->par_assignment_drum[par_layer];
159
  else
160
    return (par_layer >= 16) ? SEQ_PAR_Type_None : tcc->lay_const[0*16 + par_layer];
161
}
162
 
163
 
164
/////////////////////////////////////////////////////////////////////////////
174 tk 165
// Sets a value of parameter layer
166
// (using this interface function to allow dynamic lists in future)
167
/////////////////////////////////////////////////////////////////////////////
328 tk 168
s32 SEQ_PAR_Set(u8 track, u16 step, u8 par_layer, u8 par_instrument, u8 value)
174 tk 169
{
328 tk 170
  u8 num_p_instruments = par_layer_num_instruments[track];
171
  if( par_instrument >= num_p_instruments )
172
    return -1;
173
  u8 num_p_layers = par_layer_num_layers[track];
174
  if( par_layer >= num_p_layers )
175
    return -2;
336 tk 176
  u16 num_p_steps = par_layer_num_steps[track];
328 tk 177
 
336 tk 178
  // modulo of num_p_steps to allow mirroring of parameter layer in drum mode
179
  step %= num_p_steps;
180
 
328 tk 181
  u16 step_ix = (par_instrument * num_p_layers * num_p_steps) + (par_layer * num_p_steps) + step;
318 tk 182
  if( step_ix >= SEQ_PAR_MAX_BYTES )
328 tk 183
    return -4; // invalid step position
318 tk 184
 
185
  seq_par_layer_value[track][step_ix] = value;
186
 
174 tk 187
  return 0; // no error
188
}
189
 
190
 
191
/////////////////////////////////////////////////////////////////////////////
192
// Returns a value of parameter layer
193
// (using this interface function to allow dynamic lists in future)
194
/////////////////////////////////////////////////////////////////////////////
328 tk 195
s32 SEQ_PAR_Get(u8 track, u16 step, u8 par_layer, u8 par_instrument)
174 tk 196
{
328 tk 197
  u8 num_p_layers = par_layer_num_layers[track];
336 tk 198
  u16 num_p_steps = par_layer_num_steps[track];
199
 
200
  // modulo of num_p_steps to allow mirroring of parameter layer in drum mode
201
  step %= num_p_steps;
202
 
328 tk 203
  u16 step_ix = (par_instrument * num_p_layers * num_p_steps) + (par_layer * num_p_steps) + step;
318 tk 204
  if( step_ix >= SEQ_PAR_MAX_BYTES )
205
    return 0; // invalid step position: return 0 (parameter not set)
206
 
207
  return seq_par_layer_value[track][step_ix];
174 tk 208
}
333 tk 209
 
210
 
211
/////////////////////////////////////////////////////////////////////////////
212
// returns the first layer which plays a note
213
/////////////////////////////////////////////////////////////////////////////
1219 tk 214
s32 SEQ_PAR_NoteGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 215
{
216
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
217
  s8 par_layer;
218
 
1219 tk 219
  if( (par_layer=tcc->link_par_layer_note) >= 0 &&
220
      !(layer_muted & (1 << par_layer)) ) {
333 tk 221
    return SEQ_PAR_Get(track, step, par_layer, par_instrument);
1219 tk 222
  }
333 tk 223
 
224
  return 0;
225
}
226
 
227
 
228
/////////////////////////////////////////////////////////////////////////////
229
// returns the first layer which plays a chord
230
/////////////////////////////////////////////////////////////////////////////
1219 tk 231
s32 SEQ_PAR_ChordGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 232
{
233
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
234
  s8 par_layer;
235
 
1219 tk 236
  if( (par_layer=tcc->link_par_layer_chord) >= 0 &&
237
      !(layer_muted & (1 << par_layer)) ) {
333 tk 238
    return SEQ_PAR_Get(track, step, par_layer, par_instrument);
1219 tk 239
  }
333 tk 240
 
241
  return 0;
242
}
243
 
244
 
245
/////////////////////////////////////////////////////////////////////////////
246
// returns the first layer which controls velocity
247
// if not assigned to a layer, returns 100 as default velocity
248
/////////////////////////////////////////////////////////////////////////////
1219 tk 249
s32 SEQ_PAR_VelocityGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 250
{
251
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
252
  s8 par_layer;
253
 
254
  // note: due to performance reasons, similar code exists in SEQ_LAYER_GetEvents()
255
 
1219 tk 256
  if( (par_layer=tcc->link_par_layer_velocity) >= 0 &&
257
      !(layer_muted & (1 << par_layer)) ) {
333 tk 258
    return SEQ_PAR_Get(track, step, par_layer, par_instrument);
1219 tk 259
  }
333 tk 260
 
261
  return 100; // default velocity
262
}
263
 
264
 
265
/////////////////////////////////////////////////////////////////////////////
266
// returns the first layer which controls note length
338 tk 267
// returns 1..96 (96 for glide, 71 if no length assigned)
333 tk 268
/////////////////////////////////////////////////////////////////////////////
1219 tk 269
s32 SEQ_PAR_LengthGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 270
{
271
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
272
  s8 par_layer;
273
 
274
  // note: due to performance reasons, similar code exists in SEQ_LAYER_GetEvents()
275
 
1219 tk 276
  if( (par_layer=tcc->link_par_layer_length) >= 0 &&
277
      !(layer_muted & (1 << par_layer)) ) {
333 tk 278
    u8 value = SEQ_PAR_Get(track, step, par_layer, par_instrument);
279
    return ((value > 95) ? 95 : value) + 1;
280
  }
281
 
282
  return 71; // no assignment
283
}
284
 
285
 
286
/////////////////////////////////////////////////////////////////////////////
287
// returns the play probability if assigned to any parameter layer
288
// Probability ranges from 0 to 100 for 0%..100%
289
// (the stored value is inverted, to that 0 results into 100%)
290
/////////////////////////////////////////////////////////////////////////////
1219 tk 291
s32 SEQ_PAR_ProbabilityGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 292
{
293
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
294
  s8 par_layer;
295
 
1219 tk 296
  if( (par_layer=tcc->link_par_layer_probability) >= 0 &&
297
      !(layer_muted & (1 << par_layer)) ) {
333 tk 298
    u8 value = SEQ_PAR_Get(track, step, par_layer, par_instrument);
299
    return (value >= 100) ? 0 : 100-value;
300
  }
301
 
334 tk 302
  return 100; // 100% probability
333 tk 303
}
304
 
305
 
306
/////////////////////////////////////////////////////////////////////////////
307
// returns the step delay if assigned to any parameter layer
338 tk 308
// Delay ranges from 0..95
333 tk 309
/////////////////////////////////////////////////////////////////////////////
1219 tk 310
s32 SEQ_PAR_StepDelayGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 311
{
312
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
313
  s8 par_layer;
314
 
1219 tk 315
  if( (par_layer=tcc->link_par_layer_delay) >= 0 &&
316
      !(layer_muted & (1 << par_layer)) ) {
333 tk 317
    s32 value = SEQ_PAR_Get(track, step, par_layer, par_instrument);
338 tk 318
    return (value > 95) ? 95 : value;
333 tk 319
  }
320
 
321
  return 0; // no delay
322
}
323
 
324
 
325
/////////////////////////////////////////////////////////////////////////////
326
// returns the roll mode if assigned to any parameter layer
327
//   0:      none
334 tk 328
//   1.. 15: 2D01..2D15
329
//  16.. 31: 3D00..3D15
330
//  32.. 47: 4D00..4D15
331
//  48.. 63: 5D00..5D15
332
//  64.. 79: 2U00..2U15
333
//  80.. 95: 3U00..3U15
334
//  96..111: 4U00..4U15
335
// 112..127: 5U00..5U15
333 tk 336
/////////////////////////////////////////////////////////////////////////////
1219 tk 337
s32 SEQ_PAR_RollModeGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
333 tk 338
{
339
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
340
  s8 par_layer;
341
 
1219 tk 342
  if( (par_layer=tcc->link_par_layer_roll) >= 0 &&
343
      !(layer_muted & (1 << par_layer)) ) {
333 tk 344
    return SEQ_PAR_Get(track, step, par_layer, par_instrument);
345
  }
346
 
347
  return 0; // no roll
348
}
349
 
350
 
351
/////////////////////////////////////////////////////////////////////////////
1024 tk 352
// returns the roll2 mode if assigned to any parameter layer
353
//   0:      none
354
//   1.. 31: 2x..
355
//  32.. 63: 3x..
356
//  64.. 95: 4x..
357
//  96..127: 5x..
358
/////////////////////////////////////////////////////////////////////////////
1219 tk 359
s32 SEQ_PAR_Roll2ModeGet(u8 track, u8 step, u8 par_instrument, u16 layer_muted)
1024 tk 360
{
361
  seq_cc_trk_t *tcc = &seq_cc_trk[track];
362
  s8 par_layer;
363
 
1219 tk 364
  if( (par_layer=tcc->link_par_layer_roll2) >= 0 &&
365
      !(layer_muted & (1 << par_layer)) ) {
1024 tk 366
    return SEQ_PAR_Get(track, step, par_layer, par_instrument);
367
  }
368
 
369
  return 0; // no roll2
370
}
371
 
372
 
373
/////////////////////////////////////////////////////////////////////////////
333 tk 374
// This function returns the string to a parameter assignment type
375
/////////////////////////////////////////////////////////////////////////////
376
char *SEQ_PAR_TypeStr(seq_par_layer_type_t par_type)
377
{
378
  if( par_type >= SEQ_PAR_NUM_TYPES )
379
    return (char *)"-----";
380
  else
381
    return (char *)seq_par_type_names[par_type];
382
}
383
 
384
 
385
/////////////////////////////////////////////////////////////////////////////
386
// This function returns the string to the assigned parameter
387
// if layer is not assigned, it returns "None "
388
/////////////////////////////////////////////////////////////////////////////
389
char *SEQ_PAR_AssignedTypeStr(u8 track, u8 par_layer)
390
{
391
  return SEQ_PAR_TypeStr(SEQ_PAR_AssignmentGet(track, par_layer));
392
}
393
 
394
 
395
/////////////////////////////////////////////////////////////////////////////
396
// Returns initial value of given parameter assignment type
397
/////////////////////////////////////////////////////////////////////////////
457 tk 398
u8 SEQ_PAR_InitValueGet(seq_par_layer_type_t par_type, u8 par_layer)
333 tk 399
{
400
  if( par_type >= SEQ_PAR_NUM_TYPES )
401
    return 0;
457 tk 402
 
403
  if( par_layer > 0 && (par_type == SEQ_PAR_Type_Note || par_type == SEQ_PAR_Type_Chord) )
404
    return 0x00; // Note/Chords are 0 by default if not in Layer A
405
 
1794 tk 406
  // new: variable init value
407
  if( par_type == SEQ_PAR_Type_CC )
408
    return seq_core_options.INIT_CC;
409
 
457 tk 410
  return seq_par_default_value[par_type];
333 tk 411
}
412
 
413
 
414