abcmidi/0000755000000000000000000000000012672020606011145 5ustar rootrootabcmidi/drawtune.c0000644000000000000000000026362112236070424013153 0ustar rootroot/* * yaps - program to convert abc files to PostScript. * Copyright (C) 1999 James Allwright * e-mail: J.R.Allwright@westminster.ac.uk * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * */ /* drawtune.c */ /* This file contains routines for generating final PostScript Output */ /* There are 2 stages to this process. First the symbol positions are */ /* calculated, then the PostScript symbols are generated. */ #ifdef _MSC_VER #define ANSILIBS 1 #endif #include #ifdef ANSILIBS #include #include #include #endif #include "abc.h" #include "structs.h" #include "sizes.h" #include "drawtune.h" /* external functions and variables */ extern struct tune thetune; extern int debugging; extern int pagenumbering; extern int barnums, nnbars; extern char outputname[256]; extern char outputroot[256]; extern int make_open(); extern void printlib(); extern int count_dots(int *base, int *base_exp, int n, int m); extern void monospace(struct tune* t); extern void spacevoices(struct tune* t); /* provided by debug.c */ extern void showtune(struct tune *t); struct key* newkey(char* name, int sharps, char accidental[], int mult[]); struct aclef* newclef(enum cleftype t, int octave); char* addstring(char *s); extern int lineno; extern int separate_voices; extern int print_xref; extern int landscape; static void pagebottom(); static void setfont(int size, int num); FILE* f = NULL; struct feature* beamset[64]; struct feature* gracebeamset[32]; int beamctr, gracebeamctr;; int rootstem; int fontsize, fontnum; int donemeter; int ingrace, inchord; int chordcount; struct feature* chordhead; double scale, descend, totlen, oldplace; int pagecount = 1; int pagelen, pagewidth, xmargin, ymargin; double scaledlen, scaledwidth; int staffsep; int eps_out; int titleleft = 0; int titlecaps = 0; int gchords_above = 1; int redcolor; /* [SS] 2013-11-04*/ enum placetype {left, right, centre}; struct font textfont; struct font titlefont; struct font subtitlefont; struct font wordsfont; struct font composerfont; struct font vocalfont; struct font gchordfont; struct font partsfont; /* arrays giving character widths for characters 32-255 */ /* font for lyrics : 13 point Times-Bold */ double timesbold_width[224] = { 3.249, 4.328, 7.214, 6.499, 6.499, 12.999, 10.828, 4.328, 4.328, 4.328, 6.499, 7.409, 3.249, 7.409, 3.249, 3.613, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 4.328, 4.328, 7.409, 7.409, 7.409, 6.499, 12.089, 9.385, 8.67, 9.385, 9.385, 8.67, 7.942, 10.113, 10.113, 5.056, 6.499, 10.113, 8.67, 12.271, 9.385, 10.113, 7.942, 10.113, 9.385, 7.227, 8.67, 9.385, 9.385, 12.999, 9.385, 9.385, 8.67, 4.328, 3.613, 4.328, 7.552, 6.499, 4.328, 6.499, 7.227, 5.771, 7.227, 5.771, 4.328, 6.499, 7.227, 3.613, 4.328, 7.227, 3.613, 10.828, 7.227, 6.499, 7.227, 7.227, 5.771, 5.056, 4.328, 7.227, 6.499, 9.385, 6.499, 6.499, 5.771, 5.121, 2.859, 5.121, 6.759, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.249, 3.613, 4.328, 4.328, 4.328, 4.328, 4.328, 4.328, 4.328, 4.328, 3.249, 4.328, 4.328, 3.249, 4.328, 4.328, 4.328, 3.249, 4.328, 6.499, 6.499, 6.499, 6.499, 2.859, 6.499, 4.328, 9.71, 3.899, 6.499, 7.409, 4.328, 9.71, 4.328, 5.199, 7.409, 3.899, 3.899, 4.328, 7.227, 7.019, 3.249, 4.328, 3.899, 4.289, 6.499, 9.749, 9.749, 9.749, 6.499, 9.385, 9.385, 9.385, 9.385, 9.385, 9.385, 12.999, 9.385, 8.67, 8.67, 8.67, 8.67, 5.056, 5.056, 5.056, 5.056, 9.385, 9.385, 10.113, 10.113, 10.113, 10.113, 10.113, 7.409, 10.113, 9.385, 9.385, 9.385, 9.385, 9.385, 7.942, 7.227, 6.499, 6.499, 6.499, 6.499, 6.499, 6.499, 9.385, 5.771, 5.771, 5.771, 5.771, 5.771, 3.613, 3.613, 3.613, 3.613, 6.499, 7.227, 6.499, 6.499, 6.499, 6.499, 6.499, 7.409, 6.499, 7.227, 7.227, 7.227, 7.227, 6.499, 7.227, 6.499, }; /* font for chord names : 12 point Helvetica */ double helvetica_width[224] = { 3.335, 3.335, 4.259, 6.671, 6.671, 10.667, 8.003, 2.651, 3.995, 3.995, 4.667, 7.007, 3.335, 3.995, 3.335, 3.335, 6.671, 6.671, 6.671, 6.671, 6.671, 6.671, 6.671, 6.671, 6.671, 6.671, 3.335, 3.335, 7.007, 7.007, 7.007, 6.671, 12.179, 8.003, 8.003, 8.663, 8.663, 8.003, 7.331, 9.335, 8.663, 3.335, 5.999, 8.003, 6.671, 9.995, 8.663, 9.335, 8.003, 9.335, 8.663, 8.003, 7.331, 8.663, 8.003, 11.327, 8.003, 8.003, 7.331, 3.335, 3.335, 3.335, 5.627, 6.671, 2.663, 6.671, 6.671, 5.999, 6.671, 6.671, 3.335, 6.671, 6.671, 2.663, 2.663, 5.999, 2.663, 9.995, 6.671, 6.671, 6.671, 6.671, 3.995, 5.999, 3.335, 6.671, 5.999, 8.663, 5.999, 5.999, 5.999, 4.007, 3.119, 4.007, 7.007, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.995, 6.671, 6.671, 2.003, 6.671, 6.671, 6.671, 6.671, 2.291, 3.995, 6.671, 3.995, 3.995, 5.999, 5.999, 3.335, 6.671, 6.671, 6.671, 3.335, 3.335, 6.443, 4.199, 2.663, 3.995, 3.995, 6.671, 11.999, 11.999, 3.335, 7.331, 3.335, 3.995, 3.995, 3.995, 3.995, 3.995, 3.995, 3.995, 3.995, 3.335, 3.995, 3.995, 3.335, 3.995, 3.995, 3.995, 11.999, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 11.999, 3.335, 4.439, 3.335, 3.335, 3.335, 3.335, 6.671, 9.335, 11.999, 4.379, 3.335, 3.335, 3.335, 3.335, 3.335, 10.667, 3.335, 3.335, 3.335, 3.335, 3.335, 3.335, 2.663, 7.331, 11.327, 7.331, 3.335, 3.335, 3.335, 3.335, }; static int ISOencoding(char ch1, char ch2) /* converts the 2 characters following '\' into an ISO Latin 1 Font */ /* character code in the range 128-255 */ { int code; code = 0; switch (ch1) { case '`': switch(ch2) { case 'A': code = 0300; break; case 'E': code = 0310; break; case 'I': code = 0314; break; case 'O': code = 0322; break; case 'U': code = 0331; break; case 'a': code = 0340; break; case 'e': code = 0350; break; case 'i': code = 0354; break; case 'o': code = 0362; break; case 'u': code = 0371; break; default: break; }; break; case '\'': switch(ch2) { case 'A': code = 0301; break; case 'E': code = 0311; break; case 'I': code = 0315; break; case 'U': code = 0332; break; case 'Y': code = 0335; break; case 'a': code = 0341; break; case 'e': code = 0351; break; case 'i': code = 0355; break; case 'o': code = 0363; break; case 'u': code = 0372; break; case 'y': code = 0375; break; default: break; }; break; case '^': switch(ch2) { case 'A': code = 0302; break; case 'E': code = 0312; break; case 'I': code = 0316; break; case 'O': code = 0324; break; case 'U': code = 0333; break; case 'a': code = 0342; break; case 'e': code = 0352; break; case 'i': code = 0356; break; case 'o': code = 0364; break; case 'u': code = 0373; break; default: break; }; break; case '"': switch(ch2) { case 'A': code = 0304; break; case 'E': code = 0313; break; case 'I': code = 0317; break; case 'O': code = 0326; break; case 'U': code = 0334; break; case 'a': code = 0344; break; case 'e': code = 0353; break; case 'i': code = 0357; break; case 'o': code = 0366; break; case 'u': code = 0374; break; case 'y': code = 0377; break; default: break; }; break; case '~': switch(ch2) { case 'A': code = 0303; break; case 'N': code = 0321; break; case 'O': code = 0325; break; case 'a': code = 0343; break; case 'n': code = 0361; break; case 'o': code = 0365; break; default: break; }; break; case 'c': switch(ch2) { case 'C': code = 0307; break; case 'c': code = 0347; break; default: break; }; break; case 'o': switch(ch2) { case 'A': code = 0305; break; case 'a': code = 0345; break; default: break; }; break; case 'A': if (ch2=='A') { code = 0305; }; if (ch2=='E') { code = 0305; }; break; case 'a': if (ch2=='a') { code = 0345; }; if (ch2=='e') { code = 0346; }; break; case 's': if (ch2=='s') { code = 0337; }; break; default: break; }; return(code); } static int getISO(char s[], int j, int* code) /* convert input into 8-bit character code */ /* s[] is input string, j is place in string */ /* returns new place in string and writes 8-bit value to code */ { int i; int count; i =j; if (s[i]=='\\') { /* look for 2 character code */ *code = ISOencoding(s[i+1], s[i+2]); if (*code != 0) { i = i+3; } else { /* look for octal code */ i = i+1; *code = 0; count = 0; while ((s[i]>='0')&&(s[i]<='7')&&(count<3)) { *code = ((*code)*8+(int)s[i]-'0')%256; count = count+1; i = i+1; }; if (*code == 0) { *code = '\\'; }; }; } else { *code = (int)s[i] & 0xFF; i = i + 1; }; return(i); } static void ISOdecode(char s[], char out[]) /* convert coded characters to straight 8-bit ascii */ { int i, j, len; int code; len = strlen(s); i = 0; j = 0; while (i 31) && (ch < 128)) { fprintf(f, "%c", s[i]); } else { fprintf(f, "\\%03o", 0xFF & (int)s[i]); }; i = i+1; break; }; }; } static double stringwidth(char* str, double ptsize, int fontno) /* calculate width of string */ { int i, len, ch; double width; int code; double baseptsize; double* charwidth; if (fontno == 3) { charwidth = &helvetica_width[0]; baseptsize = 12.0; } else { charwidth = ×bold_width[0]; baseptsize = 13.0; }; width = 0.0; len = strlen(str); i = 0; while (i < len) { i = getISO(str, i, &code); ch = code - 32; if ((ch >= 0) && (ch < 224)) { width = width + charwidth[ch]; } else { width = width + charwidth[0]; /* approximate with space */ }; }; return(width*ptsize/baseptsize); } void setscaling(char* s) /* scaling value from string following -s in arglist */ { double f; f = -1.0; sscanf(s, "%lf", &f); if (f < 0.001) { f = TUNE_SCALING; }; scale = f; } void setmargins(s) char* s; /* set margin values from string following -M in arglist */ { int i, j; xmargin = XMARGIN; ymargin = YMARGIN; if (s != NULL) { i = -1; j = -1; sscanf(s, "%dx%d", &i, &j); if ((i != -1) && (j != -1)) { xmargin = i; ymargin = j; }; }; } void setpagesize(s) char* s; /* set page size from string following -P in arglist */ { int i, j; pagelen = A4_PAGELEN - 2 * ymargin; pagewidth = A4_PAGEWIDTH - 2 * xmargin; if (s != NULL) { i = 0; j = 0; sscanf(s, "%dx%d", &i, &j); if (i == 0) { pagelen = A4_PAGELEN - 2 * ymargin; pagewidth = A4_PAGEWIDTH - 2 * xmargin; }; if (i == 1) { pagelen = US_LETTER_PAGELEN - 2 * ymargin; pagewidth = US_LETTER_PAGEWIDTH - 2 * xmargin; }; if ((i > 100) && (i > 2*xmargin) && (j > 100) && (j > 2*ymargin)) { pagewidth = i - 2 * xmargin; pagelen = j - 2 * ymargin; }; }; if (landscape) { i = xmargin; xmargin = ymargin; ymargin = i; i = pagelen; pagelen = pagewidth; pagewidth = i; }; scaledlen = ((double)(pagelen))/scale; scaledwidth = ((double)(pagewidth))/scale; } static void set_space(afont, s) /* set vertical space to appear above a line in the given font */ /* s is a string specifying space in points (default), centimetres */ /* or inches */ struct font* afont; char* s; { int count; double x; char units[40]; count = sscanf(s, "%lf%s", &x, units); if (count > 0) { if ((count >= 2) && (strncmp(units, "cm", 2) == 0)) { x = x*28.3; }; if ((count >= 2) && (strncmp(units, "in", 2) == 0)) { x = x*72.0 ; }; afont->space = (int)x; }; } static void init_font(afont, ptsize, spce, defnum, specialnum) /* initialize font structure with given values */ struct font* afont; int ptsize, spce, defnum, specialnum; { afont->pointsize = ptsize; afont->space = spce; afont->default_num = defnum; afont->special_num = specialnum; afont->name = NULL; afont->defined = 0; } static void startpage() /* Encapsulated PostScript for a page header */ { fprintf(f, "%%%%Page: %d %d\n", pagecount, pagecount); fprintf(f, "%%%%BeginPageSetup\n"); fprintf(f, "gsave\n"); if (landscape) { fprintf(f, "90 rotate %d %d T\n", xmargin, -ymargin); } else { fprintf(f, "%d %d T\n", xmargin, ymargin+pagelen); }; fprintf(f, "0.8 setlinewidth 0 setlinecap\n"); fprintf(f, "%.3f %.3f scale\n", scale, scale); fprintf(f, "%%%%EndPageSetup\n\n"); fontnum = 0; fontsize = 0; totlen = 0.0; oldplace = 0.0; descend = 0.0; } static void closepage() /* Encapsulated PostScript for page end */ { if (pagenumbering) { setfont(12, 3); pagebottom(); fprintf(f, "(%d) %.1f 0 M cshow\n", pagecount, scaledwidth/2.0); }; fprintf(f, "%%%%PageTrailer\n"); fprintf(f, "grestore\n"); fprintf(f, "showpage\n\n"); pagecount = pagecount + 1; } void newpage() /* create PostScript for a new page of paper */ /* everything will now be printed on this fresh sheet */ /* ignore the command if the sheet is completely blank */ { if (totlen > 0.0) { closepage(); startpage(); }; } static void pagebottom() /* move to the bottom of the page */ { fprintf(f, "0 %.1f T\n", -(scaledlen - totlen)); totlen = scaledlen; descend = 0.0; } static void newblock(double height, double descender) /* The page is modelled as a series of vertical bands */ /* This routine finds room for a fresh band below the current one */ /* It also does a translation to set a new y=0 line */ /* Subsequent calls may draw up to height units above or */ /* descender units below the line y=0 */ { if (totlen+(descend+height+descender) > scaledlen - (double)(pagenumbering*12)) { newpage(); }; fprintf(f, "0 %.1f T\n", - descend - height); totlen = totlen + (descend + height); descend = descender; } static void staveline() /* draw 5 lines of a stave */ { fprintf(f, "%.1f staff\n", scaledwidth); } static void printclef(struct aclef* t, double x, double yup, double ydown) /* draw a clef of the specified type */ { switch (t->type) { case treble: fprintf(f, "%.1f tclef\n", x); break; case bass: fprintf(f, "%.1f bclef\n", x); break; case alto: fprintf(f, "%.1f cclef\n", x); break; case baritone: fprintf(f, "0 %d T %.1f cclef 0 %d T\n", 4*TONE_HT, x, -4*TONE_HT); break; case tenor: fprintf(f, "0 %d T %.1f cclef 0 %d T\n", 2*TONE_HT, x, -2*TONE_HT); break; case mezzo: fprintf(f, "0 %d T %.1f cclef 0 %d T\n", -2*TONE_HT, x, 2*TONE_HT); break; case soprano: fprintf(f, "0 %d T %.1f cclef 0 %d T\n", -4*TONE_HT, x, 4*TONE_HT); break; default: break; }; if (t->octave > 0) { fprintf(f, "%.1f %.1f (%d) bnum\n", x, yup - CLEFNUM_HT + 3, t->octave); }; if (t->octave < 0) { fprintf(f, "%.1f %.1f (%d) bnum\n", x, -ydown, - t->octave); }; } void set_keysig(struct key* k, struct key* newval) /* copy across key signature */ { int i; for (i=0; i<7; i++) { k->map[i] = newval->map[i]; k->mult[i] = newval->mult[i]; }; k->sharps = newval->sharps; } static double size_keysig(char oldmap[], char newmap[]) /* compute width taken up by drawing the key signature */ { int i, n; n = 0; for (i=0; i<7; i++) { if (((newmap[i] == '=')&&(oldmap[i] != '=')) || (newmap[i] == '^') || (newmap[i] == '_')) { n = n + 1; }; }; return((double)n * 5.0); } static double size_timesig(struct fract* meter) /* compute width of the time signature */ { double len1, len2; char temp[20]; sprintf(temp, "%d", meter->num); len1 = stringwidth(temp, 16.0, 2); sprintf(temp, "%d", meter->denom); len2 = stringwidth(temp, 16.0, 2); if (len1 > len2) { return(len1); } else { return(len2); }; } static void draw_keysig(char oldmap[], char newmap[], int newmult[], double x, struct aclef* clef) /* draw key specified key signature at position x on line */ /* arrays oldmap[], newmap[], newmult[] are indexed with a=0 to g=7 */ /* sharp_pos[] and flat_pos[] give order of notes */ /* e.g. sharp_pos[0] = 8 means 1st sharp drawn is conventionally f */ /* which is in position 8 on the stave (bottom line is E = 0) */ { double xpos; static int sharp_pos[7] = { 8, 5, 9, 6, 3, 7, 4 }; static int flat_pos[7] = { 4, 7, 3, 6, 2, 5, 1}; int i; int offset, pos; int note; switch (clef->type) { case treble: offset = 0; break; case soprano: offset = 2; break; case mezzo: offset = 4; break; case alto: offset = 6; break; case tenor: offset = 8; break; case baritone: offset = 10; break; case bass: offset = 12; break; case noclef: break; }; xpos = x; /* draw naturals to cancel out old accidentals */ for (i=0; i<7; i++) { note = (sharp_pos[i] + 4) % 7; if ((newmap[note] == '=')&&(oldmap[note] != '=')) { pos = (sharp_pos[i] + offset - 3) % 7 + 3; fprintf(f, " %.1f %d nt0", xpos, pos*TONE_HT); xpos = xpos + 5; }; }; /* draw sharps */ for (i=0; i<7; i++) { note = (sharp_pos[i] + 4) % 7; if (newmap[note] == '^') { pos = (sharp_pos[i] + offset - 3) % 7 + 3; if (newmult[note] == 2) { fprintf(f, " %.1f %d dsh0", xpos, pos*TONE_HT); } else { fprintf(f, " %.1f %d sh0", xpos, pos*TONE_HT); }; xpos = xpos + 5; }; }; /* draw flats */ for (i=0; i<7; i++) { note = (flat_pos[i] + 4) % 7; if (newmap[note] == '_') { pos = (flat_pos[i] + offset - 1)%7 + 1; if (newmult[note] == 2) { fprintf(f, " %.1f %d dft0", xpos, pos*TONE_HT); } else { fprintf(f, " %.1f %d ft0", xpos, pos*TONE_HT); }; xpos = xpos + 5; }; }; fprintf(f, "\n"); } static void draw_meter(struct fract* meter, double x) /* draw meter (time signature) at specified x value */ { fprintf(f, "%.1f (%d) (%d) tsig\n", x, meter->num, meter->denom); } static double maxstrwidth(struct llist* strings, double ptsize, int fontno) /* return the width of longest string in the list */ { double width, max; char* str; max = 0.0; str = firstitem(strings); while (str != NULL) { width = stringwidth(str, ptsize, fontno); if (width > max) { max = width; }; str = nextitem(strings); }; return(max); } static void sizerest(struct rest* r, struct feature* ft) /* compute width of rest element */ { double width; if (r->multibar > 0) { ft->xleft = 0.0; ft->xright = 40.0; } else { switch (r->base_exp) { case 1: case 0: ft->xleft = 2.5; ft->xright = 2.5; break; case -1: ft->xleft = 2.5; ft->xright = 2.5; break; case -2: ft->xleft = 3.0; ft->xright = 4.0; break; case -3: ft->xleft = 4.0; ft->xright = 3.0; break; case -4: ft->xleft = 5.0; ft->xright = 3.0; break; case -5: ft->xleft = 6.0; ft->xright = 5.0; break; case -6: default: ft->xleft = 7.0; ft->xright = 5.0; break; }; if (r->dots > 0) { ft->xright = ft->xright + (r->dots* (float) DOT_SPACE); }; }; if (r->gchords != NULL) { width = maxstrwidth(r->gchords, (double)(gchordfont.pointsize), gchordfont.default_num); if (width > ft->xleft + ft->xright) { ft->xright = (float) width - ft->xleft; }; }; } static int acc_upsize(char ch) /* returns height above note of accent */ { int size; switch (ch) { case '=': size = NAT_UP; break; case '^': size = SH_UP; break; case '_': size = FLT_UP; break; default: size = 0; break; }; return(size); } static int acc_downsize(char ch) /* returns depth below note of accent */ { int size; switch (ch) { case '=': size = NAT_DOWN; break; case '^': size = SH_DOWN; break; case '_': size = FLT_DOWN; break; default: size = 0; break; }; return(size); } static void setstemlen(struct note* n, int ingrace) /* work out how long stem needs to be for an isolated note */ /* if the note is in a beamed set, the length may be altered later */ { if (n->base_exp >= 0) { n->stemlength = 0.0; } else { if (ingrace) { if (n->beaming != single) { n->stemlength = GRACE_STEMLEN; /* default stem length */ /* value will be recalculated later by setbeams() */ } else { switch(n->base_exp) { case -6: n->stemlength = (float) GRACE_STEMLEN + 2* (float) TAIL_SEP* (float) 0.7; break; case -5: n->stemlength = (float) GRACE_STEMLEN + (float) TAIL_SEP* (float) 0.7; break; default: n->stemlength = (float) GRACE_STEMLEN; /* default stem length */ break; }; }; } else { if (n->beaming != single) { n->stemlength = STEMLEN; /* default stem length */ /* value will be recalculated later by setbeams() */ } else { switch(n->base_exp) { case -6: n->stemlength = (float) STEMLEN + 2* (float) TAIL_SEP; break; case -5: n->stemlength = (float) STEMLEN + (float) TAIL_SEP; break; default: n->stemlength = (float) STEMLEN; /* default stem length */ break; }; }; }; }; } static void sizenote(struct note* n, struct feature* f, int ingrace) /* compute width and height of note element */ { double width; char* decorators; int i; f->ydown = (float) TONE_HT*(n->y - 2); f->yup = (float) TONE_HT*(n->y + 2); if (ingrace) { f->xleft = (float) GRACE_HALF_HEAD; f->xright = (float) GRACE_HALF_HEAD; } else { if (n->base_exp >= 1) { f->xleft = HALF_BREVE; f->xright = HALF_BREVE; } else { f->xleft = HALF_HEAD; f->xright = HALF_HEAD; }; if (n->fliphead) { if (n->stemup) { f->xright = (float) f->xright + (float) HALF_HEAD * 2; } else { f->xleft = f->xleft + (float) HALF_HEAD * 2; }; }; }; if (n->dots > 0) { f->xright = f->xright + (n->dots* (float) DOT_SPACE); }; if ((n->stemup) && (n->base_exp <= -3) && (n->beaming==single)) { if (f->xright < (HALF_HEAD + TAILWIDTH)) { f->xright = HALF_HEAD + TAILWIDTH; }; }; if (n->accidental != ' ') { f->xleft = (float) HALF_HEAD + (float) ACC_OFFSET + (n->acc_offset-1) * (float) ACC_OFFSET2; if (n->stemup) { f->ydown = (float) TONE_HT*(n->y) - (float)(acc_downsize(n->accidental)); } else { f->yup = (float) ((float) TONE_HT*(n->y) + (double)(acc_upsize(n->accidental))); }; }; if (n->stemlength > 0.0) { if (n->stemup) { f->yup = TONE_HT*(n->y) + n->stemlength; } else { f->ydown = TONE_HT*(n->y) - n->stemlength; }; }; if (n->accents != NULL) { decorators = n->accents; for (i=0; i<(int) strlen(decorators); i++) { switch(decorators[i]) { case 'H': case '~': case 'u': case 'v': case 'T': f->yup = f->yup + BIG_DEC_HT; break; case 'R': if (n->stemup) { f->ydown = f->ydown + BIG_DEC_HT; } else { f->yup = f->yup + BIG_DEC_HT; }; break; case 'M': case '.': if (n->stemup) { f->ydown = f->ydown + SMALL_DEC_HT; } else { f->yup = f->yup + SMALL_DEC_HT; }; break; default: /* this should never happen */ event_error("Un-recognized accent"); break; }; }; }; if (n->syllables != NULL) { width = maxstrwidth(n->syllables, (double)(vocalfont.pointsize), vocalfont.default_num); if (width > f->xleft + f->xright) { f->xright = (float) width - f->xleft; }; }; if (n->gchords != NULL) { width = maxstrwidth(n->gchords, (double)(gchordfont.pointsize), gchordfont.default_num); if (width > f->xleft + f->xright) { f->xright = (float) width - f->xleft; }; }; } static void spacechord(struct feature* chordplace) /* prevents collision of note heads and accidentals in a chord */ /* sets fliphead and acc_offset for all notes in chord */ { struct feature* place; struct note* anote; int thisy, lasty, lastflip; int stemdir; int doneflip; int ygap[10]; int accplace; int i; /* first flip heads */ place = chordplace; lasty = 200; lastflip = 1; doneflip = 0; while ((place != NULL) && (place->type != CHORDOFF)) { if ((place->type == CHORDNOTE) || (place->type == NOTE)) { anote = place->item; thisy = anote->y; if ((lasty - thisy <= 1) && (lastflip != 1)) { anote->fliphead = 1; stemdir = anote->stemup; lastflip = 1; doneflip = 1; } else { lastflip = 0; }; lasty = thisy; }; place = place->next; }; /* now deal with accidentals */ for (i=0; i<10; i++) { ygap[i] = 200; }; if ((doneflip) && (stemdir == 0)) { /* block off space where note is */ ygap[0] = -200; }; place = chordplace; while ((place != NULL) && (place->type != CHORDOFF)) { if ((place->type == CHORDNOTE) || (place->type == NOTE)) { anote = place->item; thisy = anote->y; if (anote->accidental != ' ') { /* find space for this accidental */ accplace = 0; while ((accplace <10) && (ygap[accplace] < thisy)) { accplace = accplace + 1; }; anote->acc_offset = accplace + 1; ygap[accplace] = thisy - 6; }; }; place = place->next; }; } static void sizechord(struct chord* ch, int ingrace) /* decide on stem direction and set default stem length for a chord */ { if ((ch->ytop + ch->ybot < 8)||(ingrace)) { ch->stemup = 1; } else { ch->stemup = 0; }; ch->stemlength = STEMLEN; } static void setxy(double* x, double* y, struct note* n, struct feature* ft, double offset, double half_head) /* compute x,y co-ordinates above note for drawing a beam */ { if (n->stemup) { *x = ft->x + half_head; *y = (double)(TONE_HT*n->y) + n->stemlength - offset; } else { *x = ft->x - half_head; *y = (double)(TONE_HT*n->y) - n->stemlength + offset; }; } static void drawtuple(struct feature* beamset[], int beamctr, int tupleno) /* label a beam which is a tuplet of notes (e.g. triplet) */ { double x0, x1, y0, y1; struct note* n; int stemup; x0 = beamset[0]->x; n = beamset[0]->item; stemup = n->stemup; if (stemup) { y0 = (double)(TONE_HT*n->y) + n->stemlength; } else { y0 = (double)(TONE_HT*n->y) - n->stemlength; }; x1 = beamset[beamctr-1]->x; n = beamset[beamctr-1]->item; if (stemup) { y1 = (double)(TONE_HT*n->y) + n->stemlength; } else { y1 = (double)(TONE_HT*n->y) - n->stemlength; }; if (stemup) { fprintf(f, " %.1f %.1f (%d) bnum", (x0+x1)/2, (y0+y1)/2 + TUPLE_UP, tupleno); } else { fprintf(f, " %.1f %.1f (%d) bnum", (x0+x1)/2, (y0+y1)/2 + TUPLE_DOWN, tupleno); }; } static void drawhtuple(double xstart, double xend, int num, double y) /* draw a tuple using half-brackets */ /* used for tuples which do not correspond to a beam */ { double xmid; xmid = (xstart + xend)/2; fprintf(f, " %.1f %.1f %.1f %.1f hbr", xstart, y, xmid-6.0, y); fprintf(f, " %.1f %.1f %.1f %.1f hbr", xend, y, xmid+6.0, y); fprintf(f, " %.1f %.1f (%d) bnum\n", xmid, y-4.0, num); } static void drawbeam(struct feature* beamset[], int beamctr, int dograce) /* draw a beam spanning the notes in array beamset[] */ { int i, d; int donenotes; int start, stop; double x0, x1, y0, y1, offset; struct note* n; int stemup, beamdir; double half_head; if (beamctr==0) { event_error("Internal error: beam with 0 notes"); showtune(&thetune); return; exit(0); }; if (beamset[0]->type != NOTE) { event_error("Internal error: beam does not start with NOTE"); exit(0); }; fprintf(f, "\n"); if (redcolor) fprintf(f,"1.0 0.0 0.0 setrgbcolor\n"); n = beamset[0]->item; stemup = n->stemup; beamdir = 2*stemup - 1; donenotes = 1; d = -3; offset = 0.0; if (dograce) { half_head = GRACE_HALF_HEAD; } else { half_head = HALF_HEAD; }; while (donenotes) { donenotes = 0; start = -1; for (i=0; iitem; if (n->base_exp <= d) { if (start == -1) { start = i; setxy(&x0, &y0, n, beamset[i], offset, half_head); }; stop = i; setxy(&x1, &y1, n, beamset[i], offset, half_head); }; if ((n->beaming == endbeam) || (n->base_exp > d)) { if (start != -1) { /* draw unit */ if (start == stop) { if (start != 0) { /* half line in front of note */ n = beamset[start-1]->item; setxy(&x0, &y0, n, beamset[start-1], offset, half_head); x0 = x0 + (x1-x0)/2; y0 = y0 + (y1-y0)/2; } else { /* half line behind note */ n = beamset[start+1]->item; setxy(&x1, &y1, n, beamset[start+1], offset, half_head); x1 = x1 + (x0-x1)/2; y1 = y1 + (y0-y1)/2; }; if (dograce) { fprintf(f, "%.1f %.1f %.1f %.1f gbm2\n", x0, y0, x1, y1); } else { fprintf(f, "%.1f %.1f %.1f %.1f %.1f bm\n", x0, y0, x1, y1, (double)(beamdir * TAIL_WIDTH)); }; } else { if (dograce) { fprintf(f, "%.1f %.1f %.1f %.1f gbm2\n", x0, y0, x1, y1); } else { fprintf(f, "%.1f %.1f %.1f %.1f %.1f bm\n", x0, y0, x1, y1, (double)(beamdir * TAIL_WIDTH)); }; }; donenotes = 1; start = -1; }; }; }; d = d - 1; offset = offset + TAIL_SEP; }; if (redcolor) fprintf(f,"0 setgray\n"); } static void sizevoice(struct voice* v, struct tune* t) /* compute width and height values for all elements in voice */ { struct feature* ft; struct note* anote; struct key* akey; struct aclef* theclef; char* astring; struct fract* afract; struct rest* arest; struct note* lastnote; struct chord* thischord; struct feature* chordplace; struct tuple* thistuple; enum tail_type chordbeaming; int intuple, tuplecount; struct feature* tuplefeature; ingrace = 0; inchord = 0; intuple = 0; tuplefeature = NULL; chordhead = NULL; thischord = NULL; chordplace = NULL; v->clef->type = t->clef.type; v->clef->octave = t->clef.octave; if (v->keysig == NULL) { event_error("Voice has no key signature"); }; ft = v->first; lastnote = NULL; while (ft != NULL) { ft->xleft = 0.0; ft->xright = 0.0; ft->ydown = 0.0; ft->yup = 0.0; switch (ft->type) { case SINGLE_BAR: ft->xleft = (float) 0.8; ft->xright = 0.0; break; case DOUBLE_BAR: ft->xleft = 3.0; ft->xright = 0.0; break; case BAR_REP: ft->xleft = 1.0; ft->xright = 10.0; break; case REP_BAR: ft->xleft = 1.0; ft->xright = 10.0; break; case REP1: break; case REP2: break; case PLAY_ON_REP: break; case BAR1: break; case REP_BAR2: ft->xleft = 6.0; ft->xright = 5.0; break; case DOUBLE_REP: ft->xleft = 10.0; ft->xright = 10.0; break; case THICK_THIN: ft->xleft = 0.0; ft->xright = 6.0; break; case THIN_THICK: ft->xleft = 6.0; ft->xright = 0.0; break; case PART: astring = ft->item; case TEMPO: break; case TIME: afract = ft->item; if (afract == NULL) { afract = &v->meter; }; ft->xleft = 0; ft->xright = (float) size_timesig(afract); break; case KEY: ft->xleft = 0; akey = ft->item; ft->xright = (float) size_keysig(v->keysig->map, akey->map); set_keysig(v->keysig, akey); break; case REST: arest = ft->item; sizerest(arest, ft); if (intuple) { if (ft->yup > thistuple->height) { thistuple->height = ft->yup; }; tuplecount = tuplecount - 1; if (tuplecount <= 0) { tuplefeature->yup = thistuple->height + HTUPLE_HT; intuple = 0; thistuple = NULL; tuplefeature = NULL; }; }; break; case TUPLE: thistuple = ft->item; if (thistuple->beamed == 0) { intuple = 1; tuplecount = thistuple ->r; thistuple->height = (double)(10*TONE_HT); tuplefeature = ft; }; break; case NOTE: anote = ft->item; setstemlen(anote, ingrace); sizenote(anote, ft, ingrace); if (inchord) { if (chordcount == 0) { chordhead = ft; thischord->ytop = anote->y; thischord->ybot = anote->y; chordbeaming = anote->beaming; } else { if (anote->y > thischord->ytop) { thischord->ytop = anote->y; }; if (anote->y < thischord->ybot) { thischord->ybot = anote->y; }; if (ft->xleft > chordhead->xleft) { chordhead->xleft = ft->xleft; }; if (ft->xright > chordhead->xright) { chordhead->xright = ft->xright; }; if (ft->yup > chordhead->yup) { chordhead->yup = ft->yup; }; if (ft->ydown > chordhead->ydown) { chordhead->ydown = ft->ydown; }; ft->type = CHORDNOTE; }; chordcount = chordcount + 1; }; if (intuple) { if (ft->yup > thistuple->height) { thistuple->height = ft->yup; }; tuplecount = tuplecount - 1; if (tuplecount <= 0) { tuplefeature->yup = thistuple->height + HTUPLE_HT; intuple = 0; thistuple = NULL; tuplefeature =NULL; }; }; break; case NONOTE: break; case OLDTIE: break; case TEXT: break; case SLUR_ON: break; case SLUR_OFF: break; case TIE: break; case CLOSE_TIE: break; case TITLE: break; case CHANNEL: break; case TRANSPOSE: break; case RTRANSPOSE: break; case GRACEON: ingrace = 1; break; case GRACEOFF: ingrace = 0; break; case SETGRACE: break; case SETC: break; case GCHORD: break; case GCHORDON: break; case GCHORDOFF: break; case VOICE: break; case CHORDON: inchord = 1; chordcount = 0; thischord = ft->item; chordplace = ft; spacechord(chordplace); break; case CHORDOFF: if (thischord != NULL) { anote = chordhead->item; thischord->beaming = chordbeaming; if (thischord->beaming == single) { sizechord(thischord, ingrace); }; }; inchord = 0; chordhead = NULL; thischord = NULL; chordplace = NULL; break; case SLUR_TIE: break; case TNOTE: break; case LT: break; case GT: break; case DYNAMIC: break; case LINENUM: lineno = (int)(ft->item); break; case MUSICLINE: break; case MUSICSTOP: break; case WORDLINE: break; case WORDSTOP: break; case INSTRUCTION: break; case NOBEAM: break; case CLEF: theclef = ft->item; if (theclef == NULL) { theclef = v->clef; }; ft->yup = (double)8*TONE_HT; ft->ydown = 0.0; switch (theclef->type) { case treble: ft->yup = (double)TREBLE_UP; ft->ydown = (double)TREBLE_DOWN; ft->xright = TREBLE_RIGHT; ft->xleft = TREBLE_LEFT; break; case baritone: ft->yup = (double)12*TONE_HT; ft->xright = CCLEF_RIGHT; ft->xleft = CCLEF_LEFT; break; case tenor: ft->yup = (double)10*TONE_HT; ft->xright = CCLEF_RIGHT; ft->xleft = CCLEF_LEFT; break; case alto: ft->xright = CCLEF_RIGHT; ft->xleft = CCLEF_LEFT; break; case mezzo: ft->ydown = (double)2*TONE_HT; ft->xright = CCLEF_RIGHT; ft->xleft = CCLEF_LEFT; break; case soprano: ft->ydown = (double)4*TONE_HT; ft->xright = CCLEF_RIGHT; ft->xleft = CCLEF_LEFT; break; case bass: ft->xright = BASS_RIGHT; ft->xleft = BASS_LEFT; break; case noclef: break; }; if (theclef->octave > 0) { ft->yup = ft->yup + CLEFNUM_HT; }; if (theclef->octave < 0) { ft->ydown = ft->ydown + CLEFNUM_HT; }; v->clef->type = theclef->type; v->clef->octave = theclef->octave; break; case PRINTLINE: break; case NEWPAGE: break; case LEFT_TEXT: break; case CENTRE_TEXT: break; case VSKIP: break; case SPLITVOICE: break; default: printf("unknown type %d\n", ft->type); break; }; ft = ft->next; }; } static void sizetune(struct tune* t) /* compute width and height values for all elements in the tune */ { struct voice* v; v = firstitem(&t->voices); while (v != NULL) { sizevoice(v, t); v = nextitem(&t->voices); }; } static void singlehead(double x, double y, int base, int base_exp, int dots) /* draws a note head */ { int i; double dot_offset; fprintf(f, "%.1f %.1f ", x, y); /* note head */ dot_offset = HALF_HEAD; switch(base_exp) { case 1: fprintf(f, "BHD"); dot_offset = HALF_BREVE; break; case 0: fprintf(f, "HD"); break; case -1: fprintf(f, "Hd"); break; default: if (base_exp > 1) { fprintf(f, "BHD"); dot_offset = HALF_BREVE; event_warning("Note value too long to represent"); } else { fprintf(f, "hd"); }; break; }; if (dots == -1) { event_warning("Note value cannot be represented"); }; for (i=1; i <= dots; i++) { fprintf(f, " %.1f 3.0 dt", (double)(dot_offset+DOT_SPACE*i)); }; } static void drawhead(struct note* n, double x, struct feature* ft) /* draw just the head of a note together with any decorations */ /* and accidentals */ { int i; char* decorators; double ytop, ybot; double notex, accspace; int offset; if (n->fliphead) { if (n->stemup) { notex = x + 2.0 * HALF_HEAD; } else { notex = x - 2.0 * HALF_HEAD; } } else { notex = x; }; singlehead(notex, (double)(TONE_HT*n->y), n->base, n->base_exp, n->dots); if (n->acc_offset == 0) { accspace = ACC_OFFSET; } else { if (n->fliphead) { /* compensate for flipped note head */ if (n->stemup) { offset = n->acc_offset; } else { offset = n->acc_offset - 2; }; } else { offset = n->acc_offset - 1; }; accspace = ACC_OFFSET + ACC_OFFSET2 * offset; }; switch (n->accidental) { case '=': fprintf(f, " %.1f nt", accspace); break; case '^': if (n->mult == 1) { fprintf(f, " %.1f sh", accspace); } else { fprintf(f, " %.1f dsh", accspace); }; break; case '_': if (n->mult == 1) { fprintf(f, " %.1f ft", accspace); } else { fprintf(f, " %.1f dft", accspace); }; break; default: break; }; i = 10; while (n->y >= i) { fprintf(f, " %d hl", i*TONE_HT); i = i + 2; }; i = -2; while (n->y <= i) { fprintf(f, " %d hl", i*TONE_HT); i = i - 2; }; if (n->accents != NULL) { decorators = n->accents; ytop = (n->y + 2) * TONE_HT; ybot = (n->y - 2) * TONE_HT; if (n->stemup) { ytop = ytop + n->stemlength; } else { ybot = ybot - n->stemlength; }; for (i=0; i< (int) strlen(decorators); i++) { switch (decorators[i]) { case '.': if (n->stemup) { fprintf(f, " %.1f stc", ybot+STC_OFF); ybot = ybot - SMALL_DEC_HT; } else { fprintf(f, " %.1f stc", ytop+STC_OFF); ytop = ytop + SMALL_DEC_HT; }; break; case 'R': if (n->stemup) { fprintf(f, " %.1f cpd", ybot+CPD_OFF); ybot = ybot - SMALL_DEC_HT; } else { fprintf(f, " %.1f cpu", ytop+CPU_OFF); ytop = ytop + SMALL_DEC_HT; }; break; case 'M': if (n->stemup) { fprintf(f, " %.1f emb", ybot+EMB_OFF); ybot = ybot - SMALL_DEC_HT; } else { fprintf(f, " %.1f emb", ytop+EMB_OFF); ytop = ytop + SMALL_DEC_HT; }; break; case 'H': fprintf(f, " %.1f hld", ytop+HLD_OFF); ytop = ytop + BIG_DEC_HT; break; case '~': fprintf(f, " %.1f grm", ytop+GRM_OFF); ytop = ytop + BIG_DEC_HT; break; case 'u': fprintf(f, " %.1f upb", ytop+UPB_OFF); ytop = ytop + BIG_DEC_HT; break; case 'v': fprintf(f, " %.1f dnb", ytop+DNB_OFF); ytop = ytop + BIG_DEC_HT; break; case 'T': fprintf(f, " %.1f trl", ytop+TRL_OFF); ytop = ytop + BIG_DEC_HT; break; default: break; }; }; }; fprintf(f, "\n"); } static void drawgracehead(struct note* n, double x, struct feature* ft, enum tail_type tail) /* draw the head of a grace note */ { int i; double y; y = (double)(TONE_HT*n->y); switch (tail) { case nostem: /* note head only */ fprintf(f, "%.1f %.1f gn", x, y); break; case single: /* note head with stem and tail */ fprintf(f, "%.1f %.1f %.1f gn1", x, y, n->stemlength); break; case midbeam: case startbeam: case endbeam: /* note head with stem and tail */ fprintf(f, "%.1f %.1f %.1f gnt", x, y, n->stemlength); break; }; switch (n->accidental) { case '=': fprintf(f, " %.1f %.1f gnt0", x-ACC_OFFSET, y); break; case '^': if (n->mult == 1) { fprintf(f, " %.1f %.1f gsh0", x-ACC_OFFSET, y); } else { fprintf(f, " %.1f %.1f gds0h", x-ACC_OFFSET, y); }; break; case '_': if (n->mult == 1) { fprintf(f, " %.1f %.1f gft0", x-ACC_OFFSET, y); } else { fprintf(f, " %.1f %.1f gdf0", x-ACC_OFFSET, y); }; break; default: break; }; i = 10; while (n->y >= i) { fprintf(f, " %.1f %.1f ghl", x, (double)i*TONE_HT); i = i + 2; }; i = -2; while (n->y <= i) { fprintf(f, " %.1f %.1f ghl", x, (double)i*TONE_HT); i = i - 2; }; fprintf(f, "\n"); } static void handlegracebeam(struct note *n, struct feature* ft) /* this is called to set up the variables needed to lay out */ /* beams for grace notes */ { switch (n->beaming) { case single: gracebeamctr = -1; break; case startbeam: gracebeamset[0] = ft; gracebeamctr = 1; break; case midbeam: case endbeam: if (gracebeamctr > 0) { gracebeamset[gracebeamctr] = ft; if (gracebeamctr < 32) { gracebeamctr = gracebeamctr + 1; } else { event_error("Too many notes under one gracebeam"); }; } else { event_error("Internal beaming error"); exit(1); }; break; case nostem: break; }; } static void drawgracenote(struct note* n, double x, struct feature* ft, struct chord* thischord) /* draw an entire grace note */ { handlegracebeam(n, ft); drawgracehead(n, x, ft, n->beaming); if (n->beaming == endbeam) { drawbeam(gracebeamset, gracebeamctr, 1); }; fprintf(f, "\n"); } static void singletail(int base, int base_exp, int stemup, double stemlength) /* draw the tail of a note if it has one */ { switch(base_exp) { case 0: case -1: case -2: break; case -3: if (stemup) { fprintf(f, " %.1f f1u", stemlength); } else { fprintf(f, " %.1f f1d", stemlength); }; break; case -4: if (stemup) { fprintf(f, " %.1f f2u", stemlength); } else { fprintf(f, " %.1f f2d", stemlength); }; break; case -5: if (stemup) { fprintf(f, " %.1f f3u", stemlength); } else { fprintf(f, " %.1f f3d", stemlength); }; break; case -6: if (stemup) { fprintf(f, " %.1f f4u", stemlength); } else { fprintf(f, " %.1f f4d", stemlength); }; break; default: if (base_exp < -6) { event_warning("Note value too small to represent"); if (stemup) { fprintf(f, " %.1f f4u", stemlength); } else { fprintf(f, " %.1f f4d", stemlength); }; }; break; }; } static void drawchordtail(struct chord* ch, double x) /* draw the tail to a set of notes belonging to a single chord */ { if (ch->base > 1) { fprintf(f, "%.1f setx ", x); if (ch->stemup) { fprintf(f, "%.1f sety ", (double)(ch->ybot*TONE_HT)); fprintf(f, " %.1f su ", ch->stemlength + (double)((ch->ytop - ch->ybot)*TONE_HT)); } else { fprintf(f, "%.1f sety ", (double)(ch->ytop*TONE_HT)); fprintf(f, " %.1f sd ", ch->stemlength + (double)((ch->ytop - ch->ybot)*TONE_HT)); }; if (ch->beaming == single) { singletail(ch->base, ch->base_exp, ch->stemup, ch->stemlength+ (double)((ch->ytop - ch->ybot)*TONE_HT)); }; fprintf(f, "\n"); }; } static void showtext(struct llist* textitems, double x, double ystart, double ygap) /* This routine deals with lyrics, guitar chords and instructions */ /* print text item at specified point */ /* if a string starts with ':' this means it is a special symbol */ { double ygc; char* gc; gc = firstitem(textitems); ygc = ystart; while (gc != NULL) { if (*gc == ':') { switch (*(gc+1)) { case 'p': /* part label */ fprintf(f, " %.1f %.1f %.1f (", x, ygc, ygap); ISOfprintf(gc+2); fprintf(f, ") boxshow "); break; case 's': fprintf(f, " %.1f %.1f segno\n", x, ygc); break; case 'c': fprintf(f, " %.1f %.1f coda\n", x, ygc); break; default: break; }; } else { fprintf(f, " %.1f %.1f (", x, ygc); ISOfprintf(gc); fprintf(f, ") gc "); }; gc = nextitem(textitems); ygc = ygc - ygap; }; } static void define_font(struct font* thefont, char* s) /* set up a font structure with user-defined font and pointsize */ { char fontname[80]; int fontsize, params; params = sscanf(s, "%s %d", fontname, &fontsize); if (params >= 1) { if (strcmp(fontname, "-") != 0) { if (thefont->name != NULL) { free(thefont->name); }; thefont->name = addstring(fontname); thefont->defined = 0; }; if (params == 2) { thefont->pointsize = fontsize; }; }; } int read_boolean(s) char *s; /* set logical parameter from %%command */ /* part of the handling for event_specific */ { char p[10]; int result; p[0] = '\0'; sscanf(s, " %10s", p); result = 1; if ((strcmp(p, "0") == 0) || (strcmp(p, "no") == 0) || (strcmp(p, "false") == 0)) { result = 0; }; return(result); } void font_command(p, s) /* execute font-related %%commands */ /* called from event_specific */ char* p; char*s; { if (strcmp(p, "textfont") == 0) { define_font(&textfont, s); }; if (strcmp(p, "titlefont") == 0) { define_font(&titlefont, s); }; if (strcmp(p, "subtitlefont") == 0) { define_font(&subtitlefont, s); }; if (strcmp(p, "wordsfont") == 0) { define_font(&wordsfont, s); }; if (strcmp(p, "composerfont") == 0) { define_font(&composerfont, s); }; if (strcmp(p, "vocalfont") == 0) { define_font(&vocalfont, s); }; if (strcmp(p, "gchordfont") == 0) { define_font(&gchordfont, s); }; if (strcmp(p, "partsfont") == 0) { define_font(&partsfont, s); }; if (strcmp(p, "titlespace") == 0) { set_space(&titlefont, s); }; if (strcmp(p, "subtitlespace") == 0) { set_space(&subtitlefont, s); }; if (strcmp(p, "composerspace") == 0) { set_space(&composerfont, s); }; if (strcmp(p, "vocalspace") == 0) { set_space(&vocalfont, s); }; if (strcmp(p, "wordsspace") == 0) { set_space(&wordsfont, s); }; if (strcmp(p, "gchordspace") == 0) { set_space(&gchordfont, s); }; if (strcmp(p, "textspace") == 0) { set_space(&textfont, s); }; if (strcmp(p, "partsspace") == 0) { set_space(&textfont, s); }; if (strcmp(p, "staffsep") == 0) { sscanf(s, "%d", &staffsep); }; if (strcmp(p, "titleleft") == 0) { titleleft = read_boolean(s); }; if (strcmp(p, "titlecaps") == 0) { titlecaps = read_boolean(s); }; } static void setfont(int size, int num) /* define font point size and style */ { if ((fontsize != size) || (fontnum != num)) { fprintf(f, "%d.0 F%d\n", size, num); fontsize = size; fontnum = num; }; } static void setfontstruct(struct font* thefont) /* set font according to font structure */ { if (thefont->name == NULL) { setfont(thefont->pointsize, thefont->default_num); } else { if (thefont->defined == 0) { /* define font */ fprintf(f, "/%s-ISO /%s setISOfont\n", thefont->name, thefont->name); fprintf(f, "/F%d { /%s-ISO exch selectfont} def\n", thefont->special_num, thefont->name); thefont->defined = 1; } setfont(thefont->pointsize, thefont->special_num); }; } static void notetext(struct note* n, int* tupleno, double x, struct feature* ft, struct vertspacing* spacing) /* print text associated with note */ { if (n->beaming == endbeam) { drawbeam(beamset, beamctr, 0); if (*tupleno != 0) { drawtuple(beamset, beamctr, *tupleno); *tupleno = 0; }; }; fprintf(f, "\n"); if (n->instructions != NULL && spacing != NULL) { setfontstruct(&partsfont); showtext(n->instructions, x - ft->xleft, spacing->yinstruct, (double)(partsfont.pointsize+partsfont.space)); }; if (n->gchords != NULL && spacing != NULL) { setfontstruct(&gchordfont); showtext(n->gchords, x - ft->xleft, spacing->ygchord, (double)(gchordfont.pointsize+gchordfont.space)); }; if (n->syllables != NULL && spacing != NULL) { setfontstruct(&vocalfont); showtext(n->syllables, x - ft->xleft, spacing->ywords, (double)(vocalfont.pointsize + vocalfont.space)); }; } static void handlebeam(struct note* n, struct feature* ft) /* set up some variables needed to lay out the beam for a set of */ /* notes beamed together */ { switch (n->beaming) { case single: beamctr = -1; break; case startbeam: beamset[0] = ft; beamctr = 1; rootstem = n->stemup; break; case midbeam: case endbeam: if (beamctr > 0) { beamset[beamctr] = ft; if (beamctr < 64) { beamctr = beamctr + 1; } else { event_error("Too many notes under one beam"); }; } else { event_error("Internal beaming error"); }; n->stemup = rootstem; break; }; } static void drawnote(struct note* n, double x, struct feature* ft, struct chord* thischord, int* tupleno, struct vertspacing* spacing) /* draw a note */ { handlebeam(n, ft); if (redcolor) fprintf(f,"1.0 0.0 0.0 setrgbcolor\n"); drawhead(n, x, ft); if (thischord == NULL) { if (n->base > 1) { if (n->stemup) { fprintf(f, " %.1f su", n->stemlength); } else { fprintf(f, " %.1f sd", n->stemlength); }; }; }; if (n->beaming == single) { singletail(n->base, n->base_exp, n->stemup, n->stemlength); }; fprintf(f, "\n"); if (redcolor) fprintf(f,"0 setgray\n"); notetext(n, tupleno, x, ft, spacing); } static void drawrest(struct rest* r, double x, struct vertspacing* spacing) /* draw a rest of specified duration */ { int i; if (redcolor) fprintf(f,"1.0 0.0 0.0 setrgbcolor\n"); if (r->multibar > 0) { fprintf(f, "(%d) %.1f %d mrest ", r->multibar, x, 4*TONE_HT); } else { reducef(&r->len); switch (r->base_exp) { case 1: fprintf(f, "%.1f %d r0 ", x, 4*TONE_HT); break; case 0: fprintf(f, "%.1f %d r1 ", x, 4*TONE_HT); break; case -1: fprintf(f, "%.1f %d r2 ", x, 4*TONE_HT); break; case -2: fprintf(f, "%.1f %d r4 ", x, 4*TONE_HT); break; case -3: fprintf(f, "%.1f %d r8 ", x, 4*TONE_HT); break; case -4: fprintf(f, "%.1f %d r16 ", x, 4*TONE_HT); break; case -5: fprintf(f, "%.1f %d r32 ", x, 4*TONE_HT); break; case -6: fprintf(f, "%.1f %d r64 ", x, 4*TONE_HT); break; default: event_error("Cannot represent rest length"); break; }; }; for (i=1; i <= r->dots; i++) { fprintf(f, " %.1f 3.0 dt", (double)(HALF_HEAD+DOT_SPACE*i)); }; fprintf(f, "\n"); if (redcolor) fprintf(f,"0 setgray\n"); if (r->instructions != NULL) { setfontstruct(&partsfont); showtext(r->instructions, x, spacing->yinstruct, (double)(partsfont.pointsize+partsfont.space)); }; if (r->gchords != NULL) { setfontstruct(&gchordfont); showtext(r->gchords, x, spacing->ygchord, (double)(gchordfont.pointsize+gchordfont.space)); }; } static void setbeams(struct feature* note[], struct chord* chording[], int m, double stemlen) /* choose the spatial postioning of beams and compute appropriate stem */ /* lengths for all notes within the beam */ { int i; double min[64]; double lift; struct note* anote; int stemup; double x1, y1, x2, y2, xi, yi; double max; /* printf("Doing setbeams m=%d\n", m); */ anote = note[0]->item; stemup = anote->stemup; /* calculate minimum feasible stem lengths */ /* bearing in mind space needed for the tails */ for (i=0; iitem; anote->stemup = stemup; switch (anote->base) { default: case 8: min[i] = TAIL_SEP; break; case 16: min[i] = 2*TAIL_SEP; break; case 32: min[i] = 3*TAIL_SEP; break; case 64: min[i] = 4*TAIL_SEP; break; }; if (anote->accidental == ' ') { min[i] = min[i] + TONE_HT; } else { if (stemup) { min[i] = min[i] + (double)acc_upsize(anote->accidental); } else { min[i] = min[i] + (double)acc_downsize(anote->accidental); }; }; min[i] = min[i] + TONE_HT; /* require at least this much clearance */ if (stemup) { if (chording[i] == NULL) { min[i] = TONE_HT*anote->y + min[i]; /* avoid collision with previous note */ if ((i > 0) && (min[i-1] - TONE_HT < min[i])) { min[i-1] = min[i]; }; } else { min[i] = TONE_HT*chording[i]->ytop + min[i]; }; } else { if (chording[i] == NULL) { min[i] = TONE_HT*anote->y - min[i]; /* avoid collision with previous note */ if (i > 0) { anote = note[i-1]->item; if (anote->y*TONE_HT < min[i]) { min[i] = anote->y*TONE_HT; }; }; } else { min[i] = TONE_HT*chording[i]->ybot - min[i]; }; }; }; /* work out clearance from a straight line between 1st and last note */ x1 = note[0]->x; anote = note[0]->item; y1 = anote->y*TONE_HT; x2 = note[m-1]->x; anote = note[m-1]->item; y2 = anote->y*TONE_HT; if (x1 == x2) { printf("Internal error: x1 = x2 = %.1f\n", x1); x2 = x2 + 1; }; lift = 0.0; max = 0.0; if (stemup) { for (i=0; ix; yi = y1 + (y2-y1)*(xi-x1)/(x2-x1); if (min[i] - yi > lift) { lift = min[i] - yi; }; if (min[i] - yi < max) { max = min[i] - yi; }; }; if (lift - max < stemlen) { lift = stemlen - max; }; } else { for (i=0; ix; yi = y1 + (y2-y1)*(xi-x1)/(x2-x1); if (min[i] - yi < lift) { lift = min[i] - yi; }; if (min[i] - yi > max) { max = min[i] - yi; }; }; if (max - lift < stemlen) { lift = max - stemlen; }; }; /* raise the line just enough to clear notes */ for (i=0; iitem; xi = note[i]->x; if (stemup) { anote->stemlength = (float) (y1 + (y2-y1)*(xi-x1)/(x2-x1) + lift - TONE_HT*anote->y); } else { anote->stemlength = - (float) ((y1 + (y2-y1)*(xi-x1)/(x2-x1) + lift - TONE_HT*anote->y)); }; }; /* now transfer results to chords */ for (i=0; iitem; chording[i]->stemup = anote->stemup; if (chording[i]->stemup) { chording[i]->stemlength = anote->stemlength; } else { chording[i]->stemlength = (float) (anote->stemlength - (double)((chording[i]->ytop - chording[i]->ybot)*TONE_HT)); }; }; }; }; static void beamline(struct feature* ft) /* compute positioning of beams for one stave line of music */ { struct feature* p; struct note* n; struct feature* beamnote[64]; struct chord* chording[64]; struct chord* lastchord; struct feature* gracebeamnote[64]; struct chord* gracechording[64]; struct chord* gracelastchord; int i, j; int ingrace; p = ft; ingrace = 0; lastchord = NULL; gracelastchord = NULL; while ((p != NULL) && (p->type != PRINTLINE)) { switch (p->type) { case NOTE: if (ingrace) { n = p->item; if (n == NULL) { event_error("Missing NOTE!!!!"); exit(0); }; if (n->beaming == startbeam) { j = 0; }; if (n->beaming != single) { gracebeamnote[j] = p; gracechording[j] = gracelastchord; j = j + 1; }; if ((n->beaming == endbeam)||(j==10)) { setbeams(gracebeamnote, gracechording, j, GRACE_STEMLEN); j = 0; }; } else { /* non-grace notes*/ n = p->item; if (n == NULL) { event_error("Missing NOTE!!!!"); exit(0); }; if (n->beaming == startbeam) { i = 0; }; if (n->beaming != single) { beamnote[i] = p; chording[i] = lastchord; i = i + 1; }; if ((n->beaming == endbeam)||(i==64)) { setbeams(beamnote, chording, i, STEMLEN); i = 0; }; }; break; case CHORDON: if (ingrace) { gracelastchord = p->item; } else { lastchord = p->item; }; break; case CHORDOFF: if (ingrace) { gracelastchord = NULL; } else { lastchord = NULL; }; break; case GRACEON: ingrace = 1; break; case GRACEOFF: ingrace = 0; gracelastchord = NULL; break; default: break; }; p = p->next; }; } static void measureline(struct feature* ft, double* height, double* descender, double* yend, double* yinstruct, double* ygchord, double* ywords) /* calculate vertical space (height/descender) requirement of current line */ { struct feature* p; struct note* n; struct rest* r; double max, min; int gotgchords, gcount; int gotinstructions, icount; int gotwords, wcount; int gotends; char* gc; p = ft; min = 0.0; max = 8*TONE_HT; gotgchords = 0; gotwords = 0; gotinstructions = 0; gotends = 0; while ((p != NULL) && (p->type != PRINTLINE)) { switch (p->type) { case NOTE: n = p->item; if (n == NULL) { event_error("Missing NOTE!!!!"); exit(0); } else { if (n->gchords != NULL) { gcount = 0; gc = firstitem(n->gchords); while (gc != NULL) { gcount = gcount + 1; gc = nextitem(n->gchords); }; if (gcount > gotgchords) { gotgchords = gcount; }; }; if (n->instructions != NULL) { icount = 0; gc = firstitem(n->instructions); while (gc != NULL) { icount = icount + 1; gc = nextitem(n->instructions); }; if (icount > gotinstructions) { gotinstructions = icount; }; }; if (n->syllables != NULL) { wcount = 0; gc = firstitem(n->syllables); while (gc != NULL) { wcount = wcount + 1; gc = nextitem(n->syllables); }; if (wcount > gotwords) { gotwords = wcount; }; }; /* recalculate note size in case of new stemlen */ sizenote(n, p, ingrace); if (p->yup > max) { max = p->yup; }; if (p->ydown < min) { min = p->ydown; }; }; break; case REST: r = p->item; if (r == NULL) { event_error("Missing REST!!!!"); exit(0); } else { if (r->gchords != NULL) { gcount = 0; gc = firstitem(r->gchords); while (gc != NULL) { gcount = gcount + 1; gc = nextitem(r->gchords); }; if (gcount > gotgchords) { gotgchords = gcount; }; }; if (r->instructions != NULL) { icount = 0; gc = firstitem(r->instructions); while (gc != NULL) { icount = icount + 1; gc = nextitem(r->instructions); }; if (icount > gotinstructions) { gotinstructions = icount; }; }; }; break; case REP1: case REP2: case PLAY_ON_REP: case BAR1: case REP_BAR2: gotends = 1; break; case TUPLE: case CLEF: if (p->yup > max) { max = p->yup; }; if (-(p->ydown) < min) { min = -(p->ydown); }; break; case TEMPO: if (gotinstructions == 0) { gotinstructions = 1; }; break; default: break; }; p = p->next; }; if ((gotgchords > 0) && (gchords_above)) { max = max + (gchordfont.pointsize + gchordfont.space)*gotgchords; *ygchord = max - (gchordfont.pointsize + gchordfont.space); }; if (gotinstructions > 0) { max = max + INSTRUCT_HT*gotinstructions; *yinstruct = max - INSTRUCT_HT; }; if (gotends) { max = max + END_HT; *yend = max - END_HT; }; if ((gotgchords > 0) && (!gchords_above)) { *ygchord = min - (gchordfont.pointsize + gchordfont.space); min = min - (gchordfont.pointsize + gchordfont.space)*gotgchords; }; if (gotwords > 0) { *ywords = min - (vocalfont.pointsize + vocalfont.space); min = min - (vocalfont.pointsize + vocalfont.space)*gotwords; }; *height = staffsep + max; *descender = -min; } static void printtext(place, s, afont) enum placetype place; char* s; struct font* afont; /* print text a line of text in specified font at specified place */ { newblock((double)(afont->pointsize + afont->space), 0.0); setfontstruct(afont); fprintf(f, "("); ISOfprintf(s); switch (place) { case left: fprintf(f, ") 0 0 M show\n"); break; case right: fprintf(f, ") %.1f 0 M lshow\n", (double) scaledwidth); break; case centre: fprintf(f, ") %.1f 0 M cshow\n", scaledwidth/2.0); break; }; } void vskip(double gap) /* skip over specified amount of vertical space */ { newblock(gap, 0.0); } void centretext(s) char* s; /* print text centred in the middle of the page */ /* used by %%centre command */ { printtext(centre, s, &textfont); } void lefttext(s) char* s; /* print text up against the left hand margin */ /* used by %%text command */ { printtext(left, s, &textfont); } static void draw_tempo(double x_init, double y_init, struct atempo* t) /* print out tempo as specified in Q: field */ /* this goes to the left of the tune's title */ { int base, base_exp, dots; double x, y; char ticks[30]; if (t != NULL) { x = x_init; y = y_init; /* fprintf(f, "gsave 0.7 0.7 scale\n"); */ setfont(12, 3); if (t->pre != NULL) { fprintf(f, "%.1f %.1f M (", x, y); ISOfprintf(t->pre); fprintf(f, ") show\n"); x = x + stringwidth(t->pre, 12, 3) + HALF_HEAD * 2; }; if (t->count != 0) { dots = count_dots(&base, &base_exp, t->basenote.num, t->basenote.denom); singlehead(x, y, base, base_exp, dots); if (base >= 2) { fprintf(f, " %.1f su", TEMPO_STEMLEN); }; singletail(base, base_exp, 1, TEMPO_STEMLEN); x = x + 20.0; sprintf(ticks, "= %d", t->count); fprintf(f, " %.1f %.1f M (%s) show\n", x, y, ticks); x = x + stringwidth(ticks, 12, 3); }; if (t->post != NULL) { fprintf(f, "%.1f %.1f M ( ", x, y); ISOfprintf(t->post); fprintf(f, ") show\n"); }; /* fprintf(f, "grestore\n"); */ }; } static void voicedivider() /* This draws a horizontal line. It is used to mark where one voice */ /* ends and the next one starts */ { newblock((double)staffsep, 0.0); fprintf(f, " %.1f %.1f M %.1f %.1f L\n", scaledwidth/4.0, -descend, scaledwidth*3/4.0, -descend); newblock((double)staffsep, 0.0); } static void resetvoice(struct tune* t, struct voice * v) /* sets up voice with initial attributes as defined in abc tune header */ { v->place = v->first; if (v->clef == NULL) { v->clef = newclef(t->clef.type, t->clef.octave); } else { v->clef->type = t->clef.type; v->clef->octave = t->clef.octave; }; if (v->keysig == NULL) { v->keysig = newkey(t->keysig->name, t->keysig->sharps, t->keysig->map, t->keysig->mult); } else { free(v->keysig->name); v->keysig->name = addstring(t->keysig->name); set_keysig(v->keysig, t->keysig); /* v->keysig->sharps = t->keysig->sharps; */ }; v->meter.num = t->meter.num; v->meter.denom = t->meter.denom; } static void resettune(struct tune* t) /* initializes all voices to their start state */ { struct voice* v; v = firstitem(&t->voices); while (v != NULL) { resetvoice(t, v); v = nextitem(&t->voices); }; } void setup_fonts() { init_font(&textfont, TEXT_HT, 1, 1, 5); init_font(&titlefont, TITLE1_HT, 0, 0, 6); init_font(&subtitlefont, TITLE2_HT, 0, 0, 7); init_font(&wordsfont, WORDS_HT, 1, 0, 8); init_font(&composerfont, COMP_HT, 1, 1, 9); init_font(&vocalfont, LYRIC_HT, 1, 2, 10); init_font(&gchordfont, CHORDNAME_HT, 1, 3, 11); init_font(&partsfont, INSTRUCT_HT, 1, 3, 12); staffsep = VERT_GAP; } void open_output_file(filename, boundingbox) char* filename; struct bbox* boundingbox; /* open output file and write the abc2ps library to it */ { f = fopen(filename, "w"); if (f == NULL) { printf("Could not open file!!\n"); exit(0); }; printf("writing file %s\n", filename); printlib(f, filename, boundingbox); fontsize = 0; fontnum = 0; startpage(); } void close_output_file() /* complete last page and close file */ { if (f != NULL) { closepage(); fclose(f); f = NULL; }; } static int endrep(inend, end_string, x1, x2, yend) int inend; char* end_string; double x1, x2, yend; /* draws either 1st or 2nd ending marker */ { if (inend != 0) { fprintf(f, "%.1f %.1f %.1f (%s) endy1\n", yend, x1, x2, end_string); }; return(0); } static void drawslurtie(struct slurtie* s) /* draws slur or tie corresponding to the given structure */ { double x0, y0, x1, y1; struct feature* ft; struct note* n; struct rest* r; ft = s->begin; if (ft == NULL) { event_error("Slur or tie missing start note"); return; }; x0 = ft->x; if ((ft->type == NOTE) || (ft->type == CHORDNOTE)) { n = ft->item; y0 = (double)(n->y * TONE_HT); } else { if (ft->type == REST) { r = ft->item; y0 = (double)(4 * TONE_HT); } else { printf("Internal error: NOT A NOTE/REST (%d)in slur/tie\n" ,ft->type); return; }; }; if (s->crossline) { /* draw to end of stave */ x1 = scaledwidth + xmargin/(2.0*scale); y1 = y0; } else { /* draw slur/tie to other element */ ft = s->end; if (ft == NULL) { event_error("Slur or tie missing end note"); return; }; x1 = ft->x; if ((ft->type == NOTE) || (ft->type == CHORDNOTE)) { n = ft->item; y1 = (double)(n->y * TONE_HT); } else { if (ft->type == REST) { r = ft->item; y1 = (double)(4 * TONE_HT); } else { printf("Internal error: NOT A NOTE/REST (%d)in slur/tie\n" ,ft->type); return; }; }; }; if (n->stemup) { fprintf(f, " %.1f %.1f %.1f %.1f slurdown\n", x0, y0, x1, y1); } else { fprintf(f, " %.1f %.1f %.1f %.1f slurup\n", x0, y0, x1, y1); }; } static void close_slurtie(struct slurtie* s) /* This deals with the special case of a slur or tie running beyond */ /* one line of music and into the next. This draws the part on the */ /* second line of music */ { double x0, y0, x1, y1; struct feature* ft; struct note* n; struct rest* r; if ((s == NULL) || (s->crossline == 0)) { return; } else { /* draw slur/tie to other element */ ft = s->end; if (ft == NULL) { event_error("Slur or tie missing end note"); return; }; x1 = ft->x; if ((ft->type == NOTE) || (ft->type == CHORDNOTE)) { n = ft->item; y1 = (double)(n->y * TONE_HT); } else { if (ft->type == REST) { r = ft->item; y1 = (double)(4 * TONE_HT); } else { printf("Internal error: NOT A NOTE/REST (%d)in slur/tie\n" ,ft->type); return; }; }; }; x0 = TREBLE_LEFT + TREBLE_RIGHT; y0 = y1; if (n->stemup) { fprintf(f, " %.1f %.1f %.1f %.1f slurdown\n", x0, y0, x1, y1); } else { fprintf(f, " %.1f %.1f %.1f %.1f slurup\n", x0, y0, x1, y1); }; } static void blockline(struct voice* v, struct vertspacing** spacing) /* gets vertical spacing for current line */ { struct feature* ft; /* struct vertspacing* spacing; */ ft = v->place; /* find end of line */ while ((ft != NULL) && (ft->type != PRINTLINE)) { ft = ft->next; }; if ((ft != NULL) && (ft->type == PRINTLINE)) { *spacing = ft->item; } else { *spacing = NULL; event_error("Expecting line of music - possible voices mis-match"); }; } static void printbarnumber(double x, int n) { if (barnums <0 ) return; if (x + 15.0 > scaledwidth) return; fprintf(f, " %.1f %.1f (%d) bnum\n", x, 28.0, n); } static void underbar(struct feature* ft) /* This is never normally called, but is useful as a debugging routine */ /* shows width of a graphical element */ { fprintf(f, " %.1f -10 moveto %.1f -10 lineto stroke\n", ft->x - ft->xleft, ft->x + ft->xright); } static int printvoiceline(struct voice* v) /* draws one line of music from specified voice */ { struct feature* ft; struct note* anote; struct key* akey; char* astring; struct fract* afract; struct rest* arest; struct tuple* atuple; double x; int sharps; struct chord* thischord; int chordcount; double xchord; struct aclef* theclef; int printedline; double xend; int inend; char endstr[80]; int ingrace; struct vertspacing* spacing; struct dynamic *psaction; /* skip over line number so we can check for end of tune */ while ((v->place != NULL) && ((v->place->type == LINENUM) || (v->place->type == NEWPAGE) || (v->place->type == LEFT_TEXT) || (v->place->type == CENTRE_TEXT) || (v->place->type == VSKIP))) { if (v->place->type == LINENUM) { lineno = (int)(v->place->item); }; if (v->place->type == NEWPAGE) { newpage(); }; if (v->place->type == LEFT_TEXT) { printtext(left, v->place->item, &textfont); }; if (v->place->type == CENTRE_TEXT) { printtext(centre, v->place->item, &textfont); }; if (v->place->type == VSKIP) { vskip((double)((int)v->place->item)); }; v->place = v->place->next; }; if (v->place == NULL) { return(0); }; inend = 0; ingrace = 0; chordcount = 0; v->beamed_tuple_pending = 0; x = 20; thischord = NULL; if (v->keysig == NULL) { event_error("Voice has no key signature"); } else { sharps = v->keysig->sharps; }; /* draw stave */ ft = v->place; blockline(v, &spacing); if (spacing != NULL) { newblock(spacing->height, spacing->descender); staveline(); fprintf(f, "0 0 M 0 24 L\n"); }; x = 0.0; /* now draw the line */ printedline = 0; while ((ft != NULL) && (!printedline)) { /* printf("type = %d\n", ft->type); */ switch (ft->type) { case SINGLE_BAR: fprintf(f, "%.1f bar\n", ft->x); printbarnumber(ft->x, (int)ft->item); break; case DOUBLE_BAR: fprintf(f, "%.1f dbar\n", ft->x); printbarnumber(ft->x, (int)ft->item); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case BAR_REP: fprintf(f, "%.1f fbar1 %.1f rdots\n", ft->x, ft->x+10); printbarnumber(ft->x, (int)ft->item); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case REP_BAR: fprintf(f, "%.1f rdots %.1f fbar2\n", ft->x, ft->x+10); printbarnumber(ft->x, (int)ft->item); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case REP1: inend = endrep(inend, endstr, xend, ft->x - ft->xleft, spacing->yend); inend = 1; strcpy(endstr, "1"); xend = ft->x + ft->xright; break; case REP2: inend = endrep(inend, endstr, xend, ft->x - ft->xleft, spacing->yend); inend = 2; strcpy(endstr, "2"); xend = ft->x + ft->xright; break; case PLAY_ON_REP: inend = endrep(inend, endstr, xend, ft->x - ft->xleft, spacing->yend); inend = 1; strcpy(endstr, ft->item); xend = ft->x + ft->xright; break; case BAR1: fprintf(f, "%.1f bar\n", ft->x); printbarnumber(ft->x, (int)ft->item); inend = endrep(inend, endstr, xend, ft->x - ft->xleft, spacing->yend); inend = 1; strcpy(endstr, "1"); xend = ft->x + ft->xright; break; case REP_BAR2: fprintf(f, "%.1f rdots %.1f fbar2\n", ft->x, ft->x+10); printbarnumber(ft->x, (int)ft->item); inend = endrep(inend, endstr, xend, ft->x - ft->xleft, spacing->yend); inend = 2; strcpy(endstr, "2"); xend = ft->x + ft->xright; break; case DOUBLE_REP: fprintf(f, "%.1f fbar1 %.1f rdots %.1f fbar2 %.1f rdots\n", ft->x, ft->x+10, ft->x+2, ft->x-8); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case THICK_THIN: fprintf(f, "%.1f fbar1\n", ft->x); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case THIN_THICK: fprintf(f, "%.1f fbar2\n", ft->x); inend = endrep(inend, endstr, xend, ft->x, spacing->yend); break; case PART: astring = ft->item; break; case TEMPO: draw_tempo(ft->x, spacing->yinstruct, ft->item); break; case TIME: afract = ft->item; if (afract==NULL) { if (v->line == midline) { draw_meter(&v->meter, ft->x); }; } else { setfract(&v->meter, afract->num, afract->denom); if (v->line == midline) { draw_meter(afract, ft->x); }; }; break; case KEY: akey = ft->item; if (v->line == midline) { draw_keysig(v->keysig->map, akey->map, akey->mult, ft->x, v->clef); }; set_keysig(v->keysig, akey); break; case REST: arest = ft->item; drawrest(arest, ft->x, spacing); if (v->tuple_count > 0) { if (v->tuple_count == v->tuplenotes) { v->tuple_xstart = ft->x - ft->xleft; }; if (v->tuple_count == 1) { v->tuple_xend = ft->x + ft->xright; drawhtuple(v->tuple_xstart, v->tuple_xend, v->tuplelabel, v->tuple_height+4.0); }; v->tuple_count = v->tuple_count - 1; }; break; case TUPLE: atuple = ft->item; if (atuple->beamed) { v->beamed_tuple_pending = atuple->n; v->tuplenotes = atuple->r; v->tuple_count = 0; } else { v->tuple_height = atuple->height; v->tuplenotes = atuple->r; v->tuplelabel = atuple->label; v->tuple_count = atuple->r; }; break; case NOTE: anote = ft->item; if (thischord == NULL) { if (ingrace) { drawgracenote(anote, ft->x, ft, thischord); } else { drawnote(anote, ft->x, ft, thischord, &v->beamed_tuple_pending, spacing); if (v->tuple_count > 0) { if (v->tuple_count == v->tuplenotes) { v->tuple_xstart = ft->x - ft->xleft; }; if (v->tuple_count == 1) { v->tuple_xend = ft->x + ft->xright; drawhtuple(v->tuple_xstart, v->tuple_xend, v->tuplelabel, v->tuple_height+4.0); }; v->tuple_count = v->tuple_count - 1; }; }; } else { xchord = ft->x; /* make sure all chord heads are aligned */ if (ingrace) { handlegracebeam(anote, ft); drawgracehead(anote, ft->x, ft, nostem); } else { handlebeam(anote, ft); drawhead(anote, ft->x, ft); if (chordcount == 0) { notetext(anote, &v->beamed_tuple_pending, ft->x, ft, spacing); }; chordcount = chordcount + 1; }; }; break; case CHORDNOTE: anote = ft->item; if (ingrace) { drawgracehead(anote, xchord, ft, nostem); } else { drawhead(anote, xchord, ft); }; break; case NONOTE: break; case OLDTIE: break; case TEXT: break; case SLUR_ON: drawslurtie(ft->item); break; case SLUR_OFF: close_slurtie(ft->item); break; case TIE: drawslurtie(ft->item); break; case CLOSE_TIE: close_slurtie(ft->item); break; case TITLE: break; case CHANNEL: break; case TRANSPOSE: break; case RTRANSPOSE: break; case GRACEON: ingrace = 1; break; case GRACEOFF: ingrace = 0; break; case SETGRACE: break; case SETC: break; case GCHORD: break; case GCHORDON: break; case GCHORDOFF: break; case VOICE: break; case CHORDON: thischord = ft->item; chordcount = 0; drawchordtail(thischord, ft->next->x); break; case CHORDOFF: thischord = NULL; if (v->tuple_count > 0) { if (v->tuple_count == v->tuplenotes) { v->tuple_xstart = ft->x - ft->xleft; }; if (v->tuple_count == 1) { v->tuple_xend = ft->x + ft->xright; drawhtuple(v->tuple_xstart, v->tuple_xend, v->tuplelabel, v->tuple_height+4.0); }; v->tuple_count = v->tuple_count - 1; }; break; case SLUR_TIE: break; case TNOTE: break; case LT: break; case GT: break; case DYNAMIC: psaction = ft->item; if(psaction->color == 'r') redcolor = 1; /* [SS] 2013-11-04 */ if(psaction->color == 'b') redcolor = 0; break; case LINENUM: lineno = (int)(ft->item); break; case MUSICLINE: v->line = midline; break; case PRINTLINE: inend = endrep(inend, endstr, xend, scaledwidth, spacing->yend); printedline = 1; v->line = newline; break; case MUSICSTOP: break; case WORDLINE: break; case WORDSTOP: break; case INSTRUCTION: break; case NOBEAM: break; case CLEF: theclef = ft->item; if (theclef != NULL) { v->clef->type = theclef->type; v->clef->octave = theclef->octave; }; if (v->line == midline) { printclef(v->clef, ft->x, ft->yup, ft->ydown); }; break; case NEWPAGE: event_warning("newpage in music line ignored"); break; case LEFT_TEXT: event_warning("text in music line ignored"); break; case CENTRE_TEXT: event_warning("centred text in music line ignored"); break; case VSKIP: event_warning("%%vskip in music line ignored"); break; case SPLITVOICE: break; default: printf("unknown type: %d\n", (int)ft->type); break; }; ft = ft->next; }; v->place = ft; return(1); } static int finalsizeline(struct voice* v) /* does final beaming and works out vertical height for */ /* one line of specified voice */ { struct feature* ft; double height, descender; double yend, yinstruct, ygchord, ywords; struct vertspacing* avertspacing; /* skip over line number so we can check for end of tune */ while ((v->place != NULL) && ((v->place->type == LINENUM) || (v->place->type == NEWPAGE) || (v->place->type == LEFT_TEXT) || (v->place->type == CENTRE_TEXT) || (v->place->type == VSKIP))) { v->place = v->place->next; }; if (v->place == NULL) { return(0); }; ft = v->place; beamline(ft); measureline(ft, &height, &descender, ¥d, &yinstruct, &ygchord, &ywords); /* newblock(height, descender); */ /* find end of line */ while ((ft != NULL) && (ft->type != PRINTLINE)) { ft = ft->next; }; if ((ft != NULL) && (ft->type == PRINTLINE)) { avertspacing = ft->item; avertspacing->height = (float) height; avertspacing->descender = (float) descender; avertspacing->yend = (float) yend; avertspacing->yinstruct = (float) yinstruct; avertspacing->ygchord = (float) ygchord; avertspacing->ywords = (float) ywords; ft = ft->next; }; v->place = ft; return(1); } static void finalsizetune(t) struct tune* t; /* calculate beaming and calculate height of each music line */ { struct voice* thisvoice; int doneline; thisvoice = firstitem(&t->voices); while (thisvoice != NULL) { doneline = 1; while (doneline==1) { doneline = finalsizeline(thisvoice); }; thisvoice = nextitem(&t->voices); }; } static int getlineheight(struct voice* v, double* height) /* calculate vertical space for one line of music from specified voice */ { struct vertspacing* spacing; /* go over between line stuff */ while ((v->place != NULL) && ((v->place->type == LINENUM) || (v->place->type == NEWPAGE) || (v->place->type == LEFT_TEXT) || (v->place->type == CENTRE_TEXT) || (v->place->type == VSKIP))) { if (v->place->type == LINENUM) { lineno = (int)(v->place->item); }; if (v->place->type == LEFT_TEXT) { *height = *height + textfont.pointsize + textfont.space; }; if (v->place->type == CENTRE_TEXT) { *height = *height + textfont.pointsize + textfont.space; }; if (v->place->type == VSKIP) { *height = *height + (double)((int)v->place->item); }; v->place = v->place->next; }; if (v->place == NULL) { return(0); }; /* skip over rest of line */ while ((v->place != NULL) && (v->place->type != PRINTLINE)) { v->place = v->place->next; }; if (v->place != NULL) { spacing = v->place->item; *height = *height + spacing->height + spacing->descender; v->place = v->place->next; }; return(1); } static double tuneheight(t) struct tune* t; /* measures the vertical space needed by the tune */ { char* atitle; char* wordline; struct voice* thisvoice; int doneline; double height; char *notesfield; /* from N: field */ height = 0.0; resettune(t); atitle = firstitem(&t->title); while (atitle != NULL) { height = height + titlefont.pointsize + titlefont.space; atitle = nextitem(&t->title); }; if ((titleleft == 1) && (t->tempo != NULL)) { height = height + titlefont.pointsize + 2*titlefont.space; }; if (t->composer != NULL) { height = height + composerfont.pointsize + composerfont.space; }; if (t->origin != NULL) { height = height + composerfont.pointsize + composerfont.space; }; if (t->parts != NULL) { height = height + composerfont.pointsize + composerfont.space; }; notesfield = firstitem(&t->notes); while (notesfield != NULL) { height = height + composerfont.pointsize + composerfont.space; notesfield = nextitem(&t->notes); }; thisvoice = firstitem(&t->voices); if (separate_voices) { thisvoice = firstitem(&t->voices); while (thisvoice != NULL) { doneline = 1; while (doneline==1) { doneline = getlineheight(thisvoice, &height); }; thisvoice = nextitem(&t->voices); if (thisvoice != NULL) { height = height + 2.0 * staffsep; }; }; } else { doneline = 1; while(doneline) { thisvoice = firstitem(&t->voices); doneline = 0; while (thisvoice != NULL) { doneline = (getlineheight(thisvoice, &height) || doneline); thisvoice = nextitem(&t->voices); }; }; }; wordline = firstitem(&t->words); while (wordline != NULL) { height = height + wordsfont.pointsize + wordsfont.space; wordline = nextitem(&t->words); }; return(height); } void printtune(struct tune* t) /* draws the PostScript for an entire abc tune */ { int i; char *atitle; char *notesfield; /* from N: field */ char *wordline; int notesdone; int titleno; struct voice* thisvoice; int doneline; double firstvline, lastvline; struct voice* firstvoice; char xtitle[200]; struct bbox boundingbox; enum placetype titleplace; redcolor = 0; /* [SS] 2013-11-04 */ resettune(t); sizetune(t); resettune(t); if (separate_voices) { monospace(t); } else { spacevoices(t); }; resettune(t); finalsizetune(t); if (debugging) { showtune(t); }; if (eps_out) { if (landscape) { boundingbox.llx = ymargin; boundingbox.lly = xmargin; boundingbox.urx = (int) (ymargin + tuneheight(t) * scale); boundingbox.ury = xmargin + pagewidth; } else { boundingbox.llx = xmargin; boundingbox.lly = (int) (ymargin + pagelen - tuneheight(t) * scale); boundingbox.urx = xmargin + pagewidth; boundingbox.ury = ymargin + pagelen; }; sprintf(outputname, "%s%d.eps", outputroot, t->no); open_output_file(outputname, &boundingbox); } else { make_open(); if ((totlen > 0.0) && (totlen+descend+tuneheight(t) > scaledlen-(double)(pagenumbering))) { newpage(); }; }; resettune(t); notesdone = 0; if (titleleft) { titleplace = left; } else { titleplace = centre; }; atitle = firstitem(&t->title); titleno = 1; while (atitle != NULL) { if (titleno == 1) { if (titlecaps) { for (i=0; i< (int) strlen(atitle); i++) { if (islower(atitle[i])) { atitle[i] = atitle[i] + 'A' - 'a'; }; }; }; if ((print_xref) && (strlen(atitle) < 180)) { sprintf(xtitle, "%d. %s", t->no, atitle); printtext(titleplace, xtitle, &titlefont); } else { printtext(titleplace, atitle, &titlefont); }; } else { printtext(titleplace, atitle, &subtitlefont); }; titleno = titleno + 1; atitle = nextitem(&t->title); }; if (t->tempo != NULL) { if (titleleft) { newblock((double)(titlefont.pointsize + titlefont.space*2), 0.0); }; draw_tempo(10.0, 0.0, t->tempo); }; if (t->composer != NULL) { printtext(right, t->composer, &composerfont); }; if (t->origin != NULL) { printtext(right, t->origin, &composerfont); }; if (t->parts != NULL) { printtext(right, t->parts, &composerfont); }; notesfield = firstitem(&t->notes); while (notesfield != NULL) { printtext(left, notesfield, &composerfont); notesfield = nextitem(&t->notes); }; donemeter = 0; /* musicsetup(); */ thisvoice = firstitem(&t->voices); while (thisvoice != NULL) { thisvoice->clef->type = t->clef.type; thisvoice->clef->octave = t->clef.octave; setfract(&thisvoice->meter, t->meter.num, t->meter.denom); thisvoice->place = thisvoice->first; thisvoice = nextitem(&t->voices); }; if (separate_voices) { thisvoice = firstitem(&t->voices); while (thisvoice != NULL) { doneline = 1; while (doneline==1) { doneline = printvoiceline(thisvoice); }; thisvoice = nextitem(&t->voices); if (thisvoice != NULL) { voicedivider(); }; }; } else { doneline = 1; while(doneline) { thisvoice = firstitem(&t->voices); firstvoice = thisvoice; doneline = 0; while (thisvoice != NULL) { doneline = (printvoiceline(thisvoice) || doneline); if (thisvoice == firstvoice) { firstvline = totlen; } else { lastvline = totlen; if (lastvline > firstvline) { fprintf(f, "0 24 M 0 %.1f L\n", lastvline - firstvline); }; firstvline = totlen; }; thisvoice = nextitem(&t->voices); }; }; }; /* musicrestore(); */ wordline = firstitem(&t->words); while (wordline != NULL) { printtext(left, wordline, &wordsfont); wordline = nextitem(&t->words); }; if (eps_out) { close_output_file(); }; } abcmidi/configure.ac0000644000000000000000000000203311617434730013436 0ustar rootroot# -*- Autoconf -*- # Process this file with autoconf to produce a configure script. AC_PREREQ([2.67]) AC_INIT([abcmidi], [2011-08-03], [seymour.shlien@crc.ca]) AC_CONFIG_SRCDIR([abc.h]) AC_CONFIG_HEADERS([config.h]) # Checks for programs. cflags_save="$CFLAGS" AC_PROG_CC CFLAGS="$cflags_save" dnl This mechanism allows one to enable debug compilations... AC_ARG_ENABLE(debug, [ --enable-debug Enable debugging information], USE_DEBUG="$enableval", USE_DEBUG="no") if test $USE_DEBUG = yes ; then CFLAGS="$CFLAGS -g" else CFLAGS="$CFLAGS -O2" fi AC_PROG_INSTALL # Checks for libraries. # FIXME: Replace `main' with a function in `-lm': AC_CHECK_LIB([m], [main]) # Checks for header files. AC_CHECK_HEADERS([stdlib.h string.h]) # Checks for typedefs, structures, and compiler characteristics. AC_TYPE_SIZE_T # Checks for library functions. AC_FUNC_ERROR_AT_LINE AC_FUNC_MALLOC AC_CHECK_FUNCS([strcasecmp strchr]) AC_CONFIG_FILES([Makefile]) AC_OUTPUT abcmidi/CHANGES0000644000000000000000000130650012562316654012156 0ustar rootroot2003 March 27: Updated the man pages to abc2abc, abc2midi and midi2abc and created a new man page for yaps. Minor changes to midifile.c and midifile.h were made to minimize the number of warning error messages. Midi2abc was upgraded to be in line with the version I use with the script midi2abc.tcl. The syntax in mftext.c was improved to reduce the number of compilation warnings. 2003 April 12 abc2midi: for abc tunes with no guitar chords, an error message "Command not recognized" is issued whenever a %%MIDI chordprog or %%MIDI bassprog command is encountered. The problem occurs mainly with runabc, which performs only one pass through the tune and is unable to know whether guitar chords are present before sending %%MIDI commands. Since no MIDI program command is issued in this situation, the error message was disabled, The fix was made in dodeferred() in genmidi.c 2003 April 12 abc2midi assumes the ratio of 2:1 for long/short notes in broken rhythms specified with angle brackets (eg. c>d), Though this can be changed using the %%MIDI ratio command, it is inconvenient for many users since it is necessary to edit each tune in the abc file in order to effect this change. A new command parameter -RS (ratio standard) changes default ratio to 3:1 which is the standard music notation. The new parameter still allows the %%MIDI ratio command to override the default. The change was incorporated in event_init() of store.c. 2003 Apri 19 The proposed abc standard allows non numeric identifications for the voice field, eg. V: soprano instead of V:1. If you are creating a midi file, each unique identification string will mapped to a sequential numbers 1,2 etc, as if you had used numbers originally. The change allows abcMIDI to handle a number of new multivoiced abc files which have adopted this convention. Only the first 20 characters of the identification string are distinguished. Anything following the identification string is ignored. The identification string should not end with an equal sign =. If nonnumeric identifications are used, abc2midi will print the mapping between the id's and the numbers. This may be useful for catching spelling errors in the id's. The fix was made in function parsefield in parseabc.c. The change does not yet allow V: commands to appear before the body of the tune. A number of abc files may designate a rest using x instead of z. This means that this rest exists but should not appear in the printed score. I have modified the parser so it shall now interpret x as rest; however, if you are using yaps to print the score, this rest will still remain visible. Abc2midi will now treat x exactly like z. Abc2abc will probably automatically convert the x's to z's whether you want it or not. A minor change was made in parsemusic in parseabc.c. It is necessary to modify toabc.c and yapstree.c to fix the remaining problems. 2003 April 27 Guitar chords. The base note preceeded by a slash in the guitar chord may now be in lower case as well as upper case. For example, "G/B" and "G/b" will both be treated the same way. This complies with the proposed abc standard 1.7.6 (abc-draft.txt) and avoids problems with some files in the Nottingham database. The fix was made in event_handle_gchord in store.c. Guitar chords. When there is a change of meter, the gchord beat does not seem to get changed. I inserted a call to setbeat() in writetrack() in genmidi.c whenever a TIME feature is encountered. It was also necessary to change the definition of setbeat in store.c from static to external. 2003 May 3 Karoake lyrics: Improved the documentation for the functions write_syllable and getword in genmidi.c which handle the lyrics in the w: body line. If a bar line is placed in the lyric line between two tied notes, for example see below, "C6" c> G E2- | E2 (3 c d c | "E7" B> ^G E2- | E4 | w: All of me, | * why not take | all of me.* ^ write_syllable loses synchrony with the music while searching for the next bar line in the music. The problem was fixed by resetting waitforbar to 0 between the two calls of write_syllable, in writetrack (genmidi.c) after TNOTE is handled. I found most warning messages about mismatched lyric syllables to music notes have to do with users failing to notate syllables correctly when tied notes occur. (Failure to place a * or _ (underscore) preceding syllable of tied note. Confusing hyphen with underscore...) 2003 May 4 abc2midi file xref: Abc2midi has the option of converting only a particular tune in a abcfile to a midi file by specifying the X: reference number immediately following the abc file name. When this feature is used, warning messages such as Warning in line 28: T: outside tune body - possible missing X: The problem occurs in the function parsefield in parseabc.c. In order to catch the reference number of the selected tune, every line of the input file is parsed. A flag "parsing" equal to 0 or 1 is used to turn on the parsing inside the body of the of the music. This flag is turned in function event_refno() in store.c by calling the function parseon() in parseabc.c. Unfortunately all field lines (eg. T: , M:, L:, V: ...) were unaffected by this flag and continued to be parsed. When the T: field command is encountered, it falls through to the default: in parsefield and it is processed by the function, event_field in store.c. Event_field was designed to treat the T: and R: conditions but before handling these conditions it checks whether the control flag dotune is set. This flag is also set by event_refno. If the flag is not set, then event_field assumes that a T: field command was encountered without a preceding X: reference field which is a valid error condition. Since all field lines in the abc file are parsed this introduces other problems. Any anomaly in the field lines whether they are from the selected tune or not are reported. For example, if a user has selected for example tune 500 from a large abc file, errors in the field lines of other tunes will be reported. Furthermore, in some cases the program may crash in processing a field line of another tune. To address these problems, the functions parseline and parsefield in parseabc.c were modified so that all field lines (except for the X: field line) and all text lines are ignored for nonselected tunes. Parseline checks whether the flag parsing is set before calling parsemusic or event_text. In parsefield, the condition key == 'X' was moved from the switch control structure and treated separately immediately when entering this function. If parsing flag has not been set, the function returns immediately after checking for key == 'X'. This introduces a new problem. If the abc file has no X: field, the abcmidi programs does nothing without any error indication. To handle, this situation I introduced a the global variable parsing_started into parseabc.c, It is initialized to 0 and set to 1 when the function parseron() is called. Prior to the end of the function parsefile, the parsing_started variable is checked. If it is still 0, an error message is returned. Finally, event_linebreak() is suppressed in parsefile() whenever the variable parsing is not set. This avoids a lot of blank line output from abc2abc whenever the X: field is missing from the input abc file. This is a major change to the code, since it affects three programs, abc2midi, yaps and abc2abc. I hope this has not introduced new problems. 2003 May 11 Many tunes have a left repeat sign (|:) missing. In most cases it is fairly clear where to place the repeat sign and abc2midi merely puts a warning message "Assuming repeat". When you are processing a large group of abc tunes these messages may be annoying. A new parameter -NAR (no assuming repeat) will suppress this message when you are running abc2midi. However, occasionally you get the error message "Found unexpected :| ...". This is a more serious problem. Due to some ambiguity, the program store.c was unable to place a missing |: into the tune. During the second pass, genmidi.c encounters the :| and does not know where to begin the repeat. This is a real error since the repeat will not occur. This error message is not suppressed. The instructions !trill! and !fermata! are recognized by yaps and abc2midi and are treated in the same way as the decorations T and H preceding a note. To do this I introduced a new integer global array decorator_passback[] which is set by event_handle_instruction in both yapstree.c and store.c. The array is passed between files parseabc.c, store.c and yapstree.c as an extern. 2003 May 18 The symbol y used to denote a space in Barfly, is ignored and no longer causes an error message. It is deleted by abc2abc. 2003 May 19 Added an option to number bars in yaps. Note the bar numbers may not match those in abc2midi or other abc*ps programs. Introduced global flag barnums and global integer nnbars in yapstree.c which is set by event_init and linked to drawtune.c. Added new -k option in event_init in yapstree.c. In event_bar in yapstree.c passed the current bar number instead of NULL in addfeature. In drawtune.c introduced a new function printbarnumber which is called in various places in the function printvoiceline. %%MIDI chordname accepts negative semitone shifts relative to root. In function event_specific in store.c, replaced readnump with readsnump. 2003 May 22 Bar numbering in yaps is now in agreement with abc2midi but may differ by one unit with abc2ps and other members of its family. See abcguide.txt for more discussion. I moved the position of the call to checkbar() in event_bar() (yapstree.c) so it occurs before addfeature is called rather than after. The decoration field line d: (used inabcm2ps) is not parsed as a music line but is an ignored field line. Change was made in parseabc.c in parsefield() and parseline(). 2003 May 31 Yaps crashes when it encounters text preceeded by an underscore in a guitar chord. For example "G" AB/2B/2 "_quiet" DD| g/2g/2d/2d/2 | here yaps crashes when the function event_handle_gchord (in yapstree.c) encounters the text _quiet. The problem was fixed by ensuring that, cv->instruction_pending is not NULL prior to adding anything to this structure. 2003 June 6 Yaps ignores any guitar chords placed in front of a chord if the notes in the chord are not in descending order. For example in the following line |"Gm"[G2B2][Ac]|[Bd][Ac][GB]|"D"[A/2c/2][A/2c/2][Ac][Bd]| the guitar chords Gm and D do not appear because they precede a chords [G2B2] and [A/2c/2]. This problem also applies to any instructions (eg. !quiet!) which immediately precede a chord. The problem has to do with the way the gchord and instructions are processed by yapstree.c. When they are first encountered they are placed in temporary places, cv->gchord_pending and cv->instructions->pending. When the next note is encountered, the function newnote moves them to fields associated with that note. Unfortunately, when printvoiceline in drawtune.c processes the notes in a chord it expects the guitar chord or instructions to be associated with the first note encountered in the chord. (It checks chordcount variable.) This is not always true because the function insertnote in yapstree.c for some reason will reorder the the notes in the chord if they are not in descending order. The fix was to modify noteinsert in yapstree.c so that if it reorders the notes in the chord, it also moves the gchord and instructions fields to be with the first note. 14 June 2003 Yaps produces a segmentation error when it fails to find an expected continuation line and attempts to print a guitar chord.(eg.) X:1 T:example K:C "C" abcd|\ (In this example there is no more records following the backslash.) The error occurs when it tries to execute showtext in the function notetext in the file drawtune.c. The fix was to ensure that the pointer spacing is not NULL prior to calling showtext. 21 June 2003 Abc2midi assumes the last %%MIDI gchord string specified as the default for the start of the tune. In the following tune, X: 1 T: gchords M:4/4 L:1/4 K:C "C" CCCC|CCCC| %%MIDI gchord czcz FFFF|FFFF| %%MIDI gchord fzzz GGGG|GGGG| %%MIDI gchord fcfz CCCC|CCCC| the gchord string was not set for the first two bars. It was expected that abc2midi would use the system default for 4/4 time, i.e. fzczfzcz. Instead, the last defined gchord fzfz was assumed, which is not expected. If the user places another %%MIDI gchord string before the first bar or adds a redundant meter field M:4/4 just before the first bar, everything is ok. Abc2midi calls setbeat which calls set_gchords just after it processes the first K: declaration in the field area. When abc2midi writes the first track writetrack(0) containing the melody, everything is still ok, except that the accompaniment is not written at this point. Each time writetrack encounters another %%MIDI gchord declaration, set_gchord changes the gchord string. When it is time to start the accompaniment track, the gchord string was left as the last declared string. The fix was to move the setbeat invocation from headerprocess() in store.c to the beginning of writetrack in genmidi.c when the accompaniment track is identified. I also added a short caveate in abcguide.txt about the setting of MIDI gchord string. 28 June 2003 The %%MIDI transpose command transposes all channels including the drum channel. For the drum channel, the pitch component selects the percussion instrument, so transposition is not appropriate here. The fix was applied to the function save_note in the file genmidi.c. Transposition is blocked if the drum channel 9 (counting from 0) is selected. 29 June 2003 Besides the key signature, the K: field can contain many other descriptors, such as the clef (treble, bass...), the octave and transposition. The code for parsing the K: field parsekey was rather convoluted and hard to understand. It was simplified by breaking it up into several functions. During this process, I discovered an Easter Egg (undocumented feature) in abc2midi. It is possible to transpose an individual voice without affecting the other voices. The documentation to these features was improved in abcguide.txt. 1 July 2003 The single voice transpose function described above does not work correctly in combination with the global transpose initiated by the %%MIDI transpose (or rtranspose) function. The original code in store.c and genmidi.c was confusing since communications between the two files was performed by both the feature/pitch arrays and a global variable global_transpose which was linked to both files using an extern int declaration. Here is a short description on how it was originally. Parsekey passes transpose to event_key. When a new transpose value is obtained from event_key, the TRANSPOSE flag is added to the feature array and the value of transpose is put in the pitch array. In addition the global_transpose variable (a variable linked to genmidi.c) is also set to transpose if event_key obtains the transpose value before getting to the body of the music. When a transpose value is obtained from event_specific (i.e. from a %%MIDI transpose indication) a TRANSPOSE flag is also added to the feature array and the linked variable global_transpose is always set to the transpose value. Genmidi.c processes the TRANSPOSE feature in the function writetrack. At the start of every track, writetrack sets the transpose variable (here not linked with store.c) to global_transpose. When TRANSPOSE feature is encountered the variable transpose is extracted from the pitch array. The transpose value is added to the note pitch whenever a note is issued. The transpose value is also stashed away by save_state in case a REPEAT feature is encountered. In this situation, the stashed value is recovered by restore_state. It would make more sense to treat transpose and global_transpose independently. i.e. new pitch = pitch + transpose + global_transpose. Also it would be be a good idea not to pass global_transpose to genmidi.c using "extern int" but setting it using a new feature GTRANSPOSE in the feature array. Fix: GTRANSPOSE introduced in abc.h. global_transpose variable and associated code eliminated from store.c. In writetrack in store.c, another switch condition for GTRANSPOSE was introduced. global_transpose initialized to 0. transpose initialized to 0 in starttrack. In noteon_data and addtoQ transpose + global_transpose are added to pitch. These changes now allow global_transpose and transpose functions to work together and independently. Basically transposition is now performed by either or both variables 'transpose' and 'global_transpose'. The only difference between these variables is that the transpose variable is reinitialized to zero each time a new track is started, while global_transpose is only initialized at the start of the tune. These variables are set only through the feature/pitch arrays in store.c. 5 July 2003 Abcm2ps allows the voice field to contain additional descriptor information such as the clef name. This information may indicate a voice transposition by one octave. Abc2midi and other abcMIDI programs currently ignore this information. Fix: A new function parsevoice was introduced into parseabc. which contains a combination of the code in both parsefield and parsekey. New parameters were introduced to event_voice in store.c, yapstree.c, toabc.c, parseabc.c and parseabc.h in order to pass this information. In store.c, event_voice will call event_octave if gotoctave is set and insert a TRANSPOSE feature in the feature/pitch array. In toabc.c, event_voice will also output the clef if gotclef is set. In the event that treble+8, treble-8, or tenor-8 is specified, parsevoice will set octave to the appropriate value and set gotoctave so that event_voice in store.c will also issue an event_octave. The transpose indication in the clef is detected in the function isclef() in parseabc.c which now has extra parameters. Please note no transposition is assumed for the bass clef. If it is desired that abc2midi transpose that voice, a octave=-1 or -2, should be included in the K: or V: field. 6 July 2003 Abc2midi considers the placement of a V: indication outside the music body (in the header) as an error and ignores it. Other applications such as abcm2ps permit V: indications to occur music header. In such instances, the voice field specifies information such as the clef to be used for that voice. Several changes were needed to handle the this convention. (1) In event_voice, the check "pastheader" was disabled; however, it is important not to call checkbreak() prior to passing the header. (2) It is necessary to create the first voicecontext structure immediately after the parser is started rather than wait for the first K: field (which ends the header block). Therefore, the code v = newvoice(1); head = v; was moved to event_refno and event_key was replaced getvoicecontext(1); (3) Normally event_octave will transpose all the music voices if it is called in the music header. This needs to be disabled when it is called from event_voice. A new parameter, local (as opposed to global) was introduced into event_voice to indicate such a situation. (It was necessary to also put this change in parseabc.c, yapstree.c, toabc.c, parseabc.h, in addition to store.c) 12 July 2003 Abc2midi loses synchronization between voices when a voice change occurs in the middle of a bar. The following tune does not get converted correctly into a MIDI file. X:1 T: sample M: 2/4 L: 1/8 K:G V:1 |:AG Bc| V:2 |:C2 C2| V:1 AG Bc|[1 V:2 C2 C2|[1 V:1 CDEF:|[2 EFG2| V:2 D2 D2:|[2 G4| The problem occurs when writetrack (in genmidi) is processing the second repeat. When it comes to the bar marked with a [1 it attempt to skip to the bar labeled [2, however, it failed to check for a voice change. (It is unusual to switches voices in the middle of a bar.) Instead it another [1 and outputs numerous error messages. The problem was fixed by checking for a voice change and searching for the continuation of the current active voice using the findvoice function. Yaps terminates prematurely if a tune does not contain a M: indication in the header. Yaps reports that there is no M: field but when it attempts to set it to the default 4/4 in startbody(), no voice structure has been created. To fix this problem lines of code, setvoice(1) and startbody() were interchanged in event_true_key() in yapstree.c 13 July 2003 Yaps bar alignment fails in multivoiced files containing tuples (eg. triplets). For example, X: 1 T: yaps trips on triplets M: 2/4 L: 1/8 K: G V:1 C4|C4|(3BBB (3BBB|C4|C4| V:2 F4|F4|F4|F4|F4| The bars for the second line do line up after the triplets. The function advance() in position.c does not set the notelengths in the case of triplets. As a result, spaceline() in position.c has the incorrect temporal position of the notes when it tries to place the notes on the staff. Fix: a new variable tuplenotes was introduced in the struct note (struct.h). This variable is set in event_note, in yapstree.c and contains the sequence number of the tuple note (descending). In event that advance() detects a tuple note (based on this variable), the temporal length is adjusted by multiplying it by the tuplefactor. (A new function mulfract was introduced for this purpose.). The notes and bars are lined up now, but more work is probably needed to get more pleasing spacing. 19 July 2003 Abc2midi fails to set key signature sharps or flats pattern in multivoiced tunes with voice indications in the header. For example in the following tune, X: 1 T: G minor scale M: 2/4 L: 1/8 V:2 K: Bb V:2 GABc|defg| the notes B and e are not flattened in the output MIDI file. This is a new bug I introduced in July 5, 2003 when I extended the abcMIDI package to handle voice field indications in the header block. For each voice there is a separate voicecontext structure which contains its own basemap for sharpening or flattening selected notes. See store.c code. (This permits the option of a voice to have its own key signature which is different from the other voices.) There is also a global voicecontext structure used for applying the key signature to all voices if they are not indicated separately. The global key signature is copied to the voicecontext of a separate voice at the time that the voicecontext structure is created. Unfortunately, if the voicecontext structure is created prior to setting the overall key signature with the first K: indicator, then the basemap for that voice is set for C major or A minor. Fix: a new flag, keyset was introduced in the voicecontext structure. This flag indicates whether the key signature was known at the time when the voicecontext structure was allocated by newvoice(). Whenever getvoicecontext() switches voices context, it now checks keyset to determine whether it is necessary to copy the basemap and related variables from the global voicecontext structure. I: octave=n has been disabled in abc2midi. Since an octave shift can be indicated in either the K: or V: field, it is no longer necessary to use the info field for setting the octave range. I have disabled this feature to discourage using the info field for setting the octave range. 20 July 2003 The hidden rest (x) was introduced in abcMIDI in April 19 2003. Abc2midi treated it as a regular rest but abc2abc automatically converted it into a regular rest z. The new functionality to transpose separate voices that was introduced in abc2midi now makes abc2abc even more useful. I have upgraded abc2abc so it now preserves the hidden rests in the abc files. Yaps continues to not distinguish the two types of rests (like abc2midi). Fix: introduced an extra variable in event_rest in parseabc.c, store.c, yapstree.c, toabc.c and parseabc.h. In toabc.c event_rest emits an x instead of a z if a hidden rest is detected. 16 August 2003 Abc2midi: The drum accompaniment is started or stopped using the instruction command !drum! and !nodrum!. The !drum! and !nodrum! commands are not part of the abc standard so other applications such as abc2ps and related clones do not understand this instruction. The programs either ignore or it or return a warning. I have introduced an alternate method of starting and stopping the drum track using the MIDI indications. %%MIDI drumon and %%MIDI drumoff This is similar to the method of starting and stopping gchords. (%%MIDI gchordon and %%MIDI gchordoff). I feel this is the preferred method and the older method will probably be deprecated. Fortunately, I am the only one using drum accompaniment (eg. isra.abc) so all of this has little impact. August 22 2003 Midi2abc creates a abc file with a blank title. It is more useful to place the name of the input midi file in the title. Midi2abc puts a blank line in the abc file in the event that a newline character \n is embedded in the meta_text. A blank line signifies the end of a tune, so the remaining part of the abc file is not processed. The function remove_carriage_return was updated so it now checks for both \r and \n. August 31 2003 Reorganized and improved documentation of midi2abc.c Many MIDI files have multiple tempo indications. In fact some MIDI files change the tempo at every beat. Midi2abc assumes the last tempo indication; however, in some MIDI files the tempo slows down at the end. When the resulting abc file is converted back to a MIDI file it plays much slower than the original. I have modified midi2abc so that it now assumes the first tempo indication and ignores all following indications. September 8 2003 Midi2abc identifies drum tracks (channel 10) but it needs to issue a %%MIDI channel 10 to that voice so that abc2midi will know to assign that voice channel 10. Printtrack was modified to test for a drum track. Added two new parameters, -bpl and -bps to control the formatting of the output abc file. These parameters control the number of bars printed per line, and the number of bars to be associated with a music staff. The -obpl (one bar per line) parameter is deprecated. September 13 2003 Midi2abc by default does not use the PPQN information in the MIDI header to determines the note length in MIDI pulses. Furthermore it ignores any time signature information in the MIDI file that may be present. Most MIDI files do contain valid information so midi2abc produces the best output when run time options -xl and -xm are included. Midi2abc was modified to make these run time options the default and the unnecessary flags -xl and -xm are now removed. To allow the user to force midi2abc to estimate xunits (MIDI pulses per standard unit note length) from the note duration statistics, a new option -gu was now introduced. Since this is a major change in how midi2abc runs, the version number was bumped up to 2.6. September 14 2003 Contrary to the documentation, the anacrusis is not specified in beats but in abc half unit lengths where a unit length is given in the L: field in the header. For example if L:1/8 and M: 4/4, an anacrusis of 1 beat is specified as 4 (i.e. four 1/16 units). This is due to the way the quantized music is represented in midi2abc. Midi2abc does not allow notes shorter than than 1/2 an L: unit. Therefore if the unit length is L: 1/8, the shortest note that can be produced by abc2midi is a sixteenth note. Note lengths are stored internally in midi2abc as numerator/denominator where the denominator is always 2. So a sixteenth note is quantized to a numerator value of 1. Therefore midi2abc has difficulty representing very short notes that are encountered in trills or drum rolls. In such situations you should use the -s option for short notes to get an approximation. This also explains why printtrack, findana and guessana want the barsize to be measured in half abc unit lengths (barsize is doubled in the calling sequence for these functions.) I have corrected the readme.txt and the midi2abc.1 man file. September 21 2003 Laura Michaels contributed patches to store.c, genmidi.c and abc.h to handle the Copyright extended information field (see abc2-draft) and to improve the production of Karaoke MIDI files. Laura Michaels also provided makefiles for other compilers such as Ming and Watfor. More details follow. The proposed standard introduces a new field using the syntax %%abc-copyright (c) Copyright John Smith 2003 Abc2midi now inserts this in the MIDI file in the form of a metatext copyright tag. Changes were made to the event_specific function in store.c to process the copyright information. Karaoke file applications such as Winamp, VanBasco;s Karaoke player, and WinKaraoke (on Windows) have difficulty extracting the composer and copyright information fields and confuse them with the Karaoke text. The function karaokestarttrack in genmidi.c was modified to handle additional @T information lines for composer and copyright information after the title line in the first MIDI track. In the Karaoke track (track 3), this information was also added in the form of @I fields. Also other abc information fields such as H: and A: were suppressed in the Karaoke track by setting texton to 0 in printtrack. The 98 character limit for text lines handled by event_field in store.c was changed to 255 (see default case in switch (k)). September 28 2003 For multivoiced abc files there is a need to be able to apply a fermata to a rest. For example, consider this file. X: 1 T: fermata applied to rest M: 2/4 L: 1/8 K: G [V:1] CDEF|GAF!fermata!G|C2 C2| [V:2] EFGA|Bcd!fermata!z|C2 C2| [V:1] CDEF|GAF!fermata!G|C2 C2| [V:2] EFGA|Bcd!fermata!G|C2 C2| If the fermata is not applied to the rest, there is a loss of synchronization between the two voices. The function event_rest was modified to get the array decorators from one of its passed parameters. In store.c event_rest would double the length of the rest (including hidden rests) if decorators[FERMATA] is set. In parseabc.c it was necessary to to update the decorators array for the case 'z' and 'x', prior to passing it to event_rest. Changes were also required in yapstree.c and toabc.c even though event_rest does not use the decorators array in these files. The declarations for event_rest in parseabc.h also needed to be changed. September 29 2003 A new problem with setbeat (store.c) was discovered. For the file X:1 T: time sig M: 2/4 L: 1/8 K: G "C" G2 G2| G2 G2| [M:3/4] G2 G2 G2|G2 G2 G2| The gchord output was not correct for the first two bars. This was caused by several problems in the code. (1) Setbeat calls set_gchord to set the gchord_seq, gchord_len, g_num, and g_denom used by dogchords. The values for g_num and g_denom were incorrect because they were computed from mtime_num and mtime_denom which were set by set_meter. The values of mtime_num and mtime_denom were the last values in the previous tracks processed so if there was a change of meter in the tune they would not reflect the initial value. (2) Setbeat chooses the appropriate gchord string on the basis of the time signature stored in the time_num and time_denom array. It is therefore necessary that these values remain current to the current context during the writetrack pass. Therefore set_meter was modified to update time_num and time_denom whenever it is called. Set_meter is called in several places. It was called in starttrack with the global parameters time_num and time_denom. Unfortunately these parameters are affected by the event_timesig which is called during the parsing stage. Therefore their values reflect the last time signature encountered during the parsing stage. It is necessary to cache the initial settings of the time signature set in the header block. New variables header_time_num and header_time_denom are defined in store.c and passed to genmidi.c as externals. In writetrack, for the accompaniment track it was necessary to call set_meter() with the header time signatures just prior to setbeat(). Set_meter is also called by write_meter in genmidi.c. Write_meter is called whenever a TIME feature (for time signature) is encountered. Fortunately, the correct time signature stored in the num[] and denom[] arrays are used. Setbeat is called shortly after in printtrack. October 13 2003 Though most MIDI files indicate a time signature few also indicate a key signature. Though midi2abc reports any key signature it finds in the MIDI file, it does not use it but insists on determining it by scanning all notes and choosing the key signature that minimizes the number of accidentals. This works fine if there are no key changes in the music. If the MIDI file does indeed indicate key signatures and key changes then midi2abc should use this information in creating the abc file. In a similar vein, for some MIDI files there may be more than one meter change. Midi2abc uses the first time signature that is indicated in the MIDI file. If it encounters other time signature indications later, it reports it but it still uses the initial time signature to transcribe the file. Again it would be desirable if midi2abc would act on this information. Looking at midi2abc.c, it was noticed that the function findkey() is always invoked except when the key signature is passed in one of the run time parameters. If a key signature or time signature metatext command is encountered, a time stamped text message is added to the tlistx structure associated with that track. These text messages are sent to the abc file at the appropriate time using the handletext function which is invoked by printtrack; however, no adjustment is made for any key or meter change. Further the barsize is assumed to be fixed. The barsize is a local variable in the main program and it is passed to printtrack as one of its parameters. The barsize controls the placement of bar lines in the output abc file. Numerous changes were needed to fix these problems. (1) A new global flag, gotkeysig was introduced to the code. It is initialized to zero but set to 1 whenever a key signature metatext command is encountered. (2) A new variable 'type' was added to the tlistx structure. If tlistx.text contains the key signature, tlistx.type is set to 1. If tlistx.text contains the time signature, tlistx.type is set to 2. For everything else, tlistx.type is set to 0. (3) The 'type' variable was added to the addtext() function and in the many places where it was invoked. (4) In the function txt_keysig(), the verbose message sent to the tlistx structure was replaced with just the sf and mi (number of sharps/flats and major/minor flag). (5) In the function txt_timesig(), The verbose message was replaced with just the key signature nn/denom. (6) Major additions were made to the function handletext() which now does more than just print text at the appropriate place. If the text string is a key signature or time signature as indicated by the type variable, then the key signature or time signature parameters are extracted. If it is a key signature, setupkey(sf) is called which does all the work of printing the K: field and setting up the tables for suppressing the accidentals. If it is a time signature, a M: %d/%d %d command is printed (time signature and pulses per quarter note). (7) The barsize variable was turned into a global variable like asig and bsig. (8) The function txt_timesig() was broken into two functions, txt_timesig and setup_timesig(). The new function setup_timesig() updates the global variables, asig, bsig and barsize. If unitlen was never set, it is also set as well as xunit. Because the notes are quantized in a separate pass, we must use a fixed xunit and unitlen for the entire file. Setup_timesig() is also called during the printtrack pass whenever handletext() detects a meter change. (9) Printtrack uses the barnotes counter to decide when to place a bar line. It is set to barsize at the beginning of each bar and it is decremented by each note. When it reaches zero a new bar line is issued. (It is done this way in order to handle anacrusis.) If barsize changes after the start of the bar it is necessary to correct barnotes. Printtrack keeps track of the previous barsize (last_barsize) and uses that to fix barnotes. (10) Added a new option -gk to force midi2abc to guess the key signature by minimizing accidentals even though the key signature is already indicated in the MIDI file. Normally it will automatically guess the key signature if no key signature is found in the file and the key signature is not specified with the -k parameter. Unfortunately, this was not all the needed changes. For multitrack MIDI files it is customary to reserve the first track for handling global operations such as tempo, key, meter changes, and text messages. The remaining tracks contain the actual music. In the case of multivoiced abc files, it is necessary to apply the meter change or key change to each voice. Therefore for each voice, midi2abc needs to also check the tlistx structure in track zero for any such changes. Another handletext() call was added to to printtrack to handle this situation. Abc2midi does not follow this convention exactly. For single voice abc files with possible bass/chord or drum accompaniment and possible Karaoke, it uses several tracks but it does not reserve track 0 for this special purpose. For multi voice abc files, abc2midi does use track 0 for this special purpose and places text and metatext commands grabbed from track one; however, because the delta times from the missing notes were not accounted for, the delta times for the time signature and key signatures are not correct. (They are all zero.) Fortunately, each track also has any key or time signature metatext commands with the correct delta times (assuming the abc file was notated correctly), so that information in track zero is not needed. The simplest fix was to suppress output of these meta commands in track 0. In writetrack (genmidi.c) a new flag 'timekey' was introduced to suppress MIDI commands for key/meter changes in track 0. The function setupkey does not work correctly after the first call to this function. After that, the accidentals are put in the wrong place. It was noticed that the array key[] is initialized to zero in the function findkey() instead of setupkey where it is actually used. Findkey() is normally only called once if it is called. The initialization code was moved to setupkey. October 25 2003 When the MIDI file has more than one key signature or time signature, the first key signature or time signature displayed in the header block reflects the last signature that was encountered in the MIDI file rather than the initial initial signature. This is corrected later on, however the abc file looks strange. To fix this problem new variables, header_asig, header_bsig, header_unitlen, header_keysig and header_bb were introduced. When parsing the MIDI file, they are set to the first time signature or key signature encountered. They are printed in the header block. For multitrack MIDI files, midi2abc prints out all the textual information for track 0 immediately following the end of the header block (first K: indication). This unfortunately may include a whole list of key signature or time signature meta text commands resulting in a correct but rather confusing abc file. To avoid this situation a new variable, trackno, was added to the function handletext. The function handletext now suppresses the K:, M:, and L: indications for track zero when the MIDI file has more than one track. October 26 2003 There are still circumstances where a redundant key signature or time signature is printed in the abc file. To avoid these situations new variables, active_asig, active_bsig and active_keysig were introduced. They are set to the current status. Before printing a new signature, the present status is checked and only changes are printed. November 9 2003 Midi2abc frequently fails to detect triplets in the MIDI file; even when it has been notated correctly using a music notation program. Therefore sets of triplets may be converted into D3/2D-[D/2-D/2]D A3/2B-[B/2C/2-]C| instead of (3D2D2D2 (3A2B2C2| which is another annoyance. Midi2abc.c has a special function called dospecial which attempts to detect broken notes (eg. C > D) and triplets; however, it does not seem to work consistently. The problem is that all notes are quantized to units of 1/32 or 1/16 notes, (depending on the meter). The length of a triplet note is 1/12 or 1/24 which does not get quantized exactly. Thus the representation of this sequence (calling scannotes in the debugger) appears as follows. Pitch 62 chan 0 vel 127 time 160 xnum 3 playnum 3 Pitch 62 chan 0 vel 90 time 160 xnum 2 playnum 3 Pitch 62 chan 0 vel 90 time 160 xnum 3 playnum 3 Pitch 69 chan 0 vel 90 time 160 xnum 3 playnum 3 Pitch 71 chan 0 vel 90 time 160 xnum 2 playnum 3 Pitch 60 chan 0 vel 90 time 160 xnum 3 playnum 3 time is in units of midi pulses, xnum and playnum are in quantized half units where xunit = 120 midi pulses. The time and xnum are the inter-onset time of the note (length between onset of this note and the next note). Playnum is the quantized duration of the note (from midi on to midi off). All of these variables are computed by the function quantize() in midi2abc. Note that 160 is not divided even by the half unit = 60. Playnum is rounded up but xnum compensates for the fact that it may have been too long in the previous note. The code in the function dospecial is far from transparent. It looks ahead one or two notes to determine whether this note and the following notes should be treated differently (either as broken or triplets) and uses the return character or featurecount array to signal to printtrack how to handle these notes. One of the tests in dospecial is the line just before the broken rhythm tests is (reformatted for clarity) if ((v2 < pnum) || (v2 > 1 + pnum) || (pnum == 0) || (v1+v2 > *barnotes )) { return(' '); where v1,v2 refer to the xnum values of this note and the next note and playnum is the playnum value of the next note. v2 happened to be less than pnum due to the adjustment discussed above, so the program returns from this function without testing for broken notes or triplets. I commented out /* (v2 default_length is placed in num, denom storage. CHORDOFFEX is a new feature type added to abc.h for handling this situation. Genmidi.c treats CHORDOFF and CHORDOFFEX the same way. A new function fix_enclosed_note_lengths was introduced to readjust the note lengths of all the notes in the chord in the event that it is set outside the enclosing brackets (i.e. CHORDOFFEX). The function tiefix now keeps track of the chord start ([) in the variable chord_start. When it encounters a CHORDOFFEX, it calls fix_enclosed_note_lengths. November 07 2004: -chord extension continued yaps: Unlike abc2midi, yaps only performs one pass through the abc file while preparing a very detailed layout of the music in a complex data tune data structure. You can view part of this structure by running yaps with the -d parameter. This data structure is passed to printtune() in drawtune.c. A new function fix_enclosed_note_lengths was created in the file yapstree.c to adjust the note durations. This function is called by event_chordoff when the parser encounters the end of a chord (']'). The new function does nothing if ] is not followed by a note length. Otherwise it corrects cv->barcount in order to avoid warnings regarding the number of beats in the bar. It replaces the note duration of each note in the chord with the new note duration. The function count_dots is called to replace the note duration representation. (There still seems to be a problem here.) abc2abc: Minimal changes in toabc.c were made. The function event_chordoff was modified to output the note length information following the chord if any and to correct the bar count. November 20 2004 The fix for handling chord extensions in yaps did not work properly and would frequently place tails on notes which should not have tails. It was discovered that chords have their own structure for indicating their PostScript representation and their tail is drawn by a function called drawchordtail. The yapstree.c function event_chordoff was modified to also update the chord structure when the chord extension occurs. Introduced a new folder called programming in the doc subdirectory and moved abc2midi.txt, midi2abc.txt and coding.txt into this folder. The folder contains some program implementation details. The file yaps.txt was renamed to yapshelp.txt. A new file yaps.txt describing the implementation of yaps was prepared. November 28 2004 Abc2midi new feature: all notes in a chord are started at the same instant. Inserting a short delay between the start of the notes in the chord would provide more control over the timbre. However to ensure that the music is not lengthened, it is necessary to ensure that all the notes end at the same time. Implementation of this feature was not easy due to the way the notes are handled are converted to MIDI commands in genmidi.c and the complexity of the queues.c code. MIDI note on commands are sent by a long chain of function calls starting with the function call to noteon(). Noteon() determines the velocity of the note from the beatstring and current context and then calls noteon_data(). Noteon_data() calls midi_noteon() and updates the tracklen. Midi_noteon() calls mf_write_midi_event which finally records the MIDI command. The MIDI command to stop playing the note is sent to a queue by the function addtoQ which is defined in the queue.c file. Finally if this note is not inside a chord, or if a end of chord feature has been encountered, the notes in the queue all processed by calling the function delay(). Delay() converts the note duration in MIDI tick units and calls the function timestep() which is defined in queues.c. The global variable delta_time indicates the time delay in MIDI tick units to execute the MIDI command. All MIDI command specify times relative to the time of the last command. Functions in genmidi.c generally reset delta_time to zero after sending a MIDI command. Otherwise, delta_time is adjusted by timestep() in queues.c. In order to control the delay intervals between notes in a chord, new global variables notecount, notedelay and totalnotedelay were introduced into genmidi.c. If notecount is greater than 1, delta_time is changed to notedelay and totalnotedelay is incremented by this amount. It is necessary to shorten the shifted notes by totalnotedelay so that they end at the same time. The new length is passed to addtoQ in queues.c. At the end of the chord, notecount and totalnotedelay are reset to zero. December 4 2004: (Continued from November 28 2004.) Unfortunately addtoQ does not know that the shortened notes have been shifted. When correcting the delay of the cached note in the structure, addtoQ now takes into account that the new note was shifted with respect to the previous note by notedelay which is also passed as a global variable. Finally, it was also necessary to adjust delta_time in timestep() by totalnotedelay. More comments were added to the code addtoQ and timestep in queues.c. The notedelay variable is set to 10 MIDI units as a default. (There are 480 MIDI units in one quarter note beat.) A new MIDI command %%MIDI chordattack n, was introduced in dodeferred() (genmidi.c) to allow the user to fine tune this variable. I do not recommend making this variable larger than the smallest note in the tune, (eg. 30 units if there are 1/16 note chords.) The abcguide.txt and abc2midi.1 documentation was updated. Thanks go to Hudson Lacerda for suggesting this improvement. Midi2abc outputs MIDI metatext commands as abc comments. In some cases they can be interpreted as pseudo comments causing undesirable actions by other software. For example, in the following the title MIDI program 17 is converted to metatext in the MIDI file. When midi2abc converts the MIDI file back to an abc file the text can be interpreted as a %%MIDI command. X:1 T:MIDI program 17 C:Hudson Lacerda M:12/8 L:1/8 Q:1/4=120 K:C %MIDI C,^C,D,^D,E,F,^F,G,^G,A,^A,B, | C^CD^DEF^FG^GA^AB | c^cd^def^fg^ga^ab | c'^c'd'^d'e'f'^f'g'^g'a'^a'b' | -- output from midi2abc -- X: 1 T: from (null) M: 12/8 L: 1/8 Q:1/4=120 K:C % 0 sharps %%MIDI program 17 %%MIDI C,^C,D, ^D,E,F, ^F,G,^G, A,^A,B,| \ =C^C=D ^DE=F ^F=G^G =A^AB| \ =c^c=d ^de=f ^f=g^g =a^ab| \ =c'^c'=d' ^d'e'=f' ^f'=g'^g' =a'^a'b'| As suggested by Hudson Lacerda, the fix is to add a space before the metatext. The sprintf statement near the end of the function txt_metatxt() was modified. Midi2abc should place the input file name in the title line instead of null. This has been changed. December 09 2004 Abc2midi new feature: introduced %%MIDI randomchordattack n. The delay between notes in a chord will vary randomly between 0 and n-1 MIDI units. It is recommended that n is not longer than the shortest chord. (If the shortest chord consisting of two notes is a 1/16 note then n should be not greater than 480/4 = 120. If there are three notes in the chord n should be less than 480/8 since the delays add up.) December 12 2004 - also see June 13 2005 New feature: chord extension applied to tied chords. In order for abc2midi to handle the syntax [CEG]3-[CEG]2 or something similar, it was necessary to make more changes in the code store.c. The code dotie() was not easy to figure out. To avoid working with this code, abc2midi patches up the feature,num,denom arrays so that it appears the same as if the old syntax [C3-E3-G3-][C2E2G2] was used instead. New functions, insertfeature() and removefeature() were written to insert or remove a feature in the middle of the arrays. The dotie() function was modified to also detect the CHORDOFFEX feature and treat it the same way as a CHORDOFF. The function fix_enclosed_note_lengths was modified to also catch the TNOTE feature and treat as a NOTE feature. A new function patchup_chordtie was introduced. The function stuffs a TIE feature after each note in the chord and returns the position of the first TIE. Many changes were made to the tiefix function(). Another local variable, chord_end was added. Chord_start and chord_end keep track of the feature index positions of the last chord scanned. If a TIE feature is immediately preceeded by a CHORDOFF or CHORDOFFEX feature, then that tie is stripped off and new ties are stuffed into the chord using the function patch_chordtie. Tiefix then backups into this chord so it can run dotie on all the internal ties. December 17 2004 Finished debugging chord tie feature. Tiefix no longer runs fix_enclosed_note_length when it backs up into the chord. Abc2midi: Limin Wang discovered and D.J. Bernstein reported two unprotected buffer overflows in store.c. This allows an attacker to gain control of the computer through a malicious abc file in an email message or from a web page that is fed into abc2midi. This applies to all versions of abc2midi. The buffers are now protected. Yaps, midi2abc: minor changes to reduce likelihood of buffer overflow. December 18 2004 Abc2midi new feature: Abc2midi recognizes the !f!, !pp!, etc indications and adjusts the audio level in the output MIDI file accordingly. Unfortunately this may get in the way for multivoiced abc files where the indications are placed in one voice but not the others. When the file is typeset by abcm2ps the output looks fine, but one of the voices is inaudible in the MIDI file. An example, is shown below. X: 1 T:ff_pp_1_1 C:ff_pp_1_1: the second voice is covered by the first one C:but the score could be interpreted as they both have to C:be played with the same intensity M:4/4 L:1/4 Q:1/4=100 %%MIDI transpose -12 %%staves (1 2) V: 1 clef=treble V: 2 clef=treble %V: 3 clef=treble % K:C %%measurenb 0 % [V: 1] G A c e | e c A G | A G A G | [V: 2] !ppp!C E E E | G E E E | F E D C | Things get more complicated when 2 or 3 voices share one stave (eg. classical guitar notation). It is not desirable to have to many "p"s printed over and under the stave. Abc2midi does not understand !crescendo! and !diminuendo! notation. A simple but not a perfect solution, is to introduce a new option in abc2midi which will tell abc2midi to ignore all dynamic indications. Fix: thanks to Michele for the code and suggestion. A new option -NFNP (no f no p) was introduced in store.c. Abcguide.txt and abcmidi.1 documentation was also updated. Abc2midi: Wrong tempo when L: missing in a multivoiced file. Abc2midi should assume a L:1/8 when the meter is 3/4 or larger and L:1/16 otherwise in the event that the default length of a note is not specified.. This works correctly for most abc files but fails in the following example. (The tune is played at the wrong tempo.) X: 1 T: no L M: 3/4 L: 1/8 Q: 80 V:1 clef=treble V:2 clef=treble K: G V: 1 abcdf2|gabcG2| V: 2 ABCDF2|ABCDF2| Analysis: abc2midi checks for missing L: in the function headerprocess() when it reaches the start of the tune body (the first K: field). If the note length, global.default_length, was not set at this point then it is set to 8 or 16. When a new voice is created by event_voice, it assumes a note length specified by global.default_length. In the above example, an event_voice is called prior to the start of the body so global.default_length is still undefined. The default_length for the voice remains undefined and abc2midi runs unpredictably. Fix: headerprocess now sets default_length to global.default_length for any voices that have already been created. January 1 2005 Abcmidi: does not handle a tie broken by a voice switch. In the following example, X:1 T: tie M: 2/4 L: 1/4 K: G V:1 AB-| V:2 cd| V:1 Bc| V:2 G2| the tie joining B is interrupted by a voice change. Abc2midi fails to join the notes. Fix: the functions tiefix and dotie now check for a voice change and do not attempt to tie notes belonging to different voices. Abcmidi: abcmidi fails to assign the channel to correct program (musical instrument) for the first note in a multivoiced abc file. In the following example: X:1 T: MIDI program M: 2/4 L: 1/4 V: S clef=treble name="Soprano" V: A clef=treble name="Alto" %%MIDI program 1 60 %%MIDI program 2 60 K: G V: S G A|B C|G A|F G| V: A z2|G A|F G|G A| The first note G is played on the piano instead of the French Horn as indicated by the command %%MIDI program 1 60 Analysis: the MIDI indications are inserted into the track number associated with the voice. In this example, voice A is mapped into track 2 and all the program indications are put into track 2. The midi player processes the tracks sequentially and does not see the program change in time to affect the first note in voice S so it is played on the default instrument, acoustic grand (piano). The simplest fix is to ensure all the MIDI indications go into the first voice as shown here. X:1 T: MIDI program M: 2/4 L: 1/4 V: S clef=treble name="Soprano" V: A clef=treble name="Alto" V: S %%MIDI program 1 60 %%MIDI program 2 60 K: G V: S G A|B C|G A|F G| V: A z2|G A|F G|G A| Alternatively you can place the %%MIDI program indication in the voice that it affects. (The channel number is no longer needed then.) See below. X:1 T: MIDI program M: 2/4 L: 1/4 V: S clef=treble name="Soprano" V: A clef=treble name="Alto" V: S K: G V: S %%MIDI program 60 G A|B C|G A|F G| V: A %%MIDI program 60 z2|G A|F G|G A| I shall update abcguide.txt regarding this issue. January 8 2005 Another exploitable error in store.c was found by Anselm Lingnau which causes a buffer overflow for %%abc-copyright. A fix using the snprintf routine was suggested. The snprintf routine is a recent addition to the C compiler; for those running older compilers you will need to download a portable GPL implementation of snprintf() from http://www.ijs.si/software/snprintf in order to compile and link abc2midi. (In case the web site changes, search for snprintf portable implementation.) If you are running an old or nonstandard operating system for which there is little likelihood of a buffer overflow exploit taking over your computer and it is too cumbersome to include snprintf, then you can define NO_SNPRINTF (in store.c) and it will use sprintf. Michele has added an additional correction to the broken tie fix I made on January 1 2004. In order to handle the following example which includes a chord in voice 2. X:1 T: tie M: 2/4 L: 1/4 K: G % V:1 AB-| V:2 [dA]c| V:1 Bc| V:2 GG| it is necessary to add if(localvoiceno != voiceno) break; after case CHORDOFFEX: in the function dotie. January 9 2005 Abc2midi: new decorations !arpeggio! and !breath! are introduced. When the !arpeggio! instruction precedes a chord, the notedelay time is temporarily set to three times its normal value. For the time being, the !breath! instruction is treated exactly the same as a staccato marking. (i.e. the length of the note is halved and followed by a rest of the same value.) Implementation: a new decoration BREATH was added and a new feature ARPEGGIO was added in abc.h. In store.c, additional code was added to event_handle_instruction to handle the !arpeggio! and !breath! commands. In event_note, both STACCATO and BREATH decorator flags are checked and treated the same way. New global variables staticnotedelay and staticchordattack were added and linked to notedelay and chordattack in several places. In writetrack, genmidi.c, a separate case statement in the main switch statement was introduced for ARPEGGIO. It changes the values of notedelay and noteattack to 3 times its nominal value. (They are restored back to their nominal values after a CHORDOFF or CHORDOFFEX feature.) Jan 22 2005 Abc2midi: a missing break statement caused abc2midi to crash when encountering !arpeggio!. Added a tune demonstrating the !arpeggio! instruction to demo.abc. Midi2abc: normally midi2abc groups the notes forming a beat together so that abc*2ps produces a pretty output. For some raw abc output, (eg.) B3/2z4^dz/2e3/2z3/2| it is easier to edit it if there is a space between every note (eg.) B3/2 z4 ^d z/2 e3/2 z3/2| A new option -nogr has been added to midi2abc. If it is included as one of the run time options, then a space is inserted between all notes that are not in triplets. Changes were made to printchord and printtrack in midi2abc.c. (Search for nogr to see changes.) February 03 2005 Abc2abc: introduced a new run time parameter -usekey. This is a generalization of the -nokeys -nokeyf transformation which converts the music representation to the key of C inserting any accidentals to preserve the original key signature. Now you can force abc2abc to represent the music in any key signature. The -usekey parameter is followed by a number specifying the number of sharps (positive number) or number of flats (negative number) in the desired key signature. Implementation in toabc.c: if usekey parameter is set to a nonzero value, the nokey parameter is set so that event_note2 is used to process the note. Setup_sharp_flats adjusts the arrays flatsym and sharpsym to match the desired key signature. The function printpitch prints the notes using these two arrays. February 04 2005 Abc2midi: It has been proposed that a new option be introduced that would propogate dynamic indications (pp, ff, etc) from voice 1 to all other voices so that they need only be declared once in voice 1. This would provide another solution to the problem discussed in December 18 2004 resulting in the introduction of the -NFNP option. Introduction of this feature is deferred for the time being but here is a description of what is involved in implementing such a feature. When parseabc.c sees an instuction eg. !ff!, it calls event_instruction (in parser2.c) which calls split_string which calls event_handle_instruction (in store.c). Event_handle_instruction interprets the instruction and calls event_specific with a MIDI beat x x x x command. Event_specific passes the string to textfeature which adds an entry DYNAMIC to the feature array and a pointer to the string in the pitch array. Note the feature array is used to handle all the voices, and the list of voice features are separated by VOICE entries. The problem is that it is impossible to propogate the DYNAMIC instructions to the other voices because the other voices may not exist (in the case the voices are specified serially in the abc file). The function writetrack in genmidi.c separates the specific voice from the feature array and creates a separate MIDI track for each voice. To address this problem, we would leave the code in store.c and parseabc.c however we would need to change writetrack in genmidi. Writetrack would now have to keep track of the beat number when processing a voice. When a DYNAMIC feature is encountered in voice 1, the beat number where this has occurred would be stored in an array, along with a pointer to the dynamic indication string. For all other voices, the DYNAMIC feature would be ignored but instead the beat number would be compared with the beat number where the dynamic indication occurred and dodeferred would be called when the beat number equals or exceeds the numbers cached away for voice 1. Worked on this project is deferred for the present time. February 05 2005 Abc2midi tie bug: For the file X:1 T: tie bug M: 2/4 L: 1/8 K: G [FA]-[FA] FA| abc2midi fails to tie the F# note. Fix: replaced the line 737 (in removefeature) in store.c pitchline[i] = pitch[i+1]; with pitchline[i] = pitchline[i+1]; February 12 2005 (also see June 13 2005) Michele reports the following bug in the function dotie in store.c. For the following tune, % X: 1 T: Tie bug M:C L:1/4 K:D [V: 1] | f/e/g/f/-f2 | [V: 2] | d3/2 d/-d2 | abc2midi returns the message Error in line 7 : Could not find note to be tied. The message is wrong, since abc2midi handles both ties correctly. Michele added the conditional break statements if(localvoiceno != voiceno) break; after case TIE: and after case CHORDON: which seems to fix the problem. Analysis: The function dotie is a real birds nest of code. Here is a description of how it works. Dotie is called by tiefix when a TIE feature is encountered. It has two parameters, j the index in the feature array where TIE was encountered and xinchord, a flag indicating whether the TIE is enclosed in a chord (eg [A-B] A). The reason for the complexity of the code is because the function dotie is controlled by three semaphores tietodo, done, and tied_denom. To start, dotie searches backwards for the note preceding the tie, and calls its address (in the feature space) tienote. It changes feature[tienote] from NOTE to TNOTE. It changes feature[j] from TIE to REST and sets the rest length to that of tienote (so they are both the same). Finally it sets the semaphores done = 0; tied_num = num[tienote]; tietodo = 1; which controls the stopping conditions of the following while loop that searches for the following note to be tied to tienote. Now the fun begins. To simplify things assume we do not have chords. The loop begins with the variable place set to j, the original position of the TIE now converted to a rest. So the first feature in the loop is guaranteed to be a REST. case REST: subtracts the length of the rest from tied_num so it is back to zero. Now the semaphores are done = 0; tietodo = 1; tied_num = 0; The loop variable place is incremented and now feature[place] probably points to a NOTE. Case NOTE: since tietodo is not zero the function compares the pitches (pitchline) of place and tienote. If they are equal, the tienote length is increased by the place note, the tied_num semaphore is also increased by the place note. Feature[place] is changed from a NOTE to a REST and to make things more confusing, if we are not in a chord the length of tied_num is now decremented by the place note so that it is back to zero. Finally the tietodo variable is also set to zero indicating that we have finally joined the two notes in the tie. The semaphores are now: done = 0; tietodo = 0; tied_num = 0; Unfortunately the while loop does not stop here and this is the reason for the spurious error message described above. In order for the while loop to stop, the variable done must be set to a nonzero value. This usually happens when the next NOTE or REST is found. In the above example, the next note is found in a different voice. The remedy is probably to end the while loop when tietodo is zero. However, since the code is working fine now I am rather reluctant to try it in case another bug surfaces. Feb 13 2005 Abcmidi /abcm2ps incompatibility problem for decorations applied to chords. It is perfectly normal to apply a fermata or a staccatto to a chord, eg H[C2E2G2] or .[CEG]; in fact abcm2ps prefers that you do it this way rather than [.C.E.G]. Abc2midi handles both notations correctly but it sends the following warning message if you use the former convention. Warning in line 6 : decorations applied to chord Nevertheless, abc2midi sends the chord decoration to each note in the chord and everything works fine provided you don't attempt to apply roll, trill or ornamentation to a chord. In the later case you receive an error message and the decoration is not applied. It is therefore preferable that parseabc does not produce this warning when abc2midi is running. Fix: it is convenient if parseabc.c knows which program is running (i.e. abc2midi, abc2abc or yaps). A new typedef programname which distinguishes ABC2MIDI, YAPS, and ABC2MIDI was added to abc.h. A programname variable called "program" was added as a global variable to store.c, yapstree.c and toabc.c and set to proper value. The program variable is linked to parseabc.c as an extern global. This variable is used to fine tune parseabc.c. Unfortunately not everything is well with yaps and abc2abc. Like abc2midi, the chord decoration is applied to every note in the chord. In the case of yaps, this does not produce an aesthetically pleasing result. Since yaps is not the preferred postscript converter and I am also not very knowledgeable of its internals, yaps shall remain as it is and the warnings serve a useful purpose. In the case of abc2abc, it is not desirable that it automatically converts H[A2C2E2] to [HA2HC2HE2] or something similar. A few more changes are necessary. It was necessary to introduce a new parameter (chorddecorators) into the function event_chordon. This entailed making changes to parseabc.h, parseabc.c, store.c, yapstree.c and toabc.c. In store.c and yapstree.c the new parameter is not used; however, in toabc.c extra code was added to event_chordon to print out any decorations applied to the chord. In parseabc.c the decorators were not inherited from the chorddecorators when parseabc.c was linked to toabc.c. Unfortunately event_chordon is also called by the function event_chord which handles the obsolete form of chords +CEG+. For store.c, yapstree.c and toabc.c, I introduced a global array dummydecorators[DECSIZE] which is initialized to zero's in event_init. This array is used in event_chord. February 14 2005 Abc2abc prints garbage in the V: field (reported by Hudson Lacerda). Given a normal file : X:1 T: abc2abc V: bug M: 4/4 L: 1/8 K: C V: 1 CDE FGABC| def gab c'2| V: 2 C8|C8| abc2abc outputs X: 1 T:abc2abc V: bug M:4/4 L:1/8 K:C V:1 name=(LI CDE FGABC| def gab c'2| V:2 name=(LI C8|C8| Analysis: the local variable gotname in the function parsevoice in parseabc is never initialized to zero. The problem was fixed by adding gotname = 0; February 21 2005 Microtone note capability has been introduced into abc2midi. A _/ means lower the pitch of the following note by a half a semitone. A ^/ means raise the pitch of the following note by a half a semitone. The microtone notation does not propogate across a measure but applies to only the immediate note. For chords in the same channel (voice), the microtone will apply to both notes no matter how it has been notated. For example [C_/E] is the same as [_/C_/E]. Following the convention in abcm2ps, (see features.txt in abcm2ps distribution), _3/4C will depress C by 3/4 of a semitone. It is assumed that the pitch range of the MIDI synthesizer pitch wheel is + or - two semitones in compliance with the General MIDI specifications. The maximum permissible pitchbend is therefore 2 semitones. Implementation: added a new function ismicrotone() called by parsenote() in parseabc.c. I also introduced functions event_microtone() and event_normal_tone() in store.c, yapstree.c and toabc.c. There has been no change to the operation of yaps or abc2abc. February 26 2005 Finished microtone implementation and added microtone documentation in abcguide.txt. March 12 2005 Abc2midi: There is a loss of synchrony in multivoiced files when a fermata is applied to notes of unequal lengths. For example: X:1 T: Fermata M:2/4 L:1/4 K: G V:1 cdef|B2 Hc2|gabc| V:2 efga|DHe3|gabc| the fermata is applied to c2 and e3 for voices 1 and 2. The fermata doubles the length of the notes c2 and e3 and there is a loss of synchrony between the voices in the next bar. Solution: I introduced new MIDI commands which control how the fermata is applied. %%MIDI fermatafixed The fermata adds a unit lengths to the note so HC2 is played C3. %%MIDI fermataproportional (default) the unit length is doubled so HC2 is played C4. Implementation: added new global flag fermata_fixed and modified event_specific to set this flag. Modified FERMATA treatment in event_note and event_rest. March 18 2005 Microtones in abc2midi. It is not clear whether the microtone notation should be treated as an accidental or a decoration. The abc2midi software treats it as a decoration. Thus in the following: X:1 T:micro Q:60 K:C =C ^/C ^C _/D D _/D ^C ^/C =C the second to last note ^/C is played as ^^/C since the accidental in the previous note propogates across the measure. If you want =^/C you must specify it in this manner. If ^/ and _/ satisfy the rules of accidentals then, they would be interpreted the same way as double sharps and double flats. Thus if you wrote ^^F E ^F G: the first note would be played as G and the third note would be played as F#. (You would not write ^^F E ^=F G.) It is not clear from the abc standard, the meaning of the following: [K: G] ^/F D E G| Is the first note a F natural raised a quarter tone, or is it a F# (as indicated by the key signature) raised by a quarter tone? Presently abc2midi treats it as the latter. To treat the notation as accidentals would mean that the quarter tones would propogate across a measure like sharps and flats. This would require introducing more code into abc2midi. (Further there would be other issues relating to transposition in abc2abc.) March 19 2005 abc2midi optional guitar chord syntax. The function event_handle_gchord in store.c was modified to ignore the parentheses in the guitar chord. (eg. "(C)" CDEF etc. ) The optional guitar chord is played. March 25 2005 abc2midi: note tied to two notes. In the following sample the tied note is not played correctly in the repeat. X:1 T: note tied to two notes M: 2/4 L: 1/8 K:G %%MIDI program 73 |:G2D2|ABCD-|[1 D4 :|[2 D2 G2| Unfortunately this is a difficult problem to fix. Store.c creates a feature/pitch/num/denom arrays which tells writetrack in genmidi.c how to create the MIDI file. Repeat actions are encoded into the feature array using the instructions BAR_REP, REP_BAR, PLAY_ON_REP, etc, which instruct writetrack to backtrack in the feature array and repeat certain sections. In other words the repeats are not expanded until writetrack creates the MIDI track. Tied notes are handled by the function dotie in store.c that determines which notes are tied and combines the tied notes into one note instruction in the feature array. In the above example, the tied note D-D4 in the first repeat and D-D2 in the second repeat have different durations. Dotie can only assign the D tied note one duration so it will be wrong in one of the repeats. To make things worse the code in dotie is unmanageable (see comments February 12 2005). To fix the problem the joining of ties, it would need to be done at the time that the repeats are expanded in writetrack rather than in a separate pass performed by dotie in store.c. The handling of ties is messy because they can also be embedded in chords; they cross barlines introducing problems with accidentals in music notation; interleaving of voices breaks up ties; we want abc2midi to gracefully handle tie syntax errors provide useful error message. Multiple repeats (eg |...|[1...|[2,3...|[4... :|) introduce another headache. One way of avoiding this problem is to notate the above sample differently as shown below. X:1 T: better way of handling tied notes in repeats M: 2/4 L: 1/8 K:G %%MIDI program 73 |:G2D2|[1 ABCD-| D4 :|[2 ABCD-| D2 G2| There is now five bars instead of four, but it avoids the above problem. Abc2midi: an alternative method for embedding %%MIDI commands. The syntax for placing %%MIDI instructions in the abc file requires that each command occupies a separate line in the abc file. This makes the resulting file look messy when you want to do drumon, drumoff, gchordon, gchordoff, in the middle of a line. The problem gets worse when the abc file also has lyrics included using the w: field command. It has been suggested that there should be an option to place MIDI instructions in the information field: eg.[I: MIDI drumon]. Abc2midi does have provision to parse inline I: fields using the function event_info. However, the code expects the field satisfy a specific syntax of the form [I: key1 = value1 key2 = value2 etc.] Thus you specify as many keys as you wish in the I: field. So far I have modified the function event_info_key in store.c so that it will now forward any info field commands of the form [I:MIDI = stuff] to the function event_specific which handles all %%MIDI commands. Thus you can now do the following. X:1 T: event info used for MIDI M:4/4 L:1/4 K:G [I: MIDI = program 70] DDEE|[I:MIDI=program 42] GEFG| instead of X:1 T: event info used for MIDI M:4/4 L:1/4 K:G %%MIDI program 70 DDEE|\ %%MIDI program 42 GEFG| Any %%MIDI command described in abcguide.txt may be embedded in the I: field; however the '=' is very important. Otherwise abc2midi will assume this field is just for the user's interest and just ignore it. Here is another example: X:1 T: event info used for MIDI M:4/4 L:1/4 K:G [I: oboe MIDI = program 69 MIDI = gchord fzcz MIDI = chordprog 1] BAG2|\ "G" EC GG|[I:MIDI= bassprog 100] DDDD|[I: MIDI =gchord ffffffff] G4| March 28 2005 Acciaccatura grace note notation. Abcm2ps compatability feature. Abc2mps accepts the notation {/b}a where the slash before the b tells it to display the grace note b as an acciaccatura. Parseabc.c does not understand this notation and returns an error message "Unrecognized character /". Fix: parseabc.c was modified to keep track whether it is inside a grace sequence using a new global variable ingrace. When the function parsemusic encounters a / that is not a note length indicator, it will call event_acciaccatura if ingrace flag is set. This function does nothing in abc2midi and yaps but it prints the / character in abc2abc. April 02 2005 Abc2midi does not handle microtones properly in multivoiced files. For example in, X:3 T:Miudezas C:Hudson Lacerda M:none Q:1/8=132 "ca." L:1/8 K:none clef=treble V:1 name="Clarineta em Sib" {=B}_/G {=B}^g | {=B}^F {_/e}=B {_/e}^/c' |\ {_/e}_/G {_/e}_/d' {=a}_/e | the first note B (grace note) was affected by the microtone which was intended to be applied on the second note G. Analysis: Multivoiced files (i.e. using V:1, V:2 etc.) place a header track (track 0) in the MIDI file where global DYNAMIC features such as %%MIDI program may be defined for all other voices.Since the microtone uses the %%MIDI pitchbend, it is also treated as a DYNAMIC feature. As a result the header track contains many pitchbends but no notes. This unfortunately handles all other notes in channel 0 in a random fashion. Fix: a new parameter, noteson, was introduced into the function dodeferred which handles all DYNAMIC features. Noteson is also a local variable controled by writetrack to specify whether NOTE features are to be processed by writetrack. This flag is now also used by dodeferred to determine whether pitchbend MIDI commands are to be inserted. April 07 2005 Introduced a new feature to midi2abc. Midi2abc.exe -mftext will now produce a mftext output of a specified input MIDI file. It was preferable to build mftext into midi2abc since I changed the output format; also runabc already links to too many executables and I would not like to keep track of version numbers for another program. April 09 2005 I have modified toabc.c (abc2abc) so that it will no longer transpose voices assigned to the drum channel (%%MIDI channel 10). Implementation: added a new entry, drumchan, in the voicetype structure which indicates whether this voice is to played on drums. Also added a new global, drumchan which is linked to voice.drumchan for the currently active voice. The event_specific function has been extended to catch %%MIDI channel 10 and update drumchan. The function setvoice() initializes voice[].drumchan to 0 when a new voice is created. The functions event_note1 and event_note2 now check the drumchan flag before transposing the note. April 10 2005 Abc2abc - abcm2ps compatibility issue. Abc2abc does not recognize the sname= "...". Fix: introduced new function parsesname in parseabc.c added new parameters to event_voice in parseabc.c, store.c, yapstree.c and toabc.c. (See September 26 2004 in this file for more details.) April 15 2005 Midi2abc: fixed problem causing midi2abc to crash when the MIDI command indicating the time signature is missing from the file. April 22 2005 Abc2midi: pitchbend inside a tied note. In the following example, the third note is held too long. X:1 T: bends M: 2/4 L: 1/8 K: G %%MIDI program 60 G4|G4|G2-_/G2|G4| Fix: in function dodeferred() (genmidi.c) for command == pitchbend, added tracklen = tracklen + delta_time; delta_time = 0L; after write_event(pitch_wheel, chan, data, 2); Also listen to the example 11 in demo.abc. April 23 2005 Abcmidi: introduced two more MIDI commands. %%MIDI portamento n turns on the portamento controller on the current channel and sets it to n. n is a 7 bit number which specifies the rate slides the pitch between two notes. (Unless you are composing 20 th century classical music, you may not wish to use this feature. Avoid slides between large pitch intervals.) %%MIDI noportamento turns off the portamento controller on the current channel. April 24 2005 Integration of abcmatch into abcmidi package. The main() function in parseabc.c was moved into store.c, yapstree.c, and toabc.c .The function parsetune was placed in parseabc.c. All makefiles were updated. (I cannot verify all of them; report any corrections to me.) The files abcstore.c and abcparse.c are no longer needed; delete them if they are lieing around. April 29 2005 Cleaned up all the compilation errors that occur in Microsoft Visual C version 6.0. May 03 2005 Abc2midi abcm2ps compatability feature: add new %%MIDI command %%MIDI beatmod n where n is a positive or negative integer. The command will increment (decrement) the loudness of the on beat, off beat and other notes by the amount n. Introduced new instructions: !<(! or !<)! or !crescendo(! or !crescendo)! which act like %%MIDI beatmod 15 Also !>(! or !>)! or !diminuendo(! or !diminuendo)! act like %%MIDI beatmod -15 Thus a pair of !<(! and !<)! does two loudness increments. One at the beginning of the crescendo and one at the end of the crescendo. This is not a gradual change but it is better than doing nothing. If the default beatmod value (15 or -15) is not ideal, you can change it using %%MIDI deltaloudness n where n is a positive number. Sample test file below: X: 1 T: crescendo M: 2/4 L: 1/8 K: G %%MIDI deltaloudness 20 !mf!cdef|edcB| !<(! cdef|!<)! edcB|AAAA| !>(! cdef|!>)! edcB|AAA| !crescendo(! cdef |!crescendo)!|edcB|AAA| !diminuendo(! cdef |!diminuendo)!|edcB|AAA| Implementation: updated dodeferred in genmidi.c, added global velocitychange in store.c and new code in event_specific and event_handle_instructions. abcguide.txt and abc2midi.1 documentation were updated. May 06 2005 It has been suggested that some abc2midi options could be global when they are used outside of a tune. For example: %%MIDI chordname %%MIDI ratio %%MIDI beat %%MIDI program It is rather difficult to add this feature since the handling of these options is not centralized but spread out in the store.c and genmidi.c code. Some of these options apply to specific voices which do not get instantiated until the voice is defined in the tune. This makes the full implementation rather formidable. I have introduced new code event_specific_in_header in store.c that attempts to handle some of the MIDI directives. Many of the MIDI directives send information to the feature[] array which does not exist prior to parsing the tune. I have not attempted to handle those directives. Presently, the only MIDI commands that will be recognized outside the tune are %%MIDI C %%MIDI nobarlines %%MIDI barlines %%MIDI fermatafixed %%MIDI fermataproportional %%MIDI ratio %%MIDI chordname %%MIDI deltaloudness All other MIDI commands outside the tune are ignored and will produce the warning "cannot handle this MIDI directive here". The following is a sample test file. %MIDI C 48 %%MIDI nobarlines %%MIDI ratio 5 1 %%MIDI chordname ugly 1 2 3 4 X: 1 T: test global settings M: 2/4 L: 1/8 K: C "G"CDEF|"Gugly" D>EF>C|^ABDA|AAC2| May 08 2005 Abc2midi: voice splitting. In some pieces of music a voice splits in two or more voices only in some measures. The new abc standard (and abcm2ps) provides a syntax for splitting a voice in a bar using the & symbol. When placed within a measure, it splits the current voice and attributes the notes that follow to the second voice. Voice splits are handled by creating separate voices which are in turn converted into separate MIDI tracks. To implement this feature, new variables were introduced into the voice structure defined in store.c int nbars; /* counts number of bars processed in voice */ int tosplitno /* points to new voice to handle split */ int fromsplitno /* points to voice initiating the split */ Both tosplitno and fromsplitno are intialized to -1 implying that a split voice does not yet exit. In an event of a split, tosplitno points to the new voice to go to. If it is -1, a a new voice needs to be created, and fromsplitno in the new voice is set to the voice from which initiated the split. In order not to confuse the new voice number with a voice number generated by a V: field, the split voice numbers start from 32. Global variables in store.c were introduced. int numsplits; /* keeps track of the number of split voices generated */ int splitdepth; /* keeps track of the number of splits in a bar */ A new function event_split_voice in store.c is called by parsemusic in parseabc.c when a '&' is encountered in a music line. A new function resync_split_voice adds bars of rests into the split voice so that bar is in the right position. A new function complete_all_split_voices ensures all split voices are the right length in order to avoid annoying messages like: Warning in line 7 : Track 2 is 3840 units long not 4800 A new function recurse_back_to_original_voice is called to recover from a split when a new bar line is encountered (see event_bar). Sample test file: X: 1 T: testing voice split M: 2/4 L: 1/8 K: G A4| G4 & e2g2|BGEE|CAEE & d2f2|F2G2| May 12 2005 Wrote a new function dumpfeat(n1,n2) in genmidi.c which prints out the contents of the feature,pitch,num,denom array between n1 and n2. The function is usually called in the debugger after stopping at a breakpoint in finishfile. May 13 2005 Abc2midi split voices: Problems occur when the music contains repeats. It is necessary to transfer the repeats to the split voice. The function event_bar checks for any repeat symbols. There are two cases. If we are already in a split voice then (eg. abcd & defg :|) we have to propagate the repeat back to the original voice while recursing back. If we are not in a split voice but we know that this voice does link to split voices, then we (eg abcd & defg |abcd :|) need to propagate the repeats downwards to the all the split voices. The function event_playonrep is also called by the parser and needs to check for split voices. May 14 2005 Now there is still another problem: the parser might encounter a repeat symbol before it knows that this voice splits. We must find a way of getting those repeat codes into the newly created split voice. Solution: a new function start_new_voice_and_sync is called when a split voice is first created. It scans the parent voice copying rests and various types of barlines and repeat codes into the feature array of the newly created voice. If it encounters a %%MIDI program, that is also copied. This way the new voice also inherits the same music instrument as its parent. If you wish to change the instrument of the split voice, you can do it this way. C2 EF & [I:MIDI= program 10] F2 D2| The new instrument will apply to all following bars of the split voice. Abc2abc was made split voice compliant. May 19 2005 Midicopy: will now return the playing time of the extracted segment. This only works when a segment is extracted using any combination of the -from and -to runtime parameters. Otherwise it returns 0.0. The program makes adjustments for any tempo changes that may occur inside this segment. May 21 2005 Corrected a bug in midi2abc. It was returning the time in seconds instead of beats when running with the -mftext option. May 22 2005 Midicopy: for some reason the meta command mf_write_tempo (which originated from midifile.c) alway writes delta_time 0. As a result all tempo meta commands are at the wrong time. When this was changed, tempo changes seem to be handled better. Midicopy now caches all tempo changes in a array of structures called tempo_array. This is used to update the current_tempo when other tracks (not containing tempo commands) are processed. The correct tempo is needed in order to get an accurate estimate of the playing time of the output file. A new function update_current_tempo is called each time Mf_currtime is updated. May 28 - 31 2005 June 04-06 2005 Midi2abc often produces a mess for piano music sequenced into a single track. There are many chords played by the left hand and the right hand usually has a different rhythm. Midi2abc tries to place all notes sounding at the same time into a single chord. To handle notes of different durations, some notes are tied to the next chord and others are not. The resulting output looks something like this. X: 1 T: Scarlatti, sonata 1 %***Missing time signature meta command in MIDI file M: 4/4 L: 1/8 Q:1/4=120 % Last note suggests Phrygian mode tune K:F % 1 flats % (C) John Sankey 1998 z/2d/2 (3efga/2-[a/2A/2] _d/2A/2[=d/2-D/2][d/2-E/2]\ [d/2-F/2]d/2-[d/2-G/2][d/2-A/2]| \ [d/2A,/2][e/2-_D/2][e/2A,/2][f/2=D/2-] [d/2D/2]z/2[g/2E/2-][e/2E/2]\ [a/2F/2-][f/2F/2][e/2G/2-][d/2G/2] [_dA]z/2[a/2-A/2-]| \ [a/2A/2][b/2A/2-][b/2a/2A/2] etc... Converting it to PostScript file produces something very difficult to read. Ideally the notes played by the different hands should be separated into two tracks. Chords should avoid internal tied noted. The abc standard contains the provision for splitting the notes in a single bar into separate voices. This should provide a means of simplifying the output. A new runtime parameter -splitbars was introduced, producing an output similar to below. X: 1 T: Scarlatti, sonata 1 %***Missing time signature meta command in MIDI file M: 4/4 L: 1/8 Q:1/4=120 % Last note suggests Phrygian mode tune K:F % 1 flats % (C) John Sankey 1998 z/2d/2 (3efga zd3- & \ z3A/2_d/2 A/2=D/2 (3EFGA/2A,/2 &\ d/2efgazd/2 z2| \ (3ef/2d/2z/2Ea/2f/2Gz2z/2 (3b/2a/2b/2 &\ EF GA A,_D/2A,/2 =Dz/2g/2& \ z3e f/2d/2z/2Ea/2f/2G/2-| b/2a/2b/2 etc.... Implementation: Separating the parts is complicated and incorporating these algorithms into midi2abc.c was even more difficult. The anote structure was extended to contain two new values. Posnum stores the position of the start of the note in xunit units. Splitnum assigns the note to one of several split voices. New functions label_split_voices and label_split scan the entire track and separate all the notes into separate parts when necessary. A note is assigned to an existing part if it follows the previous note or forms a chord matching the length of the previous note. Otherwise, label_split_voices searches for another active part satisfying this criterion. If there is no active part available, the note is put into a new part. Bar lines are ignored at this stage. Once all the notes are labeled into separate parts, the xnum value associated with the notes are updated so they indicate the number of units to the next note in the same part. A new version of printtrack called printtrack_with_splits was created from the printtrack code. In order to use as much of the original printtrack code, it make multiple passes through the same bar whenever the bar contains notes from different parts. In each pass a single part active in this bar is processed and printed. The code is barely working and is still experimental. It will probably not produce correct results for complicated MIDI files. Fortunately most MIDI files have proper chords and do not require this feature. June 04 2005 A problem with abcmatch.c causes it to return a bad xref number after processing the last tune in the file. This causes runabc.tcl to report an error similar to Error: can't read "tuneid(84)" :no such element in array. when running extras/grouper. The problem is that the notes variable in abcmatch.c does not get initialized to zero if parsetune() fails because it encounters an eof. To fix the problem, the function startfile() in matchsup.c is made global instead of static and it is called prior to calling parsetune() in abcmatch.c. June 10 2005 Midi2abc -splitbars: fixed segmentation error which occurs for tracks not containing any notes. June 13 2005 Abc2midi: "Time mismatch at tie" error when chord length declared outside of chord. X:1 T: multiple tie M: 2/4 L: 1/8 K:C [CE]/2-[CE]/2-[CE]|[CE]/2-[CE]/2-[CE]| K: G [C-E-]/2[CE]/2 [F2D2] [FD]| [C/2-E/2-][C/2E/2] [F2D2] [FD] | Abc2midi does not tie notes correctly in the above example. The chord extensions in November 4 2004 and December 12 2004 do not work correctly in combination. The problem occurs in the function dotie in the lines case CHORDOFF: case CHORDOFFEX: if(localvoiceno != voiceno) break; inchord = 0; /* subtract time from tied time */ addfract(&tied_num, &tied_denom, -num[place], denom[place]); break; after addfract subtracts num/denom from tied_num/tied_denom, tied_num should be zero. However, tied_num/tied_denom was not yet adjusted by fix_enclosed_note_length, so tied_num/tied_denom is not equal to num[place]/denom[place]. Since dotie finds tied_num to be non-zero in code /* tie in note */ if (tied_num != 0) { event_error("Time mismatch at tie"); }; it thinks that the notes inside the chord have unequal lengths and reports the time mismatch error. Furthermore, fix_enclosed_note_length is eventually called after the notes were tied making a further mess. Fix: Instead of calling fix_enclosed_note_length in a separate pass during tiefix, fix_enclosed_note_length is called during the parsing stage whenever a CHORDOFFEX feature is added (see event_chordoff). The variable nochordfix is now redundant and removed from the code. This guarantees that dotie sees the correct note lengths inside the chord. June 14 2005 Abc2midi: chord ties. In the following example, X:1 T: multiple ties M: 2/4 L: 1/8 K:C [CE]/2-[CE]/2-[CE]-|[CE]/2-[CE]/2-[CE]| The E notes are not joined. Fix: the function call patchup_chordtie was moved from tiefix to event_tie. In addtoQ (queues.c) a check for negative delay caused by apeggiate code Q[*ptr].delay = Q[*ptr].delay - wait -notedelay; if (Q[*ptr].delay < 0) Q[*ptr].delay = 0; was added. June 17 2005 Midi2abc: fixed bug in -splitbars causing program to go into an endless loop and various other bugs. June 25 2005 Midicopy: added line void WriteVarLen() in function mf_write_tempo to be compatible with the new gcc compiler. June 25 2005 Abc2midi: tieing repeated notes inside chords. Abc2midi returns a "Time mismatch at tie" error message for the following file. X: 1 T: tie M: 2/4 L: 1/8 K: C [CC]-[CC]-[CC]z| Analysis. The line is converted to [C-C-][C-C-][CC]z| and the function dotie attempts to tie C to the next note it sees which is the next C inside the same chord. This changes the length of the note in the chord leading to the above error message. Fix: a new variable samechord is introduced. When it is set to 1 it signifies that we are in the same chord where the tie mark - was placed, we do not link the tienote to any notes in that same chord. The flag samechord is cleared whenever we leave the chord (CHORDOFF or CHORDOFFEX). It is set again whenever a tie mark occurs inside a chord is encountered. Please note: a tie only connects one note. Therefore C-[CC] will tie C to only the first C in the chord. June 26 2005 Abc2midi does not correctly handle more than one bar split. In the following example, X: 1 T: testing voice split M: 2/4 L: 1/8 K: G %%MIDI program 24 A4 & c4 |G2F2 & BBDD & E,,4| E,,4 is played in the first bar coincident with A4 instead of the second bar. Analysis: various bugs caused abc2midi to fail with more than one split. locate_voice() must use voice indexno rather than voiceno. start_new_voice_and_sync must pass the voice indexno rather than voiceno to locate_voice(). June 27 2005 Midi2abc: changed name of parameter -usesplits to -splitbars. Added new parameter -splitvoices which eliminates non homophonic chords (ie. polyphonic) by splitting entire voices. Implementation: added new function printtrack_split_voice to midi2abc. June 28-30 2005 Midi2abc: fixed numerous bugs in printtrack_split_voice() and printtrack_with_splits(). July 02 2005 Abcmatch: upgraded the handling of chords and ties to be compatible with abc2midi. July 09 2005 Abcmatch: added an option to ignore simple bars. Midi2abc: withdrew -Midigram option and replaced it with -midigram. Note onset and offset time are now printed in MIDI time units rather than quarter notes units. July 14 2005 Abc2midi: voice split causes infinite loop when play on repeat (eg [1 or [2) specified. For the following file X:1 T:reproduce the bug in a smaller file C:H. C. L. Smith L:1/4 M:1/4 K:C D|:C|[1F:|[2F|E&C|| abc2midi emits the following error message in an endless loop. Error in line 8 : Bad variant list : reproduce the bug in a smaller file Warning in line 8 : Bar 2 has 2 units instead of 1 Error in line 8 : Bad variant list : reproduce the bug in a smaller file Warning in line 8 : Bar 2 has 2 units instead of 1 Error in line 8 :.... Analysis: when writing the voice split in bar E & C||, the function inlist (in genmidi.c) fails to get the repeat on repeat number (eg [2)) which was set for top level voice but not for the split voice. Fix: the problem was traced to the function start_new_voice_and_sync in store.c. It copies the repeat BAR feature (SINGLE_BAR, DOUBLE_BAR, etc..) to the split voice but for the PLAY_ON_REP feature it must also copy the pointer to the part number stored in denom[]. Now both feature[j] and denom[j] are both copied for all bar type features. July 15 2005 The above file exposes yet another problem leading to a loss of synchronization between the voices. The first indication that there is still something else wrong are the messages. Warning in line 8 : Bar 2 has 2 units instead of 1 Warning in line 8 : Bar 3 has 3 units instead of 1 in repeat Warning in line 8 : Track 2 is 4320 units long not 2880 When playing the output MIDI file, the note C in the split is played two bars late extending track 2. Analysis: A play on repeat symbol is always preceded by a bar or repeat bar (ie. | or :|). The function start_new_voice_and_sync treats the play on repeat symbol as another bar line and inserts a rest to complete the bar when in fact, it should just insert a PLAY_ON_REP. Since this bar is played twice, the C note comes two bars late. Treating PLAY_ON_REP as a separate case fixed the problem. July 17 2005 Abc2midi: voice split synchronization error when not all measures are equal in length. In the following file, the tune begins with an incomplete measure. X:1 T: anacrusis M: 2/4 L: 1/8 K: F AG|Fc Fc| d2 e2 & B2 c2| Analysis: start_new_voice_and_sync unfortunately assumes that every measure contains 2 beats. Fix: the function now counts the number of beats in each bar it processes. Abc2midi: MIDI attributes inheritance. As discussed in May 14, 2005 split voices inherit the MIDI characteristics from their ancestor. The following file does not work as expected. X:1 T:inherit 1 M:4/4 L:1/16 Q:1/4 =20 K: C %%MIDI channel 2 %%MIDI program 2 50 B2G2A2B2 EDEF EGFA & z2E4 D2 C8|] The split voice z2E4 ... is played on the Acoustical Piano (program 0) instead of the synthetic strings. However the following file works correctly. X:2 T:inherit 2 M:4/4 L:1/16 Q:1/4 =20 K: C %%MIDI program 50 B2G2A2B2 EDEF EGFA & z2E4 D2 C8|] Analysis: Each split gets its own voice and each voice gets its own channel number unless it is changed explicitly. The above should be equivalent to X:1 T:inherit 1 M:4/4 L:1/16 V:1 %%MIDI channel 2 %%MIDI program 2 50 B2G2A2B2 EDEF EGFA| V:2 %%MIDI channel 2 %%MIDI program 2 50 z2E4 D2 C8 Unfortunately, the %%MIDI channel 2 did not propogate to the split voice. Voice 1 was assigned channel 2 but voice 2 still had channel 1 (writetrack automatically assigns the first channel which is not in use). The bug was fixed by ensuring the CHANNEL feature also propogates into the split voice. You may wonder why X:2 worked correctly. This is because the MIDI program command without the channel indication applies to whatever channel is currently active. July 23 2005. Fixed bug causing midi2abc.exe to produce a segmentation error when running with the -splitbars option. (Failed to save state when doing a split voice context switch due to encountering an end of track before an end of measure. As a result the restored chordhead would point to the wrong place.) Added more code around line 2480 in printtrack_with_splits in midi2abc.c. August 13 2005. Abc2midi.exe does not handle correctly chords of the form [CE]2 when embedded in a triplet. For example in the file, X:1 T: triplet M: 4/4 L: 1/4 K:C (3C2 D2 [CE]2 | abc2midi produces an error messages Warning in line 6 : Different length notes in tuple Warning in line 6 : Different length notes in tuple and the [CE] chord is the wrong length. Analysis: event_note processes the internal lengths of the notes in a chord before it encounters the end of chord marker (]) and it does not know that the internal lengths may be adjusted externally after the end of chord. It sees the wrong length, and sends a warning. Event_chordoff fails to make an adjustment for the triplet (tuple) so that the function fix_enclosed_note_lengths sets the lengths of the internal chord notes to the wrong length. Fix: event_note bypasses the tuple test (for triplets) if the notes are inside a chord. The tuple test was also added in event_chordoff. It adjusts the setting of the note lengths (chord_n, chord_m) if the chord is inside a tuple. If chord_n and chord_m are not 1,1 then fix_enclosed_note_lengths is called. August 13 2005 Abc2midi.exe has difficulty handling tied notes enclosed in a slur. For example for the tune X:1 T: slur 1 M: 2/4 L: 1/8 K: G (GB-B) C|(DEF) B| the following messages appear Warning in line 6 : Slur in abc taken to mean a tie Error in line 6 : Bad tie: possibly two ties in a row Error in line 6 : Cannot find note before tie Surprisingly, the output MIDI file is still correct. Analysis and fix: Abc2midi does almost nothing when it encounters slurs. However, when it sees repeated notes inside a slur it tries to tie them together. For example for (G B B), abc2midi would try to tie the two B's together. This is the source of the above problem. I do not think this is a very useful feature so I have turned this feature off (in event_sluroff store.c). August 13 2005 The abc2-draft standard, http://abc.sourceforge.net/standard/abc2-draft.html has deprecated the !...! notation in favour of the +...+ notation. In order to comply with the change, abc2midi, abc2abc and yaps were modified to accept either convention. Thus you can use +trill+, +fermata+ +pp+ etc. as well as the deprecated notation (!trill! etc.). There is one conflict: in the early days of abc notation chords were notated as +CEG+ instead of [CEG]. There is probably very little music using this old convention. If you need to handle the old chord notation, you must now add the option -OCC to abc2midi, abc2abc or yaps. Sample file: X:1 T: decorations M: 2/4 L: 1/8 K: G +<(+ [CE]4 +<)+ |[CE] +trill+ DEF| !<(! [CE]4 !<)! |[CE] !trill! DEF| Implementation: Introduced a new global, oldchordconvention into parseabc.c which is linked externally to store.c, toabc.c and yaps.c. If this global is unset (ie. 0), then parsemusic in parseabc.c treats + and ! in the same manner. August 17 2005 Added new run time parameters to midicopy -fromsec and -tosec allowing you to select a section in terms of time in seconds. September 13 2005 Midicopy using the -fromsec option to select the start of the output MIDI file causes the music to be delayed by the the same amount of seconds. Analysis, the first note on (or note off) of the track has a delta_time equal to the time of the first note in the selected section of the original file. TiMidity has no problem since it ignores this delay. Other MIDI players are less compliant. This is a hard bug to fix properly when the tempo varies across the MIDI file. For such files, it is recommended that you use the -from and -to parameters and express the times in MIDI tick (pulse) units. The program now computes the right delay using the first tempo specification in the MIDI file. I noticed that when midicopy truncates the beginning of a file, a track may begin with a MIDI off command of a note that has not been turned on. I don't think this causes a problem. September 19 2005 Incorporated changes suggested by Mikhail Teterin into parseabc.c and store.c to modernize the C code. This includes the replacing of the functions casecmp(s1,s2) and stringcmp(s1,s2) with functions built into the C compiler. If this causes any problems with your compiler please notify me as soon as possible. Other changes were added to make the code more efficient and eliminate some warning messages. September 19 - October 8 2005 Abc2midi: another bug related to split chords was found. In the following example X:1 T: split test file M: 2/4 L: 1/8 Q: 50 K: D CD |EF AB & CD FG| G2 | BD D2 & GB B2| The zero th and second bar are only one beat long. The fix described on June 17 th handles the zero'th bar correctly but it does not address the second bar since a different function resync_split_voice is called to maintain synchrony. This function assumes all bars are a fixed length as specified in the time signature. This was a difficult bug to fix since it required major changes to the code. A new function sync_voice replaces the code for start_new_voice_and_sync and resync_split_voice. A test file used to debug these changes, split.abc, is included in the programming directory. Hopefully, I will not need to return to this file many times. October 8 2005 Abc2midi, yaps, abc2abc : extraneous warning "Slur within slur". For the following example, X:1 T: 2 slurs M: 2/4 L: 1/8 K: C V: 1 C2 (C2 |\ V: 2 (A2 G2) |\ V:1 D2) E2| V:2 G4| we get the warning Warning in line 9 : Slur within slur. Analysis, there are two overlapping slurs, but they are in separate voices so this should be no problem. Parseabc.c merely keeps a count of the number of open slurs with the variable slur and does not note that they are associated with specific voices. Fix: the warning message has been moved to store.c. October 9 2005 Abc2midi: grace notes are not applied correctly to a chord. In the following example, X:1 T: grace/chord M:2/4 L:1/8 K:G V:1 D4|{c'}[g3b3] c|z2 G2| V:2 F4|G3 e|z2 D2| The length of the host chord [g3b3] is not adjusted correctly. This results in a loss of synchronization between voice 1 and 2. Analysis: several bugs related to host chords were fixed in my new function applygrace_new() in store.c. The original code, applygrace_orig was also fixed. October 10 2005 Updated makefiles/unix.mak. Cleaned up some of the -Wall warning messages. November 6 2005 New abc2midi feature for supporting drum tracks. Notes played on MIDI channel 10 (counting from 1), are interpreted by the General MIDI instrument as one of 47 percussion instruments (see abcguide.txt for list). Unfortunately, notating the music in this manner is rather awkward if you wish to convert it to common music notation using abcm2ps. Usually, only a few percussion instruments are used. To allow for better drum notation, you can alter the mapping between notes and percussion instruments using the new %%MIDI drummap command. For example for the tune: X:1 T: illustrating drummap command M: 4/4 L: 1/8 K: none %%MIDI channel 10 %%MIDI drummap E 36 %%MIDI drummap G 38 %%MIDI drummap _e 42 |: E2 GE zE z2 & z_e z_e z_e z_e :| would be played on the percussion instruments bass drum (36) acoustic snare (38) and closed hi-hat (42). Implementation: added new function parse_drummap() genmidi.c which handles the %%MIDI drummap command. parse_drummap() is called from the function dodeferred(). November 6 2005 Abc2midi: split voice does not propogate the octave shift command. eg. X:15 T: splits with octave=1 M: 4/4 L: 1/4 K: G octave=1 G A B C & E F G A| The notes E F G A are played an octave lower than intended. Fix: the v->octaveshift variable is passed to the split voice in the function event_split. December 08 2005 Abc2midi: the drummap feature illustrated on November 06 2005 produces an improper MIDI file. eg. X:1 T:unfinished M:2/4 L:1/16 K:F V:1 %%MIDI channel 10 %%MIDI drummap ^^g 72 % Long Whistle %%MIDI drummap _a 58 % Vibraslap ^^gz _a2-_a4 |] midi2abc.exe unfinished1.mid -mftext Header format=1 ntrks=2 division=480 Track 1 contains 40 bytes 0.00 Metatext tempo = 120.00 bpm 0.00 Metatext key signature F (-1/0) 0.00 Metatext time signature=2/4 0.00 Metatext (Seqnce/Track Name) unfinished Track 2 contains 35 bytes 0.00 Metatext (Seqnce/Track Name) unfinished 0.00 Note on 10 c5 105 0.25 Note off 10 a5 0 0.50 Note on 10 a#3 80 2.00 Note off 10 g#5 0 The note on's have the translated pitches but the note off's have the original pitches. As a result none of the MIDI note on's are properly terminated. For percussion instruments, this may not be noticeable since a decay is already built in. However, some midi players may complain. Fix: the function midi_noteoff in genmidi.c now checks for for channel 10. December 09 2005 Abcmidi: transposition should not be applied to the music in channel 10. In the following example X:1 T: drum transpose M: 2/4 L: 1/8 K: G transpose=-3 V:1 FAFA|EFG2| V:2 %%MIDI channel 10 %%MIDI drummap g 72 % Long Whistle %%MIDI drummap a 58 % Vibraslap agag|agag| The transpose=-3 changes percussion instruments. Fix: a test for channel 10 is made before the call to noteon_data() in the function noteon() in genmidi.c. Also in writetrack, a similar test was applied before addtoQ in two places (NOTE: and TNOTE:). December 17 2005 Abc2midi new feature: certain instruments such as an organ have no greatly emphasized beat notes and sound unnatural when the beat algorithm accents the down and off beats. To turn this feature use %%MIDI nobeataccents To turn it back on %%MIDI beataccents By default beat accents are turned on for any new tune. Thanks to Mike Scott for contributing the code to genmidi.c Implementation: a new variable beataccents which acts as a flag was introduced. January 7 2006 I have started looking into the problem of adding the split voice feature into yaps. In order for yaps to handle split voices, it was necessary to introduce a new feature code SPLITVOICE into abc.h. This had minor impact on the debugging code for genmidi.c and matchsup.c. Event_split_voice in yapstree.c now needs to insert a SPLITVOICE feature. To avoid "unknown type" message originating from sizevoice (in drawtune.c) it was necessary to add a case statement for SPLITVOICE even though it does nothing. To assist in debugging, the code in the showline function was split into a new function showfeature in debug.c. The real work is done in the function advance(..) in the file position.c (see additions in programming/yaps.txt). In order to allow spacemultiline to process all the notes playing at the same time, major changes are necessary. We want advance() to check a measure for splitvoices, and if found process all the notes in the bar in the order that they would be played. This means extending the voice structure defined in structs.h so that it maintains status information for v->tuplefactor, v->inchord, v->place,v->time for all splitvoices and telling advance() to handle the splitvoices in parallel. This work is beyond me at the present time and no further work was done. January 13 2006 abc2midi fails to tie note correctly in chord with an augmented unison interval. In the following example X:1 T:A) Matching non-perfect primes M:C L:1/2 K:C [=D^D-] [=D^D] z [=D-^D] [^D=D] z the D- tie and ^D- are done improperly. Analysis: In order to tie notes across bar lines where the accidental is assumed, (e.g. A_B-|BD), the function dotie performs the tie based on the pitch line (in the staff) rather than the actual pitch. Unfortunately there are cases where we run into trouble such as above. Partial Fix: dotie() has a new flag called newbar, which is set to 1 whenever a nonprocessed tie is followed by barline. The pitchline[] test is now only activated when newbar is set. Unfortunately, this is not a complete fix. The same problem reappears with this file for the second and third lines. X:1 T:Matching non-perfect primes M:2/4 L:1/2 K:C [=D^D-]| [^D=D] | z2 | [=D^D-]| [=D^D] | z2 | [=D-^D]| [^D=D] | z2 | [=D-^D]| [=D^D] | z2 | The feature array does not record whether accidentals have been spelled out explicitly so further checks cannot be done when applying ties across bar lines. I recommend that one just changes the order of the notes in the chord in order to get it to work. Fortunately, this problem occurs rarely. January 14 2006 Abc2midi fails to tie microtonal notes correctly. In the following example: X:1 T: tied microtonal pitches M:C L:1/2 K:C C ^13/16C - ^13/16C ^13/16C ^13/16C ^13/16C - C The two notes on the second line are tied together, but the first note is in C rather than ^13/16C causing an audible pitchbend. The notes in the third line are correct pitches but not joined. The tied notes in the fourth line are both incorrect pitches. Analyses: looking at the mftext output from midi2abc reveals the problem. midi2abc.exe tmp/X1.mid -mftext Header format=0 ntrks=1 division=480 Track 1 contains 141 bytes 0.00 Metatext tempo = 227.00 bpm 0.00 Metatext key signature C (0/0) 0.00 Metatext time signature=4/4 0.00 Program 1 73 (Flute) 0.00 Metatext (Seqnce/Track Name) tied microtonal... 0.00 Note on 1 c4 127 2.00 Note off 1 c4 0 2.00 Pitchbnd 1 msb=0 lsb=90 2.00 Note on 1 c4 107 2.00 Pitchbnd 1 msb=0 lsb=64 4.00 Pitchbnd 1 msb=0 lsb=90 6.00 Note off 1 c4 0 6.00 Pitchbnd 1 msb=0 lsb=64 6.00 Pitchbnd 1 msb=0 lsb=90 6.00 Note on 1 c4 107 8.00 Note off 1 c4 0 8.00 Pitchbnd 1 msb=0 lsb=64 8.00 Pitchbnd 1 msb=0 lsb=90 8.00 Note on 1 c4 117 10.00 Note off 1 c4 0 10.00 Pitchbnd 1 msb=0 lsb=64 10.00 Pitchbnd 1 msb=0 lsb=90 10.00 Note on 1 c4 107 10.00 Pitchbnd 1 msb=0 lsb=64 14.00 Note off 1 c4 0 This is another example where the handling of tied notes in dotie() store.c and writetrack() in genmidi.c have gets in the way. (The code was written before microtones was introduced into abcmidi.) The parser encircles every microtonal note with an event_microtone and event_normal_tone. The function dotie changes the tied note from NOTE to TNOTE, the TIE to a REST, and the note being tied to a REST. The function writetrack() unfortunately applies the delay() function for the NOTE feature but not for TNOTE. As a result, the pitchbend is restored to normal before the note even starts playing. Modernizing the tienote function (see February 12 2005 comments) is not an option since there were too many cases to worry about and it would probably take a long time to get out all the bugs out. Fix: a small patch was added to tienote() in store.c. It removes the DYNAMIC feature restoring the pitchbend to normal if it finds one immediately following the TNOTE. January 15 2006 The contour matching algorithm in abcmatch.c has been changed to use pitch interval between adjacent notes. A new run time parameter, -qnt was added which quantizes the contour interval. Details in abcmatch.txt. January 16 2006 Added new feature to yaps that allows you to switch from black to red output using !red! or +red+ instruction command. To restore insert !black! or +black+ in the abc file. e.g. X: 356 T:Banks of the Nile M:4/4 L:1/4 K:Eb B/2-G/2| F E F G| c B G E| F E- C C| C3 C|!red! E E G B!black!| c2 e c/2c/2| B B E F| G3 E/2E/2| E E G B| c c e c/2c/2| B B E F| G3 B/2G/2| F E F G| c B G E| F- E C C| C3|| The notes in the 6 bar are printed in red for emphasis. Implementation: In structs.h added a new structure struct dynamic {char color;}; In yapstree.c, added code to event_handle_instruction to detect !red! and !black! and addfeature(DYNAMIC,psaction) where psaction is a *dynamic struct. In drawtune.c added code to printvoiceline() to take appropriate issue a postscript command to change the color when it detects a DYNAMIC: feature. January 29 2006 Abc2midi: improved the microtone pitch accuracy. Replaced the code event_microtone (in store.c) with the code contributed by Hudson Lacerda. Introduced some support for single note tuning change using the universal system exclusive messages. Added new function in midifile.c single_note_tuning_change(). In function dodeferred in genmidi.c added a %%MIDI snt k pitch command where snt stands for single note tuning, k is the MIDI pitch being retuned (a number between 0 to 127) and pitch is a floating point number representing the new pitch value. Sample file follows. X:1 T: single note tuning M: 2/4 L: 1/8 K: G C \ %%MIDI snt 60 61.5 C cd| I have not yet updated abcguide.txt since this feature is provisional right now. Not all MIDI devices support this universal system exclusive message. February 05 2006 Abc2midi.exe eliminated the warning for microtones "divisor not a power of 2". Introduced a new copy of readlen (readlen_nocheck which is called by ismicrotone() and does not report this error.) March 14 2006 Abc2abc does not recognize "middle=XXX" in the V: field which is used by abcm2ps and silently drops it when transposing abc files. The fix was provided by Mike Scott who also cleaned up the parameter calling sequence to event_voice in parseabc.c. This also involved altering the code in store.c, yapstree.c, matchsup.c, and toabc.c. Thank you. Added #include to crack.c, mftext.c, pslib.c and queues.c which cleans up some of the compilation warnings.(Thanks to Martin Tarenskeen.) Apr 21 2006 (Mike Scott) The 'y' spacing character used by Barfly and abcm2ps was being silently dropped in parseabc.c. Added support for this (including a length specifier - is this used by anything?) to parseabc.c and abc2abc.c; stubs in the other modules including yaps mean they behave as before. June 7 2006 Midicopy: new runtime parameters -frombeat and -tobeat were introduced to copy a selection of a midi file. Midifile: new code was introduced to process an individual track in a multitrack MIDI file. June 25 2006 Abc2midi: added new feature to provide control over the articulation of the notes. The feature %%MIDI trim x/y introduces a gap between notes of duration x/y where x/y is the fraction of the unit note length defined by the L: field command. This gap is made by shortening every note by this amount whenever it is possible. If the note is too short, the gap is reduced. Slurs indicated by parentheses in the music body temporarily disable this feature. Implementation: added a new feature SETTRIM in abc.h. Added new globals variables trim,trim_num,trim_denom in genmidi.c. Added additional code in writetrack to initialize trim_num,trim_denom and to modify notes for switch conditions NOTE:, CHORDOFF:, and CHORDOFFEX. Added new switch state in writetrack to interpret feature SETTRIM. In store.c, added more code in event_specific to interpret the %%MIDI trim command. Abcguide.txt, abc2midi.1 and demo.abc were all updated. Thanks to Jacques Le Normand for the suggestion. July 28 2006 Midicopy still does not extract correctly a segment from some MIDI files when it is specified using the -fromsec and -tosec parameters. This occurs in multitrack MIDI files containing numerous tempo changes. Time units measured in seconds do not correspond between tracks. It was decided to completely change the method of handling segment extraction when time is specified in seconds. It is assumed that all tempo indications are placed in track 1 of the MIDI file. Tempo changes in other tracks are ignored. An initial pass is made through track 1 to extract all the tempo changes and store them in an array. This is used to map time in seconds to MIDI pulses or ticks. The -fromsec and -tosec parameters are converted to pulse units using this mapping. The program then extracts the MIDI information falling in this time interval. July 28 2006 Abc2midi returns the error message "First lyrics line must come after first music line" when processin abc files with lyrics and inline voice commands. For example X:1 T: inline voice M:5/8 L: 1/8 K:G [V:1] cdefg w: c d e f g [V:2] cdefg w: c d e f g I have little experience with lyrics in abc files. The problem is caused by the fact that the inline voice command starts up a new track which resets the variable thismline = -1. This indicates that a new music line was not yet encountered for this voice. If the notes cdefg were placed in a separate line, then the variable thismline was be set to the current line number and everything would be all right. Unfortunately, this is not the case and the abc2 draft standard excepts this syntax. See abc.sourceforge.net/standard/abc2-draft.html and in particular the canzonetta.abc file on that page. There is no easy way of detecting music information at this point other than updating the variable thismline every time a note is processed. Instead, I disabled the error message by commenting the line thismline = -1; in genmidi.c. Hopefully, this does not cause more damage. July 29 2006 Abc2midi: microtones (pitchbend) does not work correctly for tied notes enclosed in a slur. For example: X:1 T:bad pitchbend when tie + slur M:4/4 L:1/8 K:C "^Bad pitch bend when tie+slur" (^1/2C- ^1/2C =C) a- a4 | ^1/2C- ^1/2C =C a- a4 In the first bar, the tie does not work correctly and 3 notes are heard instead of two. Furthermore the first note does not have a pitchbend applied. In the second bar, the notes are played correctly. Analysis: running midi2abc with the -mftext option provides some indication of the problem. 0.00 Pitchbnd 1 msb=0 lsb=80 0.00 Note on 1 c4 105 0.00 Pitchbnd 1 msb=0 lsb=64 0.50 Pitchbnd 1 msb=0 lsb=80 1.00 Note off 1 c4 0 1.00 Pitchbnd 1 msb=0 lsb=64 1.00 Note on 1 c4 80 1.50 Note off 1 c4 0 The pitchbend is set prior to the note but is restored to normal immediately after the note is started (time 0.00). This is similar to the problem fixed on January 14 2006 (see this file). This suggests a problem with the function dotie(). Further analysis, revealed that the parser places a SLUR_TIE after every NOTE feature when the notes are enclosed inside a slur. The SLUR_TIE is not needed by abcmidi but it is used by yaps. Unfortunately, the function dotie() does not expect a SLUR_TIE to appear between the TNOTE and DYNAMIC so it fails to remove the DYNAMIC feature. Fix: A similar patch described in Janurary 14 2006 was added to dotie(). July 29 2006 Abc2midi: It is not commonly known that accidentals are not supposed to propogate across octaves. In the follow example, X:1 T: accidentals and octaves M: 2/4 L: 1/8 K: G C_EDe|C_EDe-|e2^f2|-f2g2| Abc2midi normally also flattens the e; however, technically it should not be doing this. Accidentals only apply to a specific note and should not affect the same pitch class in other octaves. Fix: in store.c workmap and workmul are now doubly indexed arrays. The second index keeps track of the octave. July 30 2006 Abc2abc transposition always reverts to the major key signature when it does a transposition. Analysis: the code in toabc.c represents the key signature in terms of the number of sharps and flats and ignores the mode of the original key signature when it is doing a transposition. Fix: (1) In parseabc.c the index to the array mode[] is saved in the variable modeindex when a mode string is matched. (2) in order to pass modeindex to event_key, the function parameter minor was replaced with modeindex and the variable minor was turned into a local variable which is computed from modeindex. This was done in all files where event_key is defined -- store.c, yapstree.c, matchsup.c, and toabc.c. (In actual fact, the variable minor was only used in store.c to set the minor flag in the MIDI file.) (3) A new function called compute_keysignature() from the sharps/flat representation and modeindex was added to toabc.c. (4) event_key in toabc uses this function to compute the correct key signature. August 04 2006 abc2midi: The treatment of microtones and microtones with accidentals for key signatures other than C major (or A minor) has been changed. Prior to version 1.87, if the music was in the key of G major, ^1/2F would be interpreted as raising F# by a half a microtone. Now the underlying key signature is ignored and the microtone is treated as a pure accidental. Thus ^1/2F raised F and not F#. Hopefully this is more intuitive. Thus accidentals and microtones are assumed to be applied to the natural form of the note irrespective of the key signature or the status of previous notes in the measure. However, accidentals other than microtones can still propagate to notes which do not have accidentals. To illustrate consider the following in the key of C major. _E _1/2E E __1/2E E| The second E is treated as E natural flattend by 1/2 microtone because E is always assumed to be in its natural form when preceded by any accidentals. Since the assumed natural of the second E propagates, the third E is also E natural and not Eb. The last note is Eb reduced by half a semitone. The last E would be played as Eb. See abcguide.txt for another example. Implementation turned out to be easier than expected. A new global (int microtone) was added to store.c. It is set to 1 by event_microtone and reset to 0 by event_normal_tone. The function pitchof(), now does not apply the active flats or sharps (of the key signature) or accidentals when the microtone global is set. August 4 2006 Abcm2ps has introduced an extension of the w: field referenced by the s: field which accepts ~ as a decoration. Unfortunately, the parser in the abcmidi package does not recognize this field command and attempts to treat the line as a music line. As a result a file such as X:1 T: s K:C cd ef g4 | ag ab c'4 |] s: "C"~~~ "C/E" | "Dm/F"* "G7" "C" s: .. .. +tenuto+ | .. .. !fermata! s: "_5"***"_6" | "_6"* "_7"*"_5" s: "_3"***"_3" | "_3"* "_5;3"*"_3" produces many error messages Error in line 6 : Single colon in bar Error in line 6 : Malformed note : expecting a-g or A-G Error in line 6 : *'s in middle of line ignored Error in line 7 : Single colon in bar Error in line 7 : Malformed note : expecting a-g or A-G Error in line 7 : Malformed note : expecting a-g or A-G Warning in line 7 : instruction !tenuto! ignored Error in line 7 : Malformed note : expecting a-g or A-G Error in line 7 : Malformed note : expecting a-g or A-G Error in line 8 : Single colon in bar Error in line 8 : *'s in middle of line ignored Error in line 8 : *'s in middle of line ignored Error in line 8 : *'s in middle of line ignored Error in line 9 : Single colon in bar Error in line 9 : *'s in middle of line ignored Error in line 9 : *'s in middle of line ignored Error in line 9 : *'s in middle of line ignored Similar error messages occur for other abcmidi programs, for example yaps, abc2abc etc. Fix: in parseabc.c: for function parsefield add s to the strchr string if ((inbody) && (strchr("EIKLMPQTVdwW", key) == NULL)) { event_error("Field not allowed in tune body"); and also added the case in the switch statement case 's': break; finally in parseline() added s to the strchr string in if (strchr("ABCDEFGHIKLMNOPQRSTUVdwWXZ", *p) != NULL) { q = p + 1; August 05 2006 Note trimming introduced in June 25 2006 causes loss of synchronization between two voices when notes are contained in a grace sequence. Fix: introduced a variable graceflag into writetrack() in genmidi.c. The flag is set when GRACE feature is encountered and restored to zero when GRACEOFF feature is encountered. Note trimming is disabled inside a grace sequence. Also note trimming is shutoff for short notes. In order to separate two slurs in a row, trimming is restored for the last note in a slur. August 08 2006 Abc2midi: split voices. In the file X:1 T: also D sharp continues in next bar K:C M:4/4 L:1/4 C^DEF & C4 | CDEF | The D in the second bar is sharpened. Fix: added call to function copymap() in the function recurse_back_to_original_voice(). August 29 2006 Abc2abc: handling of rests in tuples causes an error message. The problem does not occur in abc2midi or yaps. For example X:1 T: tuple rests M: 2/4 L: 1/8 K: C G4|(3z2A2B2|F4| abc2abc tuplerest.abc -t 3 X: 1 T:tuple rests M:2/4 L:1/8 K:C G4| %Error : Rest not allowed in tuple (3z2A2B2 %Error : Bar 1 is 7/12 not 2/4 |F4 %Error : Bar 2 is 1/3 not 2/4 | Fix: in the function event_rest in toabc.c, the error message was removed and the beat counter code was modified to consider tuples. September 09 2006 abc2abc: voice numbers not processed correctly. In the following example: X:1 T:voices M: 2/4 L:1/8 K:G V:1 ABCD|abcd| V:1I ABCD|abcd| V:1I was changed to V:1 producing an incorrect abc file. Analysis: the parsevoice() in parseabc decides whether the voice number is a number or a label based on the first character. Since the first character of 1I is a number it treats it as a number and ignores the I. This problem also persists for abc2midi and yaps. Fix: created a new function isnumberp(s) which determines whether the string s is a positive integer number and returns 0 for no and 1 for yes; replaced the original test with this function. September 11 2006 Abc2midi: handling of trilled notes for broken rhythms is not correct. In the following example, X:1 T: trill M: 2/4 L: 1/8 K:C %%MIDI ratio 3 1 TE>G TF3/A/| the length of notes E and G are not adjusted for broken rhythm and remain as equal values. Analysis: the handling of broken rhythms is fairly complicated in the file store.c. The location of E and G are maintained by variables v->thisstart, v->thisend and v->laststart, v->lastend by the functions marknotestart, marknoteend and marknote. (This also allows the handling of chords too.) When a > or < is encountered a number of flags (brokenpending, brokentype, brokenmult) are set by the function event_broken. The function marknotend checks these flags and calls brokenadjust to adjust the lengths of E and G using the stored variables v->thisstart, v->thisend etc. Trilling is handled by the function dotrill() which expands note E into a sequence of notes whose length depends upon the length of E and the tempo. In this example, the expansion is done prior to encountering the broken rhythm indicator >. After G is encountered, the lengths of the notes are adjusted for broken rhythm. Unfortunately, there is a bug in dotrill, and marknotestart was called for the last note in the trill sequence rather than the first note. The problem was fixed by changing this code. Note that in the above example, the number of notes in the trilled E and the trilled F are different. This is because E is not effectively expanded until after it was trilled. There is no easy fix to this problem other than avoiding mixing notations for broken rhythms. trilled F are different. than the first note September 22 2006 Midicopy.c: to avoid problems with some systems, the byte val for the runtime string -replace trk,loc,val is read as an integer (%d) instead of a char (%c). September 22 2006 Abc2abc, abc2midi etc. does not recognize "clef=G". In the following example, X:1 T: clef problem M: 2/4 L: 1/8 K: Am clef=G "Am"ABCD|ABCD| The following message appears: %Warning : cannot recognize clef indication K:Am clef=G Fix: added checks for clef=g or clef=G in the function isclef() in parseabc.c September 23 2006 Abc2abc removes blank lines from abc files. (These blank lines are usually to encircle comments between tunes in a multitune file. Analysis: whenever parseline() (in parseabc.c) detects a blank line, it calls event_blankline(). In abc2abc, event_blankline() only emits a blank line if the flag newbreaks is set. Unfortunately, this parameter is used for another purpose (i.e. reformating an abc file with new linebreaks every X bars using the -n X runtime parameter). This has nothing to do with handling already existing blank lines. Since event_blankline is called only when there is a blank line, it appears that the condition on the flag newbreaks should not be present. Fix: the condition statement was removed. A blank line will always be issued. Note that event_blankline also closes the tune and parser for that tune as usual. September 25 2006 Abc2midi: some users have complained about the unnecessary warnings and error messages issued by abc2midi. For example standard music practice does not require a leading repeat mark |: to be placed at the beginning of the sheet music and it is commonly left out in many abc transcriptions. Abc2midi typically warns the user that it has been left out but does the correct thing. Furthermore, the placement of a fermata sign will likely cause a message that a bar has too many beats. Too placate the users, I have introduced a new runtime parameter -quiet which will suppress all these messages. Note abc2midi parses the abc file in two passes and may not always handle assumed repeats correctly. For example if the tune begins with an anacrusis, abc2midi does not attempt to figure out whether the |: should be placed before or after the anacrusis. (This depends upon the placement of the end repeat.) In multipart files, abc2midi fails to place a starting repeat sign. In the case of multivoiced files, loss of synchronization between voices can occur because of user mistakes or because abc2midi made the wrong assumption. (For example, search for the word fermata in this file.) Though attempts have been made to standardize the abc music notation language, it is a living language and various variants are introduced now and then. Abc files that have been notated many years ago are not updated to correct for the various problems that are introduced by these new features. There is a variety of software to process abc files, but many of the developers have moved to other things and fail to maintain their software. Though these messages are an inconvenience to users they are useful in diagnosing problems when the MIDI file does not sound correctly. September 26 2006 Abc2midi: now supports linear temperament scale using code contributed by Magnus Jonsson. New %%MIDI commands are introduced to change the temperament. %%MIDI temperamentlinear octave_cents fifth_cents where the variables specify the size of an octave and size of a perfect fifth in cents where one cent is 1/100 of a semitone or 1/1200 of an octave. %%MIDI temperamentlinear 1200.0 700.0 produces the equal tempered scale. %%MIDI temperamentlinear 1200.5 698 produces a slightly stretched octaves and narrowed fifths. Quoting the Help for the program Scala http://www.xs4all.nl/~huygensf/scala/ A linear temperament is a cycle or chain of one particular interval, called the generator or formal fifth. Whenever by doing so a pitch originates that is outside the range of one formal octave (interval of equivalence), it is "wrapped" back inside by subtracting the formal octave value. Examples of this kind of scale are the Pythagorean scale generated by a pure fifth, and regular meantone scales. Implementation: store.c : added new globals temperament, octave_size, fifth_size which are set by %%MIDI temperamentlinear. Created a new function pitchof_b() which is similar to function pitchof() but also returns a pointer pitchbend. Pitchof_b() would eventually replace all calls to pitchof(). The function pitchof_b() applies the linear temperament scale if the global variable temperament is set. It updates the pointer pitchbend unless it was already set by a microtone. To store the pitchbend value of every note a new array bentpitch was added to the other arrays (pitch, num, denom, feature). The function event_note transfers the pitchbend value to bentpitch, so it can be used by writetrack() in the second pass (in genmidi). Other functions that had to be updated were doroll, dotrill, makecut, and doornament. genmidi.c : Added global array current_pitchbend[], which maintains the current pitchbend for each channel. It is initialized to 8192 (neutral value) by starttrack. The pitchbend value is now transferred to the function midi_noteon(). It will issue a pitchwheel command anytime a new pitchbend value occurs for the specific channel. Other functions like noteon_data() and save_note() also carry the parameter pitchbend. Limitations: linear temperament is not applied to guitar gchords. October 3 2006 Abc2midi: in order that microtones are applied correctly to in voice chords such as [CEG], it is necessary that each note in the chord be played on a separate MIDI channel. A new MIDI command "makechordchannels n" has been introduced for allocating MIDI channels specifically for the handling of chords. The value of n specifies the number of channels to be allocated. It should be one less the maximum number of notes in the chord. Note that since you have only 16 channels in a MIDI file and once the channel has been allocated it is unavailable for any other use. You need to do a separate allocation for each voice containing such chords. Implementation: In genmidi.c, introduced a global array chordchannels[] which is used to store the channel numbers for handling chords. chordchannel[0] is the channel number normally used for handling notes for that voice. Introduced a global integer nchordchannels storing the number of channels in chordchannels[]. Created a new function makechordchannels() for assigning these channels to chordchannels[]. Makechordchannels also sets the channels program (musical instrument) to the current program for the voice. (If you need to know the channel numbers that have been assigned, run abc2midi with the -v option (verbosity)). Created another branch in the function dodeferred() for handling the MIDI command makechordchannels(). October 15 2006 The following file was not parsed correctly. X:1 T: 2 or 3 tracks M: 3/4 L: 1/8 K:G g2| g2 fe b2| V:2 A2 |[B4E4] G2| Analysis: a bug I introduced recently resulted in the voice number (2) not being read correctly. Fix: in the function parsevoice() in parseabc.c, I changed the statement if (isnumberp(&s)) { to if (isnumberp(&s) == 0) { apparently, this function returns 0 if the string contains a positive number and 1 otherwise. October 27 2006 Abc2midi: using the command %%MIDI drumon causes the error MIDI read/write error : error: MIDI channel greater than 16 and abc2midi fails. This is another bug I had introduced. Adding the pitchbend parameter 8192 to save_note in function dodrus() in genmidi fixes this problem. October 27 2006 Abc2abc transpose places spurious spaces between notes breaking up the beaming pattern. For example for, X: 1 T: beaming error L: 1/8 M: 4/4 K: Eb ^C,,2 z2 z^C,/D,/ =E,/^F,/G,/=A,/ | B,/=A,/G,/^F,/ G,/=E,/^C,/D,/ E,/F,/G,/A,/ B,/A,/G,/A,/ | abc2abc beaming.abc -t 1 produces X: 1 T:beaming error L:1/8 M:4/4 K:Emaj ^^C,,2 z2 z^^C,/2 D,/2 ^E,/2^^F,/2 G,/2^A,/2 | B,/2^A,/2G,/2^^F,/2 G,/2^E,/2^^C ,/2 D,/2 E,/2 F,/2 G,/2 A,/2 B,/2 A,/2 G,/2 A,/2 | (note all the spaces between the notes in the second line of the body). Analysis: the local variable mult in event_note1() in toabc.c is used before it is defined. Fix: event_note1() now sets it to zero in case it is not set elsewhere. November 3 2006 Abc2midi bug: pitches are incorrect for staccato notes. eg X:1 T: staccato bug M:3/2 L:1/2 Q:1/4=70 %%MIDI program 16 %%MIDI nobeataccents K:C =B=c=d | .=B.=c.=d | The pitches of the last three notes have been affected by a pitchbend. Analysis: This is a bug I recently introduced. The bentpitch[] feature was not set to 8192 for staccato notes. Fix: added the following line bentpitch[notes] = active_pitchbend; before addfeature(NOTE, ...); in event_note() in store.c. Also added it in doornament(). November 3 2006 Abc2midi bug: the following file causes the error message MIDI read/write error : error: MIDI channel greater than 16 to appear. X:1 T: makechord M:3/2 L:1/2 Q:1/4=70 V:1 %%MIDI nobeataccents %%MIDI program 16 %%MIDI makechordchannels 2 V:2 %%MIDI program 16 %%MIDI makechordchannels 2 V:3 %%MIDI program 16 %%MIDI makechordchannels 2 K:C % V:1 [c'_/e'g'] V:2 [c_/eg] V:3 [C_/EG] Analysis: there was a missing parameter (bentpitch) in the function call to noteon_data() when channel == 9. As a result the function noteon_data() received a meaningless channel number. However, since channel 9 is reserved for percussion, it should never have been assigned. To fix this problem, the global variable channels[9] was set to 1 in writetrack() (genmidi.c), so that findchannel() will not select this channel. December 9 2006 Abc2midi bug: the %%MIDI drone command returns an error MIDI channel > 16. Fix: missing parameter in function midi_noteon(), pitchbend, was added. December 12 2006 Abc2midi bug: split voices does not work correctly when it is embedded in a part (eg. P:B). For example: X: 1 T: bad merge M: 4/4 L: 1/8 K: C P:A | C2 D2 E2 F2 | G2 A2 B2 c2 | P:B | C2 D2 E2 F2 & C,2 D,2 E,2 F,2 | G2 A2 B2 c2 | The split voice does not merge correctly in the above example. Analysis: not all voices may be indicated in a part. As a precaution, genmidi calls partbreak which fills in any missing voices. Unfortunately, split voices are automatically resynced which causes the voice to be filled in twice. Fix: a new global array dependent_voice[] was added in store.c and linked to genmidi.c. This array contains flags indicating where the particular voice was a natural voice created by a voice command (V:) or whether this is a split voice dependent on the natural voice. The function partbreak checks this flag and does nothing if is a dependent voice. December 21 2006 Voice bug (abc2midi, yaps): the fix described in September 9 2006 caused another bug. For the following example: X:1 T: noel M: 2/4 L: 1/4 K: C V: alpha C E|D F| V: beta A C| G B| The parser fails to handle nonnumeric voice numbers. Fix: in line 996 of parseabc.c isnumberp returns 1 if the character string is a positive number and 0 if it is not. The 0 was replaced with 1 as shown below. if (isnumberp(&s) == 1) { December 26 2006 Midi2abc bug. Some music notation programs automatically place short rests between notes and chords in order to improve the articulation. Midi2abc is able to ignore these rests using the -sr parameter as described in the midi2abc.1 documentation. Unfortunately, this feature does not work correctly when rests are placed in between chords. Analysis: the quantize() function decides whether to eliminate the rest based on the difference between the inter note interval (note->xnum) and the "on" time of the note (note->play). For some of the chordal notes, note->xnum is zero since all the notes in the chord start at the same time. This causes the program to produce erroneous results. Fix: a new function xnum_to_next_nonchordal_note() was introduced to look ahead past all the chordal notes and return the quantized note interval to the next nonchordal note. The quantize function uses this value when the -sr option is turned on. (I have a feeling this fix may not work correctly when the notes in the chord are not all equal length. In other words I do not recommend using the -sr option with -splitbars or -splitvoice.) January 02 2007 Abc2midi bug: %%MIDI trim does not work according to documentation. The trim command is used to control the articulation of notes. Like staccato it shortens the playing time of the note, leaving a silent period before the next note. According to the documentation the amount shortened should be the trim fraction time the unit note length. It turns out that the trim length was not adjusted for the unit note length so that the following example did not work. X:1 T: trim M: 2/4 L: 1/8 K: C %%MIDI trim 1/2 CDEF| Fix: store.c was modified so that trim value set is a fraction of the unit note length as defined by the L: field command. Note, that if the unit note length is changed again, it is necessary to reissue another trim command, eg. X:1 T: trim M: 2/4 L: 1/8 K: C %%MIDI trim 1/2 CDEF| L: 1/16 %%MIDI trim 1/2 CDEF CDEF CDEF CDEF| Otherwise the trim length will remain unchanged. January 06 2007 Abc2midi bug: wrong bar count when %%MIDI trim command mixed with chords. In the following example, X:1 T: Bad barcount M: 2/4 L: 1/8 K: C %%MIDI trim 1/2 AB CD |AC DF |[A2c2] DF | [AB]2 [CD]2 | Abc2midi produces the following warnings: Warning in line 9 : Bar 2 has 7/4 units instead of 2 Warning in line 10 : Bar 3 has 3/2 units instead of 2 Furthermore, this may throw off the gchord accompaniment if it exists. Fix: in writetrack for case CHORDOFF: and CHORDOFFEX:, the function addunits() is called before trim adjustment instead of after. March 15 2007 Abc2midi ends a MIDI track immediately after the last note. On some MIDI synthesizers, this introduces a small artefact at the end of the MIDI file. Fix, a short delay of 25 MIDI pulses is inserted before the end of track. This was incorporated in the function clearQ() in queues.c. Midi2abc -mftext mode was modified to report end of track meta command. December 09 2007 New feature in abc2midi: the program now recognizes the command %%propagate-accidentals not as described in http://abc.sourceforge.net/standard/abc2-draft.html directive 11.3 This command suppresses propagation of accidentals across a bar. The commands %%propagate-accidentals pitch or %%propagate-accidentals octave restores propagation. Presently only octave method is used. For example: M:2/4 L:1/8 K:Eb %%propagate-accidentals not A =A A2| A2 is flattened since the natural sign does not propagate. January 04 2008 Running yaps with the -E option to produce encapsulated postscript file (.eps) causes the program to crash with the error message *** glibc detected *** yaps: double free or corruption (!prev): 0x08d5f390 Analysis: the program attempts to close the output file twice. close_output_file was called once by printtune() (when it encountered a blank line) and again by event_eof() when it encountered an eof. The operating system does not set the filehandle to NULL after the file was closed defeating the conditional test in close_output_file. Fix: after closing the file the file handler is set to NULL. March 09 2008 Midi2abc: added a new option -title for providing the title of the tune to insert in the abc file. June 07 2008 Abc2midi: introduced a warning for chords containing unequal notes (eg. [c2e] will cause a warning to be issued). The warning was added in writetrack in genmidi.c. In order to get a reasonable output, the incorrect chord will be played as [c2e2]. (The length of the first note dominates.) June 13 2008 Abc2midi: produces a warning "Different length notes in tuple" when one of the notes in the tuple is a chord. eg. X:1 T: triplet chord M: 2/4 L: 1/16 K: D [DF]4 (3[B2d2]c2d2 | Analysis: the problem was traced to a bug in the function event_chordoff in store.c which was introduced with the chord syntax extension described in November 4 2004. In computing the tuple adjusted note length, the function always uses chord_n and chord_m parameters even when they do not apply (equal to 1/1). Fix new local variables c_m and c_n are introduced which are set to chord_n,chord_m or num[chordstart] and denum[chordstart] depending on whether the chord syntax extension is used or not. The tuplet adjusted note length is computed from c_n and c_m. It was also necessary to change event_note so that tuples are processed for chords too. June 14 2008 Abc2midi: ornaments (eg ~G3) does not work correctly for default length other than 1/8 (L: 1/8). Analysis, doornament (in store.c) assumes L:1/8 for dotted quarter notes. This was fixed. June 24 2008 Abc2midi: new feature. The %%MIDI drum line can sound quite monotonous if it is repeated each bar. To circumvent this problem a new MIDI command %%MIDI drumbars n where n is a small number will spread out the drum string over n consecutive bars. By default drumbars is set to 1 maintaining compatibility with existing abc files. You should take care that the drumstring is evenly divisible between the drumbar bars. Also the time signature should not change between bars in a drumbar unit. Sample usage: X:1 T: splitting a drum string into two bars M: 2/4 L: 1/8 K: G %%MIDI drum zdzdzdzd 39 59 50 60 %%MIDI drumon z4| z4| z4| z4| %%MIDI drumbars 2 %%MIDI drum zdzdzdzd 39 59 50 60 z4| z4| z4| z4| Implementation: All the changes were confined to genmidi.c Two new variables drumbars and drumbarcount are introduced. Drumbars modifies drum_denom in set_drums. (This changes the duration of a unit drum hit.) The function checkbar resets the drum_ptr every drumbars using the drumbarcount variable. July 2 2008 Regarding the drumbars implementation it is necessary to reset drumbarcount to 0 in writetrack after drumbars is initialized back to 1. July 17 2008 Abc2midi bug: the following sample causes abc2midi to issue a warning Warning in line 9 : Bar 0 has 10 units instead of 6 in repeat X:1 T: meter change M:5/8 L:1/8 K:C % |: [M:6/8] D6 &\ [M:6/8] E6 | [M:4/8] F4 :| Analysis: the warning is issued when writetrack is processing track 2 which is the split voice track during the repeat. The two [M:6/8] field commands ensure that the split voice track also sets the meter to 6/8 time. However the split voice track was not reset to [M:4/8] unless we do it explicitly with [M:4/8] F4 & [M:4/8] z4|. Store.c/sync_voices inserts a required rest z4 into bar 2 of the split voice but it does not include a time signature command which is needed to ensure that genmidi/checkbar will process the bar correctly. Fix: Added case TIME: addfeature(feature[j], pitch[j], num[j], denom[j]); /* copy feature */ break; /* [SS] 2008-07-17 */ into the code of sync_voices. July 17 2008 Abc2abc: removed the space between X: and the reference number. July 21 2008 Removed all static declarations in parseabc.c In parsekey(str) initialized the local string clefstr and modestr. July 21 2008 Abc2midi bug: key signature and accidental propagation applied to drum channel. In the following example, X:1 T: drum key M: 4/4 L: 1/8 K: A V:1 Z|ABcd efga| V:2 %%MIDI channel 10 G,, ^F,, z1 F,, E,, ^D,, z2|G,, ^F,, z1 F,, E,, ^D,, z2| voice 2 is assigned to the drum channel so the notes G,, ^F reference individual drum instruments rather than pitches. Since the key signature is A major (F#, C# and G#), event_note automatically raises G and F one semitone and propagates ^F across the bar. This is not desired for the drum channel. Fix: in store.c, a new variable, int drumchannel was added to struct voicecontext. It is initialized to 0. When event_specific handles a %%MIDI channel 10, drumchannel is set to 1. For other channels it is set to 0. A new function barepitch() was created from the function pitchof_b. This function does not apply the key signature or note propagation. The function event_note now checks whether v->drumchannel is set and calls barepitch() instead of pitchof_b() in such circumstances. (See Cuckoo's Nest in demo.abc for a sample.) August 4 2008 Midi2abc: new feature. The -mftext prints the name of the drum patch for channel 10 and noteon commands. August 11 2008 Abc2midi bug: The following abc file cause abc2midi to halt with a segmentation error. X:1 T: trim problem M:3/4 L:1/4 %%MIDI trim 1/8 K:C ABC|DEF| Analysis: the error occurs in event_specific when the function addfeature(SETTRIM, 1, 4*a, b*v->default_length); is called. The voice structure does not exist causing a segmentation error when v->default_length is addressed. (v does not exist until the body of the abc file.) Fix: if v does not exist, addfeature(SETTRIM,...) get the default_length from global.default_length. Comment: event_refno creates the voice structure and then destroys it when it calls startfile(). This does not cause a problem but makes the code obscure. August 12 2008 Another abc2midi trim bug: the following warnings are Warning in line 9 : unequal notes in chord 7/8 versus 1/1 Warning in line 9 : unequal notes in chord 3/4 versus 1/1 are the produced from this file. X:1 T: trim problem M:3/4 L:1/4 K:C %%MIDI trim 1/8 %%MIDI makechordchannels 2 CD[ABc]| Analysis: the problem was traced to the function writetrack in genmidi.c. The note length is trimmed inside the switch case for NOTE:. The length of the trimmed note is saved and trimming is reapplied to this length for each note of the chord. This bug was probably introduced in June 7 2008 in order to make the the first note in a chord to dominate. Fix: new variables tnote_num and tnote_denom are introduced specifically for note trimming. August 12 2008 Still another abc2midi trim bug. For split voices, the notes are trimmed in only one voice. In the following example, the notes CDE are trimmed but not EFG. X:1 T: another trim problem M:3/4 L:1/4 %%MIDI trim 1/8 %%MIDI makechordchannels 2 %%MIDI program 20 K:C CDE & EFG| Fix: another case statement SETTRIM: was added to sync_voice() in store.c Note that %%MIDI trim command only applies to a single voice. September 17 2008 Abc2midi bug: wrong bass note when expanding guitar chord with inversion. The bass note should be the note after the / rather than the pitch of the chord. Thus "C/E" should be represented by E,,x [G,E,C,] rather than C,,x [G,E,C]. Fix: case 'f' in function dogchords() in genmidi.c no tests for an inversion. If an inversion is indicated, the bass note is changed. September 18 2008 Abc2midi new feature: added the run time option (-NCOM) to suppress some textual comments in the output midi file. September 24 2008 Abc2midi bug: for multitune abc files, the temperament is not automatically turned off at the start of the next tune. Fix: temperament is initialized to zero in startfile() in store.c September 24 2008 Abc2midi new behaviour: the 'strange note' in a gchord is no longer included in the chord. (i.e. F/G is now expanded as G,, [F,A,C] instead of G,, [G,,F,A,C]. (Suggested by H. Lacerda). Change made in configure_gchord() in genmidi.c September 28 2008 Abc2midi bug when selecting tune from collection. When the abc2midi is used to create a single MIDI file from an abc file containing a collection of tune which contains %%MIDI commands, abc2midi numerous warnings 'cannot handle this MIDI directive here' for the non-selected tunes. For example abc2midi balk2.abc 237 -v Reference X: 180 Warning in line 9 : cannot handle this MIDI directive here Reference X: 181 Warning in line 34 : cannot handle this MIDI directive here Warning in line 35 : cannot handle this MIDI directive here Warning in line 36 : cannot handle this MIDI directive here Warning in line 37 : cannot handle this MIDI directive here Reference X: 182 [snip] This obscures real warnings from the selected tune. Analysis: the messages are issued by event_specific_in_header() which was designed to process MIDI commands which appear before the first tune (X: refno), in the file. The function is called when dotune == 0, which is true for unselected tunes. This means that some of the directives in the nonselected tunes (e.g. nobarlines, fermatafixed, ...) can affect the selected tune. Furthermore, some other MIDI directives which are not recognized by the function cause the above warnings to occur. In the following example (headercommands.abc), %%MIDI nobarlines X:1 T: tune 1 M: 2/4 K:G %%MIDI barlines %%MIDI program 100 X:2 T: tune 2 M: 2/4 K: F etc. the directive %%MIDI nobarlines appearing before the first tune is to apply to all tunes in the abc file except where specifically overrided (in tune 1). When we run abc2midi headercommands 2 we are expecting %%MIDI nobarlines to apply to tune 2. However, this was changed in the nonselected tune 1 and the %%MIDI program 100 command causes the message 'cannot handle this MIDI directive here'. Fix: a new global variable started_parsing initialized to zero was introduced in store.c. When event_refno is invoked, the variable started_parsing is set to 1. The function event_specific_in_header is called only if started_parsing is still 0. February 20 2009 Yaps bug. The -E option (for encapsulated postscript) does not compute the boundingbox correctly if the abc file contains note fields (N:). eg. X:1 T:A test N:A note K:C AB cd ef ga | \ AB cd ef ga | \ AB cd ef ga | \ AB cd ef ga | AB cd ef ga | \ AB cd ef ga | \ AB cd ef ga | \ AB cd ef ga |] The bottom part of the last staff is cutoff. Analysis: the function tuneheight() in drawtune.c did not account for space used by the note fields. Fix: added several lines of code to the function to scan through the notefield list and adjust the page height. March 17 2009 Abc2midi new feature: a new command %%MIDI gchordbars n was introduced that acts in the same manner as %%MIDI drumbars (see June 14 2008). but applies to the gchord string instead. The command spreads the gchord string over n consecutive bars. In the following example: X:1 T: gchordbars M: 2/4 L: 1/8 K: C %%MIDI gchordbars 2 %%MIDI gchord fzczIzHz "C" c2 "G" c2|"C" g4|"G"c4|g4| fzcz applies to bars 0 and 2 while IzHz applies to bars 1 and 3. For this function to work properly, it is important that the length of the gchord string be exactly divisible by n where n is the number of bars that the gchord string applies to. If gchordbars is not specified, it is assumed to be one bar. Implementation is similar to drumbars. New variables gchordbars and gchordbarcount were introduced in genmidi.c June 23 2009 Abc2midi does not attempt to fill in missing left repeats |: in multipart and multivoiced files. New code was introduced to solve this problem. The functions scan_for_missing_repeats(), add_missing_repeats(), clear_voice_repeat_arrays() was added to store.c. July 22 2009 Abc2midi produces irrelevant error messages %%MIDI drumon must occur after the first K: header when extracting a particular tune in a file containing a collection, eg. abc2midi balk1.abc 10 Fix: in event_specific() in store.c now check the flag dotune. if (strcmp(command,"drumon") == 0 && dotune) { addfeature(DRUMON, 0, 0, 0); etc. July 22 2009 Abc2midi produces the error message found another |: after a |: for the file X:1 T:title M:4/4 L:1/4 K:C A2 c2 :: d2 c2 :| Fix: set bar_rep_found[voicenum] = 1 after inserting missing BAR_REP. September 20 2009 Abc2midi bug: the following file produces a faulty midi file. X:1 T: bug M: 4/4 L: 1/4 K: G V:1 %%MIDI control 7 49 C4|\ %%MIDI control 7 48 C4|\ %%MIDI control 7 47 C4|\ %%MIDI control 7 46 C4| %%MIDI control 7 45 Analysis: As seen below track 1 which contains only control codes is 56 beats long while track 2 which contains the notes is only 16 notes. The control codes in track 1 are not placed at the correct times. ur@localhost abc]$ midi2abc err1.mid -mftext Header format=1 ntrks=2 division=480 Track 1 contains 57 bytes 0.00 Metatext tempo = 120.00 bpm 0.00 Metatext key signature G (1/0) 0.00 Metatext time signature=4/4 0.00 Metatext (Seqnce/Track Name) bug 0.00 CntlParm 1 Volume = 49 4.00 CntlParm 1 Volume = 48 12.00 CntlParm 1 Volume = 47 24.00 CntlParm 1 Volume = 46 40.00 CntlParm 1 Volume = 45 56.05 Meta event, end of track Track 2 contains 67 bytes 0.00 Metatext (Seqnce/Track Name) bug 0.00 CntlParm 1 Volume = 49 0.00 Note on 1 c4 105 4.00 Note off 1 c4 0 4.00 CntlParm 1 Volume = 48 4.00 Note on 1 c4 105 8.00 Note off 1 c4 0 8.00 CntlParm 1 Volume = 47 8.00 Note on 1 c4 105 12.00 Note off 1 c4 0 12.00 CntlParm 1 Volume = 46 12.01 Note on 1 c4 105 16.00 Note off 1 c4 0 16.01 CntlParm 1 Volume = 45 16.06 Meta event, end of track Explanation: when abc2midi produces a type 2 MIDI file (multitracks), track 1 only contains comments, time signature and control codes while the other tracks contain the actual note-on/note-off codes corresponding to the different voices. When abc2midi produces a type 1 MIDI file corresponding to the bare bones abc file (no voices or accompaniment), then there is only one track and all note-on/note-off commands are in the same track. For historic reasons, MIDI control codes are placed in both track 1 and track 2 for voice 1, and the control codes for the other voices are put into their own track. (I dare not change this since it could cause a problem somewhere else.) However, there appears to be a bug since the times of the control codes seem to be incorrect. Fix: I reset delta_time to 0 at the end of the function genmidi.c/dodeferred(). It seems to fix the problem. October 23 2009 Abc2midi bug: the function dograce fails to adjust the length of the host notes in a chord. In the following example X:1 T: grace chord problem M: 2/4 L: 1/8 K: C A2 B2|{edc}[cg]2 d2| The chord [cg]2 is not shortened by the length of the grace note {edc}; however if the chord is expressed as [c2g2] the chord is shortened correctly. Analysis:the function applygrace_new() in store.c fails to recognize the CHORDOFFEX feature which is used to express chords of this type. Fix: the function now checks for that feature. December 12 2009 Abc2midi bug: dynamics (eg !pp!) deletes previous rest. In the following example: X:1 T: dynamic problem M:4/4 L:1/4 K:C |ABcd|Az3|!pp!dcBA|] The rest z3 is destroyed by the !pp! indication. Analysis: this bug was introduced on September 20 2009 when delta_time was reset to 0 in dodeferred(). Fix, a global variable rest_pending was added to indicate that a rest has not yet been instantiated in the MIDI file and not to reset delta_time. The variable rest_pending is set to zero for every NOTE, TNOTE or CHORDON feature but set to 1 for a REST feature. **note** this change was undone Feb 4 2010 December 18 2009 Abc2midi bug: split voices (also known as voice overlay) works incorrectly when there are in repeats. For example X:1 T: voice overlay in repeats M: 2/4 L: 1/4 K: G |:C D &b/c/d/e/| F G:| used to work but now does not repeat the voice overlay. (It does not matter whether an opening repeat |: is present.) However, if you put a V:1 after K:G as shown here X:1 T: voice overlay in repeats M: 2/4 L: 1/4 K: G V: 1 |:C D &b/c/d/e/| F G:| it then works correctly. Analysis: this is a new bug that was introduced after the changes on June 23 2009. The function scan_for_missing_repeats corrupts the feature arrays. Here is the feature arrays just before calling scan_for_missing_repeats. 0 LINENUM 2 0 0 0 1 TITLE 0 0 0 0 2 LINENUM 3 0 0 0 3 LINENUM 4 0 0 0 4 LINENUM 5 0 0 0 5 DOUBLE_BAR 0 0 0 0 6 LINENUM 6 0 0 0 7 MUSICLINE 0 0 0 0 8 BAR_REP 0 0 0 0 9 NOTE 60 8192 1 1 10 NOTE 62 8192 1 1 11 SINGLE_BAR 0 0 0 0 12 VOICE 2 0 0 0 13 DOUBLE_BAR 0 0 0 0 14 BAR_REP 0 0 0 0 15 NOTE 83 8192 1 2 16 NOTE 72 8192 1 2 17 NOTE 74 8192 1 2 18 NOTE 76 8192 1 2 19 SINGLE_BAR 0 0 0 0 20 VOICE 1 0 0 0 21 NOTE 66 8192 1 1 22 NOTE 67 8192 1 1 23 REP_BAR 0 0 0 0 24 VOICE 2 0 0 0 25 REST 0 0 2 1 26 REP_BAR 0 0 0 0 27 VOICE 1 0 0 0 28 MUSICSTOP 0 0 0 0 29 LINENUM 7 0 0 0 30 VOICE 2 0 0 0 31 SINGLE_BAR 0 0 0 0 Here is the feature array afterwards. 1 TITLE 0 0 0 0 2 LINENUM 3 0 0 0 3 LINENUM 4 0 0 0 4 LINENUM 5 0 0 0 5 DOUBLE_BAR 0 0 0 0 6 LINENUM 6 0 0 0 7 MUSICLINE 0 0 0 0 8 BAR_REP 0 0 0 0 9 NOTE 60 8192 1 1 10 NOTE 62 8192 1 1 11 SINGLE_BAR 0 0 0 0 12 VOICE 2 0 0 0 13 DOUBLE_BAR 0 0 0 0 14 BAR_REP 0 0 0 0 15 NOTE 83 8192 1 2 16 NOTE 72 8192 1 2 17 NOTE 74 8192 1 2 18 NOTE 76 8192 1 2 19 SINGLE_BAR 0 0 0 0 20 VOICE 1 0 0 0 21 NOTE 66 8192 1 1 22 NOTE 67 8192 1 1 23 BAR_REP 0 0 0 0 24 REP_BAR 0 0 0 0 25 VOICE 2 0 0 0 26 REST 0 0 2 1 27 REP_BAR 0 0 0 0 28 VOICE 1 0 0 0 29 MUSICSTOP 0 0 0 0 30 LINENUM 7 0 0 0 31 VOICE 2 0 0 0 32 SINGLE_BAR 0 0 0 0 Note that feature BAR_REP was placed at 23 immediately before REP_BAR. The problem is that the first VOICE 1 feature was found after the first bar was processed and a split voice (VOICE 2) was generated. scan_for_missing_repeats automatically places a BAR_REP 3 indices past (24) the VOICE 1 (20) command which it expects to be before the first note. This messes up the feature array. If the abc file has a V:1 after the K: then the BAR_REP is placed at the right place. Fix: Always place a VOICE 1 command after the first K: in the abc file. In event_key (store.c) addfeature(VOICE, ...) after getvoicecontext(1) if not inside body of abc file. (There may be a K: indication inside another voice and we do not want to automatically switch to VOICE 1.) ***This change was removed on December 21 ***. December 20 2009 abc2midi bug: X:1 T: embedded V: command and voice overlay %%MIDI program 2 41 K:C [V:1] | cde2 & egc'2 | C8 & z4 e'4 | c8 :| [V:2] |C,D,E,2 | C,,8 | C,8 :| the voice overlay gets garbled but if we write V:1 | cde2 & egc'2 | C8 & z4 e'4 | c8 :| V:2 |C,D,E,2 | C,,8 | C,8 :| it works fine. In scan_for_missing_repeats changed add_leftrepeat_at[num2add] = voicestart[voicenum]+3; to add_leftrepeat_at[num2add] = voicestart[voicenum]+2; December 21 2009 abc2midi bug: abc2midi fails to convert the simple file X:1 T: one track M: 2/4 L: 1/4 K: C CD|EF|GA|Bc| Fix: removed insertion of VOICE feature after the event_key. instead event_key remembers the location to place a VOICE feature in the variable v1index in case a event_split_voice is encountered and voicesused is 0. January 05 2010 abc2midi bug: loss of voice synchronization when stacatto, chords and dynamics mixed. In the following example, X:1 T:staccato and dynamics M:4/4 L:1/8 K:G V:1 C4 G4|A4 G4| V:2 [.D4.G4]!p!C2C2|D4F4| the chord [.D4.G4] is one beat two short causing a loss of synchronization between the two voices. However if abc2midi is run with the option -NFNP which causes abc2midi to ignore the dynamic indication !p!, the voices remain in synchronization. Analysis, the stacatto markings embedded in a chord causes a REST feature to be embedded in the chord. 21 CHORDON 0 0 0 0 22 REST 62 0 2 1 23 NOTE 62 8192 1 1 24 NOTE 67 8192 1 1 25 CHORDOFF 0 0 2 1 normally a stacatto places the rest after the shortened note but for chords it is done differently. (It is rather unusual to find stacatto markings inside a chord.) Nevertheless, the notes are still played with the rest following. (Another quirk of abc2midi.) Fix: in writetrack() (genmidi.c) rest_pending is no longer reset to 0 if the note is inside a chord. **note** this change was undone Feb 4 2010 January 06 2010 Abc2midi new feature: a missing Fermata in a multivoiced tune can cause a loss of synchrony between the voices. As an aid in detecting this problem, a new run parameter was introduced. -NFEM will cause abc2midi to ignore all fermata markings in the abc tune. Implementation: introduced a new global variable ignore_fermata which is normally set to 0 into store.c. If it is nonzero, then decorators[FERMATA] is ignored. January 10 2010 Abc2midi new feature: though abc2midi should shorten the notes preceded by a grace sequence in some circumstances it may fail to shorten it the right amount causing the voice track to lose synchrony with the other tracks. As an aid to detecting this problem, a new run parameter was introduced. -NGRA will cause abc2midi to ignore all notes in a grace sequence (enclosed in curly brackets {}). Implementation: a new global variable ignore_gracenotes (normally set to 0) was introduced in store.c. If both ignore_gracenotes and gracenotes are nonzero, then event_note ignores the current note. January 14 2010 Abc2midi bug: the -NGRA option messes up the output abc file for the following example. Track 2 is shorter than track 1. X:1 T:-NGRA option makes a mess L:1/2 M:2/2 K:C V:1 |: {d-}[de]f|ga :| V:2 |: {E-}[EF]G|AB :| Analysis: (You should review the operation of dotie and tiefix as described in this file at February 12 2005. Note the many other problems that were encountered with this code.) Before calling tiefix, the feature array looks as follows. (gdb) call dumpfeat(0,notes) 0 LINENUM 3 0 0 0 1 TITLE 0 0 0 0 2 LINENUM 4 0 0 0 3 LINENUM 5 0 0 0 4 LINENUM 6 0 0 0 5 DOUBLE_BAR 0 0 0 0 6 LINENUM 7 0 0 0 7 VOICE 1 0 0 0 8 LINENUM 8 0 0 0 9 MUSICLINE 0 0 0 0 10 BAR_REP 0 0 0 0 11 GRACEON 0 0 0 0 12 TIE 0 0 0 0 13 GRACEOFF 0 0 0 0 14 CHORDON 0 0 0 0 15 NOTE 74 8192 2 1 16 NOTE 76 8192 2 1 17 CHORDOFF 0 0 2 1 18 NOTE 77 8192 2 1 19 SINGLE_BAR 0 0 0 0 20 NOTE 79 8192 2 1 21 NOTE 81 8192 2 1 22 REP_BAR 0 0 0 0 23 MUSICSTOP 0 0 0 0 24 LINENUM 9 0 0 0 25 VOICE 2 0 0 0 26 LINENUM 10 0 0 0 27 MUSICLINE 0 0 0 0 28 BAR_REP 0 0 0 0 29 GRACEON 0 0 0 0 30 TIE 0 0 0 0 31 GRACEOFF 0 0 0 0 32 CHORDON 0 0 0 0 33 NOTE 64 8192 2 1 34 NOTE 65 8192 2 1 35 CHORDOFF 0 0 2 1 36 NOTE 67 8192 2 1 37 SINGLE_BAR 0 0 0 0 38 NOTE 69 8192 2 1 39 NOTE 71 8192 2 1 40 REP_BAR 0 0 0 0 41 MUSICSTOP 0 0 0 0 42 LINENUM 11 0 0 0 43 SINGLE_BAR 0 0 0 0 Note that that there is a TIE feature enclosed in the GRACEON and GRACEOF area but there is no NOTE or REST preceding. This is because we ran abc2midi with -NGRA which had removed all the notes enclosed by the grace complex. When dotie, attempts to process the TIE at 12 it fails to find a NOTE or REST and exits; however when dotie attempts to process the TIE as 30, it finds a NOTE in a different voice at position 21 and all hell breaks loose a big mess. Fix: to prevent dotie from searching for a NOTE or REST in a previous voice, we cause a break when feature[TIENOTE] == VOICE. while ((tienote > 0) && (feature[tienote] != NOTE) && (feature[tienote] != REST)) { tienote = tienote - 1; if (feature[tienote] == VOICE) break; /* [SS] 2010-01-15 */ }; to prevent a TIE from appearing in the first place in a grace complex when -NGRA was specified we add if (gracenotes && ignore_gracenotes) return; /* [SS] 2010-01-12 */ in the event_tie() function. January 23 2010 Code clean-up to remove the numerous warnings when compiling with the -Wall compilation flag. genmidi.c, mftext.c, midifile.c, midifile.h, and store.c were modified. There are still a few warnings to be checked out later. February 01 2010 Code clean-up. Removed unused functions -- slurtotie(), applybroken(), and delendrep() in store.c. February 01 2010 Abc2midi: support for multivoiced lyrics introduced. The following tune illustrates multivoiced lyrics. X:1 T:multivoiced lyrics M:2/4 L:1/16 K:C V:1 clef=treble V:2 clef=treble %%staves 1 2 V:1 C4 C4 | E4 G4 | c8 |] w: 1 2 3 4 5 V:2 C4 E4 | C4 B,4 | C8 |] w: 11 12 13 14 15 A warning "More than one voice with words in" appears. Though the MIDI file plays properly, the lyrics do not appear correctly in MIDI file players such as Melody Player. It was necessary to some significant changes to the way the information in the w: field is transferred to the MIDI file in order to ensure compatibility. This section describes how abc2midi treats the w: field in order to incorporate lyric text into a karoake style MIDI file. For multivoiced abc files, abc2midi only handles the lyrics in the first voice. There is interest in generalizing the program so that it can handle lyrics in multiple voices which are common in choir music. Parsing stage (store.c) ------------------------ All lyric text is copied into string array called words char** words; which is allocated by checkmalloc(maxwords*sizeof(char) where maxwords is set to INITWORDS 20. Each time a w: field is encountered, event_words() in store.c is invoked and places the string of text in the w: into words[wcount] where wcount is incremented. A new feature, WORDLINE is added to the feature array. The index wcount is saved in the pitch[] component of the feature arrays. If there is no continuation, of the w: command, then a WORDSTOP feature is added to signal the end of the w: field. In the event that the wcount index reaches maxwords, the function textextend() doubles the allocated space in words[] and doubles maxwords. event_words() also verifies that the lyrics originate from only one voice. Creation of the MIDI file (genmidi.c) ------------------------------------- Genmidi records the MIDI tracks using the function writetrack() which is called by mfwrite() in midifile.c. Mfwrite() was called by finishfile() in store.c There is no one to one correspondence between voices and MIDI tracks. Some voices may have two tracks. A voice containing lyrics is mapped into two tracks, one for the notes and another for the words. Two semaphores, wordson and noteson signal writetrack whether to record only the words, only the notes or both in the track. When writetrack scans through all the features in the feat array for the specific voice, the NOTE: and TNOTE: blocks inscribe the words or notes in the MIDI file depending on the status of the wordson and noteon semaphores. The gchord accompaniment is placed in a separate track, gchordtrack which was set by finishfile() in store.c. The voice containing the gchord indications is passed frome store.c to genmidi.c by means of the variable gchordvoice. The same applies to drumtrack and dronetrack which rely on drumvoice and dronevoice to establish the synchronization. The voice structures used in store.c are not passed to genmidi.c. All the information for writing the MIDI tracks come from the above semaphores and the feature,pitch,num,denom arrays which were passed from store.c. Genmidi does not know whether it is writing a split voice track (voice overlay) or a regular voice track. They both look the same. Genmidi must know the number of tracks in the MIDI file since this is recorded in the header chunk of the MIDI file. The current design of writetrack() assumes that if a lyrics track exists it must be in track 2 (counting from zero). There can be only one lyric track. To allow more than one lyric track (or voice containing lyrics), to allow a track to have notes as well as words embedded requires passing more information to genmidi. For instance we need to know whether a particular track should record lyrics or notes, and which voice number is the source. Changes: ------- Created a new function dump_voicecontext() in store.c which prints out the descriptors of all the voice contexts. Created a new structure trackstructure in store.c struct trackstruct {enum {NOTES, WORDS, NOTEWORDS, GCHORDS, DRUMS, DRONE} tracktype; int voicenum; }; and a new array Created struct trackstruct trackdescriptor[40]; which will be shared with genmidi.c Created a new function setup_trackstructure() in store.c which modifies trackdescriptor[]. Modified writetrack() in genmidi.c so that it can write more than one lyric track. Introduced an option to write lyrics in either the same track as the notes or else in a separate track (-STFW). Added "int hasdrums" to voice structure in store.c. Added "int hasdrone" to voice structure in store.c Cleaned out dronevoice, drumvoice, dronetrack, drumtrack, gchordvoice, gchordtrack variables from store.c and genmidi.c Removed warning "More than one voice with guitar chords in" One of the benefits of the new organization is that now you can have drums and gchords in more than one voice as shown in the following examples X:1 T: double gchords M: 2/4 L: 1/8 K: C V:1 %%MIDI chordprog 1 %%MIDI gchord fffff "G" z4|z4| V:2 %%MIDI chordprog 90 %%MIDI bassprog 90 %%MIDI gchord ghii "G" z4|z4| X:1 T: drums in two voices M: 2/4 L:1/8 K: C V:1 %%MIDI drum dddddddd 35 36 37 38 35 36 37 38 %%MIDI drumon |G4|G4| V:2 %%MIDI drum d2d2 40 41 %%MIDI drumon |C2D2|EFGA| February 04 2010 Abc2midi bug: the following tune is not converted correctly and the drone is not heard. X: 129 T: Drone Bug M: 2/4 L: 1/8 K: Gdor Q:1/4=140 G\ %%MIDI drone 109 67 67 50 50 %%MIDI droneon %%MIDI program 41 | c2 c2 |(3cBA GB|c2 c2 |(3cBA GB | %%MIDI program 111 %%MIDI droneoff Analysis: this yet another bug introduced by the change in dodeferred (September 20 2009). (See also December 12 2009 and Jan 05 2010). Fix: in dodeferred replaced the lines /********* delta_time = 0L; [SS] 2009-09-20 [SS] 2009-12-12*/ if (!rest_pending) delta_time = 0L; /* [SS] 2009-12-12 */ with if(wordson+noteson+gchordson+drumson+droneon == 0) delta_time = 0L; This is a better fix to the bug addressed on September 20 2009. Removed the variable rest_pending and all references in genmidi.c February 07 2010 Abc2midi: segmentation errors when applying abc2midi on a large collection of tunes in an abc file. Analysis: two array index out of bounds problems were identified in store.c. The variable num2add was not reset to 0 in the function scan_for_missing_repeats() causing the array add_leftrepeat_at[100] to overrun when a large collection of tunes is processed. (Also many spurious BAR_REP's are inserted into the feature[] array.) A separate problem caused by insertion of BAR_REPs is that the part_start[] array no longer points to the correct location of the PART feature in the feature[] array. This causes fillvoice() to induce a segmentation error because partlabel contains bad data. Fix: (1) reset num2add to 0 in scan_for_missing_repeats(), (2) add_missing_repeats() also increments the addresses in part_start[] after each insert in the feature[] array. As a precaution, fillvoice() in genmidi() reports an error if variable partlabel is out of bounds. As a precaution v1index is also reset to -1 and splitdepth set to 0 in startfile(). February 09 2010 Abc2midi bug: drum voice fails to materialize in this tune. X: 30 T: Drum fails to materialize M: 8/4 L: 1/8 Q: 1/4=120 K: D octave=1 %%MIDI program 74 %%MIDI drum dzdzdzdzzzzzzdddd 41 43 41 43 45 45 45 45 |:z2g2e2c2 gagfe2c2|\ %%MIDI drumon z2g2e2c2 gagfe2c2| c2^d2e2ga g2^d2ccg2|\ c2^d2e2ga g2^d2ccc2:| Analysis: setup_trackstructure() sets the number of tracks to 1 if there is no drumvoice, gchordvoice, karaoke, or dronevoice. Unfortunately drumvoice was not set when %%MIDI drumon was encountered. Fix: drumvoice is set to v->indexno when %%MIDI drumon is found. February 23 2010 Abc2midi lyric bug: abc2midi does not treat the double hyphen in the w: line. In the following example X:1 T: lyric bug M: 5/4 L: 1/4 K: G cdefg w:one two--three four the word four should be under the g note not f. Analysis: the problem occurs in the function getword() in genmidi.c. After processing a syllable the second 'while loop' skips over all following control codes. It should increment syllcount when it encounters a hyphen so that another note will be skipped. February 23 2010 Abc2abc does not copy s: and d: (symbols and decoration lines) but instead puts a blank line. In the following example: X: 2 T:Aaron's (Rarified) Air M:4/4 L:1/4 K:G D|"G"DG "D7"FA|"G"G2 DD|G3/2A/2 Bc|\ d3d|"C"e3/2d/2 ce|"G"d3/2c/2 Bd|"Am"cB AG|\ s: .. .... .... .... "D7"FG AD| abc2abc example.abc abc2abc aaron.abc -t 2 X:2 T:Aaron's (Rarified) Air M:4/4 L:1/4 K:Amaj E|"A"EA "E7"GB|"A"A2 EE|A3/2B/2 cd|\ e3e|"D"f3/2e/2 df|"A"e3/2d/2 ce|"Bm"dc BA|\ "E7"GA BE| Fix: added event_field(key, place) to case 'd' and case 's' in parsefield(key,field) in parseabc.c. March 27 2010 - contributed by Bas Schoutsen abc2midi now reads w: lines starting with hyphens, example: X:1 K:C A w:la- BcdA w:---la X:2 K:C A w:la-- BcdA w:---- BcdA w:--la Fix: introduced new global variable hyphenstate in genmidi.c/getword(). April 08 2010 contribution by Bas Schoutsen Abc2midi lyric bug: tied notes at the end of the line shifts the lyrics one place further ahead in the following example. X:1 T: tie 2 M:4/4 L:1/4 K:C cdef-| w:c d e x- fgag w:-g a g Fix: in genmidi.c a new global variable onemorenote were introduced plus additional code in getword() and checksylables() to handle the situation. April 15 2010 Abc2midi: incompatibility with Melody Player, MidiNotate, NoteWorthy Player and other commercial products. In the following example, X:1 T:Zijn niet de tien gereinigd C:Willem Vogel M:C| K:C z4z2A2|[M:5/4]c4A2A2A2|[M:3/4]c4A2|[M:5/4]d4B2B2B2|[M:C|]e4A4|d4G4|c4B2A2|G6G2|A4E2E2|G4D4|E4F4|D8-|D8-|!fermata!D8|] the time signature 5/4 is placed at the beginning instead of the second measure. Analysis, the MIDI meta Text event Time signaturea= 5/4 is placed at MIDI Time = 1919 instead of MIDI Time = 1920. Apparently, when the MIDI Player performs the division 1919/480 (where 480 is the number of divisions per beat) the result is truncated instead of rounded. Fix, in set_meter(n,m) defined in genmidi.c, the last statement was changed to mf_write_meta_event(delta_time, time_signature, data, 4); (delta_time replaces 0L.) **Note** this change was retracted on July 07 2010 and a different fix was introduced. April 21 2010 Abc2midi bug: The fix described on April 15 2010 introduced a more serious bug. In the following example X: 15 T: Accompaniment starts at the wrong time M: 2/4 L: 1/8 K: Am %%MIDI program 57 | CDEF|CDEF| CDEF|CDEF| M:2/4 %%MIDI drum dddz 35 48 60 %%MIDI drumon %%MIDI gchord fczz %%MIDI bassvol 40 %%MIDI chordvol 40 |"D" dcBd |d2B2 |cBAc |B2A2 |\ z2d2- |d2B2 |c4 |B2A2 | Both the drum and chordal accompaniment start 4 bars late. If the second M:2/4 indication is left out, the accompaniment starts at the correct time. Fix: in set_meter() the change if (noteson) /* [SS] 2010-04-21 */ mf_write_meta_event(delta_time, time_signature, data, 4); /* [SS] 2010-04-15 */ else mf_write_meta_event(0L, time_signature, data, 4); /* [SS] 2010-04-15 */ seems to fix the problem. **Note** this change was retracted on July 07 2010 and a different fix was introduced. May 08 2010 Abc2midi new feature: the abc draft standard 2.0 http://abc.sourceforge.net/standard/abc2-draft.html#K:%20-%20key allows one to explicitly define all accidentals of a key signature using the notation K: exp Thus K:DPhr ^f could also be notated as K:D exp _b _e ^f where exp is an abbreviation for explicit. The standard states that the notes should be in lower case; however, as a compatibility measure with abcm2ps upper case notes are also allowed with this feature. Fix: in parseabc.c (parsekey) checked for string "exp" and set a new variable explict to 1 if the string is present. Added the variable explict to the function event_key(..) which is defined in store.c, toabc.c, yapstree.c, matchsup.c, and parseabc.h. Note the applications abc2abc, yaps, abcmatch do not support this feature presently. May 20 2010 Abc2midi in compatiblity. For the following example X: 1 T: Araber tants R: Terkish M: C L: 1/8 K: Dphr ^F D2 "A"\ | "D"FGA2 A2A2 | "Gm"B6 AG | "D"^FGA2 "Eb"BAGA | "D"GF3 z2D2 | abc2midi ignores ^F in the K: field command. The draft 2.0 standard states that modifiers should be in lower case. Thus the K: field should be written as K: Dphr ^f Since abcm2ps allows upper case modifiers too and distinguishes them, I now allow both upper and lower case modifiers. Fix: commented out if (expict) in parseabc/parsekey(). This also maintains compatibility with various Klezmer transcriptions. May 21 2010 Abc2midi bug: abc2midi crashes when the -c option (checking only) is selected. eg. abc2midi test.abc -c Floating point exception Analysis: division by zero occurs when set_meter(header_time_num, header_time_denom) because both input parameters are zero. These parameters are not set when the c option is selected. Fix: in finishfile() (store.c) set header_time_num and header_time_denom when check is set. if (check) { Mf_putc = nullputc; header_time_num = time_num; /* [SS] 2010-05-21 */ header_time_denom = time_denom; /* [SS] 2010-05-21 */ May 24 2010 Abc2midi compatibility bug: the key signature K:C^f^c is not parsed correctly. (Such indications occur in many Klezmer tunes.) Analysis: parsekey (in parseabc.c) expects a space separating the key signature modifiers ^f and ^c. Fix: readword() in parseabc.c was changed so that it splits a string when it encounters '^' and '_' as well as '='. May 26 2010 Abc2midi crashes with a segmentation error for file demo.abc (included with abcMIDI package) when run on any specific tune eg. [seymour@localhost abc]$ abc2midi demo.abc 2 writing MIDI file demo2.mid Segmentation fault Analysis: abc2midi scans the entire demo.abc file. When it encounters %%MIDI drumon in tune 7, it attempts to set v->drumon = 1. The v structure has not been allocated, so a null pointer is encountered. Fix: also tested the variable dotune in the following test if (strcmp(command,"drumon") == 0 && dotune) { /* [SS] 2010-05-26 */ in event_specific, in store.c. May 31 2010 Abc2midi does not process K: field when key is missing but sharps and flats are indicated explicitly. This typically occurs in some Klezmer tunes. In the following example X:1 T:explicit key M:2/4 L:1/8 K:^c^d^e CDEF|DEGA| abc2midi returns the messages Error in line 5 : First K: field must specify key signature Warning in line 6 : Ignoring text: CDEF|DEGA| Error in line 7 : No valid K: field found at start of tune and does not produce a MIDI file Analysis: the messages are produced when parsekey returns a zero value for the flag gotkey. Fix: if parsekey succeeds in parsing some information in the K: field (parse == 1), then gotkey is set to 1 and sf is set to 0 (i.e. C scale). June 26 2010 Abc2midi bug. Tempo command (eg Q:60) applied at the wrong place in a multivoiced abc file containing a change in dynamics. In the following example: X: 1 T: Branles M: 4/4 L:1/8 Q:1/4=110 K:C V:1 CDEF GABc | CDEF !p!GA[Q:60]Bc | V:2 K:C |[C,G,]4 [G,,F,]4 | [C,G,]4 [G,,F,]4 | the Q:60 is applied after the second note (D). Analysis: the !p! command resets delta_time to zero in track 1 (where the TEMPO command is inserted) because of the line if(wordson+noteson+gchordson+drumson+droneon == 0) delta_time = 0L; at the conclusion of the function dodeferred (in genmidi.c). As a result when TEMPO is encountered, delta_time only reflects the next two notes GA after the !p!. Unfortunately, if we do not set delta_time to 0L, then another bug comes back (September 20 2009). Fix: it is necessary to introduce another global delta_time_track0 which is shared between genmidi.c and queues.c. delta_time_track0 is updated by queues.c but is only used by the TEMPO command in genmidi.c July 1 2010 Abc2midi does not recognize tabs in field commands K: and V: eg. X: 1 T:Danse M: 4/4 L:1/8 Q:1/4=110 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% V:1 nm=Oboe snm=Ob V:2 nm=Basse snm=Bs %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% V:1 % Oboe %%MIDI channel 1 %%MIDI program 68 K:Gm GABc def2|edcd BcA2 | GABc def2|ec[Q:100]B[Q:90]d[Q:80] A[Q:70]F[Q:60]G2|] V:2 % Basse %%MIDI channel 2 %%MIDI program 46 K:Gm [G,,D,]4 [G,,D,]4 |[G,,D,]4 [G,,D,]4 |[G,,D,]4 [G,,D,]4 |[G,,D,]4 [G,,D,]4 |] %%% Analyses: tabs instead of spaces occur after V:1 and V:2. Abc2midi processes 1\tnm=Oboe as a single word etc. As a result abc2midi identifies four voices instead of 2. Fix: in readword() (parseabc.c) added (*p != '\t') in the while predicate. July 07 2010 Abc2midi bug occurs when a rest is followed by a time signature. In the following example: X:1 T: time signature M: 2/4 L: 1/8 K: C V:1 E2D2|[M:2/4] D2F2| V:2 z4|[M:2/4] f2e2| the rest z4 is held too long causing a loss of synchrony between the two voices. If the following meter change is removed in the two voices, the problem disappears. The rest is also held too long in the single voiced tune (no V: command). Analysis: this bug was introduced with the April 15 - April 21 2010 changes to write_meter() in genmidi.c (see above). Fix, I restored write_meter() to its original state reintroducing the incompatibility with Melody Player and several other players. To fix the incompatibility, delta_time was initialized to 1 instead of 0 in writetrack() (genmidi.c). July 11 2010 Abc2midi: new feature. Added warning "no default gchord string for this meter". The message appears once if no gchord string could be set and a guitar chord appears in the music. Implementation: the gchord string is set to 'x' by default. If dogchords finds 'x' it outputs the message one time. July 27 2010 Abc2midi: possible bug. No voice command assumed. In the following sample: X:1 T: voices M: 2/4 L: 1/8 K: G GABc|BAGF| V:2 FGAB|defg| tht V: field occurs past body; will include this body with this voice."); 1 voice command is missing after the K: G. abcm2ps understands that there are two voices; however, abc2midi appends the second voice to the first voice. Analysis: in order to handle named voices parsevoice in parseabc.c assigns a sequential number starting from 1 to the first voice it encounters. This gets confused with the body which also has the same voice number. I did not see any clean way of fixing this problems; however, there is now a warning in event_voice (store.c) when this potential problem occurs. {event_warning("First V: field occurs past body; will combine this body with this voice."); In order to detect this problem, it was necessary to introduce the flag bodystarted. July 29 2010 Abc2midi bug: in the following tune X:1 T: K: bug M: 4/4 L: 1/4 K: E V:1 K: treble EFGA|Bcde| the E major scale was not set up. Analysis: this bug was introduced in May 31 2010. In the second K: command, parsekey (in parseabc.c) sets sf to 0 and gotkey to 1. This forces event_key to change the key signature to the C major scale. Fix: in order to handle key signature mods, we introduced a new flag modnotes which is set when it encounters a ^, _ or == in the K: command. If gotkey is zero and modnotes is set, then explct is set to 1 so that event_key will process the key signature modifications. August 12 2010 Abc2midi bug: delayed start of drum pattern for second voice. In the following example: X:1 T: drumbug M:4/4 L:1/1 K:C % V:1 %%MIDI drumon %%MIDI drum d2zd 35 38 120 50 %| x|x| % V:2 %%MIDI drumon %%MIDI drum dzdz 67 68 100 80 %| x|x| the drum generator for the second voice begins one bar late. If you remove the comment before the single bar in second to last line, the second voice starts on time. Analysis: dodrums() in genmidi.c is called by progress_sequence in queues.c provided the Q structure is not empty (Qhead not -1). In the case of the first voice, the Q structure is setup by checkbar() in genmidi.c because it was called by softcheckbar() when the DOUBLE_BAR feature was encountered. For the second voice, no DOUBLE_BAR feature was encountered, so the Q structure was not set up for the drum track. If the voice starts with a single bar, checkbar() is called and everything is properly initialized. Fix: added to starttrack() in genmidi.c if (drumson) { /* [SS] 2010-08-12 */ drum_ptr = 0; addtoQ(0, drum_denom, -1, drum_ptr, 0); } This seems to fix the problem. August 28 2010 abc2midi bug: voice splits does not work when the unit length is not the default value 1/8. In the example X:1 T: split voice bug. K:C L:1/2 |:cd |1 c2 & e2 :|2 C2 & G2 |] The split voice was transformed with the wrong unit length. If L: is set to 1/8 the MIDI file is correct. Analysis: v->default_length has the wrong value for the split voice. Fix: in event_split_voice (store.c) v->default_length is transfered to the split voice. August 31 2010 abc2midi bug: rests inserts after [Q:1/4=100]. In the following example X:1 T: Rallentando M: 4/4 L: 1/4 Q:1/4=120 K: C C C C C | C C C C | C C C C | C C [Q:1/4=100]C [Q:1/4=80]C | C1 |] there is a large silent period inserted after the Q:1/4=100 command. Inserting a V:1 after K: C fixes this problem. Analysis: this bug was introduced on June 26 2010 in effort to fix a related problem. Unfortunately, for single track MIDI files this caused another problem. Fix: if the MIDI file has only one track, the program reverts to the old code. September 28 2010 abc2midi bug: multiple repeats does not work correctly. In the following example, X:1 T: repeats M: 2/4 L: 1/8 K: C |:G2A2|[1,3 B2f2:|[2,4 B2c2:| G2A2 is played again after the last repeat. Analysis: in genmidi.c maxrepeats was incremented to 5. Fix: limited maxrepeats to 4 or less. (Note [1,3,5 does not work because inlist() in genmidi.c does not check beyond two numbers.) November 21 2010 abc2midi bug: when the path name to the abc file contains embedded periods, eg. "C:\Documents and Settings\midi.stadsmuur.INTERN.018\Local Settings\Temp\temp.abc" abc2midi places the output midi file in the wrong folder eg. "C:\Documents and Settings\midi Analysis: the problem is in the code *filename = argv[1]; outbase = addstring(argv[1]); for (j = 0; j< (int) strlen(outbase); j++) { if (outbase[j] == '.') outbase[j] = '\0'; }; }; in the function event_init() in store.c. Fix, the loop should go backwards and stop at the first period. outbase = addstring(argv[1]); /* [RM] 2010-11-20 */ for (j = (int) strlen(outbase); j>0 ; j--) { if (outbase[j] == '.') { outbase[j] = '\0'; break; } }; Thank you Reinier Maliepaard for identifying the bug and proposing a solution. December 07 2010 abc2midi: New feature: tempo indication compatibility with abc standard 2.0. The standard allows the following syntax for the Q: command; X:1 T:tempo M:2/4 L:1/4 K:G Q: "Adagio" CD|EF| Q: "Adagio" 1/4=40 GA|Bc| Explanation: "Adagio" translates into 1/4=59. In the second Q: command, 1/4=40 overrides the default tempo for "Adagio". See abcguide.txt for other tempo directives. Please note that the double quotes are mandatory. Implementation: in store.c, translation tables temponame[] and temporate[] were added; also the function get_tempo_from_name() was introduced. December 10 2010 Abc2midi bug: abc2midi crashes if the above tempo descriptor is not enclosed in double quotes. See example below. X:1 T:tempo causes crash M:2/4 L:1/4 K:G Q: Adagio CD|EF| Analysis: the segmentation error occurs in the new function get_tempo_from_name(s) in store.c. The string s is empty nad causes the program to crash when strcasecmp() is called. Fix: added the test if (s == NULL) return 0; /* [SS] 2010-12-10 */ in get_tempo_from_name(s). Now the program returns Error in line 6 : malformed Q: field ignored December 12 2010 yaps: bug. The following file crashes yaps. X:1 T:yaps segmentation error Q:1/4=60 M:2/4 L:1/16 K:Bb Q:1/4=60 "F"F2FF AFAc |"Bb" B2 z2 B2 \ z2 | z4 | %%printtempo 0 "Bb"((3_b2a2g2) f2d2 | B2BB dBdf | "F"F2FF AFAc | "Bb"B2z2 "D"A2z2 | P:Accelerando --------------------------->---------------->----------------------- [Q:1/4=65] "Gm"G2B2 G2B2 |[Q:1/4=70] "D"A2 D4 D2 |[Q:1/4=80] "Gm"G2B2 G2B2 |[Q:1/4=90] "D"d2z2 d4 | Analysis: yaps does not expect such a long label in the P: field. Fix: in event_parts(s), in yapstree.c, changed char label[20] to char label[200]. January 1 2011 abc2midi irrelevant messages when running on a collection of tunes in a file. (eg. "voice mapping ..." and "First V: field occurs past body..."). Analysis: the variable voicecode in parseabc.c was not reset to 0 when the next tune was processed. Also the variable bodystarted in store.c was not reset to 0 when the next tune was processed. Fix: in parseabc.c, call init_voicecode() after event_ref() called; in store.c, set bodystarted to 0 in event_ref(). February 21 2011 abc2abc : the program now attempts to transpose the key modifications in the key signature. For example: K: Dphr^F will be transposed to EPhr^G (for abc2abc -t 2). Explicit key modifications are also supported. These key signatures are used a lot in Klezmer music. Unfortunately, the algorithm does not always work correctly. Perhaps someone can help me. All the new code is in toabc.c before the function event_key(). I have given up in treating double sharps and double flat modifications. April 14 2011 abc2abc bug: when using the voice extraction feature -V n, the program still reports errors occurring in other voices causing some confusion. In the following example, voice 1 has 5 beats instead of 4 in bar 1 (we count from zero). X:1 T: confusing error message M: 4/4 L: 1/4 K: C V:1 ABcg|dcABE| V:2 Acde|feFE| When extracting voice 2: abc2abc xabc.abc -V 2 X:1 T:invisible note problem M:4/4 L:1/4 K:C %Error : Bar 1 is 5/4 not 4/4 V:2 Acde|feFE| The error message applies to a problem in voice 1 even though the program is extracting voice 2. Analysis, abc2abc processes the entire file but merely suppresses all voices except the one requested. Error messages in other voices are not suppressed. Fix: the flag output_on in toabc.c is used to suppress output of the unwanted voices. The functions event_error(s) and event_warning(s) now check both flags echeck and output_on before printing. April 14 2011 abc2abc bug: when extracting a particular voice, abc2abc fails to print the part field command P:. In the following example, X:1 T: abc2abc missing part M: 2/4 L: 1/8 K: G P: Intro V:1 V:2 V:3 P:A V:1 V:2 V:3 abc2abc pabc.abc -V 1 X:1 T:abc2abc missing part M:2/4 L:1/8 K:G P:Intro V:1 V:1 P:A is missing in the output, however abc2abc pabc.abc -V 3 X:1 T:abc2abc missing part M:2/4 L:1/8 K:G P:Intro V:3 P:A V:3 P:A is present when the last voice is requested. Analysis: P:A is considered to be part of voice 3, so it was suppressed when any other voice was extracted. Fix: the P: command should be treated as the start of a new section so that the control flag output_on should be set to 1 whenenver this command is encountered. This occurs in the function event_part() in toabc.c. April 17 2011 abc2abc new feature: normally abc2abc converts all instructions (decorations) like !ppp! to +ppp+ in order to comply with the abc standard 2.0 which has deprecated the former convention. A new option -noplus, causes abc2abc to use the deprecated convention to represent all instructions and decorations. Implementation: a new global integer noplus was introduced in toabc.c code. April 17 2011 abc2abc bug: abc2abc fails to recognize clef=perc, eg. X:1 T: clef= error M: 2/4 L: 1/8 K: G V:drum clef=perc !f! CDEF| causes abc2abc to issue a warning %Warning : cannot recognize clef indication Fix: added to isclef() in parseabc.c if (strncmp(s, "perc",1) == 0 && strict==0) { gotclef = 1; } /* [SS] 2011-04-17 */ April 18 2011 abc2abc bug: fails to transfer all voice parameters. In the following example X:1 T: missing stafflines parameter M: 2/4 L: 1/8 K: G V:drum clef=perc stafflines=1 CDEF| abc2abc fails to copy 'stafflines=1' to stdout. Analysis: parsevoice in parseabc.c ignores anything it does not recognize. stafflines=1 is a parameter used by abcm2ps. Fix: added to voice_params in parseabc.h int gotother; char other[V_STRLEN]; added to parsevoice(s) in parseabc.c vparams.gotother = 0; vparams.other[0] = '\0'; if (!parsed) parsed = parseother()... introduced a new function in parseabc.c parseother(); added to event_voice() in toabc.c if( vp->gotother ) { sprintf(output, " %s", vp->other); emit_string(output);} April 19 2011 parseother() in parseabc.c added check for break caused by '='. April 19 2011 Abc2midi: By popular demand the message "missing BAR_REP for voice inserted for voice ... " has been suppressed. The BAR_REP |: is still inserted back when it is expected. (It could be inserted in the wrong place.) April 29 2011 Abc2midi: Jurgen Schwietering has contributed the roll ornament for the harp described here. The operation is quite simple, instead of generating a grace the ~ ornament on harp is a roll with the same 3 notes (always) which can be quite accurately transcribed as ~n2 := n/n/n (BTW played always with fingers 4 3 2 [a m i]) ~n3 := n/n/n2 (for dotted, execution same as previous) It is NOT a movement done before the beat like graces. It is very common among folk harpists. A new MIDI command %%MIDI harpmode 1 changes the ornament to harp mode. To switch back to regular mode, use %%MIDI harpmode 0 Alternatively, you can specify the harp mode in the command line to abc2midi, eg. abc2midi inputfile.abc -HARP Implementation: a new global variable harpmode was introduced which is modified by the MIDI command or set in event_init() in store.c. The function doornament() checks the harpmode flag and calls the new functions makeharproll3() or makeharproll() in store.c. Here is a sample file to test this feature. X:61 T:The Glass of Beer C:Reel, Trad. Irish C:Arr. Gráinne Hambly M:4/4 L:1/8 K:D Q:1/4=130 %%MIDI program 1 46 %%MIDI harpmode 1 ~B3 ~B4 B| ~B2 B/B/B ~B4| %%MIDI harpmode 0 ~B2 B/B/B ~B3 B| ~B2 B/B/B ~B4| June 6 2011 Abc2midi bug: For the following file, X:1 T:part not found M:3/8 L:1/16 P:B K:Dphr^f %MIDI gchord fzz P:A "G"cdefga:| P:B M:2/4 |:d4e4:| (Comment: a common trick in transcribing music to abc is to temporary split it into parts so that you do not have listen to the beginning each time you are checking it out. The following problem occurs when you attempt to skip the beginning.) abc2midi returns the error message genmidi.c:fillvoice partlabel -55 out of range genmidi.c:fillvoice partlabel -55 out of range and the resulting MIDI file does not contain any music. Analysis: The function findpart (in genmidi.c) looks for P:B in the feature[24] which was its original location, unfortunately it has been moved to feature[25] by add_missing_repeats() (store.c) but part_start was not updated correctly. The problem is with the loop, for (j=0;jD B,>D G>TB | GA Bc dc | GA Bc dc | [V:2] B,>A, G,>A, B,>D | G,A, B,C DC | G,A, B,C DC | The problem also appears when trills are combined with grace notes as illustrated here. X:1 L:1/8 M:3/4 K:Am Q:1/4=60 V:1 c2 {d}TcB/c/ d>B | BA Ac e>d | V:2 A2{B}A^G/A/ B>G |^GE EA c>B | Analysis: The trilled or rolled notes are expanded into a sequence of notes as soon as they are detected. As a result, the grace or broken rhythm is applied to the first note of this sequence. To fix this problem it is necessary to expand trills and rolls after broken rhythms and grace notes are treated rather than as soon as they are detected. Fix: (2012-05-29 to 2012-06-03) a new function expand_ornaments () is called by finishfile() that converts trilled and rolled notes into a sequence of notes. The defunct function dotrill() was split into dotrill_setup() (called by event_note) and dotrill_output() called by expand_ornaments(). Similarly, doroll() was split into doroll_setup() and doroll_output(). Notes to treated by expand_ornaments() were flagged using a new feature array called decotype[] which was checkmalloc'd like stressvelocity, and pitchline. If the note was flagged it is treated by either dotrill_output() or doroll_output() depending on its type. The implementation was complicated by the problem, that the internal representation of the music in the feature arrays does not preserve the key signature information which is needed to decide whether to ascend (descend) a tone or semitone in the trill or roll. Therefore it was still necessary to analyze the context of the trill or roll at the time of detection using the .._setup() functions and save the generation parameters for .._output() in a specifically designed struct called notestruct. These structures are generated as needed, but a pointer array noteaddr[1000], (assuming not more than 999 trills or rolls occur in a particular tune) is used to find the struct. The notestruct struct thus acts as a bridge between the setup and output functions. Treatment of microtones added another complications and at this point I have not verified whether the new code is correct with regard to microtones. There is still a synchronization problem when broken rhythms are combined with ornaments as illustrated below. X:1 T: ornament test M: 2/4 L: 1/8 K: G V:1 D2 >~B2 |c2 G2| V:2 F2 >D2| e2 D2| Ornaments are handled in a different fashion. If harpmode is set, then ornaments are expanded into a sequence of notes like trills and rolls. If harpmode is not set, then a grace note is inserted prior to the note and graceon() is called to make the final adjustments. Furthermore if the note is dotted, then two grace notes are added. For the present time you should avoid combining ornaments with broken rhythms in multivoiced tunes. August 08 2012 Abc2midi, yaps, abc2abc: The time signature C| or c| is now interpreted as 2/2 instead of 4/4. Implementation: added another test in void readsig() in parseabc.c October 03 2012 Chinese character support in lyrics was added to abc2midi by Bow Yi Jang . Changes were restricted to the function getword(.) in genmidi.c November 03 2012 Abc2midi multirest bug. In the following example, X:1 T: multirest problem M: 2/4 L: 1/8 K: G Z|G4|\ M:3/4 L:1/8 Z|D6| The second multirest preceding D6 is held for two beats instead of three and the warning Warning in line 9 : Bar 2 has 2 units instead of 3 appears. Analysis: the function event_mrest (store.c) uses the initial time signature 2/4 stored in time_num/time_denom which does not get updated by event_timesig() once the parser is in the body. abc2midi must keep track of two time signatures: time_num/time_denom which is declared in the initial field commands and mtime_num/mtime_denom which may be updated in the middle of the body. The initial time signature, is important for multivoiced tunes where the initial declaration is carried to the start of all the voices. The active time signature mtime_num/mtime_denom is only updated in the second stage in set_meter() when genmidi is processing the feature[] array and writing the MIDI tracks. However, the active time signature is also needed when event_mrest is called to write multiple bars of rests. Unfortunately, the active time signature was not maintained during the initial parsing stage (first stage). Fix: the variables mtime_num and mtime_num are now also used during the first pass and maintained in event_timesig(). event_mrest() uses the active time signature mtime_num/mtime_denom rather than the initial time signature time_num/time_denom. November 08 2012 Abc2midi: multirest bug part 2. The problem with meter change and multirests persists in multivoiced tunes. In the following example, X:1 T: Multirest bug part 2 M:C L:1/4 K:F V: 1 V: 2 %%MIDI program 1 73 %%MIDI program 2 40 %%staves [{ 1 2 }] [V: 1] F A z c| z4 | [M:3/8][L:1/8] F/>G/ FA|B/>c/ BA | G/>A/ GF|C3|] [V: 2] A F3 | Z | [M:3/8][L:1/8] Z | G/>A/ GA | B/>c/ BA | G3|] The first multirest Z in voice 2 is held for 3/8 instead of of 1/4. Analysis: voice 1 changes mtime_num/mtime_denom to 3/8 and it remains in that state at the start of voice 2. Fix: new variables int active_meter_num, active_meter_denom are introduced into the voicecontext struct. They are used to maintain the values of mtime_num and mtime_denom over voice switches. November 15 2012 Abc2midi extension: abc2midi treats Xn the same way as Zn, to be compatible with the new version of abcm2ps. Fix in parseabc.c added case 'X': /* [SS] 2012-11-15 */ after case 'Z': November 21 2012 Abc2midi: verbose option provides more detail if set to 4 or 5 for tracking segmentation errors. November 22 2012 The fixes for the following two problems were provided by Philippe De Muyter. The input line size in parseabc.c was increased from 256 to 512 to accommodate abc files that are automatically generated (eg midi2abc). char inputline[512]; Abc2abc truncates the voice ids when it encounters the first invalid character without giving any warning. eg. X:1 T: invalid voice M: 2/4 L: 1/8 K: G V: A_1 abcd| V: A_2 DEFG| only one voice is detected. Fix: In interpret_voicestring() in parseabc.c the following code was added after c = readword(code,s); if (*c != '\0' && *c != ' ' && *c != ']') { sprintf(msg, "invalid character `%c' in Voice ID", *c); event_error(msg); } Now abc2abc and abc2midi complain that they encountered an invalid character. November 23 2012 abc2midi bug: unable to trill or roll tied notes. In the following example X:1 T:trill-issue M:2/4 L:1/8 K:F V: 1 z4|z3d| V: 2 %%MIDI program 1 73 %%MIDI program 2 40 TF2 Tc2-| c Tf2-f| The tied notes c2-c and f2-f do not get trilled. Analysis: this bug was introduced on July 03 2012 in the attempt to fix other problems associated with trills. The function expand_ornaments() only processes NOTE features and ignores TNOTE features used to designate tied notes. Fix: The solution is to change TNOTE to a NOTE. However, writetrack() in genmidi.c processes TNOTE features in a special way in order that checkbar() will work when a tied note extends over a measure. The TNOTE invokes a midi on command but a midi off command is deduced from the following REST(s) which are associated with the tied note. Therefore, if we change TNOTE to a NOTE we also need to eliminate the REST(s) which are part of the TNOTE sequence. This is done by a new function, convert_tnote_to_note(). Unfortunately, this is not a clean fix. Checkbar() will give a misleading message when the tied note extends over a measure. Also, lyrics may not align correctly with tied and trilled notes. It gets messy to make expand_ornaments() to split up a trill across a measure. November 25 2012 Abc2midi: the compiler on Windows PC does not initialize arrays to zero when they are allocated. As a protection the arrays the bentpitch and decotype are now initialized to 0 when they are allocated. Some array pointers are now checked for valid values. December 01 2012 -- submitted by Philippe de Muyter abc2abc truncates a line to 512 characters without warning in the -P mode. (This is the continuation of the changes November 22 2012.) Analysis event_error is muted during the output so it is necessary to simulate it with a plain printf in the function print_inputline_nolinefeed() in the file parseabc.c. December 11 2012 abc2midi: bend note, new feature. Placing the instruction !bend! slides the pitch of the following note up. For examples: X:1 T: pitchbend M: 6/8 L: 1/8 K: Gdor %%MIDI program 78 whistle %%MIDI transpose 12 DEF G3|DEF !bend!G3| the second G is slid up. Implementation: added a new function note_effect to queues.c which is called by timestep(). Note effect inserts a sequence of pitch bend events prior to sending a MIDI note off. Added a new integer member, effect, to struct Qitem. The flag, effect, determines whether note_effect is invoked. An additional parameter, effect, was added to the function addtoQ which is also defined in queues.c. The function addtoQ is called in many places in genmidi.c. In abc.h added a new feature called EFFECT. The feature is inserted before a note when the instruction !bend! is encountered -- see event_handle_instruction() in store.c. In genmidi.c added a global flag, effecton, which is usually set to zero except when the EFFECT feature is encountered. The NOTE: handler in writetrack returns effecton in one of the addtoQ function calls. December 12 2012 abc2midi: bend configuration. Introduced two variables bendvelocity and bendacceleration into note_effect. Note_effect inserts 8 MIDI pitchbends equally spaced inside a note. The pitchbend is initialized to the neutral value of 8192. During the loop repeated 8 times, pitchbend and bandvelocity are incremented as follows. pitchbend = pitchbend + bendvelocity bendvelocity = bendvelocity + bendacceleration. The pitchbend is limited between 0 and 16383 usually corresponding to a negative and positive shift of two semitones on most General MIDI instruments. The variables bendvelocity and bendacceration can be set by the following %%MIDI command. %%MIDI bendvelocity n1 n2 where the integers n1 and n2 are the velocities and acceleration respectively. By default, n1 and n2 are initialized to 100 and 200. December 25 2012 Abc2midi part/trill bug. Introducing trills or ornaments in a multipart abc file causes erratic behaviour. For example, X:1 T:parts M:2/4 L:1/8 P:B K:C P:A CDEF|TGABc| P:B cBAG|FEDC| Part B is not played when the trill is present in part A. Analysis, abc2midi stores the start position of each part in the array part_start during the parsing stage. Unfortunately, things may move around during the later stages. The function expand_ornaments() inserts additional notes in the feature arrays when it does its expansion. This shifts the position of the parts and the information in the part_start array is no longer valid. Fix: created a new function fix_part_start() in store.c which is called after expand_ornaments() in finishfile(). Jan 27 2013 Abc2midi: the abc2midi allows but does not recommend the tempo command to just specify a number. eg. Q:320. abc2midi automatically assumes that this number refers to a quarter note; however, the abc standard 2.0 specifies that it should refer to the unit length specified by the L: command prior to the body. Fix: in parseabc.c changed a=1 to a=0 in the function parse_tempo(). The existing code in tempunits() in store.c does all the rest. Jan 28 2013 Abc2midi: the above change was withdrawn since there is disagreement between abc standard 1.7.6 and abc standard 2.0. February 25 2013 Abcmatch: introduced -wpitch_hist runtime parameter for computing the pitch histogram weighted by the note length. Some minor clean-up of the output. February 26 2013 Abcmatch: negative array index fixed in abcmatch.c (compute_note_histogram). Problem is exposed on Windows operating system. March 08 2013 -- patch submitted by Philippe De Muyter Abc2abc: the -V and -P options have been generalized so that more than one voice can be selected using a comma separated list. Implementation: The long global variable selected_voices represents the selected voice in a bit map. Each bit in the word corresponds to a specific voice number. Two new functions are introduced. parse_voices_selection parses the voices_string in the -P or -V command and converts it into the bitmap in the selected_voices variable. must_emit_voice(n) examines the n'th bit of the selected_voices and indicates whether it is on or off. The other change is the replacement of the control - if ((selected_voice != -1) && (n != selected_voice)) { with + if (!must_emit_voice(n)) { /* [PHDM] 2013-03-08 */ March 10 2013 -- also submitted by Philippe De Muyter abc2abc: fix chord's tuple length calculation Up to now, bar length was increased at first note of chord, and tuple status was lost at first note of last chord. When a chord in a tuple had a length modifier, the resulting bar length was wrong, which caused wrong error messages. With X:1 T:wrongbarlengtherror M:4/4 L:1/8 K:C z8 | z6 (3 [fd]/ [fd]3/ [fd] | z6 (3 [f/d/] [f3/d3/] [fd] | abc2abc gave a wrong message : %Error : Bar 1 is 13/12 not 4/4 Fix that, by incrementing bar length and decrementing `tuplenotes' at chordoff time, not at first chord note. Move also the tuple-implied length conversion in `addunits', to avoid code duplication. Because there are two ways to specify a chord length, [c2e2g2] and [ceg]2 in the first case, we must now memorize the note length to be able to retrieve it at chordoff time; this is done in the new `chordfactor' variable. Additionnaly, as 'addunits' is only called when we know the exact length of a note or chord, `repudiate_lastaddunits' is now useless and removed. March 14 2013 Abc2midi: part/repeat bug. In the following example X:1 T: Part - repeat bug Q:1/2=120 M:2/2 L:1/4 K:D %%vskip 0 P:Intro |: "Em"e4 || P:A || "D"d4 :| abc2midi returns the following messages: Error in line 12 : found another |: after a |: Warning in line 12 : Assuming repeat Warning in line 12 : replacing with double repeat (::) writing MIDI file temp21.mid Furthermore, the e4 in the Intro is repeated and then the D4 in part A is repeated. Since the P: are only labels here (there is no P: command preceding K:), it was expected that the entire the tune would be played as |: "Em" e4 | "D" d4 :| Analysis: the function scan_for_missing_repeats() which was introduced in June 23 2009 is the source of the problem. The function assumes that the tune is actually in two parts and inserts a |: in the beginning of part A. When fixreps() is called it discovers that two |: occur without an intervening :|, so it decides to replace the second |: with a double repeat ::. (Note that fixreps() would not be called if the parts were real and not just annotations.) Fix: The useless conditional statement if (J == PART || j == VOICE || j == BAR_REP etc. was commented out since it does nothing. In the following statement, an additional check parts != -1 was added. If parts == -1, this implies that the part indications are merely annotations and do imply a real part as abc2midi is concerned. Therefore bar_rep_found[] and voicestart[] are not cleared again, implying that a |: may need to be introduced at the beginning of the part if the part ends with a :|. March 20 2013 Abc2midi: invisible and visible multirest confusion with field commands. Z and X are used both as field declarations (X: reference number and Z: transcription source) and as multirests in the body. In unusual cases where the multirest is followed by a repeat sign and happens to be at the beginning of a line, it can cause confusion. For example, X:1 T: rests M:3/4 K:C c6|e6|^g6|\ X ::\ C6|e'6|^G6|\ Z :|\ [CE^G]6|] X:2 T:rests M:3/4 K:C c6|e6|^g6|\ X1::\ C6|e'6|^G6|\ Z1:|\ [CE^G]6|] are two examples which abc2midi fails to interpret correctly. parseline() in parseabc.c attempts to treat X :: and Z :| as field commands even though they are malformed. Abc2abc also does not produce correct output. Fortunately parseline issues warnings Warning in line 8 : whitespace in field declaration Warning in line 8 : potentially ambiguous line Error in line 8 : Missing Number and the transcriber is urged to reformat the line to avoid this problem. Fix: I am not sure whether I should fix this problem. In any case, I have put a small patch in parseline() so that the above examples are treated correctly. March 21 2013 abcmatch: several bug fixes and a new feature -pitch_table. Given a file containing a collection of tunes eg. Modes.abc, abcmatch Modes.abc -pitch_table will output the interval weighted pitch histogram for each tune. If the output is stored in a separate file, eg. Modes.tab, this table could be used for searching for the tune having the closest matching pitch histogram (a feature to be introduced in runabc). March 26 2013 abc2midi bug: if a chord is preceded by a Roll or Trill indication, abc2midi fails to encode the chord in the MIDI file. For example: X:1 T: chordtrill M: 4/4 L: 1/8 K:C V:1 %%MIDI program 16 T[ceg]4 [AEc]4 :| V:2 %%MIDI channel 10 GA GA GA GA :| A warning is issued that trills and rolls are not implemented for chords, but [ceg]4 is not encoded in the MIDI file. Fix: in event_note, in store.c added the lines pitchline[notes] = pitch_noacc; /* [SS] 2013-03-26 */ bentpitch[notes] = active_pitchbend; /* [SS] 2013-03-26 */ addfeature(NOTE, pitch, num*4, denom*2*(v->default_length)); /* [SS] */ following the statement event_error("Rolls and trills not supported in chords"); April 10 2013 Abc2midi: new feature. Added a new runtime option -CSM . This option allows one to customize the BarFly stress models by providing an external file. Background: the 32 stress models are presently built-in the source code in the file stresspat.c. This has the advantage that executables can be distributed without an auxiliary data file containing the models. However, the user does not have much leeway to alter the models or add additional stress models. The -CSM feature addresses this limitation by allowing the user to add more models for other rhythm designators (eg lesnoto), and to alter one or more of the existing models. There is room to add up to 16 additional models. The feature requires the user to specify a text file which contains these models. Description of the external file and how it works is given in abcguide.txt and a sample of such a file is given in the pt folder (customstress.txt). Implementation: a new function read_custom_stress_file() was introduced in the file stresspat.c. Assuming the file conforms exactly with the expected format, the function reads all the models provided. For each model, if the rhythm designator and meter conflict with one of the existing standard models, the function will update the characteristics of that model. Otherwise the function will append the model to the current list. April 11 2013 Corrected a minor error in init_stresspat() (Tango) in stresspat.c. As a convenience, I have produced default_stress.txt in the format that read_custom_stress_file() accepts. Default_stress.txt contains the built in models to abc2midi. You can find the file in the pt (Phil Taylor) folder. April 17 2013 Abcmatch: numerous bugs fixed. Introduced a new matching -norhythm. The matching algorithm ignores the length of the notes and only matches the sequence of pitches in a bar. The file abcmatch.txt was updated. More internal documentation was added in abcmatch.c April 20 2013 Abc2midi bug: combination of chords and broken rhythm. In the following example, X:1 T: broken rhythms M: 2/4 L: 1/8 K: F [DF]2 > [CE]2| The second chord [CE]2 begins before the end of chord [DF]2. Analysis: the function brokenadjust() (store.c) is called to adjust the lengths of the notes to effect the broken rhythm. It adjusts the notes inside the chord but fails to adjust the length associated with the CHORD (CHORDOFFEX feature). This causes timestep() in queues.c to be called too early, causing the second chord to start to early. Fix: in the function lenmul() added another condition, || (feature[n] == CHORDOFFEX)) /* [SS] 2013-04-20 */ April 21 2013 Fixed: a potential memory overflow in parsing the repeat string. In getrep() (parseabc.c) ensured the array index for playonrep_list does not exceed 50. April 24 2013 Suppressed warning in abc2midi. For the following example, X:1 T:TEST TUPLES M:2/2 L:1/4 Q:1/2=80 K:G [F,A,D] (3[df]/[eg]/[^e^g]/ [fa][CF] | [F,A,D] (3[d/f/][e/g/][^e/^g/] [fa][CF] | abc2midi issues the following warnings. Warning in line 7 : Different length notes in tuple for chord Warning in line 7 : Different length notes in tuple for chord Warning in line 7 : Different length notes in tuple for chord Analysis: the message is issued when closing each of the tuple chords in the first line. The length of the note in the tuple is stored in the variables tnote_num, tnote_denom when the first tuple note is encountered. Unfortunately when the chord note duration is applied (here one half), the note length no longer matches the stored values tnote_num and tnote_denom and a warning is sent. The output midi file nevertheless correct. Fix: abc2midi stores the note length of the tuple in tnote_num, and tnote_denom. A chordoff feature can modify the value of a tuple note (i.e. chord) if its length is indicated outside the chord (eg. [CE]3/2. If the modified chord length does not match the stored value tnote_num, tnote_denom set by event_note, a warning is issued. It is getting too complicated to keep track of a tuple note inside and outside a chord, so I have decided to just suppress the error message for tuples of chords. (i.e. I would have to make extensive changes to the logic of the program to get it working properly.) May 07 2013 Abcmatch: introducing -fixed runtime parameter. It allows matching to go across a bar line. See doc/abcmatch.txt for more information. May 10 2013 Midicopy: bug in extracting a segment of a MIDI file. When the segment starts in the middle of a note playing, it causes a loss of synchronization between the tracks. Analysis: there was an attempt to write a negative MIDI time increment when Mf_currcopytime exceeds Mf_currtime. Fix: set negative values to zero in the function WriteVarLen(value). June 06 2013 Abc2midi: potential segmentation error when applying stress model. The following tune contains stray text which abc2midi assumes to be part of the body of the tune. X: 157 T: Cliffs of Moher N: page 51 R: jig M: 6/8 K: Ador "Am"eaa bag| (4efaf "G"ged| "Am"c2A BAG| "Em"EFG ABc|\ "Am"eaa bag| (4efaf "G"ged| "Am"cAA BAG| "Em"EFG "Am"A3 :| "Am"efe dBA| efe dBA| "G"G2d dBA| GAB dBd|\ "Am"efe dBA| efe dBA| "G"GAB dBG| "Em"EFG "Am"A3| ~e3 dBA|~e3 dBA|"G"~G3 dBA|GAB dBd|\ "Am"efe dee|cee Bee|"G"EFG BAG|EDB, "Am" A,3| This abc file is used to generate the MIDI files and pdf file for volume 2 of the music collection used by the Ottawa Slow (Celtic) Jam. The file is derived from http://www.ceolas.org/pub/tunes/abc.tunes/sessionTunes.abc When the stray text is processed in the Barfly mode (-BF), the array index to the variable fdursum exceeds the allocated memory 32 which can cause a segmentation error on some systems. Fix: in the function fdursum_at_segment in genmidi.c, replaced inx0 = inx0 - nseg; with inx0 = inx0 % nseg; /* [SS] 2013-06-07 */ which is executed if inx0 > nseg. June 09 2013 Abcmatch: in -br mode the program returns both the number of matching bars in the tune and template. September 04 2013 Midicopy: new feature. Introduced the run time option -tempo n (beats/min). When this option is included all tempo messages in the midi file are replaced with the specified value. Implementation: in metaevent() when a tempo message is encountered, if newtempo is greater than zero, write the newtempo value instead of the value in the source midifile. The value of newtempo is set by the -tempo run time option. September 06 2013 Midicopy: new feature. Introduced the run time option -speed f (multiplier). When this option is included all tempo messages in the midi file are are multiplied by the factor f where f is a floating point number between 0.05 and 10.0. This speeds up or slows the music by this factor. September 07 2013 Midicopy: new feature. Introduced the run time option -drumfocus n m where n is the pitch code of the selected drum line and m is the velocity value to be applied to all other drum lines. The feature, highlights the selected drum line by attenuating all other drum lines by playing them at level m (m varies from 0 to 127). Implementation: the velocities of the other drum lines are set to m in function chanmessage() prior to sending a 'note on' message. September 08 2013 Midicopy: fixed function tick_to_seconds so it returns the correct time when the tempo is changed by -tempo or -speed. September 10 2013 Midi2abc, midicopy: bug fix. Midi2abc or midicopy may fail for some midi files which use the running status. A few midi files attempt to save a few bytes by not transmitting the status byte for a channel message when status byte has not changed. For clarification, the status byte contains the channel message like "note on channel 10". The status byte is followed by one or two data bytes specifying the particular note it applies to and the velocity value. Since data bytes are restricted to 6 bits and status bytes always contain a value exceeding 6 bits, it is easy to tell when a status byte is missing. The running status, saves a few bytes when several notes in a chord are turned on (or off) at the same time. The bug occurred when a metatext message is inserted inside a running status complex (eg. note on channel 10, metatext, note on channel 10). Midi2abc and midicopy abort with the message "unexpected byte 0x..". Analysis: the bug was traced to the code writetrack() in midifile.c and also midicopy.c. It is necessary to store the last status byte that occurred in the last channel message. Note a metatext message is not a channel message. A new local variable, laststatus, was introduced in the code. September 15 2013 Midicopy: new feature. Added an option -mutenodrum [level] to mute all channels to velocity level if the channel is not 9 (drum channel). If level is not provided, it is set to zero. Ocotober 1 2013 Midicopy: new feature. Added the option -setdrumloudness n m where n is the drum number between 35 and 81 inclusive and m is the new velocity between 0 and 127, All instances of the selected drum are assigned the given loudness (velocity). October 15 2013 Abcmatch: new feature. Added options -interval_hist and -interval_table to analyze the pitch intervals between adjacent notes. The program produces a histogram of the note intervals in MIDI (semitone) units. October 22 2013 Abcmatch: new feature. Added the option to accept a certain number of insertion, deletion, and substitution errors using the Levenshtein distance measure. October 28 2013 Midicopy: new feature: added the option to list the tracks to exclude from copying. eg. -xtrks 4,5 indicates to copy all tracks except 4 and 5. October 30 2013 Abc2midi: bug fix. A key change in the middle of a tune does not propagate to the split voice. In the following example, X:1 T:Test L:1/4 M:2/2 Q:1/2=110 K:C V:1 C4 | [K:Bb]B4 & B,4 | B,4 was not flattened. Analysis: the key change [K;Bb] was not propagated to the split voice. Fix: in event_split_voice() in store.c, the active basemap and basemul arrays for the voice was saved in a temporary area and transferred to the split voice. October 31 2013 abc2midi and yaps bug: for the following example, X:1 T: :|] ending M:C N:Portland p.19 R:march K:D |:"G" b2a2 "A"g2e2| "D"d4 d4 :|] abc2midi returns the error Error in line 10 : Chord already finished and yaps returns the error Error in line 7: no chord to close Analysis: these are extraneous error messages. Parsemusic() in parseabc.c detects the THIN_THICK bar line |] but does not detect it when it is preceded with ':'. Fix: check for ']' in this case and skip over. November 02 2013 Abc2midi: some instructions which are meaningful to abcm2ps are meaningless to abc2midi and cause a warning. In the following example, abc2midi cannot interpret !4! and !0!. X:1 T: instructions M: 4/4 L: 1/8 K: A "E"FEF(G "A" A2) !4!!0! [A2A2]| Warning in line 6 : instruction !4! ignored Warning in line 6 : instruction !0! ignored Analysis: event_handle_instructions(s) in store.c issues this warning when it cannot interpret this message. Fix: the message is suppressed if -quiet is included in the runtime parameters. November 2 2013 abc2midi indicates the wrong line number in a warning. In the following example, X:1 T: Slurs M: 2/4 L: 1/8 K: F z(GFE |:DE) FG| AB (3cBA:| abc2midi returns the message Error in line 8 : Unexpected end of slur found The end of slur is actually in line 7. Analysis: on the second repeat, no slur was started so an end of slur is not expected - but the line number in the error message is wrong. The repeat :| causes writetrack (in genmidi.c) to backtrack it restores the state variables to the condition where the opening repeat sign |: occurs but the state variables do not include the line number used by the warning or error message. Fix: expanded the functions save_state() and restore_state() so that the line number can also be saved. November 4 2013 abc2midi bug: A bug was detected when abc2midi is run with the Barfly stress model (-BF 1). For the following file t.abc X: 1 T: Barfly implementation bug R: jig M: 6/8 L: 1/8 K: G |: "C"c3 "G/B"B3 | "D7/A"AGF "G"GBd :| abc2midi t.abc -BF 1 the note c3 or B3 may be inaudible in some instances. Analysis: the local variable vel in the function noteon() may end up being undefined. In certain cases stress_factors() called by noteon() may not set the variable vel, in which case we expect note_beat() to be called. Unfortunately, if vel was initally nonzero note_beat is note called and vel has a random value. Fix: initialize vel to 0 in noteon(). November 04 2013 yaps fix: On January 16 2006 an option to display the notes in red was introduced. This code did not work well because the other musical components were also colored red. The problem was fixed by maintaining the color in black and temporarily switching the color to red when a note, beam or rest is drawn. A new variable redcolor was introduced in drawtune.c and set by the !red! command and reset to zero by !black!. The functions drawnote(), drawrest, and drawbeam() test this variable and switch the color to red on a temporary basis in order to draw the object. November 12 2013 abcmatch.c improvement. When running in absolute versus contour mode, abcmatch frequently transposes in the wrong direction when the key signatures differ since it does not know which direction to go. abcmatch now transposes in the direction of minimum distance between keys. For cut time C| abcmatch translates it to 4/4 rather than 2/2 so it can find more matches. Both changes are in abcmatch.c November 17 2013 abcmatch.c. Bug fixes so the matched bars have correct bar numbers. November 26 2013 abcmatch.c -br threshold applies to the number of matched bars in template instead of matched tune. December 2 2013 abc2midi bug - split voices and repeats. The following tune is not converted correctly. X:1 T: test split file 13 M: 1/4 L: 1/4 K: G |:G & E |1 D:|2 F & A| On conversion: writing MIDI file s11.mid Error in line 8 : Need || |: :| or :: to mark end of variant ending Warning in line 8 : Track 2 is 1946 units long not 2426 The program produces to MIDI tracks of unequal length. Track one contains G D G D F and track two contains E z E A. In other words track 1 plays both section one and two in the repeat instead of just section two. Surprisingly if we replace |1 and |2 with |[1 and |[2 respectively, the conversion is done correctly and there are no errors or warnings. Analysis: in the first pass the feature PLAY_ON_REP belonging to voice 1 was placed in voice 2 and two PLAY_ON_REP features appear consecutively in voice 2 resulting in the error, "Need || |: :| or :: ..." message. When the [1 and [2 are used, the internal representation contained in the feature arrays is correct. The problem was traced to the code in event_bar in store.c. When the [1 and [2 is used, the PLAY_ON_REP is handled correctly by event_playonrep() which is called directly by parsemusic in parseabc.c. When |1 or |2 is used, parsemusic does not catch these codes and they are handled (mishandled) by event_bar when a split voice is present. Fix: event_bar() was reorganized so that bar commands are sent to the original voice rather than the child split voices. When the child split voices are sync'd the bar commands are copied to the child voices. This seems to work better. The function recurse_back_and_change_bar() is no longer in use. The test tune was added to split.abc in the doc/programming/ folder. December 14 2013 abc2midi: The warning "track x is xxxx units long instead of ..." was changed to "track x is .... quarter notes long instead of ..." The change is was made in writetrack() in genmidi.c. December 25 2013 abc2midi bug: abc2midi does not read customstress files correctly using the -CSM option. The following file containing Lesnoto 7/8 7 7 110 1.3 90 1.0 80 0.7 100 1.2 90 0.8 100 1.2 90 0.8 is not read correctly. Neither the name Lesnoto or the meter is stored in the stresspat structure. Analysis: in the function read_custom_stress_file() in stresspat.c the lines stresspat[index].name = name; stresspat[index].meter = meter; copy the address instead of the contents of string arrays name and meter. The lines should read strcpy(stresspat[index].name,name); /* [RZ] 2013-12-25 */ strcpy(stresspat[index].meter, meter); /* [RZ] 2013-12-25 */ also gain and expand are not copied into the structures. add stresspat[index].vel[i] = gain; /* [RZ] 2013-12-25 */ stresspat[index].expcoef[i] = expand; /* [RZ] 2013-12-25 */ I am grateful to roman.zimmermann@gmx.at for identifying the bug and providing the fix. January 01 2014 Abcmatch: fixed matchsup.c so it catches only the first title of a tune in case that it has alternate titles. January 05 2014 Midiabc: bug the msb and lsb values were interchanged in mftext_pitchbend. mftext_pitchbend now also returns the value of bend in MIDI units. January 06-09 2014 abc2midi new feaure: introducing an option to provide microtone tuning in the key signature for example K:F ^1/2D besides flattening B also flattens D's by a half a semitone. Implementation includes changes to parsekey in parseabc.c which now has to check for microtones in the list of notes following the key signature. A new parameter modmicrotone is introduced in the function event_key() which is found in parseabc.c, store.c, yapstree.c, toabc.c and matchsup.c. A new struct 'fraction' was added in parseabc.h. In store.c altermap() has a new parameter struct modmic[7], which is used to transfer the key signature microtone specifications from modmicrotone in event_key to a new struct in the voice struct called basmic[7]. v->basmic stores the key signature microtone specs if present. Function newvoice in store.c transfers global->basemic to v->basemic. Function pitchof_b in store.c checks v->basemic to see if the note has a microtone defined in the key signature. parsenote in parseabc.c resets microtone to 0 (through event_normal_tone()) if the note is not a microtone. This is a lot of changes. I hope, I have not introduced new bugs. If a microtone is detected by parsenote(), its parameters are stored in the struct fraction setmicrotone. This struct is automatically reset to 0,0 if no microtone is detected. January 12 2014 abc2midi new feature: Makam style music (Turkish) uses a more complex music scale (as opposed to the equal temperament scale). The comma53 scale divides an octave into 53 microtones. To use this scale put "%%MIDI tuningsystem comma53" in your abc file. Implementation: added to new functions in store.c init_p48toc53 initializes the array pt48toc[]. convert_to_comma53() changes midipitch and midibend values. Added a new command, %%MIDI tuningsystem comma53 January 14 2014 corrections to convert_to_comma53(). Some debugging #defs. January 16 2014 some fixes to pitchof_b and parsekey. January 20 2014 abc2midi: microtones now propagate across a bar just like accidentals. Major modifications to pitchof_b and other minor fixes (in store.c) were made. January 26 2014 abc2midi: more microtone bug fixes. Each octave can hold its own microtones. i.e. v->workmic is now a two dimensional array just like workmap and workmul. February 05 2014 abc2midi: the following file causes abc2midi (and other programs) to behave erratically. X:9 T:Have you ever wondered? L:1/8 M:4/4 Q:1/2=90 K:G V:1 CDEF | W:| Have you ever | wondered why the | girls do | skipping, and the W:| boys play | football and the | grans do | knitting? W:| Who made the | rules that the | people all o- | bey? And W:| What's with the | "girls' thing", | "boys' thing" | anyway? X:10 T:Warm-up 1 L:1/4 M:2/2 Q:1/2=80 K:Bb |[B,DFB]2z2 | abc2midi returns the message Warning in line 9 : Potentially ambiguous line. Warning in line 9 : Ignoring reserved character W Error in line 9 : Unrecognized character: o Error in line 9 : Malformed note : expecting a-g or A-G Error in line 9 : Unrecognized character: r Error in line 9 : Unrecognized character: w Error in line 9 : Unrecognized character: o Error in line 9 : Unrecognized character: n and many more messages Analysis: abc2midi sees :| after the W and assumes it is an end repeat in the body. It tries to treat the rest of the line like music. Fix: I have improved the warning in parseabc.c so it is more meaningful. It is now Warning in line 9 : Potentially ambiguous line - either a :| repeat or a field command -- cannot distinguish. This applies to all programs, yaps, abc2abc etc but it is too much trouble to give them new version numbers. April 03 2014 Abc2midi bug: tied note at end of bar combined with Barfly stress model. In the following example: X:1 T: Stress model bug L:1/8 M:2/4 K:Gmin %%MIDI ptstress 4 100 1.10 100 1.10 100 1.0 100 0.8 |Gc BA-|AG FG| Abc2midi returns the following error message writing MIDI file stress1.mid Warning in line 7 : Bar 1 has 21/10 units instead of 2 Analysis: the problem is with the tied note A which crosses a measure. The tied notes A-|A are tied together into a single note by the function tiefix() in store.c and the stress model is applied to the combined note. This becomes obvious when running abc2midi with -v 2 option.r 2 pitch 67 from = 0/1 (0/1) to 1/2 (1/1) becomes 0/1 11/20 - 11/20 pitch 72 from = 1/2 (1/1) to 1/1 (2/1) becomes 11/20 11/10 - 11/20 pitch 70 from = 1/1 (2/1) to 3/2 (3/1) becomes 11/10 8/5 - 1/2 pitch 69 from = 3/2 (3/1) to 5/2 (5/1) becomes 8/5 51/20 - 19/20 bar 3 pitch 67 from = 0/1 (0/1) to 1/2 (1/1) becomes 0/1 11/20 - 11/20 pitch 65 from = 1/2 (1/1) to 1/1 (2/1) becomes 11/20 11/10 - 11/20 pitch 67 from = 1/1 (2/1) to 3/2 (3/1) becomes 11/10 8/5 - 1/2 bar 4 writing MIDI file stress The fix is to apply the stress model prior to combining the tied notes. The fix was applied to the function finishfile() in store.c April 10 2014 Abc2midi bug: The P: field was introduced to allow repeating parts of the tune in complex patterns such as P:ABCBD; however it is frequently used just to annotate a section of the music. When it is used as annotation, you often get annoying warnings such as. Error in line 10 : Part must be one of A-Z In some situations, this annotation may cause the music to play incorrectly. For example in this tune, X:1 T: part annotationmistaken M: 3/4 K: G V:1 B3c BA|B3c BA|B4e2|B3d ef| g4 g2|f4 e2|f3 gf2|B6| V:2 G3A GF|G3A GF|E4B2|G4E2| P: section B B4 B2|^d4 ^c2|^d3 e d2|F6| the last line in V:2 is played twice. Fix: in event_part() in store.c we check whether a valid P: command like P:A2BC was detected in the header. If none was found, abc2midi ignores any P: commands after the header. April 24 2014 abc2midi: slur bug Abc2midi sometimes reports unbalanced slurs when they are actually correct. For example X:1 T: Slur error messages L:1/8 M:2/2 Q:1/2=110 K:Dm P:A |: "Dm"a2ag a2ag | "^/"agfe dcAF | "Gm"GABA B^cdc | "^/"d^cBA BAGB | "A"A=B^cB cded | "^/"efgf eA=B^c | "^/"d(^ga)(e f)(^cd)(A |1 "^/"B)AFE GAdf :|2 "^/"B)AFE DCB,A, | P:B |: "Gm"G,BBB BcBB | "^/"B,BBB BcBB | "Dm"FAAA Adde | "^/"fedc AFED | "Gm"DBBB BcBB | "A"EAAA A=B^cA | "^/"d(^ga)(e f)(^cd)(A |1 "^/"B)AFE DCB,A,:|2 "^/"B)AFE "Dm"D4 | The following messages were returned. Warning in line 9 : No slur to close Warning in line 12 : No slur to close writing MIDI file colin1.mid Error in line 12 : Unexpected start of slur found Error in line 12 : Unexpected start of slur found Error in line 12 : Unexpected start of slur found analysis: abc2midi could not match the slurs when they cross into a part section (eg :[2 "^/" B) ...). fix: slur indications do not affect the output midi file so the messages are somewhat irrelevant. The warnings and error messages have been suppressed. August 11 2014 Introduced a new variable abcversion and parse the comment %%abc-version 2.0 or %%abc-version 2.1 if present. August 14 2014 Bug: line continuation of a lyric field w: does not work. In the following example, X:1 T: vocal M: 4/4 L: 1/4 K: G G A G B|\ E A G B| w: ga ba la ba |\ fa ma da ka| GGGB| w: la ma fa da| the line fa ma da ka is not processed as part of the previous w: field. Apparently there was an attempt in preparse_words(s) (in parseabc.c) to handle continuations of the w: field, however, the implementation was not complete. (There is no signal, telling parseline() to treat the continuation of the w: field.) Therefore this feature never worked in all of the abcmidi programs (abc2midi, abc2abc and yaps). I have decided not to support this feature and instead plan to introduce an alternative using the +: command defined in the 2.1 abc standard. The following warning message is now being issued when this situation is detected. Warning in line 8 : \n continuation no longer supported in w: line August 15 2014 New feature: the abc-version 2.1 standard introduces a new method for continuing the w; using the +: for lyrics. It also discourages the use of the backslash continuation. To handle the +: line, it was necessary to keep track of the last field command. A new global char lastfieldcmd was introduced in parseabc. The variable is modified at the end of function parsefield in parseabc.c. Presently it only signals a w: field command. For all other field commands it is set to a blank. A new case statement for +: was also introduced in parsefield(). It calls a new function, append_fieldcmd() if lastfieldcmd == 'w'. The function parseline() was extended to recoginize +: as a valid field command. The function parsefield() was modified to allow the +: command to appear in the body of the tune. August 16 2014 Continuing from above: introduced a new function concatenatestrings() in parseabc.c. In store.c, yapstree.c, toabc.c and matchsup.c introduced a new function called appendfield(). Appendfield() was only implemented in store.c where it calls a new function called append_words. In the files, appendfield() merely returns a message that it is not implemented yet. September 07 2014 Continuing from above: the function appendfield() in toabc.c was replaced so abc2abc will also handle the +: command. Note that abc2abc the -n X option which reformats with a new linebreak every X bars will probably not work correctly when the tune contains lyrics. September 09 2014 Abc2midi fix: the !bend! action does not apply correctly to microtones. In the following example: X:1 T: bend about microtone M: 4/4 L: 1/4 K: G !bend!_1/4D2 z2|!bend!D2 z2| !bend!^1/4D2 z2|!bend!D2 z2| All the bends start from D natural. Analysis: queues.c always initializes pitchbend to 8192 rather than the value set by the microtone. Fix: it was necessary to introduce another global variable, int bendstate, to be shared between genmidi.c and queues.c. The variable bendstate stores the pitchbend value when midi_noteon is called (in genmidi.c). In note_effect() in queues.c, pitchbend is set to bendstate rather than 8192. September 10 2014 September 11 2014 Abc2midi: introducing %%MIDI bendstring n1 n2 n3 ... This is a more general way of specifying the pitchbend track for a note. The command is followed by a series of integers n1, n2 etc. which specify the change to pitchbend following each time increment. Method: In genmidi.c introduced the array benddata[16] which holds the series of integers and bendnvals the number of these integers. Benddata and bendvals is passed to genmidi through an extern declaration. In dodeferred() in genmidi.c added a test for %%MIDI bendstring. In queues.c added a new function, note_effect2() which increments the pitchbend variable by benddata[i], and produces a %%MIDI pitchbend command at regular time intervals. In genmidi.c introduced a variable bendtype and set it to 1. The %%MIDI bendstring command sets bendtype to 2 to signal that the function note_effect2() should be called instead of note_effect(). September 22 2014 September 23 2014 September 24 2014 Abc2midi: when only one integer follows the %%MIDI bendstring command, the !bend! command now applies the pitchbend to the entire note. This provides another method for shifting the pitch of the note instead of preceding it with a microtone accidental. At the end of the note, the pitch of the note is restored to its original value. Implementation: in dodeferred() in genmidi.c we check for just one value following the bendstring command and set the bendtype variable to 3 so that queues.c calls the new function note_effect3(). September 28 2014 Extended the maximum bendstring length to 50. October 16 2014 Abc2midi: in some applications it may be desirable to suppresses all messages. A new option -silent was introduced to suppress the the other warnings and messages not handled by the -quiet option. eg. abc2midi nottingham.abc -silent -quiet produces almost not output except for the MIDI files. October 29 2014 ... Abc2midi: more work was done with the bar repeat code in store.c Abc2midi returns the incorrect line number when it detects a problem with bar length on repeat. Analysis: there are two functions which attempt to detect and fix problems with repeats in store.c -- scan_for_missing_repeats() and fixreps() each trying to fix different problems. When the abc tune does not have voices or parts, it was discovered that voicestart[0] is still initialized to zero and does not indicate the position of the start of the music line further the inserted DOUBLE_BAR code was placed in the wrong place by the function headerprocess(). The function scan_for_missing_repeasts() was modified to search for the first instance of MUSICLINE and to insert a DOUBLE_BAR feature immediately after. The voicestart[0] variable was set to this position. November 02 2014 Incorporated changes to the makefile and manpages suggested by Ross Gammon who does Debian Quality Assurance. November 02 2014 Abc2midi bug: the b code in the gchord string does not work correctly when there are inversions. eg. X:1 T: gchord M: 4/4 L: 1/4 K: C %%MIDI gchord fb "C" z4|"C/E" z4| The second bar is played at E,,4 [C4G,4E,4C,,4] instead of E,,4 [C4G,4E,4E,,4] Fix: In dogchords() (genmidi.c) case 'b' was changed so that it is identical to case 'f' except that there is no break ending that case (it progresses to case 'c'). November 9 2014 Abc2midi grace bug: in the following example, the grace notes cause a loss of synchronization between the two voices. X:1 T:Grace problem M: 2/4 L: 1/4 K: G Q:1/4 =60 V:1 {cde}f/|ed|cB| V:2 z|CD|CD| According to the documentation the grace notes are given a length of 1/8 or half of the unit length specified in the L: field. The three grace notes cde add up to be longer than the home note f, so it is impossible to trim f in order to accommodate the grace sequence. According to the documentation, abc2midi should cut out the grace sequence in order to avoid loss of synchronization. Instead abc2midi does not affect the grace sequence and the two voices are out of synchronization. Analysis: the function applygrace_new() in store.c computes the difference between the length of the grace sequence and the home note, but the test should read if (adjusted_num <= 0.0) /* not long enough */ instead of if (adjusted_den <= 0.0) I would guess this bug has been around since 2004. In addition I added a warning that the grace sequence is too long. The code to change the length of the grace notes to zero did not work correctly for some reason that I have not tried to figure out -- (mf_write_midi_event tries to record a delta_time = -1). Instead I just removed all the grace notes from the feature representation. November 18 2014 Abc2midi fermata bug: the !fermata! instruction applied to a rest also applies to the following chord. In the following example, X:1 T: fermata rest bug. L: 1/8 M: 6/8 K:D !fermata!z6 |[A,DF]2G [CDFA]GF |C D2 C D2| Both z6 and [A,DF]2 are doubled in length. Incidently if we substituted Hz6 for !fermata!z6, the program works correctly. Analysis: as evident in this file, this is not the first !fermata! bug. Apparently in this case, decorators[FERMATA] flag was not reset to 0 after the event_rest() in parseabc.c. The fix was to add the statement decorators[FERMATA] = 0 after the event_rest() call in parseabc.c. Note it is not correct to apply a fermata to a multirest. i.e. Z3| means three bars of rests. HZ3 does not mean three bars of fermata rests and the same applies to !fermata!Z3. In addition, I have improved the bar length warning to include the track number where it was applied. The track number is related to the voice number in some way. December 25 2014 Abc2midi new feature: the error and warning messages now provide both the line and character position location in the abc tune where the message was issued. Implementation: the character position is stored in the variable lineposition in parseabc.c. This variable is linked as an extern to store.c and genmidi.c. A new array charloc[] in store.c was introduced to record the character position when addfeature() is called. When writetrack is executed in genmidi.c, lineposition is updated for each feature element processed. lineposition and linenum are now both printed by event_error() and event_warning() in store.c. February 22 2015 bugs.debian.org reported that abc2abc, abcmatch, yaps, and midi2abc crash with certain malformed input parameters. Fixes were applied to toabc.c, abcmatch.c, yapstree.c and midi2abc.c. March 11 2015 Abc2midi multirest bug. It is common to list the voices before the time signature and unit length declaration. X:1 T: correct test file V:1 name="1_Requinta_Eb" sname="1Re_Eb" %config, program 1 72 /control 7 80 /transpose +3 V:2 name="1_Clarineta_Bb" sname="1Cl_Bb" %config, program 2 71 /control 7 80 /transpose -2 V:3 name="1_Saxofone_Eb" sname="1Sx_Eb" %config, program 3 65 /control 7 80 /transpose +3 V:4 name="1_Corneta_Bb" sname="1Cr_Bb" %config, program 4 59 /control 7 80 /transpose -2 M: 2/4 L: 1/8 K: G V: 1 C4| C4| C4| C4| V:2 z4| z4| z4| z4| V:3 Z| Z| Z| Z| V:4 Z4| In this example abc2midi does not get the correct time signature and unit length for voices 1 to 3. Fix: Added a new function meter_voice_update(n,m) which sets the meter for all declared voices if not past the header. March 16 2015 Abc2midi - new feature. In theory there should not be any limit on the number of tracks that is produced provided that the user takes care of assigning the right channels to the voices. I have extended the voicecode array in parseabc.c so that 24 voices can be handled without overruning the array. In genmidi.c I have merely changed the name of the array channels[] to channel_in_use[] so its purpose is better understood. The use of more than 16 tracks will lead to some warnings issued but the program should still produce a useful MIDI file. March 23 2015 Abc2midi - improvements. In order to support extended voice overlay, introduced two new functions event_start_extended_overlay() and event_stop_extended_overlay which are called from parsemusic() in parseabc.c when (& or &) are detected in the abc file. The two functions are defined in store.c, toabc.c, yapstree.c and matchsup.c. The functions turn on and turn off the state variable extended_overlay_running. In event_specific() in store.c we verify that channel in %%MIDI channel command lies between 1 and 16 inclusive. If not it is set to 1 and an error message is issued. A new state variable no_more_free_channels is introduced in store.c and set to zero in finishfile(). When findchannel() in genmidi.c cannot find a free channel a message "All 16 MIDI channels used up" is issued and the variable no_more_free_channels is set to 1. March 24 2015 Abc2midi - improvements. Abc2midi in the past did not keep track of the channel assignments. If we allow inheriting channel assignments for split voices, now called voice overlays, we need to know the MIDI channel assigned to the voice. I added midichannel to the voicestruct in store.c to store the MIDI channel when a %%MIDI channel is encountered. So far %%MIDI channel also calls addfeature() to add a channel feature in the feature array. (This is how the channel number has been passed to writetrack in the past.) The function findchannel() in genmidi.c does not know that a channel number was already assigned to the track (if that was the case). The voicestruct is not passed to genmidi.c from store.c but trackdescriptor is passed as an external. I therefore added midichannel to trackstruct in genmidi.h and set trackdescriptor.midichannel in the function setup_trackstructure() in store.c. Added an argument tracknum to starttrack() in genmidi.c so it can grab the midichannel number from trackdescriptor[]. The function event_split_voice() now passes the midi channel number assigned to the voice to the new voice that it creates. The behaviour of the split voice now depends on whether a channel number has been assigned to the original voice. If no channel number has been assigned, then both the original and child voice will have a midichannel of -1. If the value is -1, then a new and distinct channel number is assigned to each voice. Otherwise the original and child voices will assume to the same channel number that was given when the voice was created. March 25 2015 March 26 2015 Adding code to support extended split voices. In event_bar (store.c) do not recurse back to the original voice if inside an extended_overlay. In stop_extended_overlay(), recurse back to the original voice. The following is an example of the extended voice overlay. X:1 T: extended voice overlay M:2/4 L:1/4 K:C GA|(&Bc|de|de&FG|FG|FG|&)|DE| GA|(&Bc|de|de&FG|FG|FG|&)|DE| April 08 2015 The parsing of the key signature when it contains modifiers with double flats or double sharps does not work correctly. For example: X:1 T: double flat M: 2/4 L: 1/8 K: Ab _F__B_/2C F2 B2|C2D2| The double flat preceeding B in the key signature was interpreted as a single flat and B2 in the first bar was converted to Bb instead of A. Fix: the logic in readword() in parseabc.c was changed so that a break does not occur on the second flat or sharp. April 13 2015 Abc2midi, abc2abc, yaps : minor bug. The tune X:1 T: single colon M: 2/4 L: 1/8 K: F [|: ABcd|ABDF:|] returns a message 'Single colon in bar', otherwise the output is correct. Analysis: this is a problem with parsemusic() in parseabc.c. When the parser encounters | it check for a : following and treats them both as BAR_REP. On the other hand if the parser encounters [| it neglects to check for a following : and the : is not associated with anything. Fix: added a check for ':' in case '['. April 17 2015 Abc2midi staccato chord bug. %abc-2.1 X:1 T: staccato problem M:2/4 L:1/4 Q:1/4=116 K:D % V:K % % Case 1: works if isolated: % F A/ .[DF]/ | % % Case 2: works: % F A/ [.D/.F/] | E E & Cx | % % Case 3: works: % F A/ [DF]/ | E E & Cx | % % Case 4: doesn't work: F A/ .[DF]/ | E E & Cx | % % Case 5: doesn't work: F A/ [.D.F]/ | E E & Cx | Both cases 4 and 5 return an error message Warning in line-char 26-28 : Track 2 is 4.554167 quarter notes long not 4.054167 and the note C# in the voice overlay comes 1/2 beat late. Analysis, the staccato introduces a REST in the internal representation of the chord. When the length of the chord is specified at the end of the abc chord representation, eg. [CEG]n/m), abc2midi calls the function fix_enclosed_note_lengths which changes the lengths of all the enclosed notes to n/m. Unfortunately, the REST in the chord was not expected and was not modified. The representation of the underlying voice is incorrect and as a result the overlain voice does not get synchronized at the right place. Fix: now test for NOTE, TNOTE and REST in the chord in the function fix_enclosed_note_lengths in store.c. April 28 2015 Abc2midi: dotted slur The abc standard recognizes dotted slurs which abcm2ps displays as a slur with a dotted curve. The dotted slur is indicated with parenthesis preceded by a period as shown below. X:1 T: DottedSlur M: 2/4 L: 1/8 K: A .(ABcd)|(ABcd)|ABcd| Currently abc2midi reports the error. Error in line-char 6-0 : Malformed note : expecting a-g or A-G Analysis: parsemusic() in parseabc.c assumes '.' is a staccato decoration and expects a note to follow. Instead it sees a '(' and reports an error. Since abc2midi does not treat slurs differently, the resulting MIDI file is correct. Fix: If a '.' is encountered, parsemusic checks for a following '('. The fix also affects abc2abc, yaps, and abcmatch. April 29 2015 Abc2midi always prints its version number when it runs. May 11 2015 Abc2midi does not recognize the inline command [r: some remark]. X:1 T:Remark not allowed C:JWDJ M:4/4 L:1/4 K:C [K:D] A2 B2| [r:!fermata!]G4 |] Analysis: the 2.1 standard allows users to enter a remark inside a line using the [r: ...] inline field. This command should be treated the same way as a comment indicated with a '%' in the first column of the text line (eg.) % comment Abc2midi does not recognize r: inside an inline field command and reports an error. Error in line-char 7-13 : Field not allowed in tune body Fix: In parsefield() in parseabc.c, added r to the string EIKLMPQTVdswW+ . Thus if ((inbody) && (strchr ("EIKLMPQTVdrswW+", key) == NULL)) /* [SS] 2015-05-11 */ The following switch statement falls into case default: which treats the field as plain text. Note: Though the standard probably allows the remark to extend over several lines, eg. X:1 T:Long remark not allowed C:JWDJ M:4/4 L:1/4 K:C [K:D] A2 B2| [r: some long remark]G4 |] this is not supported in the abcmidi package. (It would require more extensive modification.) The user should use '%' to insert multiline comments. May 13 2015 abc2midi, abc2abc, yaps voice transpose bug. In the following sample, X:1 T: octave problem M: 4/4 L: 1/4 V:1 clef=treble octave=-1 V:2 clef=treble octave=-1 K:G V:1 ABCD|EFGA| V:2 abcd|ABCD| Applying abc2abc to the tune returns X:1 T:octave problem M:4/4 L:1/4 V:1 clef=treble octave=0 V:2 clef=treble octave=0 K:G V:1 ABCD|EFGA| V:2 abcd|ABCD| octave was changed to zero and abc2midi applied on the same tune does not shift down the pitch by an octave. If we change V:1 and V:2 to V:1 octave=-1 V:2 octave=-1 the programs work correctly. Analysis: This is an issue with the code parsevoice() in parseabc. The clef=treble also specifies the octave and sets the flag cgotoctave to 1. This flag indicates that the octave is also set by the clef command. If you wanted octave=-1 you should say clef=treble-8. To avoid further confusion, in the future, I modified parsevoice so that it allows octave= following the clef= property to override the octave value set by the clef= property. The parsevoice() code is rather brittle and expects all the voice parameters to be in a specific order. The code looks for the following properties in this order. clef= transpose= octave= name= sname= middle= If the properties are not in this order, they may be missed. The function parsevoice scans the V: string looking for the properties in the specific order using the 'while (*s != '\0). Each time a property is found the pointer *s is advanced past that property by one of the functions parsetranspose(), parseoctave(), parsename(), and etc and the while loop goes back to the beginning. parseclef() is called repeatedly and even though it does not find clef=, it still returns the variable 'word' which is used for matching by the above mentioned functions. If I am rewriting the code, I would replace casecmp() with strcmp() and use a switch (word) control to call one of the functions parsetranspose(), parseoctave(), and etc. This involves changing all of those functions too. Note parsetranspose() and parseoctave() are also called when the K: field is scanned. May 17 2015 abc2midi: %%MIDI makechordchannels bug The makechordchannels command was introduced in October 3 2006 for handling chords consisting of notes consisting of microtones. When the command appears after a V: declaration, too many chord channels are created which may cause the 15 channel limit (one channel is used for percussion), to be exceeded. For example, X:1 T: too many chord channels M: 2/4 L: 1/4 K:G V:1 %%MIDI beataccents %%MIDI makechordchannels 7 G2| V:2 %%MIDI program 42 %%MIDI nobeataccents E2| V:3 %%MIDI program 43 C2| The following errors are reported. Error in line-char 10-2 : All 16 MIDI channels used up. Error in line-char 15-2 : Channel limit exceeded Analysis: During the creation of track 0 (the header track in a type 1 MIDI file), the entire tune is scanned and some of the MIDI commands are activated. Unfortunately, the makechordchannels is activated twice; once for track 0 and once for track 1. The chord channels created in track 0 are never used. An abc tune that creates at type 0 MIDI file, (i.e. no voices, guitar chords, percussion etc.) would not pose a problem for this implementation. Fix: Added a test in the function makechordchannels (in genmidi.c) to prevent the creation of chord channels in track 0 for multitrack MIDI files. May 19 2015 Abc2midi temperament support was extended by Hudson F.M. Lacerda. Microtone accidentals can be used along with temperamentlinear. In that case, the accidental ratio is based on the new chromatic semitone size, defined as 7 fifths minus 4 octaves. (Run abc2midi with the verbose option (-v) to see the temperament values.) As an exception, the microtonal deviation in cents can be represented by using denominator=100 in the accidentals. For example: 
X:1
T:\%\%MIDI temperamentlinear - microtone accidentals in cents
%%postscript /ft5475{M -3 3 RM 6 -6 RL 2 SLW stroke}def
%%postscript /ft35939{2 copy ft0 M -7.5 -3 RM 12 F3 (7) show}def
M:none
K:C
%%scale 1.3
V:1
%%MIDI program 17
%%MIDI temperamentlinear 1200 702 %% Pythagorian tunings
%%MIDI makechordchannels 3
"^Pure;major;chord"\
[C_22/100EG]8 y |\
"^Pythagorian;major;chord"\
[CEG]8 y ||\
"^Pure;4:5:6:7;chord"\
[C_22/100EG_141/100B]8 y |\
"^Pythagorean;7-chord"\
[CEG_B]8 y ||

A new command %%temperamentequal was introduced.
%%MIDI temperamentequal [octave_cents] [fifth_steps] [sharp_steps] This command sets a tempered scale defined by 'ndiv' equal divisions of 'octave_cents' (default is the octave = 1200 cents). The optional parameter 'fifth_steps', if provided, is an integer that defines the size of the fifth in steps of the temperament. This sets where is the note G in the temperament. When 'fifth_steps' is omited or 0 (zero), the program computes it as an approximation of the frequency ratio 3/1, minus the (possibly tempered) octave. The optional 'sharp_steps' defines the meaning of the accidentals. 'sharp_steps' is the number of steps between a natural note and a sharpened note (e.g. between =C and ^C). By default, the size of a sharp/flat deviation is based on the size of the chromatic semitone in the specified temperament: 7 fifths minus 4 octaves. The values in use in the temperament can be viewed by running abc2midi with the command-line option -v (verbose). With temperamentequal (as with temperamentlinear), microtone accidentals are interpreted as fractions of the sharp size in the specified temperament, except if they use denominator=100, which defines microtonal deviations in cents. The conventional temperament can be reset with the command temperamentnormal. See also: temperamentlinear, temperamentnormal, makechordchannels Implementation: Changes in store.c are marked with [HL] 2015-05-15 New global variable 'sharp_size' It is the the size, in pitchbend units, of the chromatic step between (e.g.) =C and ^C. (This is computed from octave and fifth sizes when using temperamentlinear or temperamentequal.) event_specific() Function changed to modify the command temperamentlinear and to add the command temperamentequal. temperamentlinear: Compute 'sharp_size'; Print information when -v (verbose option); Fix the command name in the error message. temperamentequal (new command): Compute octave_size, fifth_size, sharp_size; Temperament information when -v (Verbose option). pitchof_b() Function changed to handle microtones in user-defined temperaments. Global variable 'sharp_size' is used for that. event_microtone() Rounding instead truncation as slight improvement of precision. (MIDI bend is rough for tuning.) May 21 2015 Abc2midi drone bug: The %%MIDI drone command is ineffective. In the following example, X: 1 T:Banks and Braes M:6/8 L:1/8 S:Slow March K:HP %%MIDI program 109 %%MIDI gracedivider 4 %%MIDI drone 67 44 45 90 90 %%MIDI droneon {Gdc}d2{g}d{g}ede|\ {g}faf{gef}e2{g}d/2e/2| the %%MIDI drone 67 44 45 90 90 does not change the drone characteristics. Analysis: The drone is put in a separate MIDI track. The %%MIDI drone command is processed in the first track, and updates the elements of the drone structure. When the drone track is written starttrack() in genmidi.c, initializes the drone structure destroying any information that was recorded. Fix: initialization of the drone structure is done during compilation time. Note, if the tune has more than one %%MIDI drone command, only the last one is effective. June 01 2015 Abc2midi new feature: introducing new commands %%MIDIdef and %%MIDIx. %%MIDIdef code line links code a unique string less than 7 letters to a line of strings that normally occurs in a MIDI command. For example %%MIDIdef bnd1 bendstring 400 400 300 100 -100 300 400 400 400 link the string bnd1 to " bendstring 400 400 300 100 -100 300 400 400 400" Now you can call up the MIDI command %%MIDI bendstring 400 400 300 100 -100 300 400 400 400 using a shorthand %%MIDIx bnd1. Example: X:1 %%MIDIdef type1 bendstring 0 0 600 600 600 600 0 -600 -600 -600 -600 -600 -120 0 %%MIDIdef type2 bendstring 0 0 0 0 0 0 400 800 800 -800 -800 -400 -400 -400 %%MIDIdef inst program 67 %%MIDIdef t3 bendstring 0 0 0 0 0 500 500 600 600 -600 -600 -500 -500 T: MIDI M:2/4 L:1/2 K: D %%MIDIx inst %%MIDIx type1 !bend!A|B|\ %%MIDIx type2 !bend!C|D| This is useful when you have several different bendstrings and you wish to call them up in different places in the tune using a code. There is a limit of 20 distinct MIDIdef's in your tune. Implementation: in parseabc.c added a new function readaln which is like readstr but scans for the next word (that may contain numerics) in the input string. (The words are separated by spaces or tabs.) In store.c, added two new functions parse_mididefs(s) and expand_midix(s) for handling the %%MIDIdef and %%MIDIx commands. These functions are called in the function event_specific(). June 02 2015 continuation: added strcmp(key, "MIDIx") in event_info_key() in store.c June 07 2015 Abc2midi bug: the !bend! command does not work inside a slur. In the following example, X:1 T: slur and bend M: 2/4 L: 1/8 K: F %%MIDI bendstring 500 500 500 0 -500 -500 -500 %%MIDI program 73 !bend! D4|(!bend! F4| D4| a bend is not applied on F4. Analysis: writetrack() in genmidi.c tests whether a note is inside a slur. If it is inside a slur, both note triming and note bending were suppressed. Fix, writetrack() was modified to allow note bending inside a slur. The MIDIdef, MIDIx code word was allowed to contain up to 31 characters. All characters except white spaces are allowed inside the code word. June 08 2015 Abc2midi bug: !bend! causes tracklenth to be too small. Fix: in timestep() in queues.c, update tracklen before note_effect is called instead as after. June 16 2015 Abc2midi new feature: introducing %%MIDI expand m/n. This acts like %%MIDI trim m/n except it expands the note by this amount. Implementation: added feature EXPAND to featuretype in abc.h. In event_specific() in store.c, test for %%MIDI command 'expand' and addfeature(EXPAND,...) if found. In genmidi.c introduce new globals (expand, expand_num, and expand_denom) which are set in writetrack when feature EXPAND is detected. If the flag expand is set, then the active note is expanded. Here is a test tune. X:1 T: note expansion M: 4/4 L: 1/2 K: G %%MIDI program 52 CD|GA| %%MIDI expand 1/2 de|fe|BA| June 16 2015 Abc2midi new feature: added track identification annotation to midi file so we know whether it is a gchord, note, lyric, drum, etc track. June 30 2015 Abc2midi split voice bug: change of unit length defined by L: does not propagate to the voice overlay. eg. X:1 T: split voice bug - unit length M: 4/4 L:1/8 K: G C8 & E8|\ L:1/4 cdAB & GAEF|G4 & D4:| causes loss of synchronization starting from the second measure. Analysis: the L:1/4 does not change the unit length in the split voice and the notes GAEF and D4 are too short. Fix: in event_split_voice() in store.c set the unit length to the same length as the parent voice. July 02 2015 Abc2abc bug: the fix introduced in May 13 2015 introduced another problem. In the example X:1 T: Octave M: 2/4 L: 1/8 K: G V:1 clef=treble+8 CDEF|ABcd| Applying abc2abc returns X:1 T:Octave M:2/4 L:1/8 K:G V:1 clef=treble+8 octave=1 CDEF|ABcd| Unfortunately the added parameter octave=1 causes abcm2ps to also display the notes one octave higher. Analysis: the parameter octave=1 is useful to abc2midi as it tells the program to shift the notes up one octave when it creates the midi file; however, this is not desired when running abcm2ps. Abcm2ps uses clef=treble+8 to place an 8 above the treble clef and that is sufficient. The problems occurs in the function isclef() in parseabc.c. The function changes gotoctave to 1 when it sees treble+8. The fix on May 13 2015 forces event_voice to issue an octave=1 when it sees cgotoctave = 1. Fix: in isclef() a conditional block {} was created for all if (fileprogram == ABC2MIDI && *gotoctave != 1 && *octave != 1) statements, and *gotoctave = 1 was moved inside this block. July 08 2015 abc2midi feature: added sus4 to the list of chord names recognized. Added hint to message 'Unrecognized chord name ...". July 15 2015 abc2midi bug: abc2midi crashes (segmentation error) on %%MIDIx. In the following example: X:1 T: segmentation error M: 2/4 L: 1/8 K: G %%MIDIx crash ABCD| abc2midi fails. Analysis: abc2midi fails to detect that there is no corresponding %%MIDIdef for the code word 'crash'. Fix: the function expand_midix() now checks for this case. July 24-28 2015 abc2midi: new feature !shape! and %%MIDI controlstring. Introduced a new midi command %%MIDI controlstring n m1 m2 m3 ... where n, m1, m2, and etc are numbers between 0 and 127. %%MIDI controlstring n m1 is equivalent to the %%MIDI control command. When more than one data value m1 and etc. follow, then this defines how to shape the note following the !shape! instruction. The following example illustrates shaping the note F4 by varying the mod wheel. X:1 T: control string M: 4/4 L: 1/4 K: G %%MIDI controlstring 1 125 80 40 0 %%MIDI program 60 !shape! F4| D4|F2G2| The midi file produced will look like Header format=0 ntrks=1 division=480 Track 1 contains 115 bytes 0.00 Metatext (Text Event) note track 0.00 Metatext tempo = 120.00 bpm 0.00 Metatext key signature G (1/0) 0.00 Metatext time signature=4/4 0.00 Metatext (Seqnce/Track Name) control string 0.00 Program 1 60 (French Horn) 0.00 Note on 1 f#4 105 1.00 CntlParm 1 Modulation Wheel = 125 2.00 CntlParm 1 Modulation Wheel = 80 3.00 CntlParm 1 Modulation Wheel = 40 3.99 CntlParm 1 Modulation Wheel = 0 4.00 Note off 1 f#4 0 4.00 Note on 1 d4 105 8.00 Note off 1 d4 0 8.00 Note on 1 f#4 105 10.00 Note off 1 f#4 0 10.00 Note on 1 g4 95 12.00 Note off 1 g4 0 12.05 Meta event, end of track The whole note F# is modified in 4 equal segments. Note the !shape! does not work in combination with the !bend! command presently. Implementation: created the new function note_effect4() in queues.c The maximum number of codenames for %%MIDIdef has been increased to 200. The codename can now be as long as 31 letters. July 27 2015 - August 3 2015 abc2midi: extension of !shape! for combining %%MIDI controlstring and %%MIDI bendstring. Implementation: added a new struct eventstruct and a struct array eventlist[200]. Created new procedures note_effect5(), output_eventlist(), and compare_events(). August 4 2015 abc2midi: channel bug. The following tune plays incorrectly. X: 1 T: channel problem M: 6/8 L: 1/8 K: G %%MIDI channel 1 %%MIDI bassprog 68 %%MIDI chordprog 20 D | "G"G3 GAB | "D"ABA ABd | The melody should be played on the Acoustic Piano; instead it is played on the oboe (MIDI program 68). Analysis: The %%MIDI channel setting is redundant and causes the problem. Both the melody and the bass accompaniment use the same channel. The command %%MIDI bassprog 68 causes the melody to be played by program 68 (the oboe). The bug was introduced in March 16 2015. The variable channel_in_use[channel] was not set to 1 correctly in starttrack() in genmidi.c. August 06 2015 Fixed compile issue on Mac OS 10.10.4 in genmidi.c August 10 2015 - August 11 2015 abc2midi new feature: %%MIDI controlstring restores the controller back to its default after the shaped note is played. The default can be changed with a regular %%MIDI control command. Implementation: added a new array controldefaults[] in genmidi.c which is linked to queue.c. abcmidi/parseabc.h0000644000000000000000000001533112505246516013106 0ustar rootroot/* parseabc.h - interface file for abc parser */ /* used by abc2midi, abc2abc and yaps */ /* abc.h must be #included before this file */ /* functions and variables provided by parseabc.c */ /* for Microsoft Visual C++ 6 */ #ifdef _MSC_VER #define KANDR #endif /* the arg list to event_voice keeps growing; if we put the args into a structure and pass that around, routines that don't need the new ones need not be altered. NB. event_voice is *called* from parseabc.c, the actual procedure is linked in from the program-specific file */ /* added middle= stuff */ #define V_STRLEN 64 struct voice_params { int gotclef; int gotoctave; int gottranspose; int gotname; int gotsname; int gotmiddle; int gotother; /* [SS] 2011-04-18 */ int octave; int transpose; char clefname[V_STRLEN+1]; char namestring[V_STRLEN+1]; char snamestring[V_STRLEN+1]; char middlestring[V_STRLEN+1]; char other[V_STRLEN+1]; /* [SS] 2011-04-18 */ }; /* holds a fraction */ struct fraction { int num; int denom; }; #ifndef KANDR extern int readnump(char **p); extern int readsnump(char **p); extern int readnumf(char *num); extern void skipspace(char **p); extern int readsnumf(char *s); extern void readstr(char out[], char **in, int limit); extern int getarg(char *option, int argc, char *argv[]); extern int *checkmalloc(int size); extern char *addstring(char *s); extern char *concatenatestring(char *s1, char *s2); extern char *lookup_abbreviation(char symbol); extern int ismicrotone(char **p, int dir); extern void event_normal_tone(void); extern void print_inputline(void); extern void print_inputline_nolinefeed(void); #else extern int readnump(); extern int readsnump(); extern int readnumf(); extern void skipspace(); extern int readsnumf(); extern void readstr(); extern int getarg(); extern int *checkmalloc(); extern char *addstring(); extern char *concatenatestring(); extern char *lookup_abbreviation(); extern int ismicrotone(); extern void event_normal_tone(); extern void print_inputline_nolinefeed(); #endif extern void parseron(); extern void parseroff(); extern int lineno; /* event_X() routines - these are called from parseabc.c */ /* the program that uses the parser must supply these routines */ #ifndef KANDR extern void event_init(int argc, char *argv[], char **filename); extern void event_text(char *s); extern void event_reserved(char p); extern void event_tex(char *s); extern void event_linebreak(void); extern void event_startmusicline(void); extern void event_endmusicline(char endchar); extern void event_eof(void); extern void event_comment(char *s); extern void event_specific(char *package, char *s); extern void event_specific_in_header(char *package, char *s); extern void event_startinline(void); extern void event_closeinline(void); extern void event_field(char k, char *f); extern void event_words(char *p, int continuation); extern void event_part(char *s); extern void event_voice(int n, char *s, struct voice_params *params); extern void event_length(int n); extern void event_blankline(void); extern void event_refno(int n); extern void event_tempo(int n, int a, int b, int rel, char *pre, char *post); extern void event_timesig(int n, int m, int dochecking); extern void event_octave(int num, int local); extern void event_info_key(char *key, char *value); extern void event_info(char *s); extern void event_key(int sharps, char *s, int modeindex, char modmap[7], int modmul[7], struct fraction modmicro[7], int gotkey, int gotclef, char *clefname, int octave, int transpose, int gotoctave, int gottranspose, int explict); extern void event_microtone(int dir, int a, int b); extern void event_graceon(void); extern void event_graceoff(void); extern void event_rep1(void); extern void event_rep2(void); extern void event_playonrep(char *s); extern void event_tie(void); extern void event_slur(int t); extern void event_sluron(int t); extern void event_sluroff(int t); extern void event_rest(int decorators[DECSIZE],int n,int m,int type); extern void event_mrest(int n,int m); extern void event_spacing(int n, int m); extern void event_bar(int type, char *replist); extern void event_space(void); extern void event_lineend(char ch, int n); extern void event_broken(int type, int mult); extern void event_tuple(int n, int q, int r); extern void event_chord(void); extern void event_chordon(int chorddecorators[DECSIZE]); extern void event_chordoff(int, int); extern void event_instruction(char *s); extern void event_gchord(char *s); extern void event_note(int decorators[DECSIZE], char accidental, int mult, char note, int xoctave, int n, int m); extern void event_abbreviation(char symbol, char *string, char container); extern void event_acciaccatura(); extern void event_start_extended_overlay(); extern void event_stop_extended_overlay(); extern void event_split_voice(); extern void print_voicecodes(void); extern void init_abbreviations(); extern void free_abbreviations(); extern void parsefile(); extern int parsetune(); #else extern void event_init(); extern void event_text(); extern void event_reserved(); extern void event_tex(); extern void event_linebreak(); extern void event_startmusicline(); extern void event_endmusicline(); extern void event_eof(); extern void event_comment(); extern void event_specific(); extern void event_specific_in_header(); extern void event_startinline(); extern void event_closeinline(); extern void event_field(); extern void event_words(); extern void event_part(); extern void event_voice(); extern void event_length(); extern void event_blankline(); extern void event_refno(); extern void event_tempo(); extern void event_timesig(); extern void event_octave(); extern void event_info_key(); extern void event_info(); extern void event_key(); extern void event_microtone(); extern void event_graceon(); extern void event_graceoff(); extern void event_rep1(); extern void event_rep2(); extern void event_playonrep(); extern void event_tie(); extern void event_slur(); extern void event_sluron(); extern void event_sluroff(); extern void event_rest(); extern void event_mrest(); extern void event_spacing(); extern void event_bar(); extern void event_space(); extern void event_lineend(); extern void event_broken(); extern void event_tuple(); extern void event_chord(); extern void event_chordon(); extern void event_chordoff(); extern void event_instruction(); extern void event_gchord(); extern void event_note(); extern void event_abbreviation(); extern void event_acciaccatura(); extern void event_start_extended_overlay(); extern void event_stop_extended_overlay(); extern void event_split_voice(); extern void print_voicecodes(); extern void init_abbreviations(); extern void free_abbreviations(); extern void parsefile(); extern int parsetune(); #endif abcmidi/midi2abc.c0000644000000000000000000026504513032167374013004 0ustar rootroot/* * midi2abc - program to convert MIDI files to abc notation. * Copyright (C) 1998 James Allwright * e-mail: J.R.Allwright@westminster.ac.uk * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * 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. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA * */ /* new midi2abc - converts MIDI file to abc format files * * * re-written to use dynamic data structures * James Allwright * 5th June 1998 * * added output file option -o * added summary option -sum * added option -u to enter xunit directly * fixed computation of xunit using -b option * added -obpl (one bar per line) option * add check for carriage return embedded inside midi text line * Seymour Shlien 04/March/00 * made to conform as much as possible to the official version. * check for drum track added * when midi program channel is command encountered, we ensure that * we are using the correct channel number for the Voice by sending * a %%MIDI channel message. * * Many more changes (see doc/CHANGES) * * Seymour Shlien 2005 * * based on public domain 'midifilelib' package. */ #define VERSION "3.01 January 01 2017" #define SPLITCODE /* Microsoft Visual C++ Version 6.0 or higher */ #ifdef _MSC_VER #define ANSILIBS #endif #include #ifdef PCCFIX #define stdout 1 #endif /* define USE_INDEX if your C libraries have index() instead of strchr() */ #ifdef USE_INDEX #define strchr index #endif #ifdef ANSILIBS #include #include #include #else extern char* malloc(); extern char* strchr(); #endif #include "midifile.h" #define BUFFSIZE 200 /* declare MIDDLE C */ #define MIDDLE 72 void initfuncs(); void setupkey(int); int testtrack(int trackno, int barbeats, int anacrusis); int open_note(int chan, int pitch, int vol); int close_note(int chan, int pitch, int *initvol); /* Global variables and structures */ extern long Mf_toberead; static FILE *F; static FILE *outhandle; /* for producing the abc file */ int tracknum=0; /* track number */ int division; /* pulses per quarter note defined in MIDI header */ long tempo = 500000; /* the default tempo is 120 quarter notes/minute */ int unitlen; /* abc unit length usually defined in L: field */ int header_unitlen; /* first unitlen set */ int unitlen_set =0; /* once unitlen is set don't allow it to change */ int parts_per_unitlen = 2; /* specifies minimum quantization size */ long laston = 0; /* length of MIDI track in pulses or ticks */ char textbuff[BUFFSIZE]; /*buffer for handling text output to abc file*/ int trans[256], back[256]; /*translation tables for MIDI pitch to abc note*/ char atog[256]; /* translation tables for MIDI pitch to abc note */ int symbol[256]; /*translation tables for MIDI pitch to abc note */ int key[12]; int sharps; int trackno, maintrack; int format; /* MIDI file type */ int karaoke, inkaraoke; int midline; int tempocount=0; /* number of tempo indications in MIDI file */ int gotkeysig=0; /*set to 1 if keysignature found in MIDI file */ /* global parameters that may be set by command line options */ int xunit; /* pulses per abc unit length */ int tsig_set; /* flag - time signature already set by user */ int ksig_set; /* flag - key signature already set by user */ int xunit_set;/* flat - xunit already set by user */ int extracta; /* flag - get anacrusis from strong beat */ int guessu; /* flag - estimate xunit from note durations */ int guessa; /* flag - get anacrusis by minimizing tied notes */ int guessk; /* flag - guess key signature */ int summary; /* flag - output summary info of MIDI file */ int keep_short; /*flag - preserve short notes */ int swallow_rests; /* flag - absorb short rests */ int midiprint; /* flag - run midigram instead of midi2abc */ #ifdef SPLITCODE int usesplits; /* flag - split measure into parts if needed */ #endif int restsize; /* smallest rest to absorb */ /* [SS] 2017-01-01 */ /*int no_triplets; flag - suppress triplets or broken rhythm */ int allow_triplets; /* flag to allow triplets */ int allow_broken; /* flag to allow broken rhythms > < */ int obpl = 0; /* flag to specify one bar per abc text line */ int nogr = 0; /* flag to put a space between every note */ int bars_per_line=4; /* number of bars per output line */ int bars_per_staff=4; /* number of bars per music staff */ int asig, bsig; /* time signature asig/bsig */ int header_asig =0; /* first time signature encountered */ int header_bsig =0; /* first time signature encountered */ int header_bb; /* first ticks/quarter note encountered */ int active_asig,active_bsig; /* last time signature declared */ int last_asig, last_ksig; /* last time signature printed */ int barsize; /* barsize in parts_per_unitlen units */ int Qval; /* tempo - quarter notes per minute */ int verbosity=0; /* control amount of detail messages in abcfile*/ /* global arguments dependent on command line options or computed */ int anacrusis=0; int bars; int keysig; int header_keysig= -50; /* header key signature */ int active_keysig = -50; /* last key signature declared */ int xchannel; /* channel number to be extracted. -1 means all */ /* structure for storing music notes */ struct anote { int pitch; /* MIDI pitch */ int chan; /* MIDI channel */ int vel; /* MIDI velocity */ long time; /* MIDI onset time in pulses */ long dtnext; /* time increment to next note in pulses */ long tplay; /* note duration in pulses */ int xnum; /* number of xunits to next note */ int playnum; /* note duration in number of xunits */ int posnum; /* note position in xunits */ int splitnum; /* voice split number */ /* int denom; */ }; /* linked list of notes */ struct listx { struct listx* next; struct anote* note; }; /* linked list of text items (strings) */ struct tlistx { struct tlistx* next; char* text; long when; /* time in pulses to output */ int type; /* 0 - comments, other - field commands */ }; /* a MIDI track */ struct atrack { struct listx* head; /* first note */ struct listx* tail; /* last note */ struct tlistx* texthead; /* first text string */ struct tlistx* texttail; /* last text string */ int notes; /* number of notes in track */ long tracklen; long startwait; int startunits; int drumtrack; }; /* can cope with up to 64 track MIDI files */ struct atrack track[64]; int trackcount = 0; int maxbarcount = 0; /* maxbarcount is used to return the numbers of bars created.*/ /* obpl is a flag for one bar per line. */ /* double linked list of notes */ /* used for temporary list of chords while abc is being generated */ struct dlistx { struct dlistx* next; struct dlistx* last; struct anote* note; }; int notechan[2048],notechanvol[2048]; /*for linking on and off midi channel commands */ int last_tick; /* for getting last pulse number in MIDI file */ char *title = NULL; /* for pasting title from argv[] */ char *origin = NULL; /* for adding O: info from argv[] */ void remove_carriage_returns(); int validnote(); void printpitch(struct anote*); void printfract(int, int); /* Stage 1. Parsing MIDI file */ /* Functions called during the reading pass of the MIDI file */ /* The following C routines are required by midifilelib. */ /* They specify the action to be taken when various items */ /* are encountered in the MIDI. The mfread function scans*/ /* the MIDI file and calls these functions when needed. */ int filegetc() { return(getc(F)); } void fatal_error(s) char* s; /* fatal error encounterd - abort program */ { fprintf(stderr, "%s\n", s); exit(1); } void event_error(s) char *s; /* problem encountered but OK to continue */ { char msg[256]; sprintf(msg, "Error: Time=%ld Track=%d %s\n", Mf_currtime, trackno, s); printf("%s",msg); } int* checkmalloc(bytes) /* malloc with error checking */ int bytes; { int *p; p = (int*) malloc(bytes); if (p == NULL) { fatal_error("Out of memory error - cannot malloc!"); }; return (p); } char* addstring(s) /* create space for string and store it in memory */ char* s; { char* p; p = (char*) checkmalloc(strlen(s)+1); strcpy(p, s); return(p); } void addtext(s, type) /* add structure for text */ /* used when parsing MIDI file */ char* s; int type; { struct tlistx* newx; newx = (struct tlistx*) checkmalloc(sizeof(struct tlistx)); newx->next = NULL; newx->text = addstring(s); newx->type = type; newx->when = Mf_currtime; if (track[trackno].texthead == NULL) { track[trackno].texthead = newx; track[trackno].texttail = newx; } else { track[trackno].texttail->next = newx; track[trackno].texttail = newx; }; } /* The MIDI file has separate commands for starting */ /* and stopping a note. In order to determine the duration of */ /* the note it is necessary to find the note_on command associated */ /* with the note off command. We rely on the note's pitch and channel*/ /* number to find the right note. While we are parsing the MIDI file */ /* we maintain a list of all the notes that are currently on */ /* head and tail of list of notes still playing. */ /* The following doubly linked list is used for this purpose */ struct dlistx* playinghead; struct dlistx* playingtail; void noteplaying(p) /* This function adds a new note to the playinghead list. */ struct anote* p; { struct dlistx* newx; newx = (struct dlistx*) checkmalloc(sizeof(struct dlistx)); newx->note = p; newx->next = NULL; newx->last = playingtail; if (playinghead == NULL) { playinghead = newx; }; if (playingtail == NULL) { playingtail = newx; } else { playingtail->next = newx; playingtail = newx; }; } void addnote(p, ch, v) /* add structure for note */ /* used when parsing MIDI file */ int p, ch, v; { struct listx* newx; struct anote* newnote; track[trackno].notes = track[trackno].notes + 1; newx = (struct listx*) checkmalloc(sizeof(struct listx)); newnote = (struct anote*) checkmalloc(sizeof(struct anote)); newx->next = NULL; newx->note = newnote; if (track[trackno].head == NULL) { track[trackno].head = newx; track[trackno].tail = newx; } else { track[trackno].tail->next = newx; track[trackno].tail = newx; }; if (ch == 9) { track[trackno].drumtrack = 1; }; newnote->pitch = p; newnote->chan = ch; newnote->vel = v; newnote->time = Mf_currtime; laston = Mf_currtime; newnote->tplay = Mf_currtime; noteplaying(newnote); } void notestop(p, ch) /* MIDI note stops */ /* used when parsing MIDI file */ int p, ch; { struct dlistx* i; int found; char msg[80]; i = playinghead; found = 0; while ((found == 0) && (i != NULL)) { if ((i->note->pitch == p)&&(i->note->chan==ch)) { found = 1; } else { i = i->next; }; }; if (found == 0) { sprintf(msg, "Note terminated when not on - pitch %d", p); event_error(msg); return; }; /* fill in tplay field */ i->note->tplay = Mf_currtime - (i->note->tplay); /* remove note from list */ if (i->last == NULL) { playinghead = i->next; } else { (i->last)->next = i->next; }; if (i->next == NULL) { playingtail = i->last; } else { (i->next)->last = i->last; }; free(i); } FILE * efopen(name,mode) char *name; char *mode; { FILE *f; if ( (f=fopen(name,mode)) == NULL ) { char msg[256]; sprintf(msg,"Error - Cannot open file %s",name); fatal_error(msg); } return(f); } void error(s) char *s; { fprintf(stderr,"Error: %s\n",s); } void txt_header(xformat,ntrks,ldivision) int xformat, ntrks, ldivision; { division = ldivision; format = xformat; if (format != 0) { /* fprintf(outhandle,"%% format %d file %d tracks\n", format, ntrks);*/ if(summary>0) printf("This midi file has %d tracks\n\n",ntrks); } else { /* fprintf(outhandle,"%% type 0 midi file\n"); */ if(summary>0) { printf("This is a type 0 midi file.\n"); printf("All the channels are in one track.\n"); printf("You may need to process the channels separately\n\n"); } } } void txt_trackstart() { laston = 0L; track[trackno].notes = 0; track[trackno].head = NULL; track[trackno].tail = NULL; track[trackno].texthead = NULL; track[trackno].texttail = NULL; track[trackno].tracklen = Mf_currtime; track[trackno].drumtrack = 0; } void txt_trackend() { /* check for unfinished notes */ if (playinghead != NULL) { printf("Error in MIDI file - notes still on at end of track!\n"); }; track[trackno].tracklen = Mf_currtime - track[trackno].tracklen; trackno = trackno + 1; trackcount = trackcount + 1; } void txt_noteon(chan,pitch,vol) int chan, pitch, vol; { if ((xchannel == -1) || (chan == xchannel)) { if (vol != 0) { addnote(pitch, chan, vol); } else { notestop(pitch, chan); }; }; } void txt_noteoff(chan,pitch,vol) int chan, pitch, vol; { if ((xchannel == -1) || (chan == xchannel)) { notestop(pitch, chan); }; } void txt_pressure(chan,pitch,press) int chan, pitch, press; { } void txt_parameter(chan,control,value) int chan, control, value; { } void txt_pitchbend(chan,lsb,msb) int chan, msb, lsb; { } void txt_program(chan,program) int chan, program; { /* sprintf(textbuff, "%%%%MIDI program %d %d", chan+1, program); */ sprintf(textbuff, "%%%%MIDI program %d", program); addtext(textbuff,0); /* abc2midi does not use the same channel number as specified in the original midi file, so we should not specify that channel number in the %%MIDI program. If we leave it out the program will refer to the current channel assigned to this voice. */ } void txt_chanpressure(chan,press) int chan, press; { } void txt_sysex(leng,mess) int leng; char *mess; { } void txt_metamisc(type,leng,mess) int type, leng; char *mess; { } void txt_metaspecial(type,leng,mess) int type, leng; char *mess; { } void txt_metatext(type,leng,mess) int type, leng; char *mess; { char *ttype[] = { NULL, "Text Event", /* type=0x01 */ "Copyright Notice", /* type=0x02 */ "Sequence/Track Name", "Instrument Name", /* ... */ "Lyric", "Marker", "Cue Point", /* type=0x07 */ "Unrecognized" }; int unrecognized = (sizeof(ttype)/sizeof(char *)) - 1; unsigned char c; int n; char *p = mess; char *buff; char buffer2[BUFFSIZE]; if ((type < 1)||(type > unrecognized)) type = unrecognized; buff = textbuff; for (n=0; n0) return; /* ignore other tempo indications */ tempo = ltempo; tempocount++; } void setup_timesig(nn, denom, bb) int nn,denom,bb; { asig = nn; bsig = denom; /* we must keep unitlen and xunit fixed for the entire tune */ if (unitlen_set == 0) { unitlen_set = 1; if ((asig*4)/bsig >= 3) { unitlen =8; } else { unitlen = 16; }; } /* set xunit for this unitlen */ if(!xunit_set) xunit = (division*bb*4)/(8*unitlen); barsize = parts_per_unitlen*asig*unitlen/bsig; /* printf("setup_timesig: unitlen=%d xunit=%d barsize=%d\n",unitlen,xunit,barsize); */ if (header_asig ==0) {header_asig = asig; header_bsig = bsig; header_unitlen = unitlen; header_bb = bb; } } void txt_timesig(nn,dd,cc,bb) int nn, dd, cc, bb; { int denom = 1; while ( dd-- > 0 ) denom *= 2; sprintf(textbuff, "%% Time signature=%d/%d MIDI-clocks/click=%d 32nd-notes/24-MIDI-clocks=%d", nn,denom,cc,bb); if (verbosity) addtext(textbuff,0); sprintf(textbuff,"%d %d %d\n",nn,denom,bb); if (!tsig_set) { addtext(textbuff,2); setup_timesig(nn, denom,bb); } if (summary>0) { if(tsig_set) printf("Time signature = %d/%d suppressed\n",nn,denom); else printf("Time signature = %d/%d\n",nn,denom); } } void txt_smpte(hr,mn,se,fr,ff) int hr, mn, se, fr, ff; { } void txt_arbitrary(leng,mess) char *mess; int leng; { } /* Dummy functions for handling MIDI messages. * */ void no_op0() {} void no_op1(int dummy1) {} void no_op2(int dummy1, int dummy2) {} void no_op3(int dummy1, int dummy2, int dummy3) { } void no_op4(int dummy1, int dummy2, int dummy3, int dummy4) { } void no_op5(int dummy1, int dummy2, int dummy3, int dummy4, int dummy5) { } void print_txt_noteon(chan, pitch, vol) int chan, pitch, vol; { int start_time; int initvol; if (vol > 0) open_note(chan, pitch, vol); else { start_time = close_note(chan, pitch,&initvol); if (start_time >= 0) /* printf("%8.4f %8.4f %d %d %d %d\n", (double) start_time/(double) division, (double) Mf_currtime/(double) division, trackno+1, chan +1, pitch,initvol); */ printf("%d %ld %d %d %d %d\n", start_time, Mf_currtime, trackno+1, chan +1, pitch,initvol); if(Mf_currtime > last_tick) last_tick = Mf_currtime; } } void print_txt_noteoff(chan, pitch, vol) int chan, pitch, vol; { int start_time,initvol; start_time = close_note(chan, pitch, &initvol); if (start_time >= 0) /* printf("%8.4f %8.4f %d %d %d %d\n", (double) start_time/(double) division, (double) Mf_currtime/(double) division, trackno+1, chan+1, pitch,initvol); */ printf("%d %ld %d %d %d %d\n", start_time, Mf_currtime, trackno+1, chan +1, pitch,initvol); if(Mf_currtime > last_tick) last_tick = Mf_currtime; } /* In order to associate a channel note off message with its * corresponding note on message, we maintain the information * the notechan array. When a midi pitch (0-127) is switched * on for a particular channel, we record the time that it * was turned on in the notechan array. As there are 16 channels * and 128 pitches, we initialize an array 128*16 = 2048 elements * long. **/ void init_notechan() { /* signal that there are no active notes */ int i; for (i = 0; i < 2048; i++) notechan[i] = -1; } /* The next two functions update notechan when a channel note on or note off is encountered. The second function close_note, returns the time when the note was turned on. */ int open_note(int chan, int pitch, int vol) { notechan[128 * chan + pitch] = Mf_currtime; notechanvol[128 * chan + pitch] = vol; return 0; } int close_note(int chan, int pitch, int *initvol) { int index, start_tick; index = 128 * chan + pitch; if (notechan[index] < 0) return -1; start_tick = notechan[index]; *initvol = notechanvol[index]; notechan[index] = -1; return start_tick; } /* mftext mode */ int prtime() { /* if(Mf_currtime >= pulses) ignore=0; if (ignore) return 1; linecount++; if(linecount > maxlines) {fclose(F); exit(0);} */ int units; units = 2; if(units==1) /*seconds*/ printf("%6.2f ",mf_ticks2sec(Mf_currtime,division,tempo)); else if (units==2) /*beats*/ printf("%6.2f ",(float) Mf_currtime/(float) division); else /*pulses*/ printf("%6ld ",Mf_currtime); return 0; } char * pitch2key(int note) { static char name[5]; char* s = name; switch(note % 12) { case 0: *s++ = 'c'; break; case 1: *s++ = 'c'; *s++ = '#'; break; case 2: *s++ = 'd'; break; case 3: *s++ = 'd'; *s++ = '#'; break; case 4: *s++ = 'e'; break; case 5: *s++ = 'f'; break; case 6: *s++ = 'f'; *s++ = '#'; break; case 7: *s++ = 'g'; break; case 8: *s++ = 'g'; *s++ = '#'; break; case 9: *s++ = 'a'; break; case 10: *s++ = 'a'; *s++ = '#'; break; case 11: *s++ = 'b'; break; } sprintf(s, "%d", (note / 12)-1); /* octave (assuming Piano C4 is 60)*/ return name; } void pitch2drum(midipitch) int midipitch; { static char *drumpatches[] = { "Acoustic Bass Drum", "Bass Drum 1", "Side Stick", "Acoustic Snare", "Hand Clap", "Electric Snare", "Low Floor Tom", "Closed Hi Hat", "High Floor Tom", "Pedal Hi-Hat", "Low Tom", "Open Hi-Hat", "Low-Mid Tom", "Hi Mid Tom", "Crash Cymbal 1", "High Tom", "Ride Cymbal 1", "Chinese Cymbal", "Ride Bell", "Tambourine", "Splash Cymbal", "Cowbell", "Crash Cymbal 2", "Vibraslap", "Ride Cymbal 2", "Hi Bongo", "Low Bongo", "Mute Hi Conga", "Open Hi Conga", "Low Conga", "High Timbale", "Low Timbale", "High Agogo", "Low Agogo", "Cabasa", "Maracas", "Short Whistle", "Long Whistle", "Short Guiro", "Long Guiro", "Claves", "Hi Wood Block", "Low Wood Block", "Mute Cuica", "Open Cuica", "Mute Triangle", "Open Triangle" }; if (midipitch >= 35 && midipitch <= 81) { printf(" (%s)",drumpatches[midipitch-35]); } } void mftxt_header (int format, int ntrks, int ldivision) { division = ldivision; printf("Header format=%d ntrks=%d division=%d\n",format,ntrks,division); } void mftxt_trackstart() { int numbytes; tracknum++; numbytes = Mf_toberead; /*if(track != 0 && tracknum != track) {ignore_bytes(numbytes); return;} */ printf("Track %d contains %d bytes\n",tracknum,numbytes); } void mftxt_noteon(chan,pitch,vol) int chan, pitch, vol; { char *key; /* if (onlychan >=0 && chan != onlychan) return; */ if (prtime()) return; key = pitch2key(pitch); printf("Note on %2d %2d (%3s) %3d",chan+1, pitch, key,vol); if (chan == 9) pitch2drum(pitch); printf("\n"); } void mftxt_noteoff(chan,pitch,vol) int chan, pitch, vol; { char *key; /* if (onlychan >=0 && chan != onlychan) return; */ if (prtime()) return; key = pitch2key(pitch); printf("Note off %2d %2d (%3s) %3d\n",chan+1,pitch, key,vol); } void mftxt_pressure(chan,pitch,press) int chan, pitch, press; { char *key; if (prtime()) return; key = pitch2key(pitch); printf("Pressure %2d %3s %3d\n",chan+1,key,press); } void mftxt_pitchbend(chan,lsb,msb) int chan, lsb, msb; { float bend; int pitchbend; /* if (onlychan >=0 && chan != onlychan) return; */ if (prtime()) return; /* [SS] 2014-01-05 2015-08-04*/ pitchbend = (msb*128 + lsb); bend = (float) (pitchbend - 8192); bend = bend/4096.0f; printf("Pitchbend %2d %d bend = %6.4f\n",chan+1,pitchbend,bend); } void mftxt_program(chan,program) int chan, program; { static char *patches[] = { "Acoustic Grand","Bright Acoustic","Electric Grand","Honky-Tonk", "Electric Piano 1","Electric Piano 2","Harpsichord","Clav", "Celesta", "Glockenspiel", "Music Box", "Vibraphone", "Marimba", "Xylophone", "Tubular Bells", "Dulcimer", "Drawbar Organ", "Percussive Organ", "Rock Organ", "Church Organ", "Reed Organ", "Accordian", "Harmonica", "Tango Accordian", "Acoustic Guitar (nylon)", "Acoustic Guitar (steel)", "Electric Guitar (jazz)", "Electric Guitar (clean)", "Electric Guitar (muted)", "Overdriven Guitar", "Distortion Guitar", "Guitar Harmonics", "Acoustic Bass", "Electric Bass (finger)", "Electric Bass (pick)", "Fretless Bass", "Slap Bass 1", "Slap Bass 2", "Synth Bass 1", "Synth Bass 2", "Violin", "Viola", "Cello", "Contrabass", "Tremolo Strings", "Pizzicato Strings", "Orchestral Strings", "Timpani", "String Ensemble 1", "String Ensemble 2", "SynthStrings 1", "SynthStrings 2", "Choir Aahs", "Voice Oohs", "Synth Voice", "Orchestra Hit", "Trumpet", "Trombone", "Tuba", "Muted Trumpet", "French Horn", "Brass Section", "SynthBrass 1", "SynthBrass 2", "Soprano Sax", "Alto Sax", "Tenor Sax", "Baritone Sax", "Oboe", "English Horn", "Bassoon", "Clarinet", "Piccolo", "Flute", "Recorder", "Pan Flute", "Blown Bottle", "Skakuhachi", "Whistle", "Ocarina", "Lead 1 (square)", "Lead 2 (sawtooth)", "Lead 3 (calliope)", "Lead 4 (chiff)", "Lead 5 (charang)", "Lead 6 (voice)", "Lead 7 (fifths)", "Lead 8 (bass+lead)", "Pad 1 (new age)", "Pad 2 (warm)", "Pad 3 (polysynth)", "Pad 4 (choir)", "Pad 5 (bowed)", "Pad 6 (metallic)", "Pad 7 (halo)", "Pad 8 (sweep)", "FX 1 (rain)", "(soundtrack)", "FX 3 (crystal)", "FX 4 (atmosphere)", "FX 5 (brightness)", "FX 6 (goblins)", "FX 7 (echoes)", "FX 8 (sci-fi)", "Sitar", "Banjo", "Shamisen", "Koto", "Kalimba", "Bagpipe", "Fiddle", "Shanai", "Tinkle Bell", "Agogo", "Steel Drums", "Woodblock", "Taiko Drum", "Melodic Tom", "Synth Drum", "Reverse Cymbal", "Guitar Fret Noise", "Breath Noise", "Seashore", "Bird Tweet", "Telephone ring", "Helicopter", "Applause", "Gunshot"}; /* if (onlychan >=0 && chan != onlychan) return; */ if (prtime()) return; printf("Program %2d %d (%s)\n",chan+1, program,patches[program]); } void mftxt_chanpressure(chan,press) int chan, press; { prtime(); printf("Chanpres %2d pressure=%d\n",chan+1,press); } void mftxt_parameter(chan,control,value) int chan, control, value; { static char *ctype[] = { "Bank Select", "Modulation Wheel", /*1*/ "Breath controller", "unknown", /*3*/ "Foot Pedal", "Portamento Time", /*5*/ "Data Entry", "Volume", /*7*/ "Balance", "unknown", /*9*/ "Pan position", "Expression", /*11*/ "Effect Control 1", "Effect Control 2", /*13*/ "unknown", "unknown", /*15*/ "Slider 1", "Slider 2", /*17*/ "Slider 3", "Slider 4", /*19*/ "unknown", "unknown", /*21*/ "unknown", "unknown", /*23*/ "unknown", "unknown", /*25*/ "unknown", "unknown", /*27*/ "unknown", "unknown", /*29*/ "unknown", "unknown", /*31*/ "Bank Select (fine)", "Modulation Wheel (fine)", /*33*/ "Breath controller (fine)", "unknown", /*35*/ "Foot Pedal (fine)", "Portamento Time (fine)", /*37*/ "Data Entry (fine)", "Volume (fine)", /*39*/ "Balance (fine)", "unknown", /*41*/ "Pan position (fine)", "Expression (fine)", /*43*/ "Effect Control 1 (fine)", "Effect Control 2 (fine)", /*45*/ "unknown", "unknown", /*47*/ "unknown", "unknown", /*49*/ "unknown", "unknown", /*51*/ "unknown", "unknown", /*53*/ "unknown", "unknown", /*55*/ "unknown", "unknown", /*57*/ "unknown", "unknown", /*59*/ "unknown", "unknown", /*61*/ "unknown", "unknown", /*63*/ "Hold Pedal", "Portamento", /*65*/ "Susteno Pedal", "Soft Pedal", /*67*/ "Legato Pedal", "Hold 2 Pedal", /*69*/ "Sound Variation", "Sound Timbre", /*71*/ "Sound Release Time", "Sound Attack Time", /*73*/ "Sound Brightness", "Sound Control 6", /*75*/ "Sound Control 7", "Sound Control 8", /*77*/ "Sound Control 9", "Sound Control 10", /*79*/ "GP Button 1", "GP Button 2", /*81*/ "GP Button 3", "GP Button 4", /*83*/ "unknown", "unknown", /*85*/ "unknown", "unknown", /*87*/ "unknown", "unknown", /*89*/ "unknown", "Effects Level", /*91*/ "Tremolo Level", "Chorus Level", /*93*/ "Celeste Level", "Phaser Level", /*95*/ "Data button increment", "Data button decrement", /*97*/ "NRP (fine)", "NRP (coarse)", /*99*/ "Registered parameter (fine)", "Registered parameter (coarse)", /*101*/ "unknown", "unknown", /*103*/ "unknown", "unknown", /*105*/ "unknown", "unknown", /*107*/ "unknown", "unknown", /*109*/ "unknown", "unknown", /*111*/ "unknown", "unknown", /*113*/ "unknown", "unknown", /*115*/ "unknown", "unknown", /*117*/ "unknown", "unknown", /*119*/ "All Sound Off", "All Controllers Off", /*121*/ "Local Keyboard (on/off)","All Notes Off", /*123*/ "Omni Mode Off", "Omni Mode On", /*125*/ "Mono Operation", "Poly Operation"}; /* if (onlychan >=0 && chan != onlychan) return; */ if (prtime()) return; printf("CntlParm %2d %s = %d\n",chan+1, ctype[control],value); } void mftxt_metatext(type,leng,mess) int type, leng; char *mess; { static char *ttype[] = { NULL, "Text Event", /* type=0x01 */ "Copyright Notice", /* type=0x02 */ "Seqnce/Track Name", "Instrument Name", /* ... */ "Lyric", "Marker", "Cue Point", /* type=0x07 */ "Unrecognized" }; int unrecognized = (sizeof(ttype)/sizeof(char *)) - 1; int len; register int n, c; register char *p = mess; if ( type < 1 || type > unrecognized ) type = unrecognized; if (prtime()) return; printf("Metatext (%s) ",ttype[type]); len = leng; if (len > 15) len = 15; for ( n=0; n */ printf( (isprint(c)||isspace(c)) ? "%c" : "\\0x%02x" , c); } if (leng>15) printf("..."); printf("\n"); } void mftxt_keysig(sf,mi) int sf, mi; { static char *major[] = {"Cb", "Gb", "Db", "Ab", "Eb", "Bb", "F", "C", "G", "D", "A", "E", "B", "F#", "C#"}; static char *minor[] = {"Abmin", "Ebmin", "Bbmin", "Fmin", "Cmin", "Gmin", "Dmin", "Amin", "Emin", "Bmin", "F#min", "C#min", "G#min"}; int index; index = sf + 7; if (prtime()) return; if (mi) printf("Metatext key signature %s (%d/%d)\n",minor[index],sf,mi); else printf("Metatext key signature %s (%d/%d)\n",major[index],sf,mi); } void mftxt_tempo(ltempo) long ltempo; { tempo = ltempo; if (prtime()) return; printf("Metatext tempo = %6.2f bpm\n",60000000.0/tempo); } void mftxt_timesig(nn,dd,cc,bb) int nn, dd, cc, bb; { int denom = 1; while ( dd-- > 0 ) denom *= 2; if (prtime()) return; printf("Metatext time signature=%d/%d\n",nn,denom); /* printf("Time signature=%d/%d MIDI-clocks/click=%d \ 32nd-notes/24-MIDI-clocks=%d\n", nn,denom,cc,bb); */ } void mftxt_smpte(hr,mn,se,fr,ff) int hr, mn, se, fr, ff; { if (prtime()) return; printf("Metatext SMPTE, %d:%d:%d %d=%d\n", hr,mn,se,fr,ff); } void mftxt_metaeot() { if (prtime()) return; printf("Meta event, end of track\n"); } void initfunc_for_midinotes() { Mf_error = error; Mf_header = txt_header; Mf_trackstart = txt_trackstart; Mf_trackend = txt_trackend; Mf_noteon = print_txt_noteon; Mf_noteoff = print_txt_noteoff; Mf_pressure = no_op3; Mf_parameter = no_op3; Mf_pitchbend = no_op3; Mf_program = no_op2; Mf_chanpressure = no_op3; Mf_sysex = no_op2; Mf_metamisc = no_op3; Mf_seqnum = no_op1; Mf_eot = no_op0; Mf_timesig = no_op4; Mf_smpte = no_op5; Mf_tempo = no_op1; Mf_keysig = no_op2; Mf_seqspecific = no_op3; Mf_text = no_op3; Mf_arbitrary = no_op2; } void initfunc_for_mftext() { Mf_error = error; Mf_header = mftxt_header; Mf_trackstart = mftxt_trackstart; Mf_trackend = txt_trackend; Mf_noteon = mftxt_noteon; Mf_noteoff = mftxt_noteoff; Mf_pressure =mftxt_pressure; Mf_parameter = mftxt_parameter; Mf_pitchbend = mftxt_pitchbend; Mf_program = mftxt_program; Mf_chanpressure = mftxt_chanpressure; Mf_sysex = no_op2; Mf_metamisc = no_op3; Mf_seqnum = no_op1; Mf_eot = mftxt_metaeot; Mf_timesig = mftxt_timesig; Mf_smpte = mftxt_smpte; Mf_tempo = mftxt_tempo; Mf_keysig = mftxt_keysig; Mf_seqspecific = no_op3; Mf_text = mftxt_metatext; Mf_arbitrary = no_op2; } void initfuncs() { Mf_error = error; Mf_header = txt_header; Mf_trackstart = txt_trackstart; Mf_trackend = txt_trackend; Mf_noteon = txt_noteon; Mf_noteoff = txt_noteoff; Mf_pressure = txt_pressure; Mf_parameter = txt_parameter; Mf_pitchbend = txt_pitchbend; Mf_program = txt_program; Mf_chanpressure = txt_chanpressure; Mf_sysex = txt_sysex; Mf_metamisc = txt_metamisc; Mf_seqnum = txt_metaseq; Mf_eot = txt_metaeot; Mf_timesig = txt_timesig; Mf_smpte = txt_smpte; Mf_tempo = txt_tempo; Mf_keysig = txt_keysig; Mf_seqspecific = txt_metaspecial; Mf_text = txt_metatext; Mf_arbitrary = txt_arbitrary; } /* Stage 2 Quantize MIDI tracks. Get key signature, time signature... */ void postprocess(trackno) /* This routine calculates the time interval before the next note */ /* called after the MIDI file has been read in */ int trackno; { struct listx* i; i = track[trackno].head; if (i != NULL) { track[trackno].startwait = i->note->time; } else { track[trackno].startwait = 0; }; while (i != NULL) { if (i->next != NULL) { i->note->dtnext = i->next->note->time - i->note->time; } else { i->note->dtnext = i->note->tplay; }; i = i->next; }; } void scannotes(trackno) int trackno; /* diagnostic routine to output notes in a track */ { struct listx* i; i = track[trackno].head; while (i != NULL) { printf("Pitch %d chan %d vel %d time %ld %ld xnum %d playnum %d\n", i->note->pitch, i->note->chan, i->note->vel, i->note->dtnext, i->note->tplay, i->note->xnum, i->note->playnum); i = i->next; }; } int xnum_to_next_nonchordal_note(fromitem,spare,quantum) struct listx* fromitem; int spare,quantum; { struct anote* jnote; struct listx* nextitem; int i,xxnum; jnote = fromitem->note; if (jnote->xnum > 0) return jnote->xnum; i = 0; nextitem = fromitem->next; while (nextitem != NULL && i < 5) { jnote = nextitem->note; xxnum = (2*(jnote->dtnext + spare + (quantum/4)))/quantum; if (xxnum > 0) return xxnum; i++; nextitem = nextitem->next; } return 0; } int quantize(trackno, xunit) /* Work out how long each note is in musical time units. * The results are placed in note.playnum */ int trackno, xunit; { struct listx* j; struct anote* this; int spare; int toterror; int quantum; int posnum,xxnum; /* fix to avoid division by zero errors in strange MIDI */ if (xunit == 0) { return(10000); }; quantum = (int) (2.*xunit/parts_per_unitlen); /* xunit assume 2 parts_per_unit */ track[trackno].startunits = (2*(track[trackno].startwait + (quantum/4)))/quantum; spare = 0; toterror = 0; j = track[trackno].head; posnum = 0; while (j != NULL) { this = j->note; /* this->xnum is the quantized inter onset time */ /* this->playnum is the quantized note length */ this->xnum = (2*(this->dtnext + spare + (quantum/4)))/quantum; this->playnum = (2*(this->tplay + (quantum/4)))/quantum; if ((this->playnum == 0) && (keep_short)) { this->playnum = 1; }; /* In the event of short rests, the inter onset time * will be larger than the note length. However, for * chords the inter onset time can be zero. */ xxnum = xnum_to_next_nonchordal_note(j,spare,quantum); if ((swallow_rests>=0) && (xxnum - this->playnum <= restsize) && xxnum > 0) { this->playnum = xxnum; }; /* this->denom = parts_per_unitlen; this variable is never used ! */ spare = spare + this->dtnext - (this->xnum*xunit/parts_per_unitlen); if (spare > 0) { toterror = toterror + spare; } else { toterror = toterror - spare; }; /* gradually forget old errors so that if xunit is slightly off, errors don't accumulate over several bars */ spare = (spare * 96)/100; this->posnum = posnum; posnum += this->xnum; j = j->next; }; return(toterror); } void guesslengths(trackno) /* work out most appropriate value for a unit of musical time */ int trackno; { int i; int trial[100]; float avlen, factor, tryx; long min; min = track[trackno].tracklen; if (track[trackno].notes == 0) { return; }; avlen = ((float)(min))/((float)(track[trackno].notes)); tryx = avlen * (float) 0.75; factor = tryx/100; for (i=0; i<100; i++) { trial[i] = quantize(trackno, (int) tryx); if ((long) trial[i] < min) { min = (long) trial[i]; xunit = (int) tryx; }; tryx = tryx + factor; }; xunit_set = 1; } int findana(maintrack, barsize) /* work out anacrusis from MIDI */ /* look for a strong beat marking the start of a bar */ int maintrack; int barsize; { int min, mincount; int place; struct listx* p; min = 0; mincount = 0; place = 0; p = track[maintrack].head; while ((p != NULL) && (place < barsize)) { if ((p->note->vel > min) && (place > 0)) { min = p->note->vel; mincount = place; }; place = place + (p->note->xnum); p = p->next; }; return(mincount); } int guessana(barbeats) int barbeats; /* try to guess length of anacrusis */ { int score[64]; int min, minplace; int i,j; if (barbeats > 64) { fatal_error("Bar size exceeds static limit of 64 units!"); }; for (j=0; jnote->pitch; max = min; totalnotes = 0; for (j=0; jnote->pitch; if (thispitch > max) { max = thispitch; } else { if (thispitch < min) { min = thispitch; }; }; n[thispitch % 12] = n[thispitch % 12] + 1; p = p->next; }; }; /* count black notes for each key */ /* assume pitch = 0 is C */ minkey = 0; minblacks = totalnotes; for (j=0; j<12; j++) { key_score[j] = n[(j+1)%12] + n[(j+3)%12] + n[(j+6)%12] + n[(j+8)%12] + n[(j+10)%12]; /* printf("Score for key %d is %d\n", j, key_score[j]); */ if (key_score[j] < minblacks) { minkey = j; minblacks = key_score[j]; }; }; /* do conversion to abc pitches */ /* Code changed to use absolute rather than */ /* relative choice of pitch for 'c' */ /* MIDDLE = (min + (max - min)/2 + 6)/12 * 12; */ /* Do last note analysis */ lastpitch = track[maintrack].tail->note->pitch; if (minkey != (lastpitch%12)) { fprintf(outhandle,"%% Last note suggests "); switch((lastpitch+12-minkey)%12) { case(2): fprintf(outhandle,"Dorian "); break; case(4): fprintf(outhandle,"Phrygian "); break; case(5): fprintf(outhandle,"Lydian "); break; case(7): fprintf(outhandle,"Mixolydian "); break; case(9): fprintf(outhandle,"minor "); break; case(11): fprintf(outhandle,"Locrian "); break; default: fprintf(outhandle,"unknown "); break; }; fprintf(outhandle,"mode tune\n"); }; /* switch to minor mode if it gives same number of accidentals */ if ((minkey != ((lastpitch+3)%12)) && (key_score[minkey] == key_score[(lastpitch+3)%12])) { minkey = (lastpitch+3)%12; }; /* switch to major mode if it gives same number of accidentals */ if ((minkey != (lastpitch%12)) && (key_score[minkey] == key_score[lastpitch%12])) { minkey = lastpitch%12; }; sharps = keysharps[minkey]; return(sharps); } /* Stage 3 output MIDI tracks in abc format */ /* head and tail of list of notes in current chord playing */ /* used while abc is being generated */ struct dlistx* chordhead; struct dlistx* chordtail; void printchordlist() /* diagnostic routine */ { struct dlistx* i; i = chordhead; printf("----CHORD LIST------\n"); while(i != NULL) { printf("pitch %d len %d\n", i->note->pitch, i->note->playnum); if (i->next == i) { fatal_error("Loopback problem!"); }; i = i->next; }; } void checkchordlist() /* diagnostic routine */ /* validates data structure */ { struct dlistx* i; int n; if ((chordhead == NULL) && (chordtail == NULL)) { return; }; if ((chordhead == NULL) && (chordtail != NULL)) { fatal_error("chordhead == NULL and chordtail != NULL"); }; if ((chordhead != NULL) && (chordtail == NULL)) { fatal_error("chordhead != NULL and chordtail == NULL"); }; if (chordhead->last != NULL) { fatal_error("chordhead->last != NULL"); }; if (chordtail->next != NULL) { fatal_error("chordtail->next != NULL"); }; i = chordhead; n = 0; while((i != NULL) && (i->next != NULL)) { if (i->next->last != i) { char msg[80]; sprintf(msg, "chordlist item %d : i->next->last!", n); fatal_error(msg); }; i = i->next; n = n + 1; }; /* checkchordlist(); */ } void addtochord(p) /* used when printing out abc */ struct anote* p; { struct dlistx* newx; struct dlistx* place; newx = (struct dlistx*) checkmalloc(sizeof(struct dlistx)); newx->note = p; newx->next = NULL; newx->last = NULL; if (chordhead == NULL) { chordhead = newx; chordtail = newx; checkchordlist(); return; }; place = chordhead; while ((place != NULL) && (place->note->pitch > p->pitch)) { place = place->next; }; if (place == chordhead) { newx->next = chordhead; chordhead->last = newx; chordhead = newx; checkchordlist(); return; }; if (place == NULL) { newx->last = chordtail; chordtail->next = newx; chordtail = newx; checkchordlist(); return; }; newx->next = place; newx->last = place->last; place->last = newx; newx->last->next = newx; checkchordlist(); } struct dlistx* removefromchord(i) /* used when printing out abc */ struct dlistx* i; { struct dlistx* newi; /* remove note from list */ if (i->last == NULL) { chordhead = i->next; } else { (i->last)->next = i->next; }; if (i->next == NULL) { chordtail = i->last; } else { (i->next)->last = i->last; }; newi = i->next; free(i); checkchordlist(); return(newi); } int findshortest(gap) /* find the first note in the chord to terminate */ int gap; { int min, v; struct dlistx* p; p = chordhead; min = gap; while (p != NULL) { v = p->note->playnum; if (v < min) { min = v; }; p = p->next; }; return(min); } void advancechord(len) /* adjust note lengths for all notes in the chord */ int len; { struct dlistx* p; p = chordhead; while (p != NULL) { if (p->note->playnum <= len) { if (p->note->playnum < len) { fatal_error("Error - note too short!"); }; /* remove note */ checkchordlist(); p = removefromchord(p); } else { /* shorten note */ p->note->playnum = p->note->playnum - len; p = p->next; }; }; } void freshline() /* if the current line of abc or text is non-empty, start a new line */ { if (midline == 1) { fprintf(outhandle,"\n"); midline = 0; }; } void printnote (struct listx *i) { printf("%ld ",i->note->time); printpitch(i->note); printfract(i->note->playnum, parts_per_unitlen); printf(" %d %d %d %d\n",i->note->xnum, i->note->playnum, i->note->posnum,i->note->splitnum); } void listnotes(int trackno, int start, int end) /* A diagnostic like scannotes. I usually call it when I am in the debugger (for example in printtrack). */ { struct listx* i; int k; i = track[trackno].head; k = 0; printf("ticks pitch xnum,playnum,posnum,splitnum\n"); while (i != NULL && k < end) { if (k >= start) printnote(i); k++; i = i->next; } } int testtrack(trackno, barbeats, anacrusis) /* print out one track as abc */ int trackno, barbeats, anacrusis; { struct listx* i; int step, gap; int barnotes; int barcount; int breakcount; breakcount = 0; chordhead = NULL; chordtail = NULL; i = track[trackno].head; gap = 0; if (anacrusis > 0) { barnotes = anacrusis; } else { barnotes = barbeats; }; barcount = 0; while((i != NULL)||(gap != 0)) { if (gap == 0) { /* add notes to chord */ addtochord(i->note); gap = i->note->xnum; i = i->next; advancechord(0); /* get rid of any zero length notes */ } else { step = findshortest(gap); if (step > barnotes) { step = barnotes; }; if (step == 0) { fatal_error("Advancing by 0 in testtrack!"); }; advancechord(step); gap = gap - step; barnotes = barnotes - step; if (barnotes == 0) { if (chordhead != NULL) { breakcount = breakcount + 1; }; barnotes = barbeats; barcount = barcount + 1; if (barcount>0 && barcount%4 ==0) { /* can't zero barcount because I use it for computing maxbarcount */ freshline(); barcount = 0; }; }; }; }; return(breakcount); } void printpitch(j) /* convert numerical value to abc pitch */ struct anote* j; { int p, po,i; p = j->pitch; if (p == -1) { fprintf(outhandle,"z"); } else { po = p % 12; if ((back[trans[p]] != p) || (key[po] == 1)) { fprintf(outhandle,"%c%c", symbol[po], atog[p]); for (i=p%12; i<256; i += 12) /* apply accidental to all octaves */ back[trans[i]] = i; } else { fprintf(outhandle,"%c", atog[p]); }; while (p >= MIDDLE + 12) { fprintf(outhandle,"'"); p = p - 12; }; while (p < MIDDLE - 12) { fprintf(outhandle,","); p = p + 12; }; }; } static void reduce(a, b) int *a, *b; { int t, n, m; /* find HCF using Euclid's algorithm */ if (*a > *b) { n = *a; m = *b; } else { n = *b; m = *a; }; while (m != 0) { t = n % m; n = m; m = t; }; *a = *a/n; *b = *b/n; } void printfract(a, b) /* print fraction */ /* used when printing abc */ int a, b; { int c, d; c = a; d = b; reduce(&c,&d); /* print out length */ if (c != 1) { fprintf(outhandle,"%d", c); }; if (d != 1) { fprintf(outhandle,"/%d", d); }; } void printchord(len) /* Print out the current chord. Any notes that haven't */ /* finished at the end of the chord are tied into the next chord. */ int len; { struct dlistx* i; i = chordhead; if (i == NULL) { /* no notes in chord */ #ifdef SPLITCODE fprintf(outhandle,"x"); #else fprintf(outhandle,"z"); #endif printfract(len, parts_per_unitlen); midline = 1; } else { if (i->next == NULL) { /* only one note in chord */ printpitch(i->note); printfract(len, parts_per_unitlen); midline = 1; if (len < i->note->playnum) { fprintf(outhandle,"-"); }; } else { fprintf(outhandle,"["); while (i != NULL) { printpitch(i->note); printfract(len, parts_per_unitlen); if (len < i->note->playnum) { fprintf(outhandle,"-"); }; if (nogr && i->next != NULL) fprintf(outhandle," "); i = i->next; }; fprintf(outhandle,"]"); midline = 1; }; }; } char dospecial(i, barnotes, featurecount,allow_broken,allow_triplets) /* identify and print out triplets and broken rhythm */ struct listx* i; int* barnotes; int* featurecount; int allow_broken,allow_triplets; { int v1, v2, v3, vt; int xa, xb; int pnum; long total, t1, t2, t3; if ((chordhead != NULL) || (i == NULL) || (i->next == NULL) /* || (asig%3 == 0) || (asig%2 != 0) 2004/may/09 SS*/) { return(' '); }; t1 = i->note->dtnext; v1 = i->note->xnum; pnum = i->note->playnum; if ((v1 < pnum) || (v1 > 1 + pnum) || (pnum == 0)) { return(' '); }; t2 = i->next->note->dtnext; v2 = i->next->note->xnum; pnum = i->next->note->playnum; if (/*(v2 < pnum) ||*/ (v2 > 1 + pnum) || (pnum == 0) || (v1+v2 > *barnotes)) { return(' '); }; /* look for broken rhythm */ total = t1 + t2; if (total == 0L) { /* shouldn't happen, but avoids possible divide by zero */ return(' '); }; /* [SS] 2017-01-01 */ if (allow_broken == 1 && ((v1+v2)%2 == 0) && ((v1+v2)%3 != 0)) { vt = (v1+v2)/2; if (vt == validnote(vt)) { /* do not try to break a note which cannot be legally expressed */ switch ((int) ((t1*6+(total/2))/total)) { case 2: *featurecount = 2; i->note->xnum = vt; i->note->playnum = vt; i->next->note->xnum = vt; i->next->note->playnum = vt; return('<'); break; case 4: *featurecount = 2; i->note->xnum = vt; i->note->playnum = vt; i->next->note->xnum = vt; i->next->note->playnum = vt; return('>'); break; default: break; }; }; }; if (allow_triplets == 0) return(' '); /* [SS] 2017-01-01 */ /* look for triplet */ if (i->next->next != NULL) { t3 = i->next->next->note->dtnext; v3 = i->next->next->note->xnum; pnum = i->next->next->note->playnum; if ((v3 < pnum) || (v3 > 1 + pnum) || (pnum == 0) || (v1+v2+v3 > *barnotes)) { return(' '); }; if ((v1+v2+v3)%2 != 0) { return(' '); }; vt = (v1+v2+v3)/2; if ((vt%2 == 1) && (vt > 1)) { /* don't want strange fractions in triplet */ return(' '); }; total = t1+t2+t3; xa = (int) ((t1*6+(total/2))/total); xb = (int) (((t1+t2)*6+(total/2))/total); if ((xa == 2) && (xb == 4) && (vt%3 != 0) ) { *featurecount = 3; *barnotes = *barnotes + vt; i->note->xnum = vt; i->note->playnum = vt; i->next->note->xnum = vt; i->next->note->playnum = vt; i->next->next->note->xnum = vt; i->next->next->note->playnum = vt; }; }; return(' '); } int validnote(n) int n; /* work out a step which can be expressed as a musical time */ { int v; if (n <= 4) { v = n; } else { v = 4; while (v*2 <= n) { v = v*2; }; if (v + v/2 <= n) { v = v + v/2; }; }; return(v); } void handletext(t, textplace, trackno) /* print out text occuring in the body of the track */ /* The text is printed out at the appropriate place within the track */ /* In addition the function handles key signature and time */ /* signature changes that can occur in the middle of the tune. */ long t; struct tlistx** textplace; int trackno; { char* str; char ch; int type,sf,mi,nn,denom,bb; while (((*textplace) != NULL) && ((*textplace)->when <= t)) { str = (*textplace)->text; ch = *str; type = (*textplace)->type; remove_carriage_returns(str); if (((int)ch == '\\') || ((int)ch == '/')) { inkaraoke = 1; }; if ((inkaraoke == 1) && (karaoke == 1)) { switch(ch) { case ' ': fprintf(outhandle,"%s", str); midline = 1; break; case '\\': freshline(); fprintf(outhandle,"w:%s", str + 1); midline = 1; break; case '/': freshline(); fprintf(outhandle,"w:%s", str + 1); midline = 1; break; default : if (midline == 0) { fprintf(outhandle,"%%%s", str); } else { fprintf(outhandle,"-%s", str); }; break; }; } else { freshline(); ch=*(str+1); switch (type) { case 0: if (ch != '%') fprintf(outhandle,"%%%s\n", str); else fprintf(outhandle,"%s\n", str); break; case 1: /* key signature change */ sscanf(str,"%d %d",&sf,&mi); if((trackno != 0 || trackcount==1) && (active_keysig != sf)) { setupkey(sf); active_keysig=sf; } break; case 2: /* time signature change */ sscanf(str,"%d %d %d",&nn,&denom,&bb); if ((trackno != 0 || trackcount ==1) && (active_asig != nn || active_bsig != denom)) { setup_timesig(nn,denom,bb); fprintf(outhandle,"M: %d/%d\n",nn,denom); fprintf(outhandle,"L: 1/%d\n",unitlen); active_asig=nn; active_bsig=denom; } break; default: break; } } *textplace = (*textplace)->next; } } #ifdef SPLITCODE /* This function identifies irregular chords, (notes which do not exactly overlap in time). The notes in the chords are split into separate lines (split numbers). The xnum (delay) to next note is updated. */ int splitstart[10],splitend[10]; /* used in forming chords from notes*/ int lastposnum[10]; /* posnum of previous note in linked list */ int endposnum; /* posnum at last note in linked list */ struct anote* prevnote[10]; /*previous note in linked list */ struct listx* last_i[10]; /*note after finishing processing bar*/ int existingsplits[10]; /* existing splits in active bar */ struct dlistx* splitchordhead[10]; /* chordhead list for splitnum */ struct dlistx* splitchordtail[10]; /* chordtail list for splitnum */ int splitgap[10]; /* gap to next note at end of split measure */ void label_split(struct anote *note, int activesplit) { /* The function assigns a split number (activesplit), to a specific note, (*note). We also update splitstart and splitend which specifies the region in time where the another note must occur if it forms a proper chord. After assigning a split number to the note we need to update note->xnum as this indicates the gap to the next note in the same split number. The function uses a greedy algorithm. It assigns a note to the first splitnumber code which satisfies the above constraint. If it cannot find a splitnumber, a new one (voice or track) is created. It would be nice if the voices kept the high and low notes (in pitch) separate. */ note->splitnum = activesplit; splitstart[activesplit] = note->posnum; splitend[activesplit] = splitstart[activesplit] + note->playnum; if (prevnote[activesplit]) prevnote[activesplit]->xnum = note->posnum - lastposnum[activesplit]; lastposnum[activesplit] = note->posnum; prevnote[activesplit] = note; /* in case this is the last activesplit note make sure it xnum points to end of track. Otherwise it will be changed when the next activesplit note is labeled. */ note->xnum = endposnum - note->posnum; existingsplits[activesplit]++; } void label_split_voices (int trackno) { /* This function sorts all the notes in the track into separate split part. A note is placed into a separate part if it forms a chord in the current part but does not have the same onset time and same end time. If this occurs, we search for another part where this does not happen. If we can't find such a part a new part (split) is created. The heuristic used needs to be improved, so that split number 0 always contains notes and so that notes in the same pitch range or duration are given the same split number. */ int activesplit,nsplits; int done; struct listx* i; int k; int firstposnum; /* initializations */ activesplit = 0; nsplits = 0; for (k=0;k<10;k++) { splitstart[k]=splitend[k]=lastposnum[k]=0; prevnote[k] = NULL; existingsplits[k] = 0; splitgap[k]=0; } i = track[trackno].head; if (track[trackno].tail == 0x0) return; endposnum =track[trackno].tail->note->posnum + track[trackno].tail->note->playnum; if (i != NULL) label_split(i->note, activesplit); /* now label all the notes in the track */ while (i != NULL) { done =0; if (nsplits == 0) { /*no splits exist, create split number 0 */ activesplit = 0; nsplits++; i->note->splitnum = activesplit; splitstart[activesplit] = i->note->posnum; splitend[activesplit] = splitstart[activesplit] + i->note->playnum; firstposnum = splitstart[activesplit]; } else { /* do a compatibility check with the last split number */ if ( ( i->note->posnum == splitstart[activesplit] && i->note->playnum == (splitend[activesplit] - splitstart[activesplit])) || i->note->posnum >= splitend[activesplit]) { if (existingsplits[activesplit] == 0) { last_i[activesplit] = i; splitgap[activesplit] = i->note->posnum - firstposnum; } label_split(i->note, activesplit); done = 1; } /* need to search for any other compatible split numbers */ if (done == 0) for (activesplit=0;activesplitnote->posnum == splitstart[activesplit] && i->note->playnum == splitend[activesplit] - splitstart[activesplit]) || i->note->posnum >= splitend[activesplit]) { if (existingsplits[activesplit] == 0) { last_i[activesplit] = i; splitgap[activesplit] = i->note->posnum - firstposnum; } label_split(i->note,activesplit); done = 1; break; } } /* No compatible split number found. Create new split */ if (done == 0) { if(nsplits < 10) {nsplits++; activesplit = nsplits-1;} if (existingsplits[activesplit] == 0) { last_i[activesplit] = i; splitgap[activesplit] = i->note->posnum - firstposnum; } label_split(i->note,activesplit); } } /* printf("note %d links to %d %d (%d %d)\n",i->note->pitch,activesplit, i->note->posnum,splitstart[activesplit],splitend[activesplit]); */ i = i->next; } /* end while loop */ } int nextsplitnum(int splitnum) { while (splitnum < 9) { splitnum++; if (existingsplits[splitnum]) return splitnum; } return -1; } int count_splits() { int i,n; n = 0; for (i=0;i<10;i++) if (existingsplits[i]) n++; return n; } void printtrack_with_splits(trackno, anacrusis) int trackno, anacrusis; /* This function is an adaption of printtrack so that notes with separate split numbers are in separated regions in the measure. (Separated with &'s). To do this we must make multiple passes through each bar and maintain separate chordlists (in event that some chords overlap over more than one measure). */ { struct listx* i; struct tlistx* textplace; struct tlistx* textplace0; /* track 0 text storage */ int step, gap; int barnotes; int barcount; int bars_on_line; long now; char broken; int featurecount; int last_barsize,barnotes_correction; int splitnum = 0; int j; int nlines; int done; nlines= 0; label_split_voices (trackno); midline = 0; featurecount = 0; inkaraoke = 0; now = 0L; broken = ' '; for (j=0;j<10;j++) { splitchordhead[j] = NULL; splitchordtail[j] = NULL; } i = track[trackno].head; textplace = track[trackno].texthead; textplace0 = track[0].texthead; /*gap = track[trackno].startunits;*/ gap = 0; if (anacrusis > 0) { barnotes = anacrusis; barcount = -1; } else { barnotes = barsize; barcount = 0; }; bars_on_line = 0; last_barsize = barsize; active_asig = header_asig; active_bsig = header_bsig; setup_timesig(header_asig,header_bsig,header_bb); active_keysig = header_keysig; handletext(now, &textplace, trackno); splitnum = 0; chordhead = splitchordhead[splitnum]; chordtail = splitchordtail[splitnum]; gap = splitgap[splitnum]; while((i != NULL)||(gap != 0)) { if (gap == 0) { /* do triplet here */ if (featurecount == 0) { if (allow_triplets || allow_broken) { /* [SS] 2017-01-01 */ broken = dospecial(i, &barnotes, &featurecount,allow_broken,allow_triplets); }; }; /* ignore any notes that are not in the current splitnum */ if (i->note->splitnum == splitnum) { /*printf("\nadding "); printnote(i); */ addtochord(i->note); gap = i->note->xnum; now = i->note->time; } i = i->next; advancechord(0); /* get rid of any zero length notes */ if (trackcount > 1 && trackno !=0) handletext(now, &textplace0, trackno); handletext(now, &textplace,trackno); barnotes_correction = barsize - last_barsize; barnotes += barnotes_correction; last_barsize = barsize; } else { step = findshortest(gap); if (step > barnotes) { step = barnotes; }; step = validnote(step); if (step == 0) { fatal_error("Advancing by 0 in printtrack!"); }; if (featurecount == 3) { fprintf(outhandle," (3"); }; printchord(step); if ( featurecount > 0) { featurecount = featurecount - 1; }; if ((featurecount == 1) && (broken != ' ')) { fprintf(outhandle,"%c", broken); }; advancechord(step); gap = gap - step; barnotes = barnotes - step; /* at the end of the bar we must decide whether to place a | or &. If we place a & then we have to return to the beginning of the bar and process the next split number. */ if (barnotes == 0) { /* end of bar ? */ nlines++; if (nlines > 5000) { printf("\nProbably infinite loop: aborting\n"); fprintf(outhandle,"\n\nProbably infinite loop: aborting\n"); return; } /* save state for the last splitnum before going to the next */ last_i[splitnum] = i; splitchordhead[splitnum] = chordhead; splitchordtail[splitnum] = chordtail; splitgap[splitnum] = gap; /* look for the next splitnum which contains notes in the current measure. If not, end the measure. */ done = 0; while (done != 1) { splitnum = nextsplitnum(splitnum); if (splitnum == -1) { fprintf(outhandle," | "); splitnum = nextsplitnum(splitnum); done = 1; break; } if (splitgap[splitnum] >= barsize) { splitgap[splitnum] -= barsize; continue; /* look for other splits */ } fprintf(outhandle, " & "); i = last_i[splitnum]; done = 1; } /* restore state for the next splitnum */ chordhead = splitchordhead[splitnum]; chordtail = splitchordtail[splitnum]; checkchordlist(); gap = splitgap[splitnum]; i = last_i[splitnum]; /* printf("returning to %ld ",i->note->time); printpitch(i->note); printf("\n"); */ barnotes = barsize; barcount = barcount + 1; bars_on_line++; if (barcount >0 && barcount%bars_per_staff == 0) { freshline(); bars_on_line=0; } /* can't zero barcount because I use it for computing maxbarcount */ else if(bars_on_line >= bars_per_line && i != NULL) { fprintf(outhandle," \\"); freshline(); bars_on_line=0;} } else if (featurecount == 0) { /* note grouping algorithm */ /* [SS] 2016-07-20 waltz is a special case */ if ((barsize/parts_per_unitlen) % 3 == 0 && asig != 3) { if ( (barnotes/parts_per_unitlen) % 3 == 0 &&(barnotes%parts_per_unitlen) == 0) { fprintf(outhandle," "); }; } else { if (((barsize/parts_per_unitlen) % 2 == 0) && (barnotes % parts_per_unitlen) == 0 && ((barnotes/parts_per_unitlen) % 2 == 0)) { fprintf(outhandle," "); }; }; } if (nogr) fprintf(outhandle," "); }; if (i == NULL) /* end of track before end of measure ? */ { last_i[splitnum] = i; splitchordhead[splitnum] = chordhead; splitchordtail[splitnum] = chordtail; splitgap[splitnum] = gap; splitnum = nextsplitnum(splitnum); if (splitnum == -1) break; chordhead = splitchordhead[splitnum]; chordtail = splitchordtail[splitnum]; gap = splitgap[splitnum]; i = last_i[splitnum]; if (barnotes != barsize) fprintf(outhandle, " & "); barnotes = barsize; } }; /* print out all extra text */ while (textplace != NULL) { handletext(textplace->when, &textplace, trackno); }; freshline(); if (barcount > maxbarcount) maxbarcount = barcount; } void printtrack_split_voice(trackno, anacrusis) /* print out one track as abc */ int trackno, anacrusis; { struct listx* i; struct tlistx* textplace; struct tlistx* textplace0; /* track 0 text storage */ int step, gap; int barnotes; int barcount; int bars_on_line; long now; char broken; int featurecount; int last_barsize,barnotes_correction; int nlines; int splitnum; int lastnote_in_split; nlines= 0; lastnote_in_split = 0; label_split_voices (trackno); midline = 0; featurecount = 0; inkaraoke = 0; now = 0L; broken = ' '; chordhead = NULL; chordtail = NULL; i = track[trackno].head; textplace = track[trackno].texthead; textplace0 = track[0].texthead; gap = track[trackno].startunits; if (anacrusis > 0) { barnotes = anacrusis; barcount = -1; } else { barnotes = barsize; barcount = 0; }; bars_on_line = 0; last_barsize = barsize; active_asig = header_asig; active_bsig = header_bsig; setup_timesig(header_asig,header_bsig,header_bb); active_keysig = header_keysig; handletext(now, &textplace, trackno); splitnum = 0; gap = splitgap[splitnum]; if (count_splits() > 1) fprintf(outhandle,"V: split%d%c\n",trackno+1,'A'+splitnum); while((i != NULL)||(gap != 0)) { if (gap == 0) { if (i->note->posnum + i->note->xnum == endposnum) lastnote_in_split = 1; /* do triplet here */ if (featurecount == 0) { if (allow_triplets || allow_broken) { /* [SS] 2017-01-01 */ broken = dospecial(i, &barnotes, &featurecount,allow_broken,allow_triplets); }; }; /* ignore any notes that are not in the current splitnum */ if (i->note->splitnum == splitnum) { /*printf("\nadding "); printnote(i); */ addtochord(i->note); gap = i->note->xnum; now = i->note->time; } i = i->next; advancechord(0); /* get rid of any zero length notes */ if (trackcount > 1 && trackno !=0) handletext(now, &textplace0, trackno); handletext(now, &textplace,trackno); barnotes_correction = barsize - last_barsize; barnotes += barnotes_correction; last_barsize = barsize; } else { step = findshortest(gap); if (step > barnotes) { step = barnotes; }; step = validnote(step); if (step == 0) { fatal_error("Advancing by 0 in printtrack!"); }; if (featurecount == 3) { fprintf(outhandle," (3"); }; printchord(step); if ( featurecount > 0) { featurecount = featurecount - 1; }; if ((featurecount == 1) && (broken != ' ')) { fprintf(outhandle,"%c", broken); }; advancechord(step); gap = gap - step; barnotes = barnotes - step; if (barnotes == 0) { nlines++; if (nlines > 5000) { printf("\nProbably infinite loop: aborting\n"); fprintf(outhandle,"\n\nProbably infinite loop: aborting\n"); return; } fprintf(outhandle,"|"); barnotes = barsize; barcount = barcount + 1; bars_on_line++; if (barcount >0 && barcount%bars_per_staff == 0) { freshline(); bars_on_line=0; } /* can't zero barcount because I use it for computing maxbarcount */ else if(bars_on_line >= bars_per_line && i != NULL) { if (!lastnote_in_split) fprintf(outhandle," \\"); freshline(); bars_on_line=0;} } else if (featurecount == 0) { /* note grouping algorithm */ /* [SS] 2016-07-20 waltz is a special case */ if ((barsize/parts_per_unitlen) % 3 == 0 && asig != 3) { if ( (barnotes/parts_per_unitlen) % 3 == 0 &&(barnotes%parts_per_unitlen) == 0) { fprintf(outhandle," "); }; } else { if (((barsize/parts_per_unitlen) % 2 == 0) && (barnotes % parts_per_unitlen) == 0 && ((barnotes/parts_per_unitlen) % 2 == 0)) { fprintf(outhandle," "); }; }; } if (nogr) fprintf(outhandle," "); }; if (i == NULL && gap == 0) { i = track[trackno].head; splitnum = nextsplitnum(splitnum); lastnote_in_split = 0; if (splitnum == -1) break; gap = splitgap[splitnum]; if(barnotes != barsize) freshline(); fprintf(outhandle,"V:split%d%c\n",trackno+1,'A'+splitnum); if (anacrusis > 0) { barnotes = anacrusis; barcount = -1; } else { barnotes = barsize; barcount = 0; }; } }; /* print out all extra text */ while (textplace != NULL) { handletext(textplace->when, &textplace, trackno); }; freshline(); if (barcount > maxbarcount) maxbarcount = barcount; } #endif void printtrack(trackno, anacrusis) /* print out one track as abc */ int trackno, anacrusis; { struct listx* i; struct tlistx* textplace; struct tlistx* textplace0; /* track 0 text storage */ int step, gap; int barnotes; int barcount; int bars_on_line; long now; char broken; int featurecount; int last_barsize,barnotes_correction; midline = 0; featurecount = 0; inkaraoke = 0; now = 0L; broken = ' '; chordhead = NULL; chordtail = NULL; i = track[trackno].head; textplace = track[trackno].texthead; textplace0 = track[0].texthead; gap = track[trackno].startunits; if (anacrusis > 0) { barnotes = anacrusis; barcount = -1; } else { barnotes = barsize; barcount = 0; }; bars_on_line = 0; last_barsize = barsize; active_asig = header_asig; active_bsig = header_bsig; setup_timesig(header_asig,header_bsig,header_bb); active_keysig = header_keysig; handletext(now, &textplace, trackno); while((i != NULL)||(gap != 0)) { if (gap == 0) { /* do triplet here */ if (featurecount == 0) { if (allow_triplets || allow_broken) { /* [SS] 2017-01-01 */ broken = dospecial(i, &barnotes, &featurecount,allow_broken,allow_triplets); }; }; /* add notes to chord */ addtochord(i->note); gap = i->note->xnum; now = i->note->time; i = i->next; advancechord(0); /* get rid of any zero length notes */ if (trackcount > 1 && trackno !=0) handletext(now, &textplace0, trackno); handletext(now, &textplace,trackno); barnotes_correction = barsize - last_barsize; barnotes += barnotes_correction; last_barsize = barsize; } else { step = findshortest(gap); if (step > barnotes) { step = barnotes; }; step = validnote(step); if (step == 0) { fatal_error("Advancing by 0 in printtrack!"); }; if (featurecount == 3) { fprintf(outhandle," (3"); }; printchord(step); if ( featurecount > 0) { featurecount = featurecount - 1; }; if ((featurecount == 1) && (broken != ' ')) { fprintf(outhandle,"%c", broken); }; advancechord(step); gap = gap - step; barnotes = barnotes - step; if (barnotes == 0) { fprintf(outhandle,"|"); barnotes = barsize; barcount = barcount + 1; bars_on_line++; if (barcount >0 && barcount%bars_per_staff == 0) { freshline(); bars_on_line=0; } /* can't zero barcount because I use it for computing maxbarcount */ else if(bars_on_line >= bars_per_line && i != NULL) { fprintf(outhandle," \\"); freshline(); bars_on_line=0;} } else if (featurecount == 0) { /* note grouping algorithm */ /* [SS] 2016-07-20 waltz is a special case */ if ((barsize/parts_per_unitlen) % 3 == 0 && asig != 3) { if ( (barnotes/parts_per_unitlen) % 3 == 0 &&(barnotes%parts_per_unitlen) == 0) { fprintf(outhandle," "); }; } else { if (((barsize/parts_per_unitlen) % 2 == 0) && (barnotes % parts_per_unitlen) == 0 && ((barnotes/parts_per_unitlen) % 2 == 0)) { fprintf(outhandle," "); }; }; } if (nogr) fprintf(outhandle," "); }; }; /* print out all extra text */ while (textplace != NULL) { handletext(textplace->when, &textplace, trackno); }; freshline(); if (barcount > maxbarcount) maxbarcount = barcount; } void remove_carriage_returns(char *str) { /* a carriage return might be embedded in a midi text meta-event. do not output this in the abc file or this would make a nonsyntactic abc file. */ char * loc; while (loc = (char *) strchr(str,'\r')) *loc = ' '; while (loc = (char *) strchr(str,'\n')) *loc = ' '; } void printQ() /* print out tempo for abc */ { float Tnote, freq; Tnote = mf_ticks2sec((long)((xunit*unitlen)/4), division, tempo); freq = (float) 60.0/Tnote; fprintf(outhandle,"Q:1/4=%d\n", (int) (freq+0.5)); if (summary>0) printf("Tempo: %d quarter notes per minute\n", (int) (freq + 0.5)); } void setupkey(sharps) int sharps; /* set up variables related to key signature */ { char sharp[13], flat[13], shsymbol[13], flsymbol[13]; int j, t, issharp; int minkey; for (j=0; j<12; j++) key[j] = 0; minkey = (sharps+12)%12; if (minkey%2 != 0) { minkey = (minkey+6)%12; }; strcpy(sharp, "ccddeffggaab"); strcpy(shsymbol, "=^=^==^=^=^="); if (sharps == 6) { sharp[6] = 'e'; shsymbol[6] = '^'; }; strcpy(flat, "cddeefggaabb"); strcpy(flsymbol, "=_=_==_=_=_="); /* Print out key */ if (sharps >= 0) { if (sharps == 6) { fprintf(outhandle,"K:F#"); } else { fprintf(outhandle,"K:%c", sharp[minkey] + 'A' - 'a'); }; issharp = 1; } else { if (sharps == -1) { fprintf(outhandle,"K:%c", flat[minkey] + 'A' - 'a'); } else { fprintf(outhandle,"K:%cb", flat[minkey] + 'A' - 'a'); }; issharp = 0; }; if (sharps >= 0) { fprintf(outhandle," %% %d sharps\n", sharps); } else { fprintf(outhandle," %% %d flats\n", -sharps); }; key[(minkey+1)%12] = 1; key[(minkey+3)%12] = 1; key[(minkey+6)%12] = 1; key[(minkey+8)%12] = 1; key[(minkey+10)%12] = 1; for (j=0; j<256; j++) { t = j%12; if (issharp) { atog[j] = sharp[t]; symbol[j] = shsymbol[t]; } else { atog[j] = flat[t]; symbol[j] = flsymbol[t]; }; trans[j] = 7*(j/12)+((int) atog[j] - 'a'); if (j < MIDDLE) { atog[j] = (char) (int) atog[j] + 'A' - 'a'; }; if (key[t] == 0) { back[trans[j]] = j; }; }; } /* Functions for supporting the command line user interface to midi2abc. */ int readnum(num) /* read a number from a string */ /* used for processing command line */ char *num; { int t; char *p; int neg; t = 0; neg = 1; p = num; if (*p == '-') { p = p + 1; neg = -1; }; while (((int)*p >= '0') && ((int)*p <= '9')) { t = t * 10 + (int) *p - '0'; p = p + 1; }; return neg*t; } int readnump(p) /* read a number from a string (subtly different) */ /* used for processing command line */ char **p; { int t; t = 0; while (((int)**p >= '0') && ((int)**p <= '9')) { t = t * 10 + (int) **p - '0'; *p = *p + 1; }; return t; } void readsig(a, b, sig) /* read time signature */ /* used for processing command line */ int *a, *b; char *sig; { char *p; int t; p = sig; if ((int)*p == 'C') { *a = 4; *b = 4; return; }; *a = readnump(&p); if ((int)*p != '/') { char msg[80]; sprintf(msg, "Expecting / in time signature found %c!", *p); fatal_error(msg); }; p = p + 1; *b = readnump(&p); if ((*a == 0) || (*b == 0)) { char msg[80]; sprintf(msg, "%d/%d is not a valid time signature!", *a, *b); fatal_error(msg); }; t = *b; while (t > 1) { if (t%2 != 0) { fatal_error("Bad key signature, divisor must be a power of 2!"); } else { t = t/2; }; }; } int is_power_of_two(int numb) /* checks whether numb is a power of 2 less than 256 */ { int i,k; k = 1; for (i= 0;i<8;i++) { if(numb == k) return(1); k *= 2; } return(0); } int getarg(option, argc, argv) /* extract arguments from command line */ char *option; char *argv[]; int argc; { int j, place; place = -1; for (j=0; j= argc+1) { /* [SS] 2015-02-22 */ Qval = readnum(argv[arg]); } else { Qval = 0; }; arg = getarg("-u", argc,argv); if (arg != -1) { xunit = readnum(argv[arg]); xunit_set = 1; } else { xunit = 0; xunit_set = 0; }; arg = getarg("-ppu",argc,argv); if (arg != -1) { val = readnum(argv[arg]); if (is_power_of_two(val)) parts_per_unitlen = val; else { printf("*error* -ppu parameter must be a power of 2\n"); parts_per_unitlen = 2; } } else parts_per_unitlen = 2; arg = getarg("-aul",argc,argv); if (arg != -1) { val = readnum(argv[arg]); if (is_power_of_two(val)) { unitlen = val; unitlen_set = 1;} else printf("*error* -aul parameter must be a power of 2\n"); } arg = getarg("-bps",argc,argv); if (arg != -1) bars_per_staff = readnum(argv[arg]); else { bars_per_staff=4; }; arg = getarg("-bpl",argc,argv); if (arg != -1) bars_per_line = readnum(argv[arg]); else { bars_per_line=1; }; extracta = (getarg("-xa", argc, argv) != -1); guessa = (getarg("-ga", argc, argv) != -1); guessu = (getarg("-gu", argc, argv) != -1); guessk = (getarg("-gk", argc, argv) != -1); keep_short = (getarg("-s", argc, argv) != -1); summary = getarg("-sum",argc,argv); swallow_rests = getarg("-sr",argc,argv); if (swallow_rests != -1) { restsize = readnum(argv[swallow_rests]); if(restsize <1) restsize=1; } obpl = getarg("-obpl",argc,argv); if (obpl>= 0) bars_per_line=1; if (!unitlen_set) { if ((asig*4)/bsig >= 3) { unitlen =8; } else { unitlen = 16; }; } arg = getarg("-b", argc, argv); if ((arg != -1) && (arg < argc)) { bars = readnum(argv[arg]); } else { bars = 0; }; arg = getarg("-c", argc, argv); if ((arg != -1) && (arg < argc)) { xchannel = readnum(argv[arg]) - 1; } else { xchannel = -1; }; arg = getarg("-k", argc, argv); if ((arg != -1) && (arg < argc)) { keysig = readnum(argv[arg]); if (keysig<-6) keysig = 12 - ((-keysig)%12); if (keysig>6) keysig = keysig%12; if (keysig>6) keysig = keysig - 12; ksig_set = 1; } else { keysig = -50; ksig_set = 0; }; if(guessk) ksig_set=1; arg = getarg("-o",argc,argv); if ((arg != -1) && (arg < argc)) { outhandle = efopen(argv[arg],"w"); /* open output abc file */ } else { outhandle = stdout; }; arg = getarg("-nt", argc, argv); if (arg == -1) { /* 2017-01-01 */ allow_triplets = 1; } else { allow_triplets = 0; }; arg = getarg("-nb", argc, argv); if (arg == -1) { /* 2017-01-01 */ allow_broken = 1; } else { allow_broken = 0; }; arg = getarg("-nogr",argc,argv); if (arg != -1) nogr=1; else nogr = 0; arg = getarg("-title",argc,argv); if (arg != -1) { title = addstring(argv[arg]); } arg = getarg("-origin",argc,argv); if (arg != -1) { origin = addstring(argv[arg]); } arg = getarg("-f", argc, argv); if (arg == -1) { arg = huntfilename(argc, argv); }; if ((arg != -1) && (arg < argc)) { F = efopen(argv[arg],"rb"); /* fprintf(outhandle,"%% input file %s\n", argv[arg]); */ } else { printf("midi2abc version %s\n usage :\n",VERSION); printf("midi2abc filename \n"); printf(" -a \n"); printf(" -xa Extract anacrusis from file "); printf("(find first strong note)\n"); printf(" -ga Guess anacrusis (minimize ties across bars)\n"); printf(" -gk Guess key signature \n"); printf(" -gu Guess xunit from note duration statistics\n"); printf(" -m 

X:1
T:\%\%MIDI temperamentlinear - microtone accidentals in cents
%%postscript /ft5475{M -3 3 RM 6 -6 RL 2 SLW stroke}def
%%postscript /ft35939{2 copy ft0 M -7.5 -3 RM 12 F3 (7) show}def
M:none
K:C
%%scale 1.3
V:1
%%MIDI program 17
%%MIDI temperamentlinear 1200 702 %% Pythagorian tunings
%%MIDI makechordchannels 3
"^Pure;major;chord"\
[C_22/100EG]8 y |\
"^Pythagorian;major;chord"\
[CEG]8 y ||\
"^Pure;4:5:6:7;chord"\
[C_22/100EG_141/100B]8 y |\
"^Pythagorean;7-chord"\
[CEG_B]8 y ||

A new command %%temperamentequal was introduced.
%%MIDI temperamentequal [octave_cents] [fifth_steps] [sharp_steps] This command sets a tempered scale defined by 'ndiv' equal divisions of 'octave_cents' (default is the octave = 1200 cents). The optional parameter 'fifth_steps', if provided, is an integer that defines the size of the fifth in steps of the temperament. This sets where is the note G in the temperament. When 'fifth_steps' is omitted or 0 (zero), the program computes it as an approximation of the frequency ratio 3/1, minus the (possibly tempered) octave. The optional 'sharp_steps' defines the meaning of the accidentals. 'sharp_steps' is the number of steps between a natural note and a sharpened note (e.g. between =C and ^C). By default, the size of a sharp/flat deviation is based on the size of the chromatic semitone in the specified temperament: 7 fifths minus 4 octaves. The values in use in the temperament can be viewed by running abc2midi with the command-line option -v (verbose). With temperamentequal (as with temperamentlinear), microtone accidentals are interpreted as fractions of the sharp size in the specified temperament, except if they use denominator=100, which defines microtonal deviations in cents. The conventional temperament can be reset with the command temperamentnormal. See also: temperamentlinear, temperamentnormal, makechordchannels Implementation: Changes in store.c are marked with [HL] 2015-05-15 New global variable 'sharp_size' It is the the size, in pitchbend units, of the chromatic step between (e.g.) =C and ^C. (This is computed from octave and fifth sizes when using temperamentlinear or temperamentequal.) event_specific() Function changed to modify the command temperamentlinear and to add the command temperamentequal. temperamentlinear: Compute 'sharp_size'; Print information when -v (verbose option); Fix the command name in the error message. temperamentequal (new command): Compute octave_size, fifth_size, sharp_size; Temperament information when -v (Verbose option). pitchof_b() Function changed to handle microtones in user-defined temperaments. Global variable 'sharp_size' is used for that. event_microtone() Rounding instead truncation as slight improvement of precision. (MIDI bend is rough for tuning.) May 21 2015 Abc2midi drone bug: The %%MIDI drone command is ineffective. In the following example, X: 1 T:Banks and Braes M:6/8 L:1/8 S:Slow March K:HP %%MIDI program 109 %%MIDI gracedivider 4 %%MIDI drone 67 44 45 90 90 %%MIDI droneon {Gdc}d2{g}d{g}ede|\ {g}faf{gef}e2{g}d/2e/2| the %%MIDI drone 67 44 45 90 90 does not change the drone characteristics. Analysis: The drone is put in a separate MIDI track. The %%MIDI drone command is processed in the first track, and updates the elements of the drone structure. When the drone track is written starttrack() in genmidi.c, initializes the drone structure destroying any information that was recorded. Fix: initialization of the drone structure is done during compilation time. Note, if the tune has more than one %%MIDI drone command, only the last one is effective. June 01 2015 Abc2midi new feature: introducing new commands %%MIDIdef and %%MIDIx. %%MIDIdef code line links code a unique string less than 7 letters to a line of strings that normally occurs in a MIDI command. For example %%MIDIdef bnd1 bendstring 400 400 300 100 -100 300 400 400 400 link the string bnd1 to " bendstring 400 400 300 100 -100 300 400 400 400" Now you can call up the MIDI command %%MIDI bendstring 400 400 300 100 -100 300 400 400 400 using a shorthand %%MIDIx bnd1. Example: X:1 %%MIDIdef type1 bendstring 0 0 600 600 600 600 0 -600 -600 -600 -600 -600 -120 0 %%MIDIdef type2 bendstring 0 0 0 0 0 0 400 800 800 -800 -800 -400 -400 -400 %%MIDIdef inst program 67 %%MIDIdef t3 bendstring 0 0 0 0 0 500 500 600 600 -600 -600 -500 -500 T: MIDI M:2/4 L:1/2 K: D %%MIDIx inst %%MIDIx type1 !bend!A|B|\ %%MIDIx type2 !bend!C|D| This is useful when you have several different bendstrings and you wish to call them up in different places in the tune using a code. There is a limit of 20 distinct MIDIdef's in your tune. Implementation: in parseabc.c added a new function readaln which is like readstr but scans for the next word (that may contain numerics) in the input string. (The words are separated by spaces or tabs.) In store.c, added two new functions parse_mididefs(s) and expand_midix(s) for handling the %%MIDIdef and %%MIDIx commands. These functions are called in the function event_specific(). June 02 2015 continuation: added strcmp(key, "MIDIx") in event_info_key() in store.c June 07 2015 Abc2midi bug: the !bend! command does not work inside a slur. In the following example, X:1 T: slur and bend M: 2/4 L: 1/8 K: F %%MIDI bendstring 500 500 500 0 -500 -500 -500 %%MIDI program 73 !bend! D4|(!bend! F4| D4| a bend is not applied on F4. Analysis: writetrack() in genmidi.c tests whether a note is inside a slur. If it is inside a slur, both note triming and note bending were suppressed. Fix, writetrack() was modified to allow note bending inside a slur. The MIDIdef, MIDIx code word was allowed to contain up to 31 characters. All characters except white spaces are allowed inside the code word. June 08 2015 Abc2midi bug: !bend! causes tracklenth to be too small. Fix: in timestep() in queues.c, update tracklen before note_effect is called instead as after. June 16 2015 Abc2midi new feature: introducing %%MIDI expand m/n. This acts like %%MIDI trim m/n except it expands the note by this amount. Implementation: added feature EXPAND to featuretype in abc.h. In event_specific() in store.c, test for %%MIDI command 'expand' and addfeature(EXPAND,...) if found. In genmidi.c introduce new globals (expand, expand_num, and expand_denom) which are set in writetrack when feature EXPAND is detected. If the flag expand is set, then the active note is expanded. Here is a test tune. X:1 T: note expansion M: 4/4 L: 1/2 K: G %%MIDI program 52 CD|GA| %%MIDI expand 1/2 de|fe|BA| June 16 2015 Abc2midi new feature: added track identification annotation to midi file so we know whether it is a gchord, note, lyric, drum, etc track. June 30 2015 Abc2midi split voice bug: change of unit length defined by L: does not propagate to the voice overlay. eg. X:1 T: split voice bug - unit length M: 4/4 L:1/8 K: G C8 & E8|\ L:1/4 cdAB & GAEF|G4 & D4:| causes loss of synchronization starting from the second measure. Analysis: the L:1/4 does not change the unit length in the split voice and the notes GAEF and D4 are too short. Fix: in event_split_voice() in store.c set the unit length to the same length as the parent voice. July 02 2015 Abc2abc bug: the fix introduced in May 13 2015 introduced another problem. In the example X:1 T: Octave M: 2/4 L: 1/8 K: G V:1 clef=treble+8 CDEF|ABcd| Applying abc2abc returns X:1 T:Octave M:2/4 L:1/8 K:G V:1 clef=treble+8 octave=1 CDEF|ABcd| Unfortunately the added parameter octave=1 causes abcm2ps to also display the notes one octave higher. Analysis: the parameter octave=1 is useful to abc2midi as it tells the program to shift the notes up one octave when it creates the midi file; however, this is not desired when running abcm2ps. Abcm2ps uses clef=treble+8 to place an 8 above the treble clef and that is sufficient. The problems occurs in the function isclef() in parseabc.c. The function changes gotoctave to 1 when it sees treble+8. The fix on May 13 2015 forces event_voice to issue an octave=1 when it sees cgotoctave = 1. Fix: in isclef() a conditional block {} was created for all if (fileprogram == ABC2MIDI && *gotoctave != 1 && *octave != 1) statements, and *gotoctave = 1 was moved inside this block. July 08 2015 abc2midi feature: added sus4 to the list of chord names recognized. Added hint to message 'Unrecognized chord name ...". July 15 2015 abc2midi bug: abc2midi crashes (segmentation error) on %%MIDIx. In the following example: X:1 T: segmentation error M: 2/4 L: 1/8 K: G %%MIDIx crash ABCD| abc2midi fails. Analysis: abc2midi fails to detect that there is no corresponding %%MIDIdef for the code word 'crash'. Fix: the function expand_midix() now checks for this case. July 24-28 2015 abc2midi: new feature !shape! and %%MIDI controlstring. Introduced a new midi command %%MIDI controlstring n m1 m2 m3 ... where n, m1, m2, and etc are numbers between 0 and 127. %%MIDI controlstring n m1 is equivalent to the %%MIDI control command. When more than one data value m1 and etc. follow, then this defines how to shape the note following the !shape! instruction. The following example illustrates shaping the note F4 by varying the mod wheel. X:1 T: control string M: 4/4 L: 1/4 K: G %%MIDI controlstring 1 125 80 40 0 %%MIDI program 60 !shape! F4| D4|F2G2| The midi file produced will look like Header format=0 ntrks=1 division=480 Track 1 contains 115 bytes 0.00 Metatext (Text Event) note track 0.00 Metatext tempo = 120.00 bpm 0.00 Metatext key signature G (1/0) 0.00 Metatext time signature=4/4 0.00 Metatext (Seqnce/Track Name) control string 0.00 Program 1 60 (French Horn) 0.00 Note on 1 f#4 105 1.00 CntlParm 1 Modulation Wheel = 125 2.00 CntlParm 1 Modulation Wheel = 80 3.00 CntlParm 1 Modulation Wheel = 40 3.99 CntlParm 1 Modulation Wheel = 0 4.00 Note off 1 f#4 0 4.00 Note on 1 d4 105 8.00 Note off 1 d4 0 8.00 Note on 1 f#4 105 10.00 Note off 1 f#4 0 10.00 Note on 1 g4 95 12.00 Note off 1 g4 0 12.05 Meta event, end of track The whole note F# is modified in 4 equal segments. Note the !shape! does not work in combination with the !bend! command presently. Implementation: created the new function note_effect4() in queues.c The maximum number of codenames for %%MIDIdef has been increased to 200. The codename can now be as long as 31 letters. July 27 2015 - August 3 2015 abc2midi: extension of !shape! for combining %%MIDI controlstring and %%MIDI bendstring. Implementation: added a new struct eventstruct and a struct array eventlist[200]. Created new procedures note_effect5(), output_eventlist(), and compare_events(). August 4 2015 abc2midi: channel bug. The following tune plays incorrectly. X: 1 T: channel problem M: 6/8 L: 1/8 K: G %%MIDI channel 1 %%MIDI bassprog 68 %%MIDI chordprog 20 D | "G"G3 GAB | "D"ABA ABd | The melody should be played on the Acoustic Piano; instead it is played on the oboe (MIDI program 68). Analysis: The %%MIDI channel setting is redundant and causes the problem. Both the melody and the bass accompaniment use the same channel. The command %%MIDI bassprog 68 causes the melody to be played by program 68 (the oboe). The bug was introduced in March 16 2015. The variable channel_in_use[channel] was not set to 1 correctly in starttrack() in genmidi.c. August 06 2015 Fixed compile issue on Mac OS 10.10.4 in genmidi.c August 10 2015 - August 11 2015 abc2midi new feature: %%MIDI controlstring restores the controller back to its default after the shaped note is played. The default can be changed with a regular %%MIDI control command. Implementation: added a new array controldefaults[] in genmidi.c which is linked to queue.c. Updated abcguide.txt. August 18 2015 abc2midi: Support for the directive %%propagate-accidentals not | octave | pitch was extended to include the three choices described in http://abcnotation.com/wiki/abc:standard:v2.1#accidental_directives Furthermore, the default was changed to 'pitch' in compliance with the standard. Implementation: All the changes were limited to the source code store.c. The flag retain_accidentals was eliminated and the switch nopropagate_accidentals was changed to propagate_accidentals in store.c. In event_specific(), the switch propagate_accidentals is set on the basis of the directive %%propagate-accidentals, to 0, 1, or 2. In pitchof_b(), the code for propagating accidentals (including microtones) was reworked. Here is a simple test file. X:1 T:accidental M:2/4 L:1/8 K:C %%propagate-accidentals pitch ^C2c2| %%propagate-accidentals not ^C2c2|\ %%propagate-accidentals octave ^C2c2|\ %%propagate-accidentals no The c2 note is affected by only the pitch directive (default). The last %%propagate_accidentals returns an error message. August 19 2015 Abc2midi: complex time signature extension. Abc2midi now interprets M: 2+3+2/8 as M:7/8. Implementation: a small loop was added in the function readsig() in parseabc.c August 20 2015 Abc2midi new feature: introducing %%MIDI controlcombo. This allows combining two controlstrings into 1. Here is an example: X:1 T: control string combo M: 4/4 L: 1/4 K: F Q: 1/4 = 60 %%MIDI program 123 # bird tweets %expression %%MIDI controlstring 11 110 90 60 40 60 60 90 110 %%MIDI controlcombo %panning %%MIDI controlstring 10 0 0 20 40 60 80 100 120 127 127 !shape! c4 | controlstring 11 varies the expression and controlstring pans the output from the left to right speaker. The %%MIDI controlcombo command tells abc2midi that the panning controlstring should be included with the expression controlstring. Implementation: in genmidi.c, the controldata array has been converted into a two dimensional array and controlvals has been converted from a scalar to a single dimensional array. A flag controlcombo indicates whether to replace or combine the new control string. Each one dimensional component of controldata stores one of the control strings into a 'layer'. In queues.c, the function note_effect4 scans all layers for data and appends it to the eventlist[]. August 20 2015 Abc2midi new feature: If two controlstring are referenced in the %%MIDIx they will combined in the manner described above. Here is a sample file. X:1 T: control string combo M: 4/4 L: 1/4 K: F Q: 1/4 = 60 %%MIDI program 123 # bird tweets %expression %%MIDIdef expr controlstring 11 110 90 60 40 60 60 90 110 %%MIDIdef pan controlstring 10 0 0 20 40 60 80 100 120 127 127 %%MIDIx expr pan !shape! c4 |C4| Implementation: expand_midix was renamed to process_midix and the code was reworked so that it would loop through all the code words and call event_midi() to process all the %%MIDI commands that were generated. August 24 2015 abc2midi bug: the following tune was not processed correctly. X:1 T: control string bug M: 4/4 L: 1/4 K: F Q: 1/4 = 60 %%MIDI program 2 %%MIDI controlstring 11 110 !shape! c4 | %%MIDI controlstring 11 60 !shape!E4|D4| All three notes c4,E4 and D4 are played at the same time. Analysis: in note_effect5() the conditional if (j > 1) should only apply to the qsort function. August 25 2015 abc2midi bugs: the following tune was not processed correctly. X:1 T: controlstring and bendstring problems M: 4/4 L: 1/4 K: F Q: 1/4 = 120 %%MIDI program 60 # French Horn %%MIDIdef expr110 controlstring 11 110 %%MIDIdef expr60 controlstring 11 60 %%MIDI bendstring 0 2000 2000 %%MIDIx expr60 !shape! c2 c2 | The resulting midi file had two problems. The first c2 was extended in length and the pitch of the second c2 was effected by the !shape! command. Fixes: the pitchwheel was restored to its initial value at the end of the altered note. When restoring the controller to the initial state we checked whether a bend string was also processed. August 28 2015 abc2midi bug: The following file produces an artefact at the end of note. X:1 %%MIDIdef voloff100 controlstring 11 100 90 80 70 60 50 40 30 %%MIDIdef no-bend bendstring T:? C: ? M: 4/4 L: 1/4 Q:1/4=130 K: none %%propagate-accidentals not %%MIDI beat 100 95 80 1 %%MIDIdef petasth bendstring 0 0 900 900 0 -900 -900 0 -400 V:1 %%MIDI program 60 % french horn [M:3/4][I: MIDIx= petasth]!shape!A[I: MIDIx=no-bend voloff100]!shape!E2 Analysis note_effect5 restores the controller defaults before the note ends causing a transient at the end of the note. Fix: the restoration is done after the note. August 30 2015 abc2midi bug: in the following tune, X:1 %%MIDIdef voloff100 controlstring 11 100 90 80 70 60 50 40 30 %%MIDIdef no-bend bendstring T: controlstring state not initialized at start of track M: 4/4 L: 1/4 K: C %%MIDIdef petasth bendstring 0 0 900 900 0 -900 -900 0 -400 V:1 %%MIDI program 60 % french horn [I: MIDIx= petasth]!shape!A2[I: MIDIx=no-bend voloff100]!shape!E2 the voloff100 is applied to A2 despite the fact the command occurs after A2 Analysis: abc2midi creates a two track file. While it is creating the header track, controlnvals[0] was set to a nonzero value after MIDIx=no_bend voloff100 was processed and controldata[] contained appropriate data to perform the voloff100. Unfortunately, when the next track written controlnvals[0] was not reset. Fix: reset controlnvals[] August 31 2015 abc2midi bug: in the following file X: 1 %%MIDIdef slur2 bendstring 0 0 0 0 0 1000 T: last bendstring not picked up M: 4/4 L: 1/4 K: G Q: 1/4=80 %%MIDI program 42 % french horn V:1 G[I: MIDIx= slur2]!bend!A the bendstring value 1000 is not picked up Fix: in do deferred() (genmidi.c) the statement if (p* == 0) break; was moved after i = i +1; September 07 2015 Abc2midi new feature: in genmidi.c, the %%MIDI bendstring command can now accept up to 100 increments to accommodate long notes (benddata[100]); and the %%MIDI controlstring command can now accept up to 100 values to accommodate long notes (controldata[3][100]). In queues.c eventlist array was extended to 500 to handle the additional complexity. September 08 2015 Abc2midi: new commands %%MIDI vol n and %%MIDI volinc m introduced where n is a number between 0 and 127 and m is a positive or negative integer. The purpose of these commands is to provide to set the velocity of the note immediately following. All remaining notes are unaffected. The commands override the effects of %%MIDI beat, %%MIDI beatstring, %%MIDI beataccents, %%MIDI beatmod, %%MIDI nobeataccents, %%MIDI stressmodel, !ppp!, !pp!, !p!, !mp!, !mf!, !f!, !ff!, !fff!, !crescendo) for the particular note that is affected. %%MIDI vol n sets the velocity of the next note to n. %%MIDI volinc m increments (or decrements) the velocity of the next note by m, automatically ensuring that the velocity is in the range 0 to 127. For example: X: 1 T: Velocity alteration M: 4/4 L: 1/4 K: F CDEF|C\ %%MIDI volinc -30 D E [I: MIDI = vol 100] F| CDEF| By default the velocities of the notes CDEF are 105, 80, 95 and 80. (You can use the %%MIDI beat command to change these values.) The %%MIDI volinc -30, decrements the default velocity of D by 30 so its velocity is 50 instead of 80. The MIDI vol 100 command embedded in the info field, sets the velocity of F to 100. The velocities of the remaining notes in the last bar retain their defaults 105,80,95 and 80. Implementation: Introduced two global integer variables single_velocity_inc and single_velocity which are set to the default values 0 and -1 in the writetrack() in genmidi.c. These default values indicate that no alterations are to be made to the following note. Introduced new functions apply_velocity_increment_for_one_note() and set_velocity_for_one_note() which is called by noteon() in genmidi.c. The function dodeferred() in genmidi.c acts on the new %%MIDI commands and changes the default values of single_velocity_inc and single_velocity. September 08 2015 Abc2midi new feature: a different syntax can be used for changing the velocity of a single note as illustrated below. X: 1 T: Velocity alteration -different syntax M: 4/4 L: 1/4 K: F CDEF|C\ I: volinc = -30 D E [I: vol = 100] F| CDEF| The behaviour is identical to the above example. Implementation: the function event_info_key() in store.c was updated to recognize the key words vol or volinc, generate the respective %%MIDI commands, and send these commands to event_specific() for processing. September 08 2015 Abc2midi: new feature. The I: info command required to have an '=' sign following the key word, so that it could handle a group of commands such as I: MIDI = program 20 MIDI = drum d2dd 76 75 75 The purpose of the '=' sign was to allow the parser to distinguish the key word(s) (here MIDI) from the value when more than one key words appear. When only one command is embedded it should be unnecessary to include the '=' sign. The following sample illustrates the more lenient syntax that is now permitted. X:1 T: Generalized info syntax M: 2/4 L: 1/8 K: F I:vol= 60 % equal sign is optional if only key word is included % in I: field. C2 E2 | [I:vol 20] D2 F2| E2 [I:volinc = 50] C2|D2 [I:volinc -50]C2| C2 E2 |\ %%MIDI vol 20 D2 F2|E2 \ % equal sign is required if more than one key word is present I: MIDI= drum d2dd 75 76 76 MIDI = program 20 %%MIDI volinc 50 C2| C2 E2| [I:MIDI= vol 20] D2 F2| Implementation: the function event_info() in parser2.abc was updated. October 04 2015 The #ifdef _MSC_VER block was changed from #define snprintf _snprintf_s to #define sprintf _snprintf in both parseabc.c and store.c (The function _snprintf_s expects additional parameters and prevents compilation on some systems.) October 04 2015 Some problems with Makefile.in were fixed. In addition an uninstall option was introduced. October 03 2015 Abc2midi: increased the size of benddata[100] to benddata[256], controldata[MAXLAYERS][100] to controldata[MAXLAYERS][256], %%MIDI bendstring will read up to 256 values in dodeferred (genmidi.c). %%MIDI controlstring will read up to 256 values in doferred (genmidi.c) eventlist struct was increased to eventlist[1000]. October 08 2015 Edited abcmatch.c genmidi.c midi2abc.c parseabc.c store.c toabc.c in order to eliminate warnings from Microsoft Visual Studio 2010. makefiles/makefile.w32 was updated to make dynamically linked executables (instead of static). October 18 2015 Edited abcmatch.c, genmidi.c, matchsup.c, mftext.c, midi2abc.c, midicopy.c, midifile.c, parseabc.c, queues.c, store.c, stresspat.c and toabc.c to clean up all the implicit int warning messages reported by the Debian compiler. November 05 2015 abc2abc: keep 'M:C' and 'M:C|'; i.e. don't automatically change them to 'M:4/4' and 'M:2/2' % sample4.abc - this file is part of abcm2ps X:1 %%abc-version 2.0 T:testing 'common time' and 'split common time' signatures T: These should be preseved when transposing % use abc2abc generated from source including fixes from 'abcMIDI-2015.11.5_LM'. % try command: 'abc2abc common_time_sigs.abc -t 2'; % check that e.g. 'C' hasn't become '4/4'. M:C L:1/4 K:C CDEF |[M:4/4] GABc|] M:2/2 CDEF |[M:C|] GABc|] November 15 2015 Addressed the following Debian compiler warning messages reported in https://qa.debian.org/bls/packages/a/abcmidi.html I pointer-cast-size-mismatch midicopy.c:371 (alpha, arm64, kfreebsd-amd64, mips64el, ppc64, ppc64el, s390x, sparc64) I pointer-cast-size-mismatch yapstree.c:1338 (alpha, arm64, kfreebsd-amd64, mips64el, ppc64, ppc64el, s390x, sparc64) I pointer-cast-size-mismatch yapstree.c:1352 (alpha, arm64, kfreebsd-amd64, mips64el, ppc64, ppc64el, s390x, sparc64) I pointer-cast-size-mismatch yapstree.c:1513 (alpha, arm64, kfreebsd-amd64, mips64el, ppc64, ppc64el, s390x, sparc64) I pointer-cast-size-mismatch yapstree.c:2176 (alpha, arm64, kfreebsd-amd64, mips64el, ppc64, ppc64el, s390x, sparc64) W implicit-declaration abcmatch.c:1274 (alpha, arm64, armel, armhf, hppa, hurd-i386, i386, kfreebsd-amd64, kfreebsd-i386, mips, mips64el, mipsel, powerpc, ppc64, ppc64el, s390x, sh4, sparc64, x32) In yapstree.c changed (void*) to (int *) to the calls to addfeature. In midicopy.c changed the call arguments of metaseqnum from (int seq) to (char c1, char c2). In abcmatch.c added #include December 19 2015 Abc2midi: bug fix - calculation of equal temperament scale was changed on October 08 2015. It has now been restored in store.c thanks to Hudson Lacerda. December 31 2015 Abc2midi bug: The following tune causes abc2midi to crash when running with -BF parameter. X:1 T: Missing R: field M: 2/4 L: 1/8 K: G %%MIDI stressmodel 2 CDEF|ABcd| abc2midi crash.abc -BF 2 3.84 December 19 2015 abc2midi Floating point exception Fix: startfile() in store.c initializes rhythmdesignator to an empty string. apply_bf_stressfactors() in store.c ensures that rhythmdesignator is set before allowing the function to continue. The function load_stress_parameters() in stresspat.c now has an error return and reports an unidentified rhythmdesignator to apply_bf_stressfactors(). January 02 2016 Abc2midi > and < action: In the past broken notes indicated by A>B and AB A G, h --> B, and i --> D %%MIDI gchord ghighi "G" G6|G6|\ % "G5" expands to G,D so g--> G, and h --> D but i --> does not map "G5" G6|G6| i does not map producing a gap in the Alberti Bass Fix: dogchords() in genmidi.c was modified to map to the last note in the gchord chord in this situation to prevent a gap. In the above example i would also map into D. February 08 2016 Abc2midi: changed dim9[5] to {0,3.6,9,13}, added sus2 and 7sus2 (in store.c). March 03 2016 Abc2abc: K: none sets all following occurrences of K: field to K: none even when they occur in separate tunes. Analysis: the global variable nokey gets set by K: none, but is never reset. This is fine if you are using the -nokeyf or -nokeys runtime parameter which applies to all tunes but not what you want if you are dealing with a tune containing a K: none command. Fix: introduced a new global nokeysig initialized to 0 into parseabc.c and toabc.c which responds to the abc2abc runtime parameters -nokeys and -nokeyf. In parsekey() in parseabc.c, the control variable nokey is initialized to nokeysig. March 15 2016 Fixed an assortment of spelling mistakes in the documentation in this file. (Also readme.txt, abcguide.txt, genmidi.c, toabc.c, abc2midi.1, crack.c, midi2abc.1, history.txt, coding.txt). Thank you Ross Gammon. May 05 2016 Abc2abc: transposition of key modifier bug. The following example illustrates a problem with the code to transpose the key modifiers. X: 25 T: C Natural, with a D sharp added to the key signature M: 2/4 L: 1/8 K: C ^d | cdef | gabc | Transposing this up by one tone (-t 2), this becomes X:25 T:C Natural, with a D sharp added to the key signature M:2/4 L:1/8 K:Dmaj =F | defg | abc'd | The key modifier was transposed to F natural instead of e sharp (chromatically identical notes) but as a result e was not upgraded to e# and the f# became f natural. The fix was a completely replacement of the code written in February 21 2011 (see above) in toabc.c. 130 lines of code was eliminated and a new function transpose_note() was introduced. The new function borrowed the transposition code from event_note, so that key modifiers were transposed the same way the notes in the music body are modified. July 20 2016 Midi2abc: note grouping for 3/4 time is incorrect. For 3/4 meter midi2abc groups the notes as EFG AGF instead of EF GA GF in a bar. Fix: in printtrack_with_splits(), printtrack_split_voice(), and printtrack(), also check for waltz time (asig == 3) before grouping notes as compound rhythm. September 20 2016 and September 25 2016 Abc2midi: only handles user defined symbols between 'H' and 'Z'. Fix: allow user defined symbols between 'A' and 'z'. Also applies to abc2abc and yaps. Parseabc.c was upgraded. January 01 2017 Midi2abc: There are times when you may wish to suppress broken rhythms but still allow triplets. For example, X:1 T:A Tune For Paddy: A Pint Of Guiness And One For The Goat M:6/8 K:Emin edB AGF | GEE E3 | edB AGF | GEE E3 | Applying abc2midi and midi2abc results in the second and forth bar appearing as GEE2D you need to use -nb. abcmidi/doc/gpl.txt0000644000000000000000000004312311620463362013242 0ustar rootroot GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) 19yy This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. 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. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) 19yy name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. abcmidi/doc/yapshelp.txt0000644000000000000000000002121711020033716014273 0ustar rootroot YAPS - an abc to PostScript Converter YAPS is Yet Another abc to PostScript converter. The original converter was Michael Methfessel's abc2ps program. Another converter is abcm2ps, based on the abc2ps code. YAPS uses the library of PostScript routines from abc2ps, but the parser and other C code does not come from abc2ps. What is PostScript ? -------------------- This program is intended for converting an abc tune to high quality printed output. If yaps created an image file in, say, GIF or PNG format it would have to decide how many pixels wide and how many pixels high the final image would be. When the image was printed on a printer capable of much higher resolution, you would be able to see that the image was built up of lower resolution pixels. PostScript gets round this limitation by storing the image as a description of all the objects that will appear on the page. These descriptions are converted to pixels at the last moment, when the resolution of the printer is known. This way, you can make full use of the resolution available. If you are lucky, you may have a PostScript printer, in which case you can send the output of yaps directly to the printer. If not, there are PostScript interpreter programs available, which will turn a PostScript image into other image formats. A popular freely available PostScript interpreter is called GhostScript. Another freely available program, GSView, provides a graphical interface to GhostScript and lets you view images on-screen. For a full description of the PostScript language, see "PostScript Language Reference (third edition)" by Adobe Systems Inc. ---------------------------------------------------------------- Executing yaps with no filename will give the yaps version and the following message: Usage: yaps [] possible options are - -d : debug - display data structure -e : draw tunes with reference numbers in list list is comma-separated and may contain ranges but no spaces e.g. 1,3,7-20 -E : generate Encapsulated PostScript -l : landscape mode -M XXXxYYY : set margin sizes in points 28.3 points = 1cm, 72 points = 1 inch -N : add page numbering -k [NN] : number every bar or every NN th bar -o : specify output file -P ss : paper size; 0 is A4, 1 is US Letter or XXXxYYY to set size in points -s XX : scaling factor (default is 0.7) -V : separate voices in multi-voice tune -x : print tune number in X: field Takes an abc music file and converts it to PostScript. If no output filename is given, then by default it is the input filename but with extension .ps . YAPS features ------------- 1. Uses the abc2midi parsing code, so hopefully compatibility with abc2midi will be good. 2. Measures the width of lyric text for lyric typesetting. 3. Uses dynamically extensible data structures in most places, so you should not be restricted by compiled-in limits. 4. Multiple voices drawn with notes played at the same time aligned. 5. Supports special characters using ISO latin 1 font. Special characters are created with a TeX-like code e.g. \'E or a 3 digit octal code e.g. \315 . 6. Supports the following clefs : baritone, tenor, alto, mezzo, soprano, treble, bass. Recommended use is I:clef=bass To make it easier to enter tunes in clefs othan than treble clef, yaps supports I:octave=-1 to indicate than a C in the tune represents the note one octave below the pitch defined in the abc standard. These may be combined in one I: statement e.g. I:clef=bass octave=-2 You can also use clefs that are one, two or three octaves higher or lower than normal using e.g. treble-8, treble+15, treble-22. The clef is drawn with a small 8, 15 or 22 above or below the clef symbol. The clef= and octave= commands may also go in the K: field e.g. K:G clef=bass-8 octave=-3 Note that there is an incompatibility between the behaviour of yaps and the behaviour of abc2ps 1.3.3. abc2ps 1.3.3 does not support the I:octave=N command, but selecting certain clefs causes it to automatically transpose by several octaves. You can produce abc that works for both by following the clef change with an I:octave=N command to do the transpose that abc2ps does automatically. 7. Produces boxed part labels. 8. Supports the segno symbol with !segno! and coda with !coda! . Other musical instructions such as !fine! and !D.C.! come out as text. 9. Supports the U: field for abbreviating symbols to single characters. e.g. U:S = !segno! allows S to be used to produce the segno symbol. Currently this only allows new symbols to be defined and does not allow the existing pre-defined symbols M,L,R,H and T to be altered. 10. Supports the following abc2ps extensions to abc : %%newpage - start a new page, %%vskip N - adds vertical space of N points. If N is followed by 'cm' or 'in' the units are taken as centimetres or inches instead of points e.g. 4cm. %%text - print text %%centre (or %%center for Americans) - print centred text. If %%text or %%centre appear in the header, the text appears above the tune. %%staffsep SIZE - set vertical blank space between 2 consecutive music staves. %%titleleft N - select title placed to the left or centred. N = 1 places the title on the left while N = 0 centres it. %%titlecaps - title is displayed in upper case (capital) letters. %%textfont NAME SIZE - select font called NAME and point size SIZE for text produced by %%text or %%centre. If only NAME is given, the font stays the same size. Likewise, if '-' is given as the NAME, only the font size changes. %%titlefont NAME SIZE - select font for title. %%subtitlefont NAME SIZE - select font for titles after the first title. %%composerfont NAME SIZE - select font for words in C: and O: fields and part specifier (P: in header). %%wordsfont NAME SIZE - select font for words in W: fields. %%partsfont NAME SIZE - select font for boxed parts and !instruction! . %%vocalfont NAME SIZE - select font for words in w: fields. %%gchordfont NAME SIZE - select font for guitar chords in the music. (It is advisable not to change the font name for the last two, since the program calculates the width of strings using default fonts) %%titlespace, %%subtitlespace, %%textspace, %%composerspace, %%wordsspace, %%partsspace, %%vocalspace and %%gchordspace determine the amount of space left above the relevant type of text. Each of these should be followed by a size in points or value in centrimetres or inches. e.g. %%composerfont 3 %%titlefont 2cm 11. Supports placing of accompaniment chords either above or below the stave. %%chordsabove - places accompaniment chords above the stave (default). %%chordsbelow - places accompaniment chords below the stave. 12. Supports optional text enclosed in quotes before and after the tempo specification in the Q: field. This extension comes from abc2ps. 13. Allows highlighting notes by switching output from black to red and vice-versa using the !red! and !black! instructions. Known bugs and Limitations -------------------------- 1. Overfull lines of music are not split over multiple lines. WARNING - the -s option is now used for scaling. Selecting separate printing of each voice (which previously used -s) is now done with -V. YAPS is still under development and missing a number of features. However, it should produce acceptable output most of the time. You may want to try abc2ps or abcm2ps if you find that YAPS will not do what you want. Viewing PostScript Files from DOS --------------------------------- Here is how I arranged things so that I can view PostScript from DOS : 1. Install Ghostscript 5.10 (compiled to run under DOS). This is not totally straightforward; you have to install the fonts separately and then set the environment variable GS_LIB to a path containing the GhostScript initialization files and the fonts. 2. Install Pictview, a free image viewer. 3. Create a small batch file ps.bat containing the following line: c:\gs5.10\gs386 -r120 -sOutputFile=out.tif -sDEVICE=tiffg3 -sPAPERSIZE=a4 -dNOPAUSE -dBATCH %1 When you run this, it creates a TIFF file out.tif containing all pages in compressed format. The following commands will show you the dots for an abc file: yaps demo.abc ps demo.ps pictview out.tif Copyright (c) James Allwright 1999 (parts of the code Copyright Michael Methfessel). This code may be freely re-distributed under the terms of the GNU public license. You are encouraged to modify and redistribute it, provided this copyright notice is retained. abcmidi/doc/yaps.10000644000000000000000000001452412564557522012772 0ustar rootroot.TH YAPS 1 "13 August 2005" .SH NAME .B YAPS \- converts an abc file to a PostScript file .SH SYNOPSIS yaps \fiabc\ file\fP [\-d] [\-e\ ] [\-E] [\-l] [\-M \fiXXXxYYY\fP] \ [\-N] [\-k nn] [\-o \fifile\ name\fP] [\-P \-\fiss\fP] [\-s \fiXX\fP] [\-V]\ [\-ver] [\-x] [\-OCC] .SH OPTIONS .TP .B -d For debugging only. Displays the internal data structures used in the program. .TP .B -e \fi\fP Draws tunes with reference numbers in a comma separated list. Spaces are not allowed but a range of reference numbers can be specified. For example, 1,3,7-10. .TP .B -E Generates Encapsulated Postscript output. .TP .B -M \fiXXXxYYY\fb Set margin sizes in points where 28.3 points = 1cm and 72 points = 1 inch. .TP .B -N Adds page numbering. .TP .B -k [nn] Adds bar numbering. If number nn is included, then every nn'th bar is numbered. Otherwise all bars are numbered. .TP .B -o \fifilename\fP Specifies the output postscript file name. .TP .B -P \fiss\fP Specifies the paper size where 0 is A4 and 1 is US Letter or XXXxYYY sets the paper size in point units. units. .TP .B -s \fiXX\fP Specifies the scaling factor (default is 0.7) .TP .B -V Voices are printed out separately for a multi-voice tune. Otherwise they are interleaved. .TP .B -ver Prints version number and exits. .TP .B -x Print tune number in X: field .TP .B -OCC Required if the tune uses the old convention for chords delineated with +..+ instead of [...]. .SH FEATURES .PP * Uses the abc2midi parsing code, so hopefully compatibility with abc2midi will be good. .PP * Measures the width of lyric text for lyric typesetting. .PP * Uses dynamically extensible data structures in most places, so you should not be restricted by compiled-in limits. .PP * Multiple voices drawn with notes played at the same time aligned. .PP * Supports special characters using ISO latin 1 font. Special characters are created with a TeX-like code e.g. \'E or a 3 digit octal code e.g. \315 . .PP * Supports the following clefs : baritone, tenor, alto, mezzo, soprano, treble, bass. Recommended use is .PP * Invisible rests (x) are displayed like normal rests. .PP * Nonnumeric voice id's, eg. V: soprano are accepted. .PP I:clef=bass .PP To make it easier to enter tunes in clefs othan than treble clef, yaps supports I:octave=-1 to indicate that a C in the tune represents the note one octave below the pitch defined in the abc standard. These may be combined in one I: statement e.g. .PP I:clef=bass octave=-2 .PP You can also use clefs that are one, two or three octaves higher or lower than normal using e.g. treble-8, treble+15, treble-22. The clef is drawn with a small 8, 15 or 22 above or below the clef symbol. The clef= and octave= commands may also go in the K: field e.g. .PP K:G clef=bass-8 octave=-3 .PP Note that there is an incompatibility between the behaviour of yaps and the behaviour of abc2ps 1.3.3. abc2ps 1.3.3 does not support the I:octave=N command, but selecting certain clefs causes it to automatically transpose by several octaves. You can produce abc that works for both by following the clef change with an I:octave=N command to do the transpose that abc2ps does automatically. .PP * Produces boxed part labels. .PP * Supports the segno symbol with !segno! and coda with !coda! . Other musical instructions such as !fine! and !D.C.! come out as text. * Supports the U: field for abbreviating symbols to single characters. e.g. .PP U:S = !segno! .PP allows S to be used to produce the segno symbol. Currently this only allows new symbols to be defined and does not allow the existing pre-defined symbols M,L,R,H and T to be altered. .PP * Supports the !red! and !black! instructions for switching from black to red or vice-versa. .PP * Supports the following abc2ps extensions to abc : .PP %%newpage - start a new page, .br %%vskip N - adds vertical space of N points. If N is followed by 'cm' or 'in' the units are taken as centimetres or inches instead of points e.g. 4cm. .br %%text - print text .br %%centre (or %%center for Americans) - print centred text. .br If %%text or %%centre appear in the header, the text appears above the tune. .PP %%staffsep SIZE - set the vertical blank space between 2 consecutive music staves. .PP %%titleleft N - select title placed to the left or centred. N = 1 places the title on the left while N = 0 centres it. .br %%titlecaps - title is displayed in upper case (capital) letters. .br %%textfont NAME SIZE - select font called NAME and point size SIZE for text produced by %%text or %%centre. If only NAME is given, the font stays the same size. Likewise, if '-' is given as the NAME, only the font size changes. .br %%titlefont NAME SIZE - select font for title. .br %%subtitlefont NAME SIZE - select font for titles after the first title. .br %%composerfont NAME SIZE - select font for words in C: and O: fields and part specifier (P: in header). .br %%wordsfont NAME SIZE - select font for words in W: fields. .br %%partsfont NAME SIZE - select font for boxed parts and !instruction! . .br %%vocalfont NAME SIZE - select font for words in w: fields. .br %%gchordfont NAME SIZE - select font for guitar chords in the music. (It is advisable not to change the font name for the last two, since the program calculates the width of strings using default fonts) .br %%titlespace, %%subtitlespace, %%textspace, %%composerspace, %%wordsspace, %%partsspace, %%vocalspace and %%gchordspace determine the amount of space left above the relevant type of text. Each of these should be followed by a size in points or value in centrimetres or inches. .br e.g. %%composerfont 3 %%titlefont 2cm .PP * Supports placing of accompaniment chords either above or below the stave. .PP %%chordsabove - places accompaniment chords above the stave (default). .br %%chordsbelow - places accompaniment chords below the stave. .PP * Supports optional text enclosed in quotes before and after the tempo specification in the Q: field. This extension comes from abc2ps. .SH AUTHOR James Allwright .SH SUPPORTED Seymour Shlien .PP More complete documentation can be found in abcguide.txt which comes with the abcMIDI distribution package. .SH VERSION This man page describes version 1.39 August 13 2005. abcmidi/doc/abc2midi.10000644000000000000000000004607712672021046013463 0ustar rootroot.TH ABC2MIDI 1 "27 August 2011" .SH NAME \fBabc2midi\fP \- converts abc file to MIDI file(s) .SH SYNOPSIS abc2midi \fIinfile\fP [\fIrefnum\fP] [\-c] [\-v] [\-ver] [\-t] [\-n limit] [\-CS] [\-quiet] [\-silent] [\-Q tempo] [\-NFNP] [\-NFER] [\-NGRA] [\-STFW] [\-OCC] [\-NCOM] [\-HARP] [\-BF] [\-TT] [\-o outfile] \-CSM [filename] .SH DESCRIPTION The default action is to write a MIDI file for each abc tune with the filename N.mid, where is the filestem of the abc file and N is the tune reference number. If the \-o option is used, only one file is written. This is the tune specified by the reference number or, if no reference number is given, the first tune in the file. .SH OPTIONS .TP .B \fIrefnum\fP process the tune with reference number \fIrefnum\fP .TP .B -c selects checking only .TP .B -v n selects verbose option where n is the level (optional) .TP .B -ver prints version number and exits .TP .B -t selects filenames derived from tune titles .TP .B -CS use 2:1 instead of 3:1 for broken rhythms .TP .B -quiet Suppresses some common warnings. .TP .B -silent Suppresses other messages. .TP .B -n \fI X\fP limits the length of the file name stem to X characters .TP .B -Q \fI tempo\fP sets the default tempo in quarter notes per minute if it was not specified in the abc header. .TP .B -NFNP Ignore any dynamic indications !f! !ff! etc. .TP .B -NFER Ignore any fermata indications (eg H or !fermata!). .TP .B -NGRA Ignore any grace notes. .TP .B -STFW Place lyric text in separate MIDI tracks. .TP .B -NCOM Suppress some comments in the output MIDI file. .TP .B -OCC Accept old chord convention (eg +D2G2+ instead of [DG]2). .TP .B -BF BarFly mode: invokes a stress model if possible. .TP .B -HARP Roll ornaments=roll are generated for the harpist (same pitch) .TP .B -TT Changes the tuning from A = 440 Hz. .TP .B -o \fIoutfile\fP write output to \fIoutfile\fP .TP .B -CSM \fIinfile\fP load a set of custom stress modes from a file .SH FEATURES .PP * Broken rhythms (>, <), chords, n-tuples, slurring, ties, staccatto notes, repeats, in-tune tempo/length/time signature changes are all supported. .PP * R:hornpipe or r:hornpipe is recognized and note timings are adjusted to give a broken rhythm (ab is converted to a>b). .PP * Most errors in the abc input will generate a suitable error message in the output and the converter keeps going. .PP * Comments and text fields in the abc source are converted to text events in the MIDI output .PP * If guitar chords are present, they are used to generate an accompaniment in the MIDI output. .PP * If there are mis-matched repeat signs in the abc, the program attempts to fix them. However, it will not attempt this if a multi-part tune description has been used or if multiple voices are in use. .PP * Karaoke MIDI files can be generated by using the w: field to include lyrics. .PP * Nonnumeric voice id's, eg. V: soprano, as proposed for the new abc standard is accepted. .PP * Invisible rests specified by x are treated the same way as normal rests (z). .PP * Decorations may be indicated using either the deprecated notation (eg. !fermata!) or the standard version 2.0 notation (eg. +fermata+). .PP .SH LIMITATIONS * No field is inherited from above the X: field of the tune. .SH "ABC SYNTAX EXTENSIONS" * There are some extensions to the abc syntax of the form .PP %%MIDI channel n .PP These control channel and program selection, transposing and various other features of abc2midi. .PP Each of these should appear on a line by itself. All of them are allowed within the abc tune body. By using these in combination with the part notation, one can, for example, play a part transposed or in a different key. .PP The idea behind this syntax is that other programs will treat it as a comment and ignore it. .PP %%MIDI channel n .PP selects melody channel n (in the range 1-16). .PP %%MIDI program [c] n .PP selects program n (in the range 1-128) on channel c. If c is not given, the program is selected on the current melody channel. Most modern tone generators follow the General MIDI standard which defines the instrument type for each program number. .PP %%MIDI beat a b c n .PP controls the way note velocities are selected. The first note in a bar has velocity a. Other "strong" notes have velocity b and all the rest have velocity c. a, b and c must be in the range 0-128. The parameter n determines which notes are "strong". If the time signature is x/y, then each note is given a position number k = 0, 1, 2 .. x-1 within each bar. Note that the units for n are not the unit note length. If k is a multiple of n, then the note is "strong". The volume specifiers !ppp! to !fff! are equivalent to the following : .P !ppp! = %%MIDI beat 30 20 10 1 .br !pp! = %%MIDI beat 45 35 20 1 .br !p! = %%MIDI beat 60 50 35 1 .br !mp! = %%MIDI beat 75 65 50 1 .br !mf! = %%MIDI beat 90 80 65 1 .br !f! = %%MIDI beat 105 95 80 1 .br !ff! = %%MIDI beat 120 110 95 1 .br !fff! = %%MIDI beat 127 125 110 1 .PP %%MIDI beatmod n .PP Increments by n (or decrements if n is negative) the velocities a, b and c described above. The instructions !crescendo(! and !crescendo)! are equivalent to inserting a %%MIDI beatmod 15 wherever they occur. (Alternatively you can use !<(! and !<)!.) Similarly the instructions !diminuendo(! and !diminuendo)! are equivalent to %%MIDI beatmod \-15. .PP %%MIDI deltaloudness n .PP where n is a small positive number. By default the crescendo and diminuendo instructions modify the beat variables a, b, and c by 15 velocity units. This instruction allows you to set this default to value n. .PP %%MIDI nobeataccents .PP For instruments such as church organ that have no greatly emphasized beat notes, using this will force use of the 'b' velocity (see %%MIDI beat) for every note irrespective of position in the bar. This allows dynamics (ff, f, etc) to be used in the normal way. .PP %%MIDI beataccents .PP Revert to emphasizing notes the the usual way. (default) .PP %%MIDI beatstring .PP This provides an alternative way of specifying where the strong and weak stresses fall within a bar. 'f' means velocity a (normally strong), 'm' means velocity b (medium velocity) and 'p' means velocity c (soft velocity). For example, if the time signature is 7/8 with stresses on the first, fourth and sixth notes in the bar, we could use the following .PP %%MIDI beatstring fppmpmp .PP %%MIDI transpose n .PP transposes the output by the specified number of semitones. n may be positive or negative. .PP %%MIDI rtranspose n .PP Relative transpose by the specified number of semitones. i.e. %%MIDI transpose a followed by %%MIDI rtranspose b results in a transposition of a+b. %%MIDI transpose b will result in a transposition of b semitones, regardless of any previous transposition. .PP %%MIDI c n .PP specifies the MIDI pitch which corresponds to c. The default is 60. This number should normally be a multiple of 12. .PP %%MIDI grace a/b .PP sets the fraction of the next note that grace notes will take up. a must be between 1 and b-1. The grace notes may not sound natural in this approach, since the length of the individual grace notes vary with the complexity of the grace and the length of the following note. A different approach (which is now the default) assumes that the grace notes always have a fixed duration. To use the other approach you would specify, %%MIDI gracedivider b where b specifies how many parts to divide the unit length specified by the L: field command. For example if b = 4 and L: = 1/8, then every grace note would be 1/(8*4) or a 32nd note. Time would be stolen from the note to which the grace notes are applied. If that note is not long enough to handle the grace then the grace notes would be assigned 0 duration. .PP %%MIDI chordname name n1 n2 n3 n4 n5 n6 .PP Defines how to play a guitar chord called "name". n1 is usually 0 and n2, n3 to n6 give the pitches of the other notes in semitones relative to the root note. There may be fewer than 6 notes in the chord, but not more.If "name" is already defined, this command re-defines it. Unlike most other commands, chordname definitions stay in effect from where they are defined to the end of the abc file. The following illustrates how m, 7, m7 and maj7 could be set up if they were not already defined. .PP %%MIDI chordname m 0 3 7 .br %%MIDI chordname 7 0 4 7 10 .br %%MIDI chordname m7 0 3 7 10 .br %%MIDI chordname maj7 0 4 7 11 .PP %%MIDI gchord string .PP sets up how guitar chords are generated. The string is a sequence made of of z's, c's f's and b's for rests, chords, fundamental and fundamental plus chord notes respectively. This specifies how each bar is to be played. An optional length is allowed to follow the z's, c's f's and b's e.g. czf2zf3. If the abc contains guitar chords, then abc2midi automatically adds chords and fundamentals after encountering the first guitar chord. It keeps using that chord until a new chord is specified in the abc. Whenever the M: field is encountered in the abc, an appropriate default string is set : .P For 2/4 or 4/4 time default is equivalent to : %%MIDI gchord fzczfzcz .P For 3/4 time default is equivalent to : %%MIDI gchord fzczcz .P For 6/8 time default is equivalent to : %%MIDI gchord fzcfzc .P For 9/8 time default is equivalent to : %%MIDI gchord fzcfzcfzc .P The gchord command has been extended to allow you to play the individual notes comprising the guitar chord. This allows you to play broken chords or arpeggios. The new codes g,h,i,j, G,H,I,J reference the individual notes starting from the lowest note of the chord (not necessarily the root in the case of inversions). For example for the C major chord, g refers to C, h refers to E and i refers to G. For a gchord command such as, .P %%MIDI gchord ghih .P Abc2midi will arpeggiate the C major guitar chord to CEGE. The upper case letters G,H,I, and J refer to the same notes except they are transposed down one octave. Note for the first inversion of the C major chord (indicated by "C/E"), E would be the lowest note so g would reference the note E. .P Like other gchord codes, you may append a numeral indicating the duration of the note. The same rules apply as before. You can use any combination of the gchord codes, (fcbghijGHIJz). .PP %%MIDI chordprog n .PP Sets the MIDI instrument for the chords to be n. If the command includes the string octave=n where n is a number between \-2 and 2 inclusive, then this will shift the pitch of the instrument by n octaves. For example %%MIDI chordprog 10 octave=1.) .PP %%MIDI bassprog n .PP Sets the MIDI instrument for the bass notes to be n. If the command includes the string octave=n where n is a number between \-2 and 2 inclusive, then this will shift the pitch of the instrument by n octaves. For example %%MIDI bassprog 10 octave=\-1.) .PP %%MIDI chordvol n .PP Sets the volume (velocity) of the chord notes at n. .PP %%MIDI bassvol n .PP Sets the volume (velocity) of the bass notes at n. There is no corresponding melodyvol command since there are 3 velocity values for melody, set using the beat command. .PP %%MIDI gchordon .PP Turns on guitar chords (they are turned on by default at the start of a tune). .PP %%MIDI gchordoff .PP Turns off guitar chords. .PP %%MIDI droneon .PP Turns on a continuous drone (used in bagpipe music) consisting of two notes. By default the notes are A, and A,, played on a bassoon at a velocity of 80. This can be configured by the %%MIDI drone command described below. .PP %%MIDI droneoff .PP Turns off the continuous drone. .PP %%MIDI drone n1 n2 n3 n4 n5 .PP Sets the drone parameters where n1 is the MIDI program, n2 and n3 specify the MIDI pitches of the two notes in the chord, and n4 and n5 specify the MIDI velocities of the two notes. If you do not set these parameters they are by default 70 45 33 80 80. A value of zero or less indicates that the setting of this parameter should be left as it is. .PP %%MIDI drum string [drum programs] [drum velocities] .PP This sets up a drum pattern. The string determines when there is a drum beat and the drum program values determine what each drum strike sounds like. .PP e.g. %%MIDI drum d2zdd 35 38 38 100 50 50 .PP The string may contain 'd' for a drum strike or 'z' for a rest. By default a voice starts with no drum pattern and '%%MIDI drumon' is needed to enable the drumming. The drum pattern is repeated during each bar until '%%MIDI drumoff' is encountered. The %%MIDI drum command may be used within a tune to change the drum pattern. This command places the drum sounds on channel 10 and assumes your tone generator complies with the General Midi standard - if it does not, then you may hear tones instead of drum sounds. .PP In both the gchord and drum commands, the standard note length of a single note f,c,z or d is not set by the L: command. Instead it is adjusted so that the entire gchord string or drum string fits exactly into one bar. In other words the duration of each note is divided by the total duration of the string. This means that, for example, the drum string "dd" is equivalent to drum string "d4d4". You cannot currently specify fractions directly (eg. C3/2) as done in the body of the music, but it is still possible to express complex rhythms. For example, to indicate a rhythm such as (3ddd d/d/d/d, you would write the string "d4d4d4d3d3d3d3". .PP %%MIDI drumbars n .PP The %%MIDI drum line can sound quite monotonous if it is repeated each bar. To circumvent this problem a new MIDI command %%MIDI drumbars n where n is a small number will spread out the drum string over n consecutive bars. By default drumbars is set to 1 maintaining compatibility with existing abc files. You should take care that the drumstring is evenly divisible between the drumbar bars. Also the time signature should not change between bars in a drumbar unit. (Sample abc file in doc/CHANGES June 24 2008.) .PP %%MIDI gchordbars n .PP This command spreads the gchord string over n consecutive bars just like drumbars (above). (A sample is found in doc/CHANGES March 17 2009.) .PP With version 1.54 Dec 4 2004 of abc2midi, notes in chords (eg. [FAc]) are not played in the same instant but offsetted and shortened by 10 MIDI time units. Thus the first note in the chord (eg. F) is played for the full indicated time, the second note (eg. A) starts 10 MIDI units later and is shortened by the same amount and the third note starts another 10 MIDI units later and is shortened by another 10 units. This introduces an "expressivo" option and avoids the heavy attack. (This does not apply to gchords or multivoiced chords.) The amount of the delay and shortening may be configured by the MIDI command .PP %%MIDI chordattack n .PP where n is a small number. If n is zero, then abc2midi should behave as in earlier versions. The delay n is in MIDI time units where there are 480 units in a quarter note beat. The program may not run correctly if n is too large and there are short chords. .PP %%MIDI randomchordattack n .PP Like above except that the delay is a random variable uniformly distributed between 0 and n-1. .PP %%MIDI trim x/y .PP where x and y are two numbers. This command controls the articulation of notes and chords by placing silent gaps between the notes. The length of these gaps is determined by x/y and the unit length specified by the L: command. These gaps are produced by shortening the notes by the same amount. If the note is already shorter than the specified gap, then the gap is set to half the length of the note. The fraction x/y indicates a note duration in the same manner as specified in the abc file. The actual duration is based on the unit length specified by the L: field command. It is recommended that x/y be a fraction close to zero. Note trimming is disabled inside slurs as specified by parentheses. You can turn off all note trimming by setting x to 0, eg 0/1. By default, note trimming is turned off at the beginning of a tune or voice command. .PP %%MIDI expand x/y .PP where x and y are two numbers defining a fraction less than 1. This command controls the articulation of notes and chords in the reverse manner. The notes are lengthened by this fraction so they overlap the start of the next note. .PP %%MIDI drummap note midipitch .PP Please see abcguide.txt. .PP %%MIDI ptstress filename .PP This command loads file filename into abc2midi which contains the Phil Taylor stress parameters and puts abc2midi in the mode where it applies these stress parameters on every note. This model runs in opposition to the standard beat model, so the MIDI beat, beatstring, beatmod commands become ineffectual. This also means that the dynamic indications !f! !pp! etc. do not work any more. .PP There are two different implementations of the stress model. Model 1 modifies the note articulation and takes control of the MIDI trim parameters too. To revert back to the standard model, put the command %%MIDI beataccents. Model 2 modifies both the onset and ending of each note allowing a musical beat to expand or contract in time. However, the length of a musical measure should be preserved. Note if you using model 2, which the current default, you must include \-BF as one of the runtime parameters of abc2midi. .PP The model divides a bar into equal segments. For each segment, a loudness or MIDI velocity is specified and a duration multiplier is specified. If a note falls into a specific segment, it assumes the velocity of that segment and its duration is modified accordingly. If the note overlaps more than one segment, then the note assumes the average of those segment values. .PP The input file specifies the number of segments and the loudness and duration multipliers for each segment. The file has the following format. The first value is the number of segments and each line specifies the velocity and duration multiplier of the specific segment. The velocity is limited to 127 and the duration is a decimal number. The note durations is modified by varying the gap between notes, so it is not possible to extend a note. This preserves the regular tempo of the music. The program scales, the note duration indications by dividing it by the maximum value which here is 1.4. .PP %%MIDI stressmodel n .PP where n is either 1 or 2, selects the stress model implementation. .PP other %%MIDI commands such as bendvelocity, bendstring, controlstring have been introduced recently and are described in the file abcguide.txt. .SH "COMPATIBILITY WITH DRAFT STANDARD 2.0" .PP The proposed standard introduces a new copyright field using the syntax .PP %%abc-copyright (c) Copyright John Smith 2003 .PP Abc2midi now inserts this in the MIDI file in the form of a metatext copyright tag. Changes were made to the event_specific function in store.c to process the copyright information. It is also copied into the Karaoke track (if it is created) as as @T field. .PP .SH SEE ALSO abc2ps(1), midi2abc(1), yaps(1). .SH AUTHOR James Allwright .SH SUPPORTED by Seymour Shlien .SH VERSION This man page describes abc2midi version 2.27 June 25 2006. .SH COPYRIGHT Copyright 1999 James Allwright .PP abc2midi is supplied "as is" without any warranty. It is free software and can be used, copied, modified and distributed without fee under the terms of the GNU General Public License. .PP More complete documentation may be found in abcguide.txt which comes with the abcMIDI distribution. abcmidi/doc/abc2abc.10000644000000000000000000000715612564557252013276 0ustar rootroot.TH ABC2ABC 1 "07 June 2011" .SH NAME abc2abc \- a simple abc checker/re-formatter/transposer .SH SYNOPSIS \fBabc2abc\fP \fIfile\fP [ \fB-s\fP ] [ \fB-n\fP ] [ \fB-b\fP ] [ \fB-r\fP ] [ \fB-e\fP ] [ \fB-t \fP\fIsemitones\fP ] [ \fB-nda\fP ] [ \fB-u\fP ] [ \fB-d\fP ] [ \fB-v\fP ] [ \fB-V\fP\fIvoice number\fP] [\fB-P\fP\fivoice number\fp] [\fB-nokeys\fP] [ \fB-nokeyf\fP] [ \fB-usekey\fP\fI(sharps/flats)\fP] [ \fB-OCC\fP ] .SH "DESCRIPTION" .PP .B abc2abc is a simple abc checker/re-formatter/transposer. It will check whether the \fIfile\fP given on the command line obeys basic abc syntax. .PP If you want to check an abc tune, it is recommended that you use .B abc2midi with the \fB-c\fP option. This performs extra checks that .B abc2abc does not do. .PP The output of .B abc2abc goes to standard output. Use redirection to save it to a file. .SH OPTIONS .TP .B \-s Rework spacing in the file (which affects how notes are beamed together when the music is printed out). This option does not appear to be working correctly. .TP .BI \-n " X" Reformats the abc file with line breaks every \fIX\fP bars. .TP .B \-b Don't do bar checking. .TP .B \-r Don't do repeat checking. .TP .B \-e Don't report errors. .TP .BI \-t " n" Transpose tune by \fIn\fP semitones. This function will also work with K: none or one of \-nokeys or \-nokeyf. If a voice is assigned to channel 10 (drum channel) using a %%MIDI channel 10 command, then this voice is never transposed. .TP .B \-nda Convert double accidentals in guitar chord to another chord though strictly not correct. .TP .B \-u Update notation; the older notation \fB+ +\fP for chords is replaced by \fB[]\fP and \fBs s\fP for slurs is replaced by \fB()\fP. .TP .B \-OCC Accept the old notation for chord. Normally this is turned off, since it conflicts with abc draft standard version 2.0 for decorations (eg. +crescendo(+). .TP .B \-d Re-notate the tune with all note lengths doubled. The unit length specified by the L: field command is halved (e.g. L:1/8 to L:1/16). .TP .B \-v Re-notate the tune with all note lengths halved. The unit length specified by the L: field command is doubled (e.g. L:1/8 to L:1/4). .TP .B \-ver Prints version number and exits. .TP .BI \-V " X[,Y...]" For multivoiced abc files (i.e. contains V: field commands), only voices \fIX[,Y,...]\fP are copied. .TP .BI \-P " X,[,Y...]" For multivoiced abc files (i.e. contains V: field commands), all voices except \fIX[,Y...]\fP remain the same. Voices X,Y... are modified according the other runtime parameters. .TP .BI \-X " n" For a file containing many tunes, the X: reference numbers are renumbered sequentially starting from number \fIn\fP. .TP .B \-nokeys No key signature will be assumed. Instead, sharps and naturals will be placed wherever they are needed. .TP .B \-nokeyf No key signature will be assumed. Instead, flats and naturals will be placed wherever they are needed. .TP .B \-usekey " sf This will force abc2abc to output the notes in the key signature keys[sf] where sf specifies the number of flats (\-negative) or sharps (+positive) in the key signature. It is a number between \-5 and +5 inclusive. .PP * Normally abc2abc will convert the deprecated notation for decorations (eg. !ppp!) to the abc version 2.0 draft standard (eg. +ppp+). If you do not wish to change to this standard include the \-OCC flag. .SH "SEE ALSO" .IR abcmtex "(1), " abc2midi "(1), " midi2abc "(1), " mftext "(1)" .SH AUTHOR This manual page was written by Anselm Lingnau and is now supported by Seymour Shlien for the GNU/Linux system. .SH VERSION This man page describes abc2abc version 1.64 from June 07 2011. abcmidi/doc/AUTHORS0000644000000000000000000000166211020033716012757 0ustar rootroot This file contains additional documentation for the abcMIDI package : Unix Man Pages -------------- * abc2midi.1 man pages for abc2midi written by Christoph Dalitz. * midi2abc.1 man page for midi2abc written by Christoph Dalitz. * abc2abc.1 man page for abc2abc written by Anselm Lingnau. * mftext.1 man page for mftext written by Anselm Lingnau. These man pages are now supported by Seymour Shlien If you wish to preview these man pages use groff with the -man option. The output is normally in postscript format, but you can override this using the -a option. For example, groff -man -a abc2midi.1 To install the man pages, copy them to appropriate directory (typically this will be /usr/man/man1). You may also need to run mandb after copying them across. Code Documentation ------------------ * abc2midi.txt : notes on the abc2midi code written by Seymour Shlien. * midi2abc.txt : notes on the midi2abc code written by Seymour Shlien. abcmidi/doc/programming/0000755000000000000000000000000011414351420014226 5ustar rootrootabcmidi/doc/programming/cvs/0000755000000000000000000000000011414351420015021 5ustar rootrootabcmidi/doc/programming/cvs/Entries0000644000000000000000000000035611020033716016357 0ustar rootroot/abc2midi.txt/1.1.1.1/Thu Sep 28 18:17:04 2006// /coding.txt/1.1.1.1/Thu Sep 28 18:17:04 2006// /midi2abc.txt/1.1.1.1/Thu Sep 28 18:17:04 2006// /split.abc/1.1.1.1/Thu Sep 28 18:17:04 2006// /yaps.txt/1.1.1.1/Thu Sep 28 18:17:04 2006// D abcmidi/doc/programming/cvs/Repository0000644000000000000000000000003011020033716017112 0ustar rootrootabcmidi/doc/programming abcmidi/doc/programming/cvs/Root0000644000000000000000000000002711020033716015664 0ustar rootroot/home/seymour/CVSREPOS abcmidi/doc/programming/coding.txt0000644000000000000000000003222012672022044016235 0ustar rootrootNotes on the code ----------------- These notes are for anyone who wants to re-compile, re-write or re-use bits of the code. Additional information is available by downloading the file abcextra.zip. This includes : * man pages for abc2midi and midi2abc. * A detailed description of the inner workings of abc2midi, written by Seymour Shlien. Compilation ----------- The file midifile.c and the header file midifile.h are slightly changed from the midifilelib distribution. To see the program dependencies, examine the Makefile. The code is written in K&R style C and should be fairly easy to compile on any system with a C compiler and a make utility. Makefiles are provided for gcc/unix, DJGPP/DOS and PCC/DOS. There are also some notes on using the GUI front-end to Pacific C/DOS. You may get warning messages if your compiler prefers ANSI C style function prototypes. Choose the most suitable makefile; unix.mak, djgpp.mak or pcc.mak and rename it as 'makefile'. If you are not using any of the above compilers, you may have to edit the makefile so that it uses compilation flags suitable for your compiler. To compile the code, type make all If the complete compilation does not work, you can try compiling the individual programs separately : make midi2abc (or make midi2abc.exe) make abc2midi (or make abc2midi.exe) make abc2abc (or make abc2abc.exe) make mftext (or make mftext.exe) make yaps (or make yaps.exe) Note that the make utility on some systems (e.g. GNU make) may require the Makefile to be a unix text file and not a DOS text file. The difference is that unix uses newline to mark the end of each line while DOS uses carriage return and newline. Note, if you have difficulty compiling the package because you do not have snprintf see the note in doc/CHANGES dated January 08 2005 (and also December 17 2004). --------------------------------------------------------------------- Calling abc2midi or midi2abc from a GUI. ---------------------------------------- The programs should now have an exit value of 0 for normal termination and 1 for an error state. However, abc2midi will still exit with 0 if it finds non-fatal errors in the code, so the user should always have the option of looking at the program's text output (I don't want to get blamed when useful diagnostic output turns into the ubiquitous 'OK' click-button). ---------------------------------------------------------------------- Man pages --------- Files: abc2midi.1 and midi2abc.1 Christoph Dalitz has written some man pages for abc2midi and midi2abc. These should be installed in the sub-directory /man1 of the directory given by the MANPATH environment variable. (The man command is usually only found on Unix variants). The source distribution has been re-organized to contain only the source and a few text files. If you want these man pages, you need to download the file abcextra.zip. --------------------------------------------------------------------- Code Layout and Indentation style --------------------------------- If you want to add your own code and make it fit in with the existing coding style, you can use GNU indent. The following is a DOS batch file to invoke indent with the appropriate options. indent -bad -bap -br -ce -cli0 -npcs -di1 -nbc -i2 -ts0 -psl -lp -ipo %1 rem rem options for GNU indent to achieve my personal style rem rem -bad blank line after declaration block rem -bap blank line after procedure body rem -br brace on same line after if, struct and enum rem -ce cuddle else rem -cli0 case at same identation as switch rem -npcs no space between procedure name and following open bracket rem -di1 one space between variable type and variable name rem -nbc comma-separated variables on the same line rem -i2 indent 2 spaces rem -ts0 no tabs rem -npsl function type on same line as function name rem -lp continuations matched to left parenthesis rem -ip0 no indention of variables in K&R function headers rem -ncs no space after cast --------------------------------------------------------------------- Extensions to the abc Format ---------------------------- 1. The parser recognizes %%package as some package-specific command and calls event_specific with the package name and the string that follows it. 2. The abc standard defines notation for 4 octaves : C, - B, C - B c - b c' - b' The parser recognizes each additional comma as meaning "going down an extra octave", giving C,, - B,, C,,, - B,,, and so on. Likewise, each additional prime symbols s interpreted as "go up an extra octave" : c'' - b'' c''' - b''' and so on. ---------------------------------------------------------------------- abc2midi -------- abc2midi consists of the following C source files: parseabc.c - parses the input text and calls a routine for every parsed element encountered. parser2.c - performs some additional parsing that may not be required. store.c - builds an internal representation of the abc tune. genmidi.c - uses the internal representation to generate the MIDI file, using calls to MIDI-specific routines in midifile.c queues.c - library of routines for handling 'queues', a data structure used internally by genmidi.c midifile.c - Thompson and Czeisperger's public domain library of MIDI file manipulation routines. In the first phase of parsing, the abc file is read and when, say, a note is encountered, the routine event_note() is called. The code for event_note is in the file store.c. Encountering an X in the abc generally causes a routine called event_X() to be called. abc2midi builds up an internal representation of the tune. At the end of the abc tune, a little bit of processing is done on the internal representation before the routine writetrack() is called to actually write out the MIDI file. If there are repeats in the music, something that appears only once in the abc may be invoked twice by writetrack(). The internal representation uses the arrays feature[], pitch[], num[], and denom[]. feature[] holds a description of an object while the other arrays hold data relating to the object. The list of possible features can be found in the file abc.h . The main features are NOTE, a note of specified duration, REST, a pause of specified duration and TNOTE, a note of specified duration with no interval between when it starts and when the next item starts. This provides a simple way of representing chords. Ties, broken rhythm signs and grace note brackets are all deal with before writetrack() is called. To add your own special features, you could define a new feature type. However, an easier option is to use the %%MIDI format. If the parser encounters "%%MIDI command", where command is not recognized by the routine event_specific(), the string following %%MIDI is stored away and passed to the routine dodeferred() by writetrack() when the MIDI file is being written. ---------------------------------------------------------------------- abc2abc ------- abc2abc shares the parser with abc2midi, but instead of storing the abc code in an internal format, it is written almost straight out again. The components of abc2abc are: parseabc.c - parser toabc.c - generates output abc. midifile.c - public domain MIDI library. ---------------------------------------------------------------------- YAPS ---- YAPS is written mainly using ANSI C style function headers and compiled and tested using DJGPP (DOS/Windows port of gcc). The code is composed of the following files: parseabc.c - reads through the abc text file. When it recognizes an abc "unit" it calls a routine such as event_note() or event_key(). yapstree.c - creates a data structure to represent a tune. Generally, I have tried to use as small a number of passes through the data structure as possible. This means that things like applying a broken rhythm symbol > is done as the notes are read in, rather than using a second pass. This results in a lot of variables being needed in 'struct voice' to keep track of what is going on as we read in the current symbols. Different sets of these variables are used on different passes through the data. drawtune.c - responsible for creating the PostScript file. When a whole tune has been read in, this calculates the size of each individual element, works out spacing within each line, decides how to place the beam for a group of beamed notes, then finally generates the PostScript for the tune. position.c - called by drawtune.c. This set of routines is responsible for spacing each line correctly. Where the input abc is multi-voice, elements played at the same time but in different voices are aligned. pslib.c - a single routine to print out the entire library of PostScript functions used by yaps. debug.c - routines to print to screen the contents of a tune data structure. abc.h - header file defining abc element types. structs.h - header file defining the data structures used by the program. The voice structure holds a lot of cuurent context information, used by the program as it does a pass through the voice. sizes.h - header file containing macros to define sizes in points for all the graphic elements. Dynamic Memory Management ------------------------- abc2midi uses a system of re-sizable arrays in order to handle arbitrary size input. This scheme was a natural way to adapt the original fixed size arrays, and is not as flexible as it might be. Yaps instead uses linked lists. There is a tune data structure containing a linked list of voices and the notes and other elements are stored in a linked list in each tune. Some music elements contain their own linked lists; for example a note may have a linked list of lyric syllables. Adding a new data item to an element (e.g. a note) involves the following : 1. find 'struct note' in structs.h and add the element. 2. Initialize it in newnote(). 3. If it is a pointer to a new data structure, make sure the new data structure is de-allocated in freevoice(). ---------------------------------------------------------------------- The abc parser -------------- The parser (parseabc.c) has been written in such a way that it forms an independent unit which must be linked with routines to handle parsed units. This is very similar to the way that the midifilelib utilities work. The abc is parsed line by line. Each line may be * A comment * A package-specific command * A field (which may have a trailing comment) * A blank line * A TeX command Having detected one of these, the parser calls an appropriate routine. If it is none of these, then within the tune body it is * A line of music (which may have a trailing comment). Which is parsed and individual elements recognized. Outside the tune body it is * A line of arbitrary text. and an appropriate routine is called. Routines called by the parser ----------------------------- These may be a bit out of date - look in the file parseabc.c for the actual interfaces. event_init(argc, argv, filename) int argc; char* argv[]; char** filename; - first routine called by the parser. Expects filename to be the name of the abc file to parse on return. event_text(s) char *s; - called whenever a line of text is encountered. event_tex(s) char *s; - called whenever a TeX command is encountered. event_linebreak() - called whenever a newline character is encountered. event_blankline() - called whenever a blank line is encountered. event_eof() - called when the end of file is reached. event_error(s) char *s; - called whenever an error condition is detected. Errors are generally not fatal within the parser. event_warning(s) char *s; - called whenever a condition which is likely to be an error is detected. event_comment(s) char *s; - called whenever a comment is encountered. The following are calls are invoked by fields in the abc : event_specific(package, s) char *package, *s; - recognizes %%package s event_length(n) int n; - recognizes L: event_refno(n) int n; - recognizes X: event_tempo(n, a, b, rel) int n, a, b; int relative; - recognizes Q: event_timesig(n, m) int n, m; - recognizes M: event_key(sharps, s, minor) int sharps; char *s; int minor; - recognizes K: event_part(s) char* s; - recognizes P: When any other field is encountered in the abc : event_field(k, f) char k; char *f; If a line of music is encountered, the elements of that line each trigger a call to one of the following events, provided that parsing of music lines has been enabled : event_graceon() event_graceoff() event_rep1() event_rep2() event_slur(t) int t; event_tie() event_rest(n,m) int n, m; event_bar(type) int type; event_space() event_lineend(ch, n) char ch; int n; event_broken(type, mult) int type, n; event_tuple(p, q, r) int p, q, r; - general tuple: q and r are zero if not present event_chord() - called whenever + is encountered. event_chordon() - called whenever [ is encountered. event_chordoff() - called whenever ] is encountered. event_gchord(s) char* s; event_reserved(p) char p; event_note(roll, staccato, updown, accidental, mult, note, octave, n, m) int roll, staccato, mult; char updown, accidental, note; int octave, n, m; In addition, there are 2 other routines : int getline() - returns the line currently being parsed parseron() - enable parsing of music lines. parseroff() - disable parsing of music lines. abcmidi/doc/programming/midi2abc.txt0000644000000000000000000002205611020033716016444 0ustar rootrootNotes on the midi2abc code -------------------------- written by Seymour Shlien midi2abc.txt - last updated December 5 1999 Introduction Midi2abc is a program for converting a midi files into an abc file. A midi file merely consists of a list of commands to turn on and off a set of voices at specific times. The time units are expressed in pulses where the number of pulses per second can be deduced from the information in the midi file. Pitch is specified in semitone units ranging from 0 to 127 where middle C is assigned a value of 60. There are two types of midi in general use. In type 0, all the voices are interleaved in time in one track. Each voice goes to a specific channel which is mapped to a particular musical instrument or program. There is a limit of 16 voices since only 4 bits are assigned to indicate the channel number. In type 2, the voices are placed in separate tracks. This format allows handling more than 16 voices. In order to create an abc file, midi2abc must determine the length of a musical unit (for example an eighth note) in terms of midi pulses, determine the key signature, and, finally map the midi commands into musical notes. Though the midi file specifies the number of pulses per quarter note (PPQN) in the Mthd header chunk, this is not necessarily an accurate indication. It is primarily used together with the tempo indication to determine the number of pulses per second. Unless the midi file was created by a computer program, the actual length of a quarter note in midi pulses can depart from the nominal indication. Midi2abc tries to determine the length using its own heuristic algorithm. The sources of the program are contained in two files: midi2abc.c and midifile.c. This document does not try to describe completely how this program works, but is more of a general road map to the software. Algorithmic Description The conversion is done in multiple passes. In the first pass, the midi file is read and an internal representation of the file is created and stored in global dynamic memory. In each subsequent pass, other information is added to the internal representation and finally it is written to the output abc file. After parsing the input run parameters and performing various initializations, the main program calls the procedure mfread which is found in the midifile.c module. Mfread parses the different midi components of the file and calls the appropriate functions midi2abc to process these components. These functions begin with the txt_ prefix, some of which are listed here. txt_header midi header chunk txt_trackstart start of midi track txt_trackend end of midi track txt_noteon note on channel command txt_noteoff note off channel command txt_program midi program definition or change txt_metatext midi textual information txt_keysig midi key signature indication txt_tempo midi tempo indication Many other functions such as txt_pressure and txt_parameter corresponding to other midi commands, do nothing here. These functions build up an internal representation of the midi file in a global structure referenced through the track[64] structure. Up to 64 midi tracks can be stored in the internal representation. Each track structure (atrack structure) contains single and double linked lists of notes or text strings which are described below. In addition there are other linked lists (referenced by playinghead and chordhead), used for keeping track of notes currently playing and musical chords. Each note is represented by an anote structure which stores various parameters of the note. The anote structure is allocated dynamically as the midi file is read. The first four entries of the structure are filled in while the structures are being created by mfread. These are entries are listed below. anote.pitch pitch in midi units anote.chan midi channel number anote.vel midi velocity (corresponding to loudness) anote.time time in midi pulses. The other entries in the anote structure are determined in later passes. The anote structures are linked together into a a listx structure which is included in the atrack structure. The head and tail of the list are contained in this structure to facilitate the construction of this list. In addition there is tlistx structure for storing all the textual information (for example words in a Karaoke midi file) which may be found in the track. There is a doubly linked list structure of anotes (dlistx, *playinghead) which is used as a work space for matching the note off command with the corresponding note on command. This is needed in order to determine the length of time the note was turned on (called anote.tplay). The internal representation is mainly constructed by the important functions txt_noteon and txt_noteoff called by mfread. These functions in turn call the functions addnote and notestop. The midi file contains separate commands for turning a note on or off so that in order to determine the length of time that a note has been on, it is necessary to match a note-off command with the corresponding note-on command. Every time a note is turned on, it is also added to the playhead (tail) structure. The procedure notestop finds the corresponding note-on command in the playhead structure, removes it, and records the duration of the note which was turned on. At the end of the first pass, the number of tracks is counted and each track is processed by the function postprocess which computes the entry anote.dtnext for each anote structure. This entry contains the time interval between the current and the next note in the linked list of notes. The abc time unit length is either 1/8 or 1/16 depending on the time signature. A time signature of 4/4 is assumed unless it is specified by the run time parameters (-m or -xm). (If -xm is specified, then the program uses the time signature given by the midi meta command if it exists in the file.) The next step involves the quantization of the midi time units expressed in pulse counts into abc time units. It is first necessary to estimate the length of an abc time unit in terms of midi time units. This either is estimated using a heuristic algorithm, guesslength, or is determined from the run time parameters (-Q or -b). The function guesslength makes an initial guess by dividing the total number of pulse counts in the track by the total number of notes. It then tries 100 different lengths in the neighbourhood of this initial guess and chooses the one which leads to the smallest quantization error. The quantization error is determined by the function quantizer which keeps track of the total deviation of the time a note starts (in pulse counts) from the expected time the note starts assuming the standard musical intervals. This deviation can either drift positively or negatively with time. The total error is determined by summing the absolute values of these deviations for each bar. Once the unit length has been determined, all the notes in all tracks are quantized by the function quantizer. This function assigns values to the anote entries, anote.xnum, anote.playnum and anote.denom. anote.xnum interval between the current note and following note. anote.playnum note duration. anote.denom always has the value of 2. A musical part does not necessarily begin at the start of a bar line, but may have some leading notes. This is called anacrusis. There are two methods to estimate the anacrusis. The function findana searches for the first upbeat by examining the velocities (loudness) of the notes. The function guessana, chooses the anacrusis which minimizes the number of tied notes across a bar line which is determined by the function testtrack. At this point the key signature of the tune must be determined. The procedure findkey computes the frequency distribution of all the notes in the piece and stores it in the local array n[]. The key signature is determined by transposing the distribution by each of the 12 keys and counting the number of sharp or flat notes. The key signature is determined from the key which leads to the minimum number of black keys on the piano. The mode of the scale (major, minor, Dorian, etc.) is determined by looking at the final note of the piece. Once the key signature is determined, the assumed flats or sharps are determined by the procedure setupkey. The program is now ready for its final pass where the musical parts (or voices) are printed in the output abc file. The procedure printtrack processes the internal representation of each midi track producing a separate voice for each track. In order to handle chords which may be present in an individual track, printtrack maintains a structure referenced by chordhead by calling the support functions addchord(), advancechord(), removechord() and printchord(). These functions handle single notes as well as chords. Another function, dospecial(), handles the triplets and broken rhythms (eg. dotted notes followed by half sized note or vice versa) whenever they are detected. The printchord() function is supported by the functions printfraction() and printpitch(). After the track is printed, the memory allocated to the structures for the internal representation of the tracks is freed. abcmidi/doc/programming/split.abc0000644000000000000000000000223712247153506016046 0ustar rootrootX:1 T: test split file 1 M: 2/4 L: 1/4 K: G G & E & C|D|GA & EF| X:2 T: test split file 2 M: 1/4 L: 1/4 K: G %%MIDI program 20 D|G & E|C|F|G & E| X:3 T: test split file 3 M: 2/4 L: 1/8 Q: 50 K: D CD |EF AB & CD FG| G2 | BD D2 & GB B2| X:4 T: test split file 4 M: 1/4 L: 1/4 K: G V:1 |:G |[1 D & B:| V:2 |:g |[1 d & b:| V:1 [2 F & A| V:2 [2 f & a| X:5 T: test split file 5 M: 1/4 L: 1/4 K: G G & E |D| X:6 T: test split file 6 M: 1/4 L: 1/4 K: G D|G & E| X:7 T: test split file 7 M: 1/4 L: 1/4 K: G D|G & E & C|F| X:8 T: test split file 8 M: 1/4 L: 1/4 K: G G & E & C|D| X:9 T: test split file 9 M: 1/4 L: 1/4 K: G G & E & C|D|F & A| X:10 T: test split file 10 M: 1/4 L: 1/4 K: G V:1 |:G |[1 D & B V:2 |:g |[1 d & b V:1 :|[2 F & A| V:2 :|[2 f & a| X:11 T: test split file 11 M: 1/4 L: 1/4 K: G |:G & E :|D|F & A| X:12 T: test split file 12 M: 1/4 L: 1/4 K: G |:G & E |D:|F & A| X:13 T: test split file 13 M: 1/4 L: 1/4 K: G |:G & E |[1 D:|[2 F & A| X:14 T: test split file 14 M: 1/4 L: 1/4 K: G |:G |[1 D & B:|[2 F & A| X:15 T: splits with octave=1 M: 4/4 L: 1/4 K: G octave=1 G A B C & E F G A| X:16 T: test split file 13 M: 1/4 L: 1/4 K: G |:G & E |1 D:|2 F & A| abcmidi/doc/programming/yaps.txt0000644000000000000000000001414311020033716015744 0ustar rootrootSome Notes on the yaps Code ------------------------------------------------------------- written by Seymour Shlien November 21 2004 This file gives an algorithmic description of the yaps program which converts an abc file to a PostScript file. The source consists of almost 10000 lines of C in the following files. parseabc.c is the front end which scans the abc file and invokes the appropriate event handler for each element it encounters (eg. bar lines, notes, chords etc.) It happens to be the front end for other programs such as abc2midi, and abc2abc. More details are given in abc2midi.txt. yapstree.c contains all the event handlers called by the parser. It produces a complex data structure called tune which references many other structures. When the parser completes processing the tune, event_blankline or event_eof calls printtune (in drawtree.c) which processes the tune structure producing a PostScript file. Unlike abc2midi, most of the layout including the detailed beaming is done in the first pass during the parsing stage. The information in this structure is then processed by drawtune.c in two more passes. An overview of these structures is provided here. More details on the tune structure is provided in this file. drawtune.c contains the function printtune which turns the tune structure into an actual PostScript file. This is done in two passes. Before writing the PostScript file it is necessary to determine the boundingbox of the output image since this information is recorded in the header of the output file. This is determined in the first pass where functions monospace() or spacevoices() (in position.c) are called. During this pass the pixel positions of each object are recorded in the associated structures. In the second pass, the actual PostScript file is written. The function calls printlib() (in pslib.c) outputs all the PostScript boiler plate macro definitions required by yaps. The information in the tune structure is used to output the music notation in a PostScript file. position.c contains functions for determining the amount of space that is required for the different music objects drawn in the PostScript file. parser2.c contains additional parsing functions missing in parseabc. They handle more recent features added to the abcmidi package. pslib.c Definition of new PostScript commands (eg. notes, clefs, stems, tails, ...) which are copied to the PostScript file. debug.c Functions which support the -d option in yaps. It prints some of the contents of the internal tune structure. Data Structures --------------- The data structures are defined in the include file structs.h. The top level structure, tune is instantiated by init_tune which is called by event_init or event_refno. It stores all the information in the abc field commands (X: ,M:, L:, C:, O: and etc.). It contains a pointer to the voice structure and a list of voice pointers where most of the body information is recorded. The voice structure is instantiated by the function newvoice which is called by setvoice(n) whenever the voice context switches in the abc file. Setvoice performs the voice switching (which occurs in voice interleaved files) and either creates a new voice or finds the matching voice structure already existing. The voice structure contains the feature structure which is somewhat similar in function to the one defined in store.c (for abc2midi). The feature structure encodes all the detailed information in the body, using the same typedef enum featuretype defined in abc.h. Unlike store.c there is no num and denom arrays. Instead the feature struct contains a void* pointer called item which can point to anything and where additional information can be stored. If the feature type is a NOTE then a "note" struct is created which records a lot of detailed information related to the placement and visual representation of the note. They include: tail_type which specifies whether the note appears in isolation or is part of a beamed group base_exp whole, half, quarter, ... notes dots how many dots follow stemlength, stemup, fliphead, pitch, octave, accidentals, accents,... (see struct.h) Most of the information except actual positioning is determined by functions such as count_dots and beamitem in yapstree.c. You can view this information by running yaps.exe with the -d run time parameter. The handling of the note positioning is quite complex as outlined below. It is therefore not easy to implement the splitvoice feature into yaps. Here is a description. The positioning of notes is done by the function spacemultiline() which calls advance() unless one is printing the voices separately. The positioning is done on all the voices at the same time to ensure that they are lined up properly. Spacemultiline accesses all the active voices using the functions firstitem() and nextitem() which are used for handling any lists of objects. Each voice maintains its own pointer to the current feature being scanned (v->place). Each voice also maintains its own pointer to the relative time of the note being scanned in the variable v->time. (v->time contains both a numerator and denominator.) The advance() function updates v->place, v->time and interprets the voice features determining the amount of space that is needed to plot the next object (itemspace) and the number of plotable objects (items). The position to plot the next object (x) is maintained by spacemultiline and passed to advance. Advance() updates v->place->x with the position to plot the object based on its width. Spacemultiline() maintains a mastertime variable for maintaining synchrony between all voices. At least two passes are made through the voice features. In the first pass provisional positions are computed for the notes. The amount of space left over in the music lines is computed and is used to determine the internote gaps. In the second pass, the notes are repositioned to use up the entire space in the staff line. Spacemultiline is called for each staff line whose end is signaled by a linefeed feature in the voice. abcmidi/doc/programming/abc2midi.txt0000644000000000000000000004260411020033716016445 0ustar rootrootSome Notes on the abc2midi Code ------------------------------- written by Seymour Shlien Abc2midi.txt - last updated 29 November 1999. This file provides an algorithmic description of the program abc2midi which converts an abc file into a midi file. The sources of abc2midi now comprising of 6700 lines of C code are contained in the following five files. parseabc.c is the front end which scans the abc file and invokes the appropriate event handler for each element it encounters (eg. bar lines, notes, chords etc.) It happens to be the front end for other programs such as abc2ps, yaps and abc2abc. store.c contains all the event handlers which are invoked from parseabc. It converts the abc file into an internal representation described later in this file. genmidi.c converts this internal representation in an output midi file. queues.c are some utilities needed by genmidi. midifile.c is a library of public domain routines to read and write midifiles. In order to handle the multiple voices, parts, repeats and accompaniments which occur in abc files, the program performs multiple passes. The midi file stores the different voices, accompaniment and lyrics in individual tracks, so it is necessary to separates these parts prior to writing it to the midi file. If there are repeats in the music, something which appears only once in the abc file may be invoked twice when creating the output midi file. Parseabc.c ---------- The parser has been written so that it should be possible to write your own utility to handle the interpreted abc and link it with the parser code. This is very similar to the way that the midifilelib utilities work. The parser is designed so that it can write out almost exactly what it reads in. This means that in some cases the level of parsing is fairly primitive and it may be necessary to make use of routines in store.c which perform further processing on an item. In the first phase of parsing, the abc file is read and when, say, a note is encountered, the routine event_note() is called. The code for event_note is in the file store.c. Encountering an X in the abc generally causes a routine called event_X() to be called. An internal representation of the tune is built up and when the end of an abc tune is reached, a little bit of processing is done on the internal representation before the routine mywritetrack() is called to actually write out the MIDI file. The main program to abc2midi is contained in this file. Since this main program is used to start other programs such as yaps, it is fairly simple. It calls event_init defined in store.c which obtains all the user parameters (eg. input filename) and then executes the top level procedure, parsefile. The procedure parsefile (filename), opens the specified file (or stdin) and processes it one character at a time. The characters fill a line buffer which is passed to the procedure parseline whenever a linebreak character (eg. linefeed) is encountered. By doing it in this fashion, abc2midi is able to eliminate the extra carriage return which occurs in DOS files. The procedure parseline first checks for blank lines and comments. A blank line signals the end of the tune and the event_blankline is called to initiate the next stage in processing. If it is neither a comment or blank line, the procedure must decide whether the line is a a field line (eg."X:2") or part of a music body (eg. "|:C>DGz|..."). This is decided using the following rule. If the first letter begins with one of the field letter commands and is immediately followed by a ":", then it is treated as a field line and parsefield is called. Otherwise if a K: field line was already encountered (variable inbody set to 1), then it is treated as a line of music. If neither case is satisfied, then the line is intepreted as plain text. The procedure parsefield identifies the particular field line type and invokes the appropriate support function or event handler. If the field command occurs after the first K: line, then only certain field lines are legal. (For example it is illegal to place a T: (title) line after the K: (key signature) line.) The procedure parsemusic is the most complex procedure in the file and recognizes the musical notes, chords, guitar chord names, bar lines, repeats, slurs, ties, graces etc. Appropriate event handlers and support functions are called to complete the tasks of parsing the information. The parsenote function, for example, must check for decorations, accidentals, octave shifts as well as identifying the note and its determining its duration. Unlike the other software modules, parseabc.c contains few global variables. The global variables linenum, inhead, inbody, parsing, slur, parserinchord indicate which lexical component of the abc tune is being processed. store.c ------- This is the most complex module consisting of almost 3000 lines of source code. This module contains all of the event handlers which may be invoked in the file parseabc.c. The main purpose of these handlers are to build up an internal representation of the abc file in the global memory arrays. This is a complete representation which allows the regeneration of the abc file (eg. abc2abc) or the creation of a midi file. The internal representation is used by the genmidi.c software to create the midi file. Global variables The internal representation is stored in global variables defined at the beginning of the file. A description of the most important variables is given here. The music is stored in the four arrays, feature, pitch, num, denom. These arrays contains a list of the lexical components in the order that they have been encountered or created. The array "feature" identifies the type of component which can be one of the following enum features. SINGLE_BAR, DOUBLE_BAR, BAR_REP, REP_BAR, REP1, REP2, BAR1, REP_BAR2, DOUBLE_REP, THICK_THIN, THIN_THICK, PART, TEMPO, TIME, KEY, REST, TUPLE, NOTE, NONOTE, OLDTIE, TEXT, SLUR_ON, SLUR_OFF, TIE, TITLE, CHANNEL, TRANSPOSE, RTRANSPOSE, GRACEON, GRACEOFF, SETGRACE, SETC, GCHORD, GCHORDON, GCHORDOFF, VOICE, CHORDON, CHORDOFF, SLUR_TIE, TNOTE, LT, GT, DYNAMIC, LINENUM, MUSICLINE, MUSICSTOP, WORDLINE, WORDSTOP The array pitch[] mainly stores the pitch of a musical note, represented in the same manner as in a midi file. Thus middle C has a value of 60. The array has other uses, for example in a LINENUM feature it stores the line number relative to the X: reference command where the lexical feature has been detected. The LINENUM feature is useful when reporting warnings or errors in the input file. Duration of the notes are represented as a fraction, where the standard unit is defined by the L: command. If feature[n] is a NOTE, then num[n] and denom[n] contain the numerator and denominator of this fraction. Here is an example of the contents of these arrays for the following small file in the same order that they are stored in these arrays. X: 1 T: sample M: 2/4 L: 1/8 K: G |: C>D[EF]G |C4:| Feature Pitch Num Denom LINENUM 2 0 0 TITLE 0 0 0 LINENUM 3 0 0 LINENUM 4 0 0 LINENUM 5 0 0 DOUBLE_BAR 0 0 0 LINENUM 6 0 0 MUSICLINE 0 0 0 BAR_REP 0 0 0 NOTE 60 2 3 NOTE 62 1 3 CHORDON 0 0 0 NOTE 64 1 2 NOTE 66 1 2 CHORDOFF 0 1 2 NOTE 67 1 2 SINGLE_BAR 0 0 0 NOTE 60 2 1 REP_BAR 0 0 0 MUSIC_STOP 0 0 0 LINENUM 7 0 0 In order to support multivoice abc files in the form V:1 | ...| ...|.... V:2 | ...| ...|.... % V:1 | ...| ...|.... V:2 | ...| ...|.... etc. abc2midi maintains a voicecontext structure for each voice. This allows each voice to define its own key signature, default note length using internal field commands. There is a head voicecontext which is used when no voice field commands are defined in the abc file. The v[] array maintains a set of all voices active in the abc file and voicecount keeps track of the number of voices. Similarly, abcmidi maintains a list of all the part stored in the feature[], pitch[], num[] and denom[] arrays. All text items (eg. title and some other fields) are stored in char atext[][] arrays, so that they can be included in the midi output file. The textual information is repeated in each track of the output midi file. Following the conventions in the midi file, the program uses the quarter note as the standard unit of time instead of the whole note. In contrast, the standard length in the abc file is based on the whole note. For example in L:1/8, the fraction refers to a whole note. In order to convert time units to quarter notes, the numerator of the time specifications for note lengths is multiplied by 4 when it is added to the feature list. Table of contents of procedures in store.c getarg(option, argc, argv) - gets run time arguments. newvoice(n) - creates a new voice context. getvoicecontext() - finds or makes a voice context. clearvoicecontexts() - frees up the memory of the voice context event_init() - called by main program event_text(s) - called when a line of text is encountered. event_reserved(p) - handles reserved character codes H-Z. event_tex(s) - called whenever a TeX command is encountered. event_linebreak() - called whenever a newline character is encountered. event_startmusicline() - called for each new music line. event_endmusicline() - called at the end of each music line. event_eof() - end of abc file encountered. event_fatal_error(s) - reports fatal error. event_error(s) - reports an error. event_warning(s) - reports a potential problem. event_comment(s) - called whenever a comment is encountered. event_specific(package, s) - recognizes %%package s. event_startinline() - beginning of an in-music field command. event_closeinline() - finishes an in-music field command. event_field(k,f) - for R:, T: and any other unprocessed field commands. event_words(p) - processes a w: field command. char_out(list,out,ch) - for building up a parts list in a P: command. read_spec() - converts P:A(AB)3 to P:AABABAB etc. event_part(s) - handles a P: field. char_break() - reports error for improper voice change. event_voice(n,s) - processes a V: field. event_length(n) - recognizes L: field event_blankline - starts finishfile() procedure. event_refno(n) - recognizes X: event_tempo(n, a, b, rel) - recognizes Q: event_timesig(n, m) - recognizes M: event_key(sharps, s, minor, modmap, modmul) - recognizes K: event_graceon() - start of grace notes, "{" encountered. event_graceoff() - end of grace notes, "}" encountered. event_rep1() - handles first repeat indicated by [1. event_rep2() - handles second repeat indicated by [2. event_slur(t) -called when s encountered in abc. event_sluron(t) called when "(" is encountered in abc. event_sluroff(t) called when ")" is encountered in abc. slurtotie() - converts slur into tied notes. event_tie() - handles tie indication "-". event_rest(n,m) - processes rest indication Z or z. event_bar(type) - processes various types of bar lines. event_space() - space character encountered. Ignored here. event_linend(ch,n) - handles line continuation at end of line (eg. \). event_broken(type, mult) - handles >, <, >> etc. in abc. event_tuple(n,q,r) - handles triplets and general tuplets. event_chord() - called whenever + is encountered. marknotestart() - remembers last few notes in voice context. marknoteend() - this is used to process broken rhythms (eg. >). marknote() - called for single note (as opposed to chord). event_chordon() - called whenever [ is encountered. event_chordoff() - called whenever ] is encountered. splitstring(s,sep,handler) - splits string with separator sep. event_instuction(s) - handles !...! event. getchordnumber(s) - searches known chords for chord s. addchordname(s, len, notes) - adds chord name to known chord list. event_gchord(s) - handles guitar chords. event_handle_gchord(s) - handler for guitar chords. event_handle_instruction(s) - handles dynamic indications (eg. !ppp!). event_finger(p) - handles 1,2,...5 in guitar chord field (does nothing). hornp(num,denom) - modifies rhythm to hornpipe. event_note(roll, staccato, updown, accidental, mult, note, octave, n, m) doroll(note,octave,n,m,pitch) - applies roll to note. dotrill(note,octave,n,m,pitch) - applies trill to note. pitchof(note,accidental,mult,octave) -finds MIDI pitch value setmap(sf,map,mult) - converts key signature to accidental map. altermap(v,modmap,modmul) - modifies accidental map. copymap(v) - sets up working accidental map at beginning of bar. addfeature(f,p,n,d) - places feature in internal tables. autoextend(maxnotes) - increase memory limits for feature arrays. textextend(maxstrings, stringarray) - resize array pointers to strings. myputc(c) - workaround for problems with PCC compiler. tiefix() - connect up tied notes. dotie(j,xinchord) - called in preprocessing stage to handle ties. addfrac(xnum,xdenom,a,b) - add a/b to the number of units in bar. applybroken(place, type, n) - adjust length of broken notes. brokenadjust() -adjust length of broken notes. applygrace() - assign lengths to grace notes. dograce() - assign lengths to grace notes. lenmul(n, a, b) - multiply num(n),denom(n) by a/b. zerobar() - start a new count of beats in the bar. delendrep() - remove bogus repeat. placeendrep(j) - patch up missing repeat. placestartrep(j) - patch up missing repeat. fixreps() - find and correct missing repeats in music. startfile() - initialization performed after an event_refno. tempounits(t_num, t_denom) - interprets Q: field. setbeat() - sets default gchord command for time signature. headerprocess() - called after the first K: field in tune. finishfile() - starts next stage of processing when end of tune is encountered. All the functions in this file respond to event calls from parseabc. Once the internal representation of the abc file is completed, the procedure finishfile is called to perform some clean up and create the midi file. An internal representation of the midi file is first created and then it is written onto the designated output file. As finishfile provides the link to the next module, genmidi.c, here is a brief description of what it does. proc finishfile performs several passes through the internal representation to clean up the graces (dograce), the tied notes (tiefix) and any unbalanced repeats. It then calls writetrack(i) for each midi track to create the internal midi representation and finally the midi representation is recorded in the output file. genmidi.c --------- The procedure finishfile described above, creates each midi track by calling the function writetrack which is defined here. To create a track from the internal representation, the program must find all the parts and put them in order with all the repeats. In addition, if it contains karaoke text, this too must be placed in a separate track. Any chordal accompaniment is generated from the guitar chord indications and placed in another track. For multivoice and multipart music, a voice may be missing in a particular part. If the voice is missing, the procedure fillvoice ensures that all voices remain properly aligned when the voice reappears in another part. Here is a simple road map to the important procedures included in this file. dodeferred is here used to handle any dynamic indications (eg. !ppp!) which may be contained in the file. The %%MIDI messages are stored in a atext string which is pointed to by the contents of the pitch[] array. checkbar is called each time a bar line is encountered and reports a warning if the wrong number of beats occur. Transitions between parts are handled by the procedure partbreak. There are a number of procedures for handling karoake text -- karaokestarttrack(), findwline(startline), getword(place,w), write_syllable(place) and checksyllables(). For the first track, the meter, tempo and key signature are recorded using the functions set_meter(n,m), write_meter(n,m), write_keysig(sf,mi). Chordal accompaniment is produced by the procedure dogchords(i). queues.c -------- For each midi note, it is necessary to send a note-on and a note-off instruction. When polyphonic music is played on the same track, keeping track of the time to issue a note-off instruction may get complicated. The procedures in this file are used to maintain a linked list for the notes to be turned off. The notes are put into the list in the order that they are encountered but the order in which to issue note-off commands is maintained by the links. As many as 50 notes playing simultaneously can be handled by the list. Addendum -------- The following section contains clarifications on various components of abc2midi. 29 June 2003 Treatment of octave shifts. The key signature field command K: has provision for shifting a note using either transpose= or octave= subcommands. Both of these functions operate quite differently and deserve some description especially for multivoiced tunes. The octave shift, is performed in event_note in store.c, using the cached value v.octaveshift which is stored in the global voicecontext structure, v. There is a structure for each voice in the abc file. Whenever a new V: command is encountered, event_voice (store.c) is invoked, which swaps the appropriate voices structure into the global v array using the function getvoicecontext(n). If getvoicecontext cannot find a cached structure for that voice, then a new voice structure is created and added to the linked list of voice structures. The v.octaveshift variable is updated by event_octave which is called by event_key (store.c) which is called by parsekey in parseabc.c (Comment: it is not too clear how an octave switch is handled in the middle of a repeat section. i.e. does the old value get restored when repeating.) (Description of transpose shift is in CHANGES July 1 2003.) abcmidi/doc/midicopy.10000644000000000000000000001114712425232236013615 0ustar rootroot.TH MIDICOPY 1 .SH NAME midicopy \- Copy selected track, channel, time interval of a MIDI file to another MIDI file .SH SYNOPSIS \fBmidicopy\fP [\fB-ver\fP] [\fB-trks\fP \fIn1,n2,..\fP]\ [\fB-xtrks\fP \fIn1,n2,..\fP]\ [\fB-chans\fP \fIn1,n2,...\fP]\ [\fB-from\fP \fIn (in midi ticks)\fP] [\fB-to\fP \fIn (in midi ticks)\fP]\ [\fB-fromsec %f\fP \fIn (in seconds)\fP] [\fB-tosec\fP \fIn (in seconds)\fP]\ [\fB-frombeat %f\fP \fIn (in beats)\fP] [\fB-tosec\fP \fIn (in beats)\fP]\ [\fB-replace\fP \fItrk,loc,val\fP] [\fB-tempo %n\fP] [\fB-speed %f\fP]\ [\fB-drumfocus\fP \fIn \fIm\fP] [\fB-mutenodrum [%d]\fP]\ [\fB-setdrumloudness\fP \fIn \fIm\fP]\ \fIinput.mid output.mid\fP .SH "DESCRIPTION" .PP .B midicopy is used to copy part of a MIDI file to another MIDI file. You can select a particular time interval, particular channels, and particular tracks or any combinations. If one or both of the run time parameters \-from or \-to are included, the program returns the playing time in seconds of the output file. Midicopy was developed by Seymour Shlien from the midifilelib distribution available from .IR http://www.harmony-central.com/MIDI/midifilelib.tar.gz . .SH OPTIONS .TP .B -ver prints version number and then exits .TP .B -trks n1,n2, etc Selects the tracks to be copied where the track numbers start from 1. If more than one track is specified, they should be separated by commas. You should always copy track 1 since by convention it contains information pertinent to all the other tracks. By default all tracks are copied unless you specify particular tracks using this run time parameter. .TP .B -xtrks n1,n2, etc Lists the tracks to exclude from copying. All other tracks are copied. This option does not work in combination with \-trks. .TP .B -chns n Like above, it specifies the MIDI channels to be copied. By default all channels are copied. Channel numbers also start from 1. .TP .B -from n The program will copy all MIDI commands starting from midi pulse number n. By default it will start from time zero or the beginning of the MIDI file. .TP .B -to n Stops copying all events after midi pulse number n. By default the file is copied to the end. .TP .B -frombeat n The program will copy all MIDI commands starting from quarter beat number n. By default it will start from time zero or the beginning of the MIDI file. .TP .B -tobeat n Stops copying all events after quarter beat number n. By default the file is copied to the end. .TP .B -fromsec n The program will copy all MIDI commands starting from time n in seconds. .TP .B -tosec n Stops copying all events after time n in seconds. These two options (\-fromsec and \-tosec) do not work accurately if the MIDI file has more than one tempo command. Only the first one is used for converting seconds into MIDI pulse units. It is therefore preferable to use the \-from and \-to options. .TP .B -replace trk,loc,val This option should be used alone. Midicopy will copy the entire file verbatim except it will replace a byte by val, where the byte is located in the specified track (trk) and specified position (loc). Commonly this function is used for changing a particular MIDI program number (instrument) associated with a channel. You need to know the byte count in the track of that parameter in order to use this function, .TP .B -tempo quarter notes/minute All tempo indications in the midi file will be replaced with the above value. .TP .B -speed factor All tempo indications in the midi file will be multiplied with this factor. Values greater than 1.0 will speed up the music while lower values slow the music. The factor is a floating point value. .TP .B -drumfocus drum-code excluded_drum_velocities The selected drum line (specified by the drum-code pitch value) is highlighted by reducing the loudness of all other drum lines to the excluded_drum_velocities value. The drum-code value must be in the range of 35 to 81 inclusive. .TP .B -mutenodrum [level] All channels which are not 9 (drum channel) are attenuated to the given level. If level is not specified, it is assumed to be zero. .TP .B -setdrumloudness n m where n is between 35 to 81 inclusive and m is the loudness between 0 and 127. The loudness of all instances of drum n are changed to m. .SH EXAMPLE .B midicopy.exe -trks 1,5 -from 2669 -to 8634 uzicko.mid fragment.mid Midicopy will copy tracks 1 and 5 starting from midi pulse position 2669 and ending at MIDI pulse position 8634. .SH "SEE ALSO" .PP .IR abcmtex "(1), " abc2abc "(1), " abc2midi "(1), " midi2abc "(1) ", yaps "(1)" .SH AUTHOR This manual page was written by Seymour Shlien. .SH VERSION This man page describes midicopy version 1.20 from October 28 2013. abcmidi/doc/abcmatch.10000644000000000000000000001223512425232230013533 0ustar rootroot.TH ABCMATCH 1 .SH NAME abcmatch \- Search for specific sequences of notes in an abc file composed of many tunes. .SH SYNOPSIS \fBabcmatch\fP \fiabc\ file\fP [\fB-c\fP] [\fB-v\fP] [\fB-r\fP] [\fB-con\fP]\ [\fB-fixed nn\fP] [\fB-qnt\fP] [\fB-lev\fP] [\fB-a\fP] [\fB-ign\fP]\ [\fB-br %d\fP] [\fB-tp abc reference file\fP] [\fB-ver\fP]\ [\fB-pitch_hist\fP] [\fB-wpitch_hist\fP] [\fB-length_hist\fP]\ [\fB-interval_hist\fP] [\fB-pitch_table\fP] [\fB-interval_table\fP]\ \fireference\ number\fP .SH "DESCRIPTION" .PP .B abcmatch is used to search for specific sequences of notes in an abc file composed of many tunes. For example, if you know a few bars of a tune, you can use this program to find the tune having this sequence and perhaps identify the tune. At a minimum, abcmatch requires two files. A template file called match.abc which contains the bars that you are searching for and a large file consisting of a hundred or more abc tunes. The program automatically loads up the match.abc file and then scans every tune in the large file .SH OPTIONS .TP .B -v and -c mainly used for debugging when the program does not do what was expected. .TP .B -ver prints version number and then exits .TP .B --norhythm Causes the matching algorithm to ignore the length of notes in a bar, thus E3/2F/D GA2 would match EFD G2A. The option ignores \-r parameter since it is now irrelevant. .TP .B -pitch_table Used to produce a interval weighted pitch histogram for each tune in the file. If this is saved in an external file, that file could be used as a database for finding tunes with similar pitch probability density functions (pdf). .TP .B -r Controls how the matching criterion handles small rhythm variations in the melody. The \-r option must be followed by a number which specifies the temporal resolution for the match. When the number is zero, this indicates that a perfect match should be performed, meaning that the lengths of each note in the bar must match exactly in order to be reported. For larger values a looser match will be performed as described below. Note lengths are converted into temporal units where a quarter note normally is assigned a value of 24. Therefore an eight note has a value of 12, a sixteenth has a value of 6, a half note has a value of 48 and etc. If you specify a temporal resolution of 12, then the pitch values of the notes only need to match at time units which are multiples of an eighth note. .TP .B -fixed n Causes the program to disregard bar lines when does the matching. It allows matching of notes between tunes having different time signatures. n is a number which specifies the exact number of notes to match. For example if n is 4, the program could match |C E G E| .. with |C E|G E| Note the matcher still starts at a beginning of a given bar for both the tune and template. .TP .B -con Specifies contour matching. In this case, the program uses the key signature only to indicate accidentals. The pitch contour is computed from the pitch difference or interval between adjacent notes. .TP .B -qnt Uses the contour matching algorithm but also quantizes the intervals using the following table: unison and semitone 0 minor 2nd to major 2nd 1 minor 3rd to major 3rd 2 any larger interval 3 Negative numbers are descending intervals. .TP .B -tp file name, reference number Substitute any tune for the template match.abc. When using this feature, the entire tune is used as a template. Abcmatch does not match the template with itself, and only bars which match bars in other tunes are reported. .TP .B -br threshold Runs the program in a brief mode designed to identify groups of tunes sharing common bars. In this mode, the program counts the numbers of bars in the test tune which are also present in match.abc. If the number of common bars is larger or equal to the threshold then the program reports the tune and the number of common bars. The program scans all the tunes in the abc file and returns a list of all the tunes which have more than a specific number of bars in common with the template, match.abc. In actual use, the program is run repeatedly by a script. For each tune in a abc file, it creates a template file called match.abc and then executes abcmatch. The outputs are displayed on the screen in a form easy to interpret. The user has no control of the matching criterion. The rhythm must match exactly and the notes are transposed to suit the key signature. In other words the \-r parameter is independent of what is specified in the parameter list. .TP .B -pitch_hist or -length_hist Runs the program in another mode. It produces a histogram of the distribution of the notes in the abc file. The pitch is indicated in midi units. Thus middle C is 60 and the pitches go up in semitone units. Following the pitch is a count of the number of times that note occurred. .TP .B -pitch_table or -interval_table Used to create a database for a collection of tunes in a file for future analysis. .SH "SEE ALSO" .PP .IR abc2abc "(1), " abc2midi "(1), " mftext "(1) ", midi2abc "(1) ", midicopy "(1) ", yaps "(1)" .SH AUTHOR This manual page was written by Ross Gammon based on abcmatch.txt by Seymour Shlien. .SH VERSION This man page describes abcmatch version 1.35 from January 15 2006. abcmidi/doc/readme.txt0000644000000000000000000005206113032167444013717 0ustar rootrootabcMIDI : abc <-> MIDI conversion utilities midi2abc version 3.01 January 01 2017 abc2midi version 3.90 September 25 2016 abc2abc version 1.88 September 25 2016 yaps version 1.65 September 25 2016 abcmatch version 1.70 November 15 2015 midicopy version 1.22 November 15 2015 24th January 2002 Copyright James Allwright J.R.Allwright@westminster.ac.uk University of Westminster, London, UK January 2017 Seymour Shlien fy733@ncf.ca This is free software. You may copy and re-distribute it under the terms of the GNU General Public License version 2 or later, which is available from the Free Software Foundation (and elsewhere). This package is to be found on the web at http://abc.sourceforge.net/abcMIDI/ (The latest versions for the time being is found on ifdo.pugmarks.com/~seymour/runabc/top.html.) Note, if you have difficulty compiling the package because you do not have snprintf see the note in doc/CHANGES dated January 08 2005 (and also December 17 2004). These programs make use of the 'midifilelib' public domain MIDI file utilities, available from http://www.harmony-central.com/MIDI/midifilelib.tar.gz If you have the source distribution and intend to re-compile the code, read the file coding.txt. --------------------------------------------------------------------- midi2abc - program to convert MIDI format files to abc notation. This program takes a MIDI format file and converts it to something as close as possible to abc text format. The user then has to add text fields not present in the MIDI header and possibly tidy up the abc note output. Features : * The key is chosen so as to minimize the number of accidentals. Alternatively, the user can specify the key numerically (a positive number is the number of sharps, a negative number is minus the number of flats). * Note length can be set by specifying the total number of bars or the tempo of the piece. Alternatively the note length can be read from the file. However, by default it is deduced in a heuristic manner from the inter-note distances. This means that you do not have to use the MIDI clock as a metronome when playing in a tune from a keyboard. * Barlines are automatically inserted. The user specifies the number of measures in the anacrusis before the first barline and the time signature. * The program can guess how many beats there should be in the anacrusis, either by looking for the first strong note or minimizing the number of notes split by a tie across a barline. * Where a note extends beyond a bar break, it is split into two tied notes. * The output has 4 bars per line. * Enough accidental signs are put in the music to ensure that no pitch errors occur if a barline is added or deleted. * The program attempts to group notes sensibly in each bar. * Triplets and broken rhythm (a>b) are supported. * Chords are identified. * Text information from the original MIDI file is included as comments. * The -c option can be used to select only 1 MIDI channel. Events on other channels are ignored. What midi2abc does not do : * Supply tune title, composer or any other field apart from X: , K:, Q:, M: and L: - these must be added by hand afterwards, though they may have been included in the text of the MIDI file. * Support duplets, quadruplets, other esoteric features. * Support mid-tune key or meter changes. * Deduce repeats. The output is just the notes in the input file. * Recover an abc tune as supplied to abc2midi. However, if you want to do this, "midi2abc -xa -f file.mid" comes close. midi2abc usage : midi2abc -a -xa extract anacrusis from file (find first strong note) -ga guess anacrusis (minimize ties across bars) -gk guess key signature by minimizing accidentals -gu guess the number of midi pulses per note from note duration statistics in the MIDI file -m