initial commit into repository0.0

7 files changed, 628 insertions, 0 deletions

diff --git a/tools/.gitignore b/tools/.gitignore
new file mode 100644
index 0000000..6d68099
--- a/dev/null
+++ b/tools/.gitignore
@@ -0,0 +1,11 @@
+Makefile.in
+*.o
+midifilter
+midi2f0
+mididump
+.libs
+.deps
+Makefile
+COPYING.cc
+filters_enumeration.cc
+filters_definition.cc
diff --git a/tools/Makefile.am b/tools/Makefile.am
new file mode 100644
index 0000000..811c4f8
--- a/dev/null
+++ b/tools/Makefile.am
@@ -0,0 +1,31 @@
+bin_PROGRAMS = midi2f0 midifilter mididump
+
+INCLUDES = -I${top_srcdir}/include ${KONFORKA_CFLAGS}
+LIBS += ${top_builddir}/lib/libmidillo.la ${KONFORKA_LIBS}
+
+midi2f0_SOURCES = midi2f0.cc \
+    COPYING.cc
+midi2f0_DEPENDENCIES = ${top_builddir}/lib/libmidillo.la
+
+midifilter_SOURCES = midifilter.cc \
+    COPYING.cc \
+    filters.list \
+    enflesh_filters_list.sh
+midifilter_DEPENDENCIES = ${top_builddir}/lib/libmidillo.la
+${srcdir}/midifilter.cc: filters_enumeration.cc filters_definition.cc
+filters_enumeration.cc filters_definition.cc: enflesh_filters_list.sh filters.list 
+        sh $^ \
+            filters_enumeration.cc filters_definition.cc
+
+mididump_SOURCES = mididump.cc \
+    COPYING.cc
+mididump_DEPENDENCIES = ${top_builddir}/lib/libmidillo.la
+
+clean-local:
+        rm -f filters_enumeration.cc filters_definition.cc
+
+
+COPYING.cc: ${top_srcdir}/COPYING
+        echo "const char * COPYING =" >$@ || (rm $@;exit 1)
+        sed 's/"/\\"/g' $< | sed 's/^/\"/' | sed 's/$$/\\n\"/' >>$@ || (rm $@;exit 1)
+        echo ";" >>$@ || (rm $@;exit 1)
diff --git a/tools/enflesh_filters_list.sh b/tools/enflesh_filters_list.sh
new file mode 100644
index 0000000..f1d8dfc
--- a/dev/null
+++ b/tools/enflesh_filters_list.sh
@@ -0,0 +1,20 @@
+#!/bin/sh
+srcfile="${1}"
+enumfile="${2}"
+deffile="${3}"
+IFS=':'
+exec 5>${enumfile}
+exec 6>${deffile}
+SEQN=0
+LN=0
+cat ${srcfile} \
+    | while read id ids help ; do
+        LN="`expr ${LN} + 1`"
+            test -z "${id}" && continue
+        test "${id}" != "${id# }" && continue
+        echo "#line ${LN} \"${srcfile}\"" >&5
+        echo " filter_${id} = ${SEQN}," >&5
+        echo "#line ${LN} \"${srcfile}\"" >&6
+        echo ' { { "'$(echo $ids|sed -e 's-/-", "-g')'", 0 }, "'"${help}"'", false },' >&6
+        SEQN="`expr ${SEQN} + 1`"
+    done
diff --git a/tools/filters.list b/tools/filters.list
new file mode 100644
index 0000000..c0fb951
--- a/dev/null
+++ b/tools/filters.list
@@ -0,0 +1,36 @@
+system:system:strip all system messages
+meta:meta:strip all meta events (except for EOT)
+
+sysex:sysex:strip sysex messages
+MTC_quarter_frame:MTC_quarter_frame/quarter_frame:strip 'MTC quarter frame' messages
+song_position_pointer:song_position_pointer:strip 'song position pointer' messages
+song_select:song_select:strip 'song select' messages
+tune_request:tune_request:strip 'tune request' messages
+
+midi_clock:midi_clock/timing_clock:strip 'midi clock' messages
+midi_tick:midi_tick:strip 'midi tick' messages
+midi_start:midi_start/start:strip 'midi start' messages
+midi_continue:midi_continue/continue:strip 'midi continue' messages
+midi_stop:midi_stop/stop:strip 'midi stop' messages
+active_sense:active_sense:strip 'active sense' messages
+
+meta_sequence_number:meta_sequence_number:strip 'sequence number' meta events
+meta_text:meta_text:strip 'text' meta events
+meta_copyright:meta_copyright:strip 'copyright' meta events
+meta_seq_track_name:meta_seq_track_name:strip 'sequence track name' meta events
+meta_instrument:meta_instrument:strip 'instrument' meta events
+meta_lyric:meta_lyric/meta_lyrics:strip 'lyric' meta events
+meta_marker:meta_marker:strip 'marker' meta events
+meta_cue_point:meta_cue_point:strip 'cue point' meta events
+meta_patch_name:meta_patch_name/meta_program_name:strip 'patch name' meta events
+meta_port_name:meta_port_name/meta_device_name:strip 'port name' meta events
+meta_tempo:meta_temp:strip 'tempo' meta events
+meta_SMPTE_offset:meta_SMPTE_offset:strip 'SMPTE offset' meta events
+meta_time_sig:meta_time_sig:strip 'time signature' meta events
+meta_key_sig:meta_key_sig:strip 'key signature' meta events
+meta_proprietary:meta_proprietary:strip 'proprietary' meta events
+
+meta_midi_channel:meta_midi_channel:strip 'midi channel' meta events
+meta_midi_port:meta_midi_port:strip 'midi port' meta events
+
+meta_unknown:meta_unknown:strip meta events not known by midillo
diff --git a/tools/midi2f0.cc b/tools/midi2f0.cc
new file mode 100644
index 0000000..dc95be6
--- a/dev/null
+++ b/tools/midi2f0.cc
@@ -0,0 +1,151 @@
+#include <getopt.h>
+#include <iostream>
+#include <algorithm>
+using namespace std;
+#include <konforka/exception.h>
+#include <midillo/SMF.h>
+using namespace midillo;
+
+#include "config.h"
+#define PHEADER PACKAGE " " VERSION " - midi2f0 - convert to midi format 0"
+#define PCOPY "Copyright (c) 2006 Klever Group"
+
+static void usage(const char *p) {
+    cerr << PHEADER << endl
+        << PCOPY << endl << endl
+        << " " << p << " [options] [<input-file>[ <output-file>]]" << endl << endl
+        << " -h, --help" << endl
+        << " --usage          display this text" << endl
+        << " -V, --version    display version number" << endl
+        << " -L, --license    show license" << endl;
+}
+
+static bool MTrk_is_empty(const MTrk_t& t) {
+    return 
+        t.events.empty()
+        || t.events.front().message.is_meta(meta_EOT);
+}
+
+static bool MTrk_deltat_lt(const MTrk_t& a,const MTrk_t& b) {
+    // we assume tracks aren't empty
+    return a.events.front().deltat < b.events.front().deltat;
+}
+
+static bool event_has_nonzero_deltat_or_is_EOT(const event_t& e) {
+    return e.deltat!=0 || e.message.is_meta(meta_EOT);
+}
+
+main(int argc,char **argv) {
+    try {
+        while(true) {
+            static struct option opts[] = {
+                { "help", no_argument, 0, 'h' },
+                { "usage", no_argument, 0, 'h' },
+                { "version", no_argument, 0, 'V' },
+                { "license", no_argument, 0, 'L' },
+                { NULL, 0, 0, 0 }
+            };
+            int c = getopt_long(argc,argv,"hVL",opts,NULL);
+            if(c==-1)
+                break;
+            switch(c) {
+                case 'h':
+                    usage(*argv);
+                    exit(0);
+                    break;
+                case 'V':
+                    cerr << VERSION << endl;
+                    exit(0);
+                    break;
+                case 'L':
+                    extern const char *COPYING;
+                    cerr << COPYING << endl;
+                    exit(0);
+                    break;
+                default:
+                    cerr << "Huh??" << endl;
+                    break;
+            }
+        }
+        const char *infile = "-";
+        if(optind<argc)
+            infile = argv[optind++];
+        const char *oufile = "-";
+        if(optind<argc)
+            oufile = argv[optind++];
+        if(optind<argc) {
+            usage(*argv);
+            exit(1);
+        }
+        SMF_t in(infile);
+        if(in.mthd.fmt==MThd_t::fmt_0) {
+            cerr << "File is already SMF 0" << endl;
+            in.save(oufile);
+        }else if(in.mthd.fmt==MThd_t::fmt_1) {
+            cerr << "Converting from SMF 1 to SMF 0" << endl;
+            SMF_t ou;
+            ou.mthd = in.mthd;
+            ou.mthd.fmt = MThd_t::fmt_0; ou.mthd.ntracks = 1;
+            ou.tracks.resize(1);
+            MTrk_t& mtrk = ou.tracks.front();
+            events_t& evs = mtrk.events;
+            for(;;) {
+                // Cleaning up empty tracks
+                in.tracks.erase(
+                        remove_if(
+                            in.tracks.begin(),in.tracks.end(),
+                            MTrk_is_empty),
+                        in.tracks.end() );
+                if(in.tracks.empty())
+                    break;
+                // Find the least deltat
+                unsigned long mindt = min_element(
+                        in.tracks.begin(), in.tracks.end(),
+                        MTrk_deltat_lt )->events.front().deltat;
+                int t=0;
+                bool reset = false;
+                for(SMF_t::tracks_t::iterator i=in.tracks.begin();i!=in.tracks.end();++i) {
+                    if(i->events.front().deltat > mindt) {
+                        i->events.front().deltat-=mindt;
+                    }else{
+                        do{
+                            evs.splice(
+                                    evs.end(),
+                                    i->events,i->events.begin() );
+                            if(reset)
+                                evs.back().deltat = 0;
+                            else 
+                                reset = true;
+                            events_t::iterator lze=find_if(
+                                    i->events.begin(),i->events.end(),
+                                    event_has_nonzero_deltat_or_is_EOT );
+                            evs.splice(
+                                    evs.end(),
+                                    i->events,i->events.begin(),lze );
+                        }while( (!MTrk_is_empty(*i)) && i->events.front().deltat==0 );
+                    }
+                }
+            }
+            event_t& eot = *evs.append_event();
+            eot.deltat=0;
+            eot.message.status = status_system_meta;
+            eot.message.meta_status = meta_EOT;
+            ou.save(oufile);
+        }else if(in.mthd.fmt==MThd_t::fmt_2) {
+            // TODO
+            cerr << "Not implemented" << endl;
+        }else{
+            cerr << "Unknown MIDI file format" << endl;
+        }
+        return 0;
+    }catch(konforka::exception& e) {
+        cerr << "Oops... Konforka exception:" << endl
+            << " what: " << e.what() << endl
+            << " where: " << e.where() << endl;
+        return 1;
+    }catch(exception& e) {
+        cerr << "Oops... Exception:" << endl
+            << " what: " << e.what() << endl;
+        return 1;
+    }
+}
diff --git a/tools/mididump.cc b/tools/mididump.cc
new file mode 100644
index 0000000..83b7086
--- a/dev/null
+++ b/tools/mididump.cc
@@ -0,0 +1,84 @@
+#include <getopt.h>
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <algorithm>
+using namespace std;
+#include <konforka/exception.h>
+#include <midillo/SMF.h>
+using namespace midillo;
+
+#include "config.h"
+#define PHEADER PACKAGE " " VERSION " - mididump - dump midi files"
+#define PCOPY "Copyright (c) 2006 Klever Group"
+
+static void usage(const char *p) {
+    cerr << PHEADER << endl
+        << PCOPY << endl << endl
+        << " " << p << " [options] [<input-file>[ <output-file>]]" << endl << endl
+        << " -h, --help" << endl
+        << " --usage          display this text" << endl
+        << " -V, --version    display version number" << endl
+        << " -L, --license    show license" << endl;
+}
+
+main(int argc,char **argv) {
+    try {
+        while(true) {
+            static struct option opts[] = {
+                { "help", no_argument, 0, 'h' },
+                { "usage", no_argument, 0, 'h' },
+                { "version", no_argument, 0, 'V' },
+                { "license", no_argument, 0, 'L' },
+                { NULL, 0, 0, 0 }
+            };
+            int c = getopt_long(argc,argv,"f:hVLl",opts,NULL);
+            if(c==-1)
+                break;
+            switch(c) {
+                case 'h':
+                    usage(*argv);
+                    exit(0);
+                    break;
+                case 'V':
+                    cerr << VERSION << endl;
+                    exit(0);
+                    break;
+                case 'L':
+                    extern const char *COPYING;
+                    cerr << COPYING << endl;
+                    exit(0);
+                    break;
+                default:
+                    cerr << "Huh??" << endl;
+                    break;
+            }
+        }
+        const char *infile = "-";
+        if(optind<argc)
+            infile = argv[optind++];
+        const char *oufile = "-";
+        if(optind<argc)
+            oufile = argv[optind++];
+        if(optind<argc) {
+            usage(*argv);
+            exit(1);
+        }
+        SMF_t in(infile);
+        if(strcmp(oufile,"-")) {
+            ofstream s(oufile); s << in;
+        }else{
+            cout << in;
+        }
+        return 0;
+    }catch(konforka::exception& e) {
+        cerr << "Oops... Konforka exception:" << endl
+            << " what: " << e.what() << endl
+            << " where: " << e.where() << endl;
+        return 1;
+    }catch(exception& e) {
+        cerr << "Oops... Exception:" << endl
+            << " what: " << e.what() << endl;
+        return 1;
+    }
+}
diff --git a/tools/midifilter.cc b/tools/midifilter.cc
new file mode 100644
index 0000000..1c130de
--- a/dev/null
+++ b/tools/midifilter.cc
@@ -0,0 +1,295 @@
+#include <getopt.h>
+#include <iostream>
+#include <string>
+#include <algorithm>
+#include <iterator>
+using namespace std;
+#include <konforka/exception.h>
+#include <midillo/SMF.h>
+using namespace midillo;
+
+#include "config.h"
+#define PHEADER PACKAGE " " VERSION " - midifilter - midi filter tool"
+#define PCOPY "Copyright (c) 2006 Klever Group"
+
+enum {
+# include "filters_enumeration.cc"
+    total_filters
+};
+
+struct filter_t {
+    const char *ids[5];
+    const char *help;
+    bool filter;
+} filters[] = {
+# include "filters_definition.cc"
+  {0,0,0}
+};
+#define FILTER(f) filters[filter_##f].filter
+
+inline ostream& operator<<(ostream& s,const filter_t& f) {
+    ios::fmtflags ff = s.flags();
+    int w = s.width(25);
+    s.unsetf(ios::right); s.setf(ios::left);
+    s << *f.ids << " " << f.help;
+    s.width(w);
+    s.flags(ff);
+    return s;
+}
+
+static bool message_is_filtered(const message_t& m) {
+    if(m.is_meta(meta_EOT))
+        return false;
+
+    if(FILTER(sysex) && (m.status==status_system_sysex || m.status==status_system_end_of_sysex))
+        return true;
+    if(FILTER(MTC_quarter_frame) && m.status==status_system_MTC_quarter_frame)
+        return true;
+    if(FILTER(song_position_pointer) && m.status==status_system_song_position_pointer)
+        return true;
+    if(FILTER(song_select) && m.status==status_system_song_select)
+        return true;
+    if(FILTER(tune_request) && m.status==status_system_tune_request)
+        return true;
+    if(FILTER(midi_clock) && m.status==status_system_midi_clock)
+        return true;
+    if(FILTER(midi_tick) && m.status==status_system_midi_tick)
+        return true;
+    if(FILTER(midi_start) && m.status==status_system_midi_start)
+        return true;
+    if(FILTER(midi_continue) && m.status==status_system_midi_continue)
+        return true;
+    if(FILTER(midi_stop) && m.status==status_system_midi_stop)
+        return true;
+    if(FILTER(active_sense) && m.status==status_system_active_sense)
+        return true;
+
+    if(FILTER(meta_sequence_number) && m.is_meta(meta_sequence_number))
+        return true;
+    if(FILTER(meta_text) && m.is_meta(meta_text))
+        return true;
+    if(FILTER(meta_copyright) && m.is_meta(meta_copyright))
+        return true;
+    if(FILTER(meta_seq_track_name) && m.is_meta(meta_seq_track_name))
+        return true;
+    if(FILTER(meta_instrument) && m.is_meta(meta_instrument))
+        return true;
+    if(FILTER(meta_lyric) && m.is_meta(meta_lyric))
+        return true;
+    if(FILTER(meta_marker) && m.is_meta(meta_marker))
+        return true;
+    if(FILTER(meta_cue_point) && m.is_meta(meta_cue_point))
+        return true;
+    if(FILTER(meta_patch_name) && m.is_meta(meta_patch_name))
+        return true;
+    if(FILTER(meta_port_name) && m.is_meta(meta_port_name))
+        return true;
+    if(FILTER(meta_tempo) && m.is_meta(meta_tempo))
+        return true;
+    if(FILTER(meta_SMPTE_offset) && m.is_meta(meta_SMPTE_offset))
+        return true;
+    if(FILTER(meta_time_sig) && m.is_meta(meta_time_sig))
+        return true;
+    if(FILTER(meta_key_sig) && m.is_meta(meta_key_sig))
+        return true;
+    if(FILTER(meta_proprietary) && m.is_meta(meta_proprietary))
+        return true;
+
+    if(FILTER(meta_midi_channel) && m.is_meta(meta_midi_channel))
+        return true;
+    if(FILTER(meta_midi_port) && m.is_meta(meta_midi_port))
+        return true;
+
+    if(FILTER(meta_unknown) && m.is_meta()) {
+        const int known_metas[] = {
+            meta_sequence_number, meta_text, meta_copyright, meta_seq_track_name,
+            meta_instrument, meta_lyric, meta_marker, meta_cue_point,
+            meta_patch_name, meta_port_name, meta_EOT, meta_tempo,
+            meta_SMPTE_offset, meta_time_sig, meta_key_sig, meta_proprietary,
+            meta_midi_channel, meta_midi_port };
+        const int* lastknown = &known_metas[sizeof(known_metas)/sizeof(*known_metas)];
+        if( find(
+                    known_metas, lastknown,
+                    m.meta_status ) == lastknown ) {
+            return true;
+        }
+    }
+
+    if(FILTER(meta) && m.is_meta())
+        return true;
+
+    return false;
+}
+
+static bool event_is_filtered(const event_t& e) {
+    return message_is_filtered(e.message);
+}
+
+static bool MTrk_is_empty(const MTrk_t& t) {
+    return 
+        t.events.empty()
+        || t.events.front().message.is_meta(meta_EOT);
+}
+
+struct filter_preset_t {
+    const char *id;
+    const char *help;
+    int filters[total_filters];
+} filter_presets[] = {
+    { "system_common", "strip system common messages",
+        { filter_sysex, filter_song_position_pointer, filter_song_select,
+            filter_tune_request, -1 } },
+    { "system_runtime", "strip system runtime messages",
+        { filter_midi_clock, filter_midi_tick, filter_midi_start,
+            filter_midi_continue, filter_midi_stop, filter_active_sense, -1 } },
+    { "meta_obsolete", "strip obsolete meta events",
+        { filter_meta_midi_channel, filter_meta_midi_port, -1 } },
+    { "meta_texts", "strip textual meta events",
+        { filter_meta_text, filter_meta_copyright,
+            filter_meta_seq_track_name, filter_meta_instrument,
+            filter_meta_lyric, filter_meta_marker, filter_meta_cue_point,
+            filter_meta_patch_name, filter_meta_port_name, -1 } }
+};
+
+inline ostream& operator<<(ostream& s,const filter_preset_t& fp) {
+    ios::fmtflags ff = s.flags();
+    int w = s.width(25);
+    s.unsetf(ios::right); s.setf(ios::left);
+    s << fp.id << " " << fp.help;
+    s.width(w);
+    s.flags(ff);
+    return s;
+}
+
+static void usage(const char *p) {
+    cerr << PHEADER << endl
+        << PCOPY << endl << endl
+        << " " << p << " [options] [<input-file>[ <output-file>]]" << endl << endl
+        << " -h, --help" << endl
+        << " --usage          display this text" << endl
+        << " -V, --version    display version number" << endl
+        << " -L, --license    show license" << endl
+        << " -f <filters>, --filter=<filters>"
+        << "                  specify the list of events (comma-separated) to" << endl
+        << "                  strip" << endl
+        << " -l, --list-filters" << endl
+        << "                  list available filters" << endl;
+}
+
+main(int argc,char **argv) {
+    try {
+        while(true) {
+            static struct option opts[] = {
+                { "help", no_argument, 0, 'h' },
+                { "usage", no_argument, 0, 'h' },
+                { "version", no_argument, 0, 'V' },
+                { "license", no_argument, 0, 'L' },
+                { "filter", no_argument, 0, 'f' },
+                { "list-filters", no_argument, 0, 'l' },
+                { NULL, 0, 0, 0 }
+            };
+            int c = getopt_long(argc,argv,"f:hVLl",opts,NULL);
+            if(c==-1)
+                break;
+            switch(c) {
+                case 'h':
+                    usage(*argv);
+                    exit(0);
+                    break;
+                case 'V':
+                    cerr << VERSION << endl;
+                    exit(0);
+                    break;
+                case 'L':
+                    extern const char *COPYING;
+                    cerr << COPYING << endl;
+                    exit(0);
+                    break;
+                case 'f':
+                    {
+                        string fs = optarg;
+                        while(!fs.empty()) {
+                            string::size_type ns = fs.find_first_not_of(" :/,;");
+                            if(ns==string::npos)
+                                break;
+                            if(ns)
+                                fs.erase(ns);
+                            string::size_type s = fs.find_first_of(" :/,;");
+                            string f;
+                            if(s==string::npos) {
+                                f = fs; fs.clear();
+                            }else{
+                                f = fs.substr(0,ns);
+                                fs.erase(0,ns+1);
+                            }
+                            for(int fn=0;fn<total_filters;++fn) {
+                                filter_t& filter = filters[fn];
+                                for(int fid=0;fid<(sizeof(filter.ids)/sizeof(*filter.ids)) && filter.ids[fid];++fid) {
+                                    if(f == filter.ids[fid])
+                                        filter.filter = true;
+                                }
+                            }
+                        }
+                    }
+                    break;
+                case 'l':
+                    cerr << PHEADER << endl
+                        << PCOPY << endl << endl;
+                    copy(
+                            filters, &filters[total_filters],
+                            ostream_iterator<filter_t>(cerr,"\n") );
+                    copy(
+                            filter_presets, &filter_presets[sizeof(filter_presets)/sizeof(*filter_presets)],
+                            ostream_iterator<filter_preset_t>(cerr,"\n") );
+                    exit(0);
+                    break;
+                default:
+                    cerr << "Huh??" << endl;
+                    break;
+            }
+        }
+        const char *infile = "-";
+        if(optind<argc)
+            infile = argv[optind++];
+        const char *oufile = "-";
+        if(optind<argc)
+            oufile = argv[optind++];
+        if(optind<argc) {
+            usage(*argv);
+            exit(1);
+        }
+        SMF_t in(infile);
+        for(SMF_t::tracks_t::iterator t=in.tracks.begin();t!=in.tracks.end();++t) {
+            for(events_t::iterator e=t->events.begin();e!=t->events.end();) {
+                if(event_is_filtered(*e)) {
+                    events_t::iterator i = e++;
+                    // we assume it is not the last event, since the last event
+                    // (meta_EOT) is unfilterable
+                    e->deltat += i->deltat;
+                    t->events.erase(i);
+                }else
+                    ++e;
+            }
+        }
+        in.tracks.erase(
+                remove_if(
+                    in.tracks.begin(),in.tracks.end(),
+                    MTrk_is_empty),
+                in.tracks.end() );
+        if(in.tracks.empty()) {
+            cerr << "We have no MIDI data in the output file";
+        }
+        in.mthd.ntracks = in.tracks.size();
+        in.save(oufile);
+        return 0;
+    }catch(konforka::exception& e) {
+        cerr << "Oops... Konforka exception:" << endl
+            << " what: " << e.what() << endl
+            << " where: " << e.where() << endl;
+        return 1;
+    }catch(exception& e) {
+        cerr << "Oops... Exception:" << endl
+            << " what: " << e.what() << endl;
+        return 1;
+    }
+}