Subversion Repositories svn.mios32

Rev

Rev 984 | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 984 Rev 2635
Line 1... Line 1...
1
// $Id: seq_label.c 984 2010-04-01 22:32:42Z tk $
1
// $Id: seq_label.c 2635 2019-01-06 17:14:01Z tk $
2
/*
2
/*
3
 * Label Routines
3
 * Label Routines
4
 *
4
 *
5
 * ==========================================================================
5
 * ==========================================================================
6
 *
6
 *
Line 15... Line 15...
15
// Include files
15
// Include files
16
/////////////////////////////////////////////////////////////////////////////
16
/////////////////////////////////////////////////////////////////////////////
17
17
18
#include <mios32.h>
18
#include <mios32.h>
19
#include <string.h>
19
#include <string.h>
-
 
20
-
 
21
#include "tasks.h"
20
22
21
#include "seq_label.h"
23
#include "seq_label.h"
22
24
23
-
 
24
/////////////////////////////////////////////////////////////////////////////
-
 
25
// Local variables
-
 
26
/////////////////////////////////////////////////////////////////////////////
-
 
27
-
 
28
static const char preset_categories[][6] = {
-
 
29
  "     ",
-
 
30
  "Synth",
-
 
31
  "Piano",
-
 
32
  "Bass ",
-
 
33
  "Drums",
-
 
34
  "Break",
-
 
35
  "MBSID",
-
 
36
  "MBFM ",
-
 
37
  "Ctrl"
-
 
38
};
-
 
39
-
 
40
-
 
41
static const char preset_labels[][16] = {
-
 
42
  "               ",
-
 
43
  "Vintage        ",
-
 
44
  "Synthline      ",
-
 
45
  "Bassline       ",
-
 
46
  "Pads           ",
-
 
47
  "Chords         ",
-
 
48
  "Lovely Arps    ",
-
 
49
  "Electr. Drums  ",
-
 
50
  "Heavy Beats    ",
-
 
51
  "Simple Beats   ",
25
#include "seq_file_presets.h"
52
  "CC Tracks      ",
-
 
53
  "Experiments    ",
-
 
54
  "Live Played    ",
-
 
55
  "Transposer     "
-
 
56
};
-
 
57
-
 
58
-
 
59
// order must match with seq_layer_preset_table_drum_notes in seq_layer.c
-
 
60
static const char preset_drum[][6] = {
-
 
61
  " BD  ",
-
 
62
  " SD  ",
-
 
63
  " CH  ",
-
 
64
  " PH  ",
-
 
65
  " OH  ",
-
 
66
  " MA  ",
-
 
67
  " CP  ",
-
 
68
  " CY  ",
-
 
69
  " LT  ",
-
 
70
  " MT  ",
-
 
71
  " HT  ",
-
 
72
  " RS  ",
-
 
73
  " CB  ",
-
 
74
  "Smp1 ",
-
 
75
  "Smp2 ",
-
 
76
  "Smp3 "
-
 
77
};
-
 
78
-
 
79
26
80
27
81
/////////////////////////////////////////////////////////////////////////////
28
/////////////////////////////////////////////////////////////////////////////
82
// Initialisation
29
// Initialisation
83
/////////////////////////////////////////////////////////////////////////////
30
/////////////////////////////////////////////////////////////////////////////
Line 90... Line 37...
90
/////////////////////////////////////////////////////////////////////////////
37
/////////////////////////////////////////////////////////////////////////////
91
// Returns number of label presets
38
// Returns number of label presets
92
/////////////////////////////////////////////////////////////////////////////
39
/////////////////////////////////////////////////////////////////////////////
93
s32 SEQ_LABEL_NumPresets(void)
40
s32 SEQ_LABEL_NumPresets(void)
94
{
41
{
95
  return sizeof(preset_labels) / 16;
42
  return SEQ_FILE_PRESETS_TrkLabel_NumGet()+1;
96
}
43
}
97
44
98
/////////////////////////////////////////////////////////////////////////////
45
/////////////////////////////////////////////////////////////////////////////
99
// This function copies a preset label (15 chars)
46
// This function copies a preset label (15 chars)
100
// Could be loaded from SD-Card later
47
// Could be loaded from SD-Card later
101
/////////////////////////////////////////////////////////////////////////////
48
/////////////////////////////////////////////////////////////////////////////
102
s32 SEQ_LABEL_CopyPreset(u8 num, char *dst)
49
s32 SEQ_LABEL_CopyPreset(u8 num, char *dst)
103
{
50
{
-
 
51
  const int max_chars = 15;
-
 
52
  s32 status = 0;
104
53
105
  if( num < SEQ_LABEL_NumPresets() ) {
54
  if( num >= 1 && num <= SEQ_FILE_PRESETS_TrkLabel_NumGet() ) {
-
 
55
    char str[max_chars+1];
-
 
56
-
 
57
    MUTEX_SDCARD_TAKE;
106
    memcpy(dst, (char *)&preset_labels[num], 15);
58
    status = SEQ_FILE_PRESETS_TrkLabel_Read(num, str);
-
 
59
    MUTEX_SDCARD_GIVE;
-
 
60
-
 
61
    if( status > 0 ) {
-
 
62
      // fill with spaces
-
 
63
      size_t len = strlen(str);
-
 
64
      strncpy(dst, str, max_chars);
107
  } else {
65
      int i;
-
 
66
      for(i=len; i<max_chars; ++i)
-
 
67
    dst[i] = ' ';
-
 
68
    }
-
 
69
  }
-
 
70
-
 
71
  if( status < 1 ) {
108
    memcpy(dst, "...............", 15);
72
    memcpy(dst, "               ", max_chars);
109
  }
73
  }
110
74
111
  return 0; // no error
75
  return 0; // no error
112
}
76
}
113
77
Line 115... Line 79...
115
/////////////////////////////////////////////////////////////////////////////
79
/////////////////////////////////////////////////////////////////////////////
116
// Returns number of category presets
80
// Returns number of category presets
117
/////////////////////////////////////////////////////////////////////////////
81
/////////////////////////////////////////////////////////////////////////////
118
s32 SEQ_LABEL_NumPresetsCategory(void)
82
s32 SEQ_LABEL_NumPresetsCategory(void)
119
{
83
{
120
  return sizeof(preset_categories) / 6;
84
  return SEQ_FILE_PRESETS_TrkCategory_NumGet()+1;
121
}
85
}
122
86
123
/////////////////////////////////////////////////////////////////////////////
87
/////////////////////////////////////////////////////////////////////////////
124
// This function copies a preset category (5 chars) into the given array
88
// This function copies a preset category (5 chars) into the given array
125
// Could be loaded from SD-Card later
89
// Could be loaded from SD-Card later
126
/////////////////////////////////////////////////////////////////////////////
90
/////////////////////////////////////////////////////////////////////////////
127
s32 SEQ_LABEL_CopyPresetCategory(u8 num, char *dst)
91
s32 SEQ_LABEL_CopyPresetCategory(u8 num, char *dst)
128
{
92
{
-
 
93
  const int max_chars = 5;
-
 
94
  s32 status = 0;
-
 
95
129
  if( num < SEQ_LABEL_NumPresetsCategory() ) {
96
  if( num >= 1 && num <= SEQ_FILE_PRESETS_TrkCategory_NumGet() ) {
-
 
97
    char str[max_chars+1];
-
 
98
-
 
99
    MUTEX_SDCARD_TAKE;
130
    memcpy(dst, (char *)&preset_categories[num], 5);
100
    status = SEQ_FILE_PRESETS_TrkCategory_Read(num, str);
-
 
101
    MUTEX_SDCARD_GIVE;
-
 
102
-
 
103
    if( status > 0 ) {
-
 
104
      // fill with spaces
-
 
105
      size_t len = strlen(str);
-
 
106
      strncpy(dst, str, max_chars);
131
  } else {
107
      int i;
-
 
108
      for(i=len; i<max_chars; ++i)
-
 
109
    dst[i] = ' ';
-
 
110
    }
-
 
111
  }
-
 
112
-
 
113
  if( status < 1 ) {
132
    memcpy(dst, ".....", 5);
114
    memcpy(dst, "     ", max_chars);
133
  }
115
  }
134
116
135
  return 0; // no error
117
  return 0; // no error
136
}
118
}
137
119
Line 139... Line 121...
139
/////////////////////////////////////////////////////////////////////////////
121
/////////////////////////////////////////////////////////////////////////////
140
// Returns number of drum presets
122
// Returns number of drum presets
141
/////////////////////////////////////////////////////////////////////////////
123
/////////////////////////////////////////////////////////////////////////////
142
s32 SEQ_LABEL_NumPresetsDrum(void)
124
s32 SEQ_LABEL_NumPresetsDrum(void)
143
{
125
{
144
  return sizeof(preset_drum) / 6;
126
  return SEQ_FILE_PRESETS_TrkDrum_NumGet();
145
}
127
}
146
128
147
/////////////////////////////////////////////////////////////////////////////
129
/////////////////////////////////////////////////////////////////////////////
148
// This function copies a preset drum label (5 chars) into the given array
130
// This function copies a preset drum label (5 chars) into the given array
149
// Could be loaded from SD-Card later
131
// Could be loaded from SD-Card later
150
/////////////////////////////////////////////////////////////////////////////
132
/////////////////////////////////////////////////////////////////////////////
151
s32 SEQ_LABEL_CopyPresetDrum(u8 num, char *dst)
133
s32 SEQ_LABEL_CopyPresetDrum(u8 num, char *dst, u8 *note)
152
{
134
{
-
 
135
  const int max_chars = 5;
-
 
136
  s32 status = 0;
-
 
137
153
  if( num < SEQ_LABEL_NumPresetsDrum() ) {
138
  if( num >= 0 && num < SEQ_FILE_PRESETS_TrkDrum_NumGet() ) {
-
 
139
    char str[max_chars+1];
-
 
140
-
 
141
    MUTEX_SDCARD_TAKE;
-
 
142
    status = SEQ_FILE_PRESETS_TrkDrum_Read(num+1, str, note, 0);
-
 
143
    MUTEX_SDCARD_GIVE;
-
 
144
-
 
145
    if( status > 0 ) {
-
 
146
      // fill with spaces
-
 
147
      size_t len = strlen(str);
154
    memcpy(dst, (char *)&preset_drum[num], 5);
148
      strncpy(dst, str, max_chars);
155
  } else {
149
      int i;
-
 
150
      for(i=len; i<max_chars; ++i)
-
 
151
    dst[i] = ' ';
-
 
152
    }
-
 
153
  }
-
 
154
-
 
155
  if( status < 1 ) {
156
    memcpy(dst, ".....", 5);
156
    memcpy(dst, "     ", max_chars);
157
  }
157
  }
158
158
159
  return 0; // no error
159
  return 0; // no error
160
}
160
}