pattern-maker.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2010-2011 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "errors.h"
  20 #include "pattern.h"
  21 #include "pattern-maker.h"
  22 #include "song.h"
  23 #include <glib.h>
  24 #include <smf.h>
  25
  26 struct event_entry
  27 {
  28     uint32_t time;
  29     uint8_t data[4];
  30 };
  31
  32 static gint event_entry_compare(gconstpointer a, gconstpointer b, gpointer unused)
  33 {
  34     const struct event_entry *ea = a, *eb = b;
  35     // Event ordering - it's to ensure bank changes are emitted before program
  36     // changes and program changes are emitted before notes.
  37     static const char event_class[8] = {
  38         8, // Note Off
  39         9, // Note On
  40         20, // Poly Pressure
  41         4, // Control Change
  42         6, // Program Change
  43         16, // Mono Pressure
  44         18, // Pitch Wheel
  45         0, // SysEx/Realtime
  46     };
  47
  48     if (ea->time < eb->time)
  49         return -1;
  50     if (ea->time == eb->time && event_class[ea->data[0] >> 4] < event_class[eb->data[0] >> 4])
  51         return -1;
  52     if (ea->time == eb->time && (ea->data[0] & 15) < (eb->data[0] & 15))
  53         return -1;
  54     if (ea->time == eb->time && ea->data[0] == eb->data[0] && ea->data[1] < eb->data[1])
  55         return -1;
  56     if (ea->time == eb->time && ea->data[0] == eb->data[0] && ea->data[1] == eb->data[1])
  57         return 0;
  58     return +1;
  59 }
  60
  61 static void event_entry_destroy(gpointer p)
  62 {
  63     struct event_entry *e = p;
  64     free(e);
  65 }
  66
  67 struct cbox_midi_pattern_maker
  68 {
  69     CBOX_OBJECT_HEADER()
  70     GTree *events;
  71 };
  72
  73 struct cbox_midi_pattern_maker *cbox_midi_pattern_maker_new(void)
  74 {
  75     struct cbox_midi_pattern_maker *maker = malloc(sizeof(struct cbox_midi_pattern_maker));
  76     maker->events = g_tree_new_full(event_entry_compare, NULL, event_entry_destroy, NULL);
  77     return maker;
  78 }
  79
  80
  81 void cbox_midi_pattern_maker_add(struct cbox_midi_pattern_maker *maker, uint32_t time, uint8_t cmd, uint8_t val1, uint8_t val2)
  82 {
  83     struct event_entry *e = malloc(sizeof(struct event_entry));
  84     e->time = time;
  85     e->data[0] = cmd;
  86     e->data[1] = val1;
  87     e->data[2] = val2;
  88
  89     g_tree_insert(maker->events, e, NULL);
  90 }
  91
  92 void cbox_midi_pattern_maker_add_mem(struct cbox_midi_pattern_maker *maker, uint32_t time, const uint8_t *src, uint32_t len)
  93 {
  94     if (len > 3)
  95     {
  96         g_warning("Event size %d not supported yet, ignoring", (int)len);
  97         return;
  98     }
  99     struct event_entry *e = malloc(sizeof(struct event_entry));
 100     e->time = time;
 101     memcpy(e->data, src, len);
 102
 103     g_tree_insert(maker->events, e, NULL);
 104 }
 105
 106 struct traverse_state
 107 {
 108     struct cbox_midi_event *events;
 109     int pos;
 110 };
 111
 112 static gboolean traverse_func(gpointer key, gpointer value, gpointer pstate)
 113 {
 114     struct traverse_state *state = pstate;
 115     struct event_entry *e = key;
 116     struct cbox_midi_event *event = &state->events[state->pos++];
 117     event->time = e->time;
 118     event->size = midi_cmd_size(e->data[0]);
 119     memcpy(event->data_inline, &e->data[0], 3);
 120     return FALSE;
 121 }
 122
 123 extern void cbox_song_add_pattern(struct cbox_song *song, struct cbox_midi_pattern *pattern);
 124
 125 struct cbox_midi_pattern *cbox_midi_pattern_maker_create_pattern(struct cbox_midi_pattern_maker *maker, struct cbox_song *song, gchar *name)
 126 {
 127     struct cbox_midi_pattern *p = malloc(sizeof(struct cbox_midi_pattern));
 128     CBOX_OBJECT_HEADER_INIT(p, cbox_midi_pattern, CBOX_GET_DOCUMENT(song));
 129     cbox_command_target_init(&p->cmd_target, cbox_midi_pattern_process_cmd, p);
 130     p->owner = NULL;
 131     p->name = name;
 132     p->event_count = g_tree_nnodes(maker->events);
 133     p->events = malloc(sizeof(struct cbox_midi_event[1]) * p->event_count);
 134
 135     struct traverse_state st = { p->events, 0 };
 136
 137     g_tree_foreach(maker->events, traverse_func, &st);
 138
 139     CBOX_OBJECT_REGISTER(p);
 140
 141     cbox_song_add_pattern(song, p);
 142
 143     return p;
 144 }
 145
 146 gboolean cbox_midi_pattern_maker_load_smf(struct cbox_midi_pattern_maker *maker, const char *filename, int *length, GError **error)
 147 {
 148     smf_t *smf = smf_load(filename);
 149     if (!smf)
 150     {
 151         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Cannot load SMF file '%s'", filename);
 152         return FALSE;
 153     }
 154
 155     int ppqn = smf->ppqn;
 156     smf_event_t *event = NULL;
 157     while ((event = smf_get_next_event(smf)) != NULL) {
 158         if (smf_event_is_metadata(event))
 159                 continue;
 160
 161         cbox_midi_pattern_maker_add_mem(maker, event->time_pulses * 1.0 * PPQN / ppqn, event->midi_buffer, event->midi_buffer_length);
 162     }
 163     if (length)
 164         *length = smf_get_length_pulses(smf) * 1.0 * PPQN / ppqn;
 165     smf_delete(smf);
 166
 167     return TRUE;
 168 }
 169
 170 void cbox_midi_pattern_maker_destroy(struct cbox_midi_pattern_maker *maker)
 171 {
 172     g_tree_destroy(maker->events);
 173     free(maker);
 174 }
 175
 176