MidiCompiler.java

package com.github.dakusui.symfonion.core;

import com.github.dakusui.logias.Logias;
import com.github.dakusui.logias.lisp.Context;
import com.github.dakusui.logias.lisp.s.Literal;
import com.github.dakusui.logias.lisp.s.Sexp;
import com.github.dakusui.symfonion.exceptions.ExceptionThrower;
import com.github.dakusui.symfonion.utils.Fraction;
import com.github.dakusui.symfonion.exceptions.SymfonionException;
import com.github.dakusui.symfonion.utils.Utils;
import com.github.dakusui.symfonion.song.*;
import com.github.dakusui.symfonion.song.Pattern.Parameters;
import com.google.gson.JsonArray;

import javax.sound.midi.*;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import static com.github.dakusui.symfonion.exceptions.ExceptionThrower.*;
import static com.github.dakusui.symfonion.exceptions.ExceptionThrower.ContextKey.JSON_ELEMENT_ROOT;

public class MidiCompiler {

  private final Context logiasContext;

  public MidiCompiler(Context logiasContext) {
    this.logiasContext = (logiasContext);
  }

  /**
   * Compiles a {@link Song} object into a map from a port name to {@link Sequence} object.
   *
   * @param song An object that holds user-provided music data.
   * @return A map from a port name to {@code Sequence} object.
   * @throws InvalidMidiDataException Won't be thrown.
   * @throws SymfonionException       Undefined part name is referenced by a bar.
   */
  public Map<String, Sequence> compile(Song song) throws InvalidMidiDataException, SymfonionException {
    System.err.println("Now compiling...");
    int resolution = 384;
    Map<String, Sequence> ret = new HashMap<>();
    Map<String, Track> tracks;
    tracks = new HashMap<>();
    for (String partName : song.partNames()) {
      Part part = song.part(partName);
      String portName = part.portName();
      Sequence sequence = ret.get(portName);
      if (sequence == null) {
        sequence = new Sequence(Sequence.PPQ, resolution / 4);
        ret.put(portName, sequence);
      }
      tracks.put(partName, sequence.createTrack());
    }

    ////
    // position is the offset of a bar from the beginning of the sequence.
    // Giving the sequencer a grace period to initialize its internal state.
    long barPositionInTicks = 0; //= resolution / 4;
    int barid = 0;
    for (Bar bar : song.bars()) {
      try (var ignored = context($(JSON_ELEMENT_ROOT, bar.rootJsonObject()))) {
        barStarted(barid);
        Groove groove = bar.groove();
        for (String partName : bar.partNames()) {
          partStarted(partName);
          Track track = tracks.get(partName);
          if (track == null) {
            aborted();
            throw partNotFound(bar.lookUpJsonNode(partName), partName);
          }
          int channel = song.part(partName).channel();
          for (List<Pattern> patterns : bar.part(partName)) {
            ////
            // relativePosition is a relative position from the beginning
            // of the bar the pattern belongs to.
            Fraction relPosInBar = Fraction.zero;
            for (Pattern each : patterns) {
              Parameters params = each.parameters();
              patternStarted();
              for (Stroke stroke : each.strokes()) {
                try {
                  Fraction endingPos = Fraction.add(relPosInBar, stroke.length());

                  stroke.compile(
                      this,
                      new MidiCompilerContext(
                          track,
                          channel,
                          params,
                          relPosInBar,
                          barPositionInTicks,
                          groove
                      )
                  );

                  relPosInBar = endingPos;
                  ////
                  // Breaks if relative position goes over the length of the bar.
                  if (Fraction.compare(relPosInBar, bar.beats()) >= 0) {
                    break;
                  }
                } finally {
                  strokeEnded();
                }
              }
              patternEnded();
            }
          }
          partEnded();
        }
        barEnded();
        barid++;
        barPositionInTicks += (long) (bar.beats().doubleValue() * resolution);
      }
    }
    System.err.println("Compilation finished.");
    return ret;
  }

  public MidiEvent createNoteOnEvent(int ch, int nKey, int velocity, long lTick) throws InvalidMidiDataException {
    return createNoteEvent(ShortMessage.NOTE_ON,
        ch,
        nKey,
        velocity,
        lTick);
  }

  public MidiEvent createNoteOffEvent(int ch, int nKey, long lTick) throws InvalidMidiDataException {
    return createNoteEvent(ShortMessage.NOTE_OFF,
        ch,
        nKey,
        0,
        lTick);
  }

  protected MidiEvent createNoteEvent(int nCommand,
                                      int ch,
                                      int nKey,
                                      int nVelocity,
                                      long lTick) throws InvalidMidiDataException {
    ShortMessage message = new ShortMessage();
    message.setMessage(nCommand,
        ch,
        nKey,
        nVelocity);
    return new MidiEvent(message,
        lTick);
  }

  public MidiEvent createProgramChangeEvent(int ch, int pgnum, long lTick) throws InvalidMidiDataException {
    ShortMessage message = new ShortMessage();
    message.setMessage(ShortMessage.PROGRAM_CHANGE, ch, pgnum, 0);

    return new MidiEvent(message, lTick);
  }

  public MidiEvent createSysexEvent(int ch, JsonArray arr, long lTick) throws InvalidMidiDataException {
    SysexMessage message = new SysexMessage();
    Context lctxt = this.logiasContext.createChild();
    Sexp channel = new Literal(ch);
    lctxt.bind("channel", channel);
    Logias logias = new Logias(lctxt);
    Sexp sysexsexp = logias.buildSexp(arr);
    Sexp sexp = logias.run(sysexsexp);
    if (Sexp.nil.equals(sexp)) {
      return null;
    }
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    baos.write(SysexMessage.SYSTEM_EXCLUSIVE);    // status: SysEx start
    Iterator<Sexp> i = sexp.iterator().assumeList();
    while (i.hasNext()) {
      Sexp cur = i.next();
      baos.write((byte) cur.asAtom().longValue());
    }
    baos.write(SysexMessage.SPECIAL_SYSTEM_EXCLUSIVE);    // End of exclusive
    try {
      baos.close();
    } catch (IOException e) {
      throw ExceptionThrower.runtimeException(e.getMessage(), e);
    }
    byte[] data = baos.toByteArray();
    message.setMessage(data, data.length);
    return new MidiEvent(message, lTick);
  }

  public MidiEvent createControlChangeEvent(int ch, int controllernum, int param, long lTick) throws InvalidMidiDataException {
    ShortMessage message = new ShortMessage();
    message.setMessage(ShortMessage.CONTROL_CHANGE, ch, controllernum, param);
    return new MidiEvent(message, lTick);
  }

  public MidiEvent createBankSelectMSBEvent(int ch, int bkmsb, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 0, bkmsb, lTick);
  }

  public MidiEvent createBankSelectLSBEvent(int ch, int bklsb, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 32, bklsb, lTick);
  }

  public MidiEvent createVolumeChangeEvent(int ch, int volume, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 7, volume, lTick);
  }

  public MidiEvent createPanChangeEvent(int ch, int pan, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 10, pan, lTick);
  }

  public MidiEvent createReverbEvent(int ch, int depth, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 91, depth, lTick);
  }

  public MidiEvent createChorusEvent(int ch, int depth, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 93, depth, lTick);
  }

  public MidiEvent createPitchBendEvent(int ch, int depth, long lTick) throws InvalidMidiDataException {
    ShortMessage message = new ShortMessage();
    message.setMessage(ShortMessage.PITCH_BEND, ch, 0, depth);
    return new MidiEvent(message, lTick);
  }

  public MidiEvent createModulationEvent(int ch, int depth, long lTick) throws InvalidMidiDataException {
    return createControlChangeEvent(ch, 1, depth, lTick);
  }

  public MidiEvent createAfterTouchChangeEvent(int ch, int v, long lTick) throws InvalidMidiDataException {
    ShortMessage message = new ShortMessage();
    message.setMessage(ShortMessage.CHANNEL_PRESSURE, ch, v, 0);
    return new MidiEvent(message, lTick);
  }

  public MidiEvent createTempoEvent(int tempo, long lTick) throws InvalidMidiDataException {
    int mpqn = 60000000 / tempo;
    MetaMessage mm = new MetaMessage();
    byte[] data = Utils.getIntBytes(mpqn);
    mm.setMessage(0x51, data, data.length);
    return new MidiEvent(mm, lTick);
  }

  public void noteProcessed() {
    System.out.print(".");
  }

  public void controlEventProcessed() {
    System.out.print("*");
  }

  public void sysexEventProcessed() {
    System.out.print("X");
  }

  public void barStarted(int barid) {
    System.out.println("bar[" + barid + "]");
  }

  public void patternStarted() {
    System.out.print("[");
  }

  public void patternEnded() {
    System.out.print("]");
  }

  public void barEnded() {
  }

  public void partStarted(String partName) {
    System.out.print("    " + partName + ":");
  }

  public void strokeEnded() {
    System.out.print("|");
  }

  public void partEnded() {
    System.out.println();
  }

  public void aborted() {
    System.out.println("aborted.");
  }

  public void noteSetProcessed() {
    System.out.print(";");
  }
}





























































Active mutators

CONDITIONALS_BOUNDARY
EMPTY_RETURNS
FALSE_RETURNS
INCREMENTS
INVERT_NEGS
MATH
NEGATE_CONDITIONALS
NULL_RETURNS
PRIMITIVE_RETURNS
TRUE_RETURNS
VOID_METHOD_CALLS

Tests examined

com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[0: POSITIVE: given: 'top level attributes are all empty' when: 'compile' then: 'empty song'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (11 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[1: POSITIVE: given: 'no pattern in sequence is given' when: 'compile' then: 'empty song'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (8 ms)
com.github.dakusui.symfonion.tests.cli.subcommands.CompileTest.test(com.github.dakusui.symfonion.tests.cli.subcommands.CompileTest) (18 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[2: POSITIVE: given: 'pattern contains no explicit event' when: 'compile' then: 'one message (end of sequence) is found'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (9 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[7: POSITIVE: given: 'sixteenth note with short gate (0.25)' when: 'compile' then: 'number of events and tick length seem ok'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (6 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[8: POSITIVE: given: 'a note and controls (program change, volume, pan, chorus, reverb, modulation, and pitch)' when: 'compile' then: 'note on/off, program change, and volume are included.'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (6 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[9: POSITIVE: given: 'a note and an 'arrayable' control (volume)' when: 'compile' then: 'arrayable control expanded.'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (6 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[3: POSITIVE: given: 'pattern contains note on, note off, program change, and bank change (LSB and MSB)' when: 'compile' then: 'number of events and tick length seem ok'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (12 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[6: POSITIVE: given: 'sixteen notes are given in two string elements' when: 'compile' then: 'number of events and tick length seem ok'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (16 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[11: POSITIVE: given: 'a note and an 'arrayable' control (volume) with nulls' when: 'compile' then: 'arrayable control expanded replacing dots with intermediate values.'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (18 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[5: POSITIVE: given: 'sixteen notes are given in a single string element' when: 'compile' then: 'number of events and tick length seem ok'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (26 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[10: POSITIVE: given: 'a note and an 'arrayable' control (volume) with nulls' when: 'compile' then: 'arrayable control expanded replacing nulls with intermediate values.'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (31 ms)
com.github.dakusui.symfonion.tests.MidiCompilerTest.exercise[4: POSITIVE: given: 'sixteen notes are given in a single string element' when: 'compile' then: 'number of events and tick length seem ok'](com.github.dakusui.symfonion.tests.MidiCompilerTest) (44 ms)
com.github.dakusui.symfonion.tests.InvalidJsonErrorTest.missingSection_parts(com.github.dakusui.symfonion.tests.InvalidJsonErrorTest) (23 ms)
com.github.dakusui.symfonion.tests.ReferenceErrorTest.missingPart(com.github.dakusui.symfonion.tests.ReferenceErrorTest) (28 ms)

Report generated by PIT 1.15.3

1		package com.github.dakusui.symfonion.core;
2
3		import com.github.dakusui.logias.Logias;
4		import com.github.dakusui.logias.lisp.Context;
5		import com.github.dakusui.logias.lisp.s.Literal;
6		import com.github.dakusui.logias.lisp.s.Sexp;
7		import com.github.dakusui.symfonion.exceptions.ExceptionThrower;
8		import com.github.dakusui.symfonion.utils.Fraction;
9		import com.github.dakusui.symfonion.exceptions.SymfonionException;
10		import com.github.dakusui.symfonion.utils.Utils;
11		import com.github.dakusui.symfonion.song.*;
12		import com.github.dakusui.symfonion.song.Pattern.Parameters;
13		import com.google.gson.JsonArray;
14
15		import javax.sound.midi.*;
16		import java.io.ByteArrayOutputStream;
17		import java.io.IOException;
18		import java.util.HashMap;
19		import java.util.Iterator;
20		import java.util.List;
21		import java.util.Map;
22
23		import static com.github.dakusui.symfonion.exceptions.ExceptionThrower.*;
24		import static com.github.dakusui.symfonion.exceptions.ExceptionThrower.ContextKey.JSON_ELEMENT_ROOT;
25
26		public class MidiCompiler {
27
28		private final Context logiasContext;
29
30		public MidiCompiler(Context logiasContext) {
31		this.logiasContext = (logiasContext);
32		}
33
34		/**
35		* Compiles a {@link Song} object into a map from a port name to {@link Sequence} object.
36		*
37		* @param song An object that holds user-provided music data.
38		* @return A map from a port name to {@code Sequence} object.
39		* @throws InvalidMidiDataException Won't be thrown.
40		* @throws SymfonionException Undefined part name is referenced by a bar.

MidiCompiler.java

Mutations

Active mutators

Tests examined