You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
449 lines
17 KiB
449 lines
17 KiB
/*********************************************************************************
|
|
*
|
|
* MIDITONES_SCROLL
|
|
*
|
|
* Decode a PLAYTUNE bytestream of notes as a time-ordered scroll, sort of like a
|
|
* piano roll with non-uniform time. This is a command-line program with no GUI.
|
|
*
|
|
*
|
|
* There are two primary uses:
|
|
*
|
|
* (1) To debug errors that cause some MIDI scripts to sound strange.
|
|
*
|
|
* (2) To create a C-program array initialized with the bytestream, but annotated
|
|
* with the original notes. This is semantically the same as the normal output
|
|
* of MIDITONES, but is easier to edit manually. The downside is that the C
|
|
* source code file is much larger.
|
|
*
|
|
* In both cases it reads a xxx.bin file that was created from a MIDI file by
|
|
* MIDITONES using the -b option.
|
|
*
|
|
*
|
|
* For use case (1), just invoke the program with the base filename. The output is
|
|
* to the console, which can be directed to a file using the usual >file redirection.
|
|
* For example, starting with the original midi file "song.mid", say this:
|
|
*
|
|
* miditones -b song
|
|
* miditones_scroll song >song.txt
|
|
*
|
|
* and then the file "song.txt" will contain the piano roll.
|
|
*
|
|
*
|
|
* For use case (2), use the -c option to create a <basefile>.c file.
|
|
* For example, starting with the original midi file "song.mid", say this:
|
|
*
|
|
* miditones -b song
|
|
* miditones_scroll -c song
|
|
*
|
|
* and then the file "song.c" will contain the PLAYTUNE bytestream C code.
|
|
*
|
|
*
|
|
* Other command-line options:
|
|
*
|
|
* -tn says that up to n tone generators should be displayed. The default
|
|
* is 6 and the maximum is 16.
|
|
*
|
|
* -v says that we expect the binary file to contain encoded note volume
|
|
* information as generated from Miditones with the -v option. That
|
|
* volume information is displayed next to each note.
|
|
*
|
|
* -vi says that we expect volume information to be in the file, but we
|
|
* should ignore it when creating the display.
|
|
*
|
|
*
|
|
* For source code to this and related programs, see
|
|
* https://github.com/LenShustek/arduino-playtune
|
|
* https://github.com/LenShustek/miditones
|
|
*
|
|
*----------------------------------------------------------------------------------
|
|
* (C) Copyright 2011,2013,2016 Len Shustek
|
|
*
|
|
* This program is free software. You can redistribute it and/or modify
|
|
* it under the terms of version 3 of the GNU General Public License as
|
|
* published by the Free Software Foundation at www.gnu.org/licenses,
|
|
* with Additional Permissions under term 7(b) that the original copyright
|
|
* notice and author attibution must be preserved and under term 7(c) that
|
|
* modified versions be marked as different from the original.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY,without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
***********************************************************************************/
|
|
/*
|
|
* Change log
|
|
*
|
|
* 26 February 2011, L.Shustek, V1.0
|
|
* - Initial release
|
|
* 29 December 2013, L.Shustek, V1.1
|
|
* - Add a "-c" option to create C code output.
|
|
* Thanks go to mats.engstrom for the idea.
|
|
* 04 April 2015, L. Shustek, V1.3
|
|
* - Made friendlier to other compilers: import source of strlcpy and strlcat,
|
|
* and fix various type mismatches that the LCC compiler didn't fret about.
|
|
* Generate "const" data initialization for compatibility with Arduino IDE v1.6.x.
|
|
* 5 August 2016, L. Shustek, V1.4
|
|
* - Add -v and -vi options to handle optional volume codes that Miditones can
|
|
* now generate.
|
|
* - Handle notes>127 as percussion, which Miditones can now generate
|
|
* - Make the number of generators be 16 maximum, but the number actually displayed
|
|
* can be specified by the -tn command-line option.
|
|
* - Remove string.h because OS X has macros for strlcpy; thus had to add strlen().
|
|
* (It's tough to write even non-GUI code for many environments!)
|
|
* - Add casts for where address subtraction is a long, like OS X.
|
|
*/
|
|
|
|
#define VERSION "1.4"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <ctype.h>
|
|
#include <stdbool.h>
|
|
#include <time.h>
|
|
#include <inttypes.h>
|
|
|
|
|
|
/*********** Global variables ******************/
|
|
|
|
#define MAX_TONEGENS 16 /* max tone generators we could display */
|
|
|
|
int gen_note[MAX_TONEGENS]; // the note we're playing, or SILENT
|
|
#define SILENT -1
|
|
int gen_volume[MAX_TONEGENS]; // the volume we're playing
|
|
|
|
FILE *infile, *outfile;
|
|
unsigned char *buffer, *bufptr;
|
|
unsigned long buflen;
|
|
unsigned int num_tonegens = 6; // default number of generators
|
|
unsigned int max_tonegen_found = 0;
|
|
unsigned int notes_skipped;
|
|
|
|
unsigned long timenow = 0;
|
|
unsigned char cmd, gen;
|
|
unsigned char *lastbufptr;
|
|
unsigned delay;
|
|
bool codeoutput = false;
|
|
bool expect_volume = false;
|
|
bool ignore_volume = false;
|
|
|
|
static char *notename[256] = {
|
|
|
|
// map from MIDI note number to octave and note name,
|
|
|
|
"-1C ","-1C#","-1D ","-1D#","-1E ","-1F ","-1F#","-1G ","-1G#","-1A ","-1A#","-1B ",
|
|
" 0C "," 0C#"," 0D "," 0D#"," 0E "," 0F "," 0F#"," 0G "," 0G#"," 0A "," 0A#"," 0B ",
|
|
" 1C "," 1C#"," 1D "," 1D#"," 1E "," 1F "," 1F#"," 1G "," 1G#"," 1A "," 1A#"," 1B ",
|
|
" 2C "," 2C#"," 2D "," 2D#"," 2E "," 2F "," 2F#"," 2G "," 2G#"," 2A "," 2A#"," 2B ",
|
|
" 3C "," 3C#"," 3D "," 3D#"," 3E "," 3F "," 3F#"," 3G "," 3G#"," 3A "," 3A#"," 3B ",
|
|
" 4C "," 4C#"," 4D "," 4D#"," 4E "," 4F "," 4F#"," 4G "," 4G#"," 4A "," 4A#"," 4B ",
|
|
" 5C "," 5C#"," 5D "," 5D#"," 5E "," 5F "," 5F#"," 5G "," 5G#"," 5A "," 5A#"," 5B ",
|
|
" 6C "," 6C#"," 6D "," 6D#"," 6E "," 6F "," 6F#"," 6G "," 6G#"," 6A "," 6A#"," 6B ",
|
|
" 7C "," 7C#"," 7D "," 7D#"," 7E "," 7F "," 7F#"," 7G "," 7G#"," 7A "," 7A#"," 7B ",
|
|
" 8C "," 8C#"," 8D "," 8D#"," 8E "," 8F "," 8F#"," 8G "," 8G#"," 8A "," 8A#"," 8B ",
|
|
" 9C "," 9C#"," 9D "," 9D#"," 9E "," 9F "," 9F#"," 9G ",
|
|
|
|
// or to channel 9 percussion notes as relocated by Miditones to notes 128..255
|
|
|
|
"P000 ", "P001 ", "P002 ", "P003 ", "P004 ", "P005 ", "P006 ", "P007 ",
|
|
"P008 ", "P009 ", "P010 ", "P011 ", "P012 ", "P013 ", "P014 ", "P015 ",
|
|
"P016 ", "P017 ", "P018 ", "P019 ", "P020 ", "P021 ", "P022 ", "P023 ",
|
|
"P024 ", "P025 ", "P026 ", "Laser", "Whip ", "ScrPu", "ScrPl", "Stick",
|
|
"MetCk", "P033 ", "MetBl", "BassD", "KickD", "SnaSt", "SnaD ", "Clap ",
|
|
"ESnaD", "FTom2", "HHatC", "FTom1", "HHatF", "LTom ", "HHatO", "LMTom",
|
|
"HMTom", "CrCym", "HTom ", "RiCym", "ChCym", "RiBel", "Tamb ", "SpCym",
|
|
"CowBl", "CrCym", "VSlap", "RiCym", "HBong", "LBong", "CongD", "Conga",
|
|
"Tumba", "HTimb", "LTimb", "HAgog", "LAgog", "Cabas", "Marac", "SWhis",
|
|
"LWhis", "SGuir", "LGuir", "Clave", "HWood", "LWood", "HCuic", "LCuic",
|
|
"MTria", "OTria", "Shakr", "Sleig", "BelTr", "Casta", "SirdD", "Sirdu",
|
|
"P088 ", "P089 ", "P090 ", "SnDmR", "OcDrm", "SmDrB", "P094 ", "P095 ",
|
|
"P096 ", "P097 ", "P098 ", "P099 ", "P100 ", "P101 ", "P102 ", "P103 ",
|
|
"P104 ", "P105 ", "P106 ", "P107 ", "P108 ", "P109 ", "P110 ", "P111 ",
|
|
"P112 ", "P113 ", "P114 ", "P115 ", "P116 ", "P117 ", "P118 ", "P119 ",
|
|
"P120 ", "P121 ", "P122 ", "P123 ", "P124 ", "P125 ", "P126 ", "P127"
|
|
};
|
|
|
|
|
|
/************** command-line processing *******************/
|
|
|
|
void SayUsage(char *programName){
|
|
static char *usage[] = {
|
|
"Display a MIDITONES bytestream",
|
|
"Usage: miditones_scroll <basefilename>",
|
|
" reads <basefilename>.bin",
|
|
" -tn displays up to n tone generators",
|
|
" -v expects and displays volume information",
|
|
" -vi expects and ignores volume information",
|
|
" -c option creates an annotated C source file as <basefile>.c",
|
|
"" };
|
|
int i=0;
|
|
while (usage[i][0] != '\0') fprintf(stderr, "%s\n", usage[i++]);
|
|
}
|
|
|
|
int HandleOptions(int argc,char *argv[]) {
|
|
/* returns the index of the first argument that is not an option; i.e.
|
|
does not start with a dash or a slash*/
|
|
|
|
int i,firstnonoption=0;
|
|
|
|
/* --- The following skeleton comes from C:\lcc\lib\wizard\textmode.tpl. */
|
|
for (i=1; i< argc;i++) {
|
|
if (argv[i][0] == '/' || argv[i][0] == '-') {
|
|
switch (toupper(argv[i][1])) {
|
|
case 'H':
|
|
case '?':
|
|
SayUsage(argv[0]);
|
|
exit(1);
|
|
case 'C':
|
|
codeoutput = true;
|
|
break;
|
|
case 'T':
|
|
if (sscanf(&argv[i][2],"%d",&num_tonegens) != 1 || num_tonegens <1 || num_tonegens > MAX_TONEGENS) goto opterror;
|
|
printf("Displaying %d tone generators.\n", num_tonegens);
|
|
break;
|
|
case 'V':
|
|
expect_volume = true;
|
|
if (argv[i][2] == '\0') break;
|
|
if (toupper(argv[i][2]) == 'I') ignore_volume = true;
|
|
else goto opterror;
|
|
break;
|
|
|
|
/* add more option switches here */
|
|
opterror:
|
|
default:
|
|
fprintf(stderr,"unknown option: %s\n",argv[i]);
|
|
SayUsage(argv[0]);
|
|
exit(4);
|
|
}
|
|
}
|
|
else {
|
|
firstnonoption = i;
|
|
break;
|
|
}
|
|
}
|
|
return firstnonoption;
|
|
}
|
|
|
|
/*************** portable string length *****************/
|
|
|
|
int strlength(const char *str) {
|
|
int i;
|
|
for (i=0; str[i] != '\0'; ++i) ;
|
|
return i;
|
|
}
|
|
|
|
/*************** safe string copy *****************/
|
|
|
|
unsigned int strlcpy(char *dst, const char *src, unsigned int siz) {
|
|
char *d = dst;
|
|
const char *s = src;
|
|
unsigned int n = siz;
|
|
/* Copy as many bytes as will fit */
|
|
if (n != 0) {
|
|
while (--n != 0) {
|
|
if ((*d++ = *s++) == '\0') break;
|
|
}
|
|
}
|
|
/* Not enough room in dst, add NUL and traverse rest of src */
|
|
if (n == 0) {
|
|
if (siz != 0) *d = '\0'; /* NUL-terminate dst */
|
|
while (*s++) ;
|
|
}
|
|
return (s - src - 1); /* count does not include NUL */
|
|
}
|
|
|
|
/*************** safe string concatenation *****************/
|
|
|
|
unsigned int strlcat(char *dst, const char *src, unsigned int siz) {
|
|
char *d = dst;
|
|
const char *s = src;
|
|
unsigned int n = siz;
|
|
unsigned int dlen;
|
|
/* Find the end of dst and adjust bytes left but don't go past end */
|
|
while (n-- != 0 && *d != '\0') d++;
|
|
dlen = d - dst;
|
|
n = siz - dlen;
|
|
if (n == 0) return (dlen + strlength(s));
|
|
while (*s != '\0') {
|
|
if (n != 1) {
|
|
*d++ = *s;
|
|
n--;
|
|
}
|
|
s++;
|
|
}
|
|
*d = '\0';
|
|
return (dlen + (s - src)); /* count does not include NUL */
|
|
}
|
|
|
|
|
|
/*************** Found a fatal input file format error ************************/
|
|
|
|
void file_error (char *msg, unsigned char *bufptr) {
|
|
unsigned char *ptr;
|
|
fprintf(stderr, "\n---> file format error at position %04X (%d): %s\n",
|
|
(unsigned int)(bufptr-buffer), (unsigned int)(bufptr-buffer), msg);
|
|
/* print some bytes surrounding the error */
|
|
ptr = bufptr - 16;
|
|
if (ptr < buffer) ptr = buffer;
|
|
for (; ptr <= bufptr+16 && ptr < buffer+buflen; ++ptr) fprintf (stderr, ptr==bufptr ? " [%02X] ":"%02X ", *ptr);
|
|
fprintf(stderr, "\n");
|
|
exit(8);
|
|
}
|
|
|
|
/************** Output a line for the current status as we start a delay **************/
|
|
|
|
// show the current time, status of all the tone generators, and the bytestream data that got us here
|
|
|
|
void print_status(void) {
|
|
if (codeoutput) fprintf (outfile, "/*"); // start comment
|
|
// print the current timestamp
|
|
fprintf (outfile, "%5d %7d.%03d ", delay, timenow/1000, timenow%1000);
|
|
// print the current status of all tone generators
|
|
for (gen=0; gen<num_tonegens; ++gen) {
|
|
fprintf (outfile, "%6s", gen_note[gen] == SILENT ? " " : notename[gen_note[gen]]);
|
|
if (expect_volume && !ignore_volume) if (gen_note[gen] == SILENT) fprintf (outfile, " ");
|
|
else fprintf (outfile, " v%-3d", gen_volume[gen]);
|
|
}
|
|
// display the hex commands that created these changes
|
|
fprintf (outfile, " %04X: ", (unsigned int)(lastbufptr-buffer)); // offset
|
|
if (codeoutput) fprintf (outfile, "*/ "); // end comment
|
|
for (; lastbufptr <= bufptr; ++lastbufptr) fprintf (outfile, codeoutput ? "0x%02X," : "%02X ", *lastbufptr);
|
|
fprintf (outfile, "\n");
|
|
lastbufptr = bufptr+1;
|
|
|
|
}
|
|
|
|
|
|
int countbits (unsigned int bitmap) {
|
|
int count;
|
|
for (count=0; bitmap; bitmap >>= 1)
|
|
count += bitmap & 1;
|
|
return count;
|
|
}
|
|
|
|
|
|
/********************* main loop ****************************/
|
|
|
|
int main(int argc,char *argv[]) {
|
|
int argno, i;
|
|
char *filebasename;
|
|
#define MAXPATH 80
|
|
char filename[MAXPATH];
|
|
unsigned int tonegens_used; // bitmap of tone generators used
|
|
unsigned int num_tonegens_used; // count of tone generators used
|
|
|
|
printf("MIDITONES_SCROLL V%s, (C) 2011,2016 Len Shustek\n", VERSION);
|
|
printf("See the source code for license information.\n\n");
|
|
if (argc == 1) { /* no arguments */
|
|
SayUsage(argv[0]);
|
|
return 1;
|
|
}
|
|
|
|
/* process options */
|
|
|
|
argno = HandleOptions(argc,argv);
|
|
filebasename = argv[argno];
|
|
|
|
/* Open the input file */
|
|
|
|
strlcpy(filename, filebasename, MAXPATH);
|
|
strlcat(filename, ".bin", MAXPATH);
|
|
infile = fopen(filename, "rb");
|
|
if (!infile) {
|
|
fprintf(stderr, "Unable to open input file %s", filename);
|
|
return 1;
|
|
}
|
|
|
|
/* Create the output file */
|
|
|
|
if (codeoutput) {
|
|
strlcpy(filename, filebasename, MAXPATH);
|
|
strlcat(filename, ".c", MAXPATH);
|
|
outfile = fopen(filename, "w");
|
|
if (!infile) {
|
|
fprintf(stderr, "Unable to open output file %s", filename);
|
|
return 1;
|
|
}
|
|
}
|
|
else outfile = stdout;
|
|
|
|
/* Read the whole input file into memory */
|
|
|
|
fseek(infile, 0, SEEK_END); /* find file size */
|
|
buflen = ftell(infile);
|
|
fseek(infile, 0, SEEK_SET);
|
|
buffer = (unsigned char *) malloc (buflen+1);
|
|
if (!buffer) {
|
|
fprintf(stderr, "Unable to allocate %ld bytes for the file", buflen);
|
|
return 1;
|
|
}
|
|
fread(buffer, buflen, 1, infile);
|
|
fclose(infile);
|
|
printf("Processing %s.bin, %ld bytes\n", filebasename, buflen);
|
|
if (codeoutput) {
|
|
time_t rawtime;
|
|
time (&rawtime);
|
|
fprintf(outfile, "// Playtune bytestream for file \"%s.bin\"", filebasename);
|
|
fprintf(outfile, " created by MIDITONES_SCROLL V%s on %s\n", VERSION, asctime(localtime(&rawtime)));
|
|
fprintf(outfile, "const byte PROGMEM score [] = {\n");
|
|
}
|
|
|
|
/* Do the titles */
|
|
|
|
fprintf(outfile, "\n");
|
|
if (codeoutput) fprintf(outfile, "//");
|
|
fprintf(outfile, "duration time ");
|
|
for (i=0; i< num_tonegens; ++i)
|
|
fprintf(outfile, expect_volume && !ignore_volume ? " gen%-5d" : " gen%-2d", i);
|
|
fprintf(outfile," bytestream code\n\n");
|
|
for (gen=0; gen<num_tonegens; ++gen)
|
|
gen_note[gen] = SILENT;
|
|
tonegens_used = 0;
|
|
lastbufptr = buffer;
|
|
|
|
/* Process the commmands sequentially */
|
|
|
|
for (bufptr = buffer; bufptr < buffer+buflen; ++bufptr) {
|
|
cmd = *bufptr;
|
|
if (cmd < 0x80) { //***** delay
|
|
delay = ((unsigned int)cmd << 8) + *++bufptr;
|
|
print_status(); // tone generator status now
|
|
timenow += delay; // advance time
|
|
}
|
|
else if (cmd != 0xf0) { // a note command
|
|
gen = cmd & 0x0f;
|
|
if (gen > max_tonegen_found) max_tonegen_found = gen;
|
|
cmd = cmd & 0xf0;
|
|
if (cmd == 0x90) { //****** note on
|
|
gen_note[gen] = *++bufptr; // note number
|
|
tonegens_used |= 1<<gen; // record that we used this generator at least once
|
|
if (expect_volume) gen_volume[gen] = *++bufptr; // volume
|
|
if (gen >= num_tonegens) ++notes_skipped; // won't be displaying this note
|
|
}
|
|
else if (cmd == 0x80) { //****** note off
|
|
|
|
if (gen_note[gen] == SILENT) file_error ("tone generator not on", bufptr);
|
|
gen_note[gen] = SILENT;
|
|
}
|
|
else file_error ("unknown command", bufptr);
|
|
}
|
|
}
|
|
|
|
|
|
/* Do the final cleanup */
|
|
|
|
delay = 0;
|
|
--bufptr;
|
|
if (codeoutput) --bufptr; //don't do 0xF0 for code, because we don't want the trailing comma
|
|
print_status(); // print final status
|
|
if (codeoutput) {
|
|
fprintf(outfile, " 0xf0};\n");
|
|
num_tonegens_used = countbits(tonegens_used);
|
|
fprintf(outfile, "// This score contains %ld bytes, and %d tone generator%s used.\n",
|
|
buflen, num_tonegens_used, num_tonegens_used == 1 ? " is" : "s are");
|
|
}
|
|
printf("\nAt most %u tone generators were used.\n", max_tonegen_found+1);
|
|
if (notes_skipped) printf("%u notes were not displayed because we were told to show only %u generators.\n", notes_skipped, num_tonegens);
|
|
printf ("Done.\n");
|
|
}
|
|
|
|
|