pxt-common-packages 10.3.1 → 10.3.3

package/libs/mixer/melody.h

@@ -31,7 +31,7 @@ struct SoundInstruction {
 
 namespace music {
 
-#define MAX_SOUNDS 5
+#define MAX_SOUNDS 8
 
 STATIC_ASSERT((1 << (16 - OUTPUT_BITS)) > MAX_SOUNDS);
 

package/libs/mixer/melody.ts

@@ -313,7 +313,7 @@ namespace music {
         }
     }
 
-    function addNote(sndInstr: Buffer, sndInstrPtr: number, ms: number, beg: number, end: number, soundWave: number, hz: number, volume: number, endHz: number) {
+    export function addNote(sndInstr: Buffer, sndInstrPtr: number, ms: number, beg: number, end: number, soundWave: number, hz: number, volume: number, endHz: number) {
         if (ms > 0) {
             sndInstr.setNumber(NumberFormat.UInt8LE, sndInstrPtr, soundWave)
             sndInstr.setNumber(NumberFormat.UInt8LE, sndInstrPtr + 1, 0)
@@ -583,6 +583,34 @@ namespace music {
         }
     }
 
+    let currentSequencer: sequencer.Sequencer;
+
+    //% shim=TD_ID
+    //% blockId=music_song_field_editor
+    //% block="$song"
+    //% song.fieldEditor=musiceditor
+    export function _songFieldEditor(song: Buffer) {
+        return song;
+    }
+
+    //% blockId=music_start_song
+    //% block="start song $song looping $loop"
+    //% song.shadow=music_song_field_editor
+    export function startSong(song: Buffer, loop: boolean) {
+        if (currentSequencer) currentSequencer.stop();
+
+        currentSequencer = new sequencer.Sequencer(new sequencer.Song(song));
+        currentSequencer.start(loop);
+    }
+
+    export function playInstructions(when: number, instructions: Buffer) {
+        queuePlayInstructions(when, instructions);
+    }
+
+    export function lookupFrequency(note: number) {
+        return freqs.getNumber(NumberFormat.UInt16LE, note * 2) || 0
+    }
+
     //% fixedInstance whenUsed block="ba ding"
     export const baDing = new Melody('b5:1 e6:3')
 

package/libs/mixer/pxt.json

@@ -14,6 +14,8 @@
         "targetoverrides.ts",
         "music.ts",
         "soundEffect.ts",
+        "instrument.ts",
+        "sequencer.ts",
         "pxtparts.json",
         "headphone.svg"
     ],

package/libs/mixer/sequencer.ts

@@ -0,0 +1,88 @@
+namespace music.sequencer {
+    export class Sequencer {
+        currentTick: number;
+        isPlaying: boolean;
+        isLooping: boolean;
+        isRunning: boolean;
+
+        constructor(public song: Song) {
+            this.currentTick = 0;
+            this.isPlaying = false;
+            this.isLooping = false;
+        }
+
+        start(loop: boolean) {
+            this.currentTick = 0;
+            this.isLooping = loop;
+            this.isPlaying = true;
+
+            if (this.isRunning) return;
+            this.isRunning = true;
+
+            control.runInParallel(() => {
+                while (this.isPlaying) {
+                    this.scheduleCurrentTick();
+
+                    this.currentTick ++;
+
+                    if (this.currentTick >= this.song.beatsPerMeasure * this.song.measures * this.song.ticksPerBeat) {
+                        if (this.isLooping) this.currentTick = 0;
+                        else this.isPlaying = false;
+                    }
+
+                    pause(this.tickToMs(1))
+                }
+                this.isRunning = false;
+            })
+        }
+
+        stop() {
+            this.isPlaying = false;
+        }
+
+        tickToMs(ticks: number) {
+            return ((60000 / this.song.beatsPerMinute) / this.song.ticksPerBeat) * ticks;
+        }
+
+        protected scheduleCurrentTick() {
+            for (const track of this.song.tracks) {
+                if (track.currentNoteEvent.startTick === this.currentTick) {
+                    if (track.isMelodicTrack) {
+                        this.scheduleMelodicTrack(track as MelodicTrack);
+                    }
+                    else {
+                        this.scheduleDrumTrack(track as DrumTrack);
+                    }
+
+                    track.advanceNoteEvent();
+                }
+            }
+        }
+
+        protected scheduleMelodicTrack(track: MelodicTrack) {
+            for (let i = 0; i < track.currentNoteEvent.polyphony; i++) {
+                playInstructions(
+                    0,
+                    renderInstrument(
+                        track.instrument,
+                        lookupFrequency(track.currentNoteEvent.getNote(i)),
+                        this.tickToMs(track.currentNoteEvent.endTick - track.currentNoteEvent.startTick),
+                        music.volume()
+                    )
+                );
+            }
+        }
+
+        protected scheduleDrumTrack(track: DrumTrack) {
+            for (let i = 0; i < track.currentNoteEvent.polyphony; i++) {
+                playInstructions(
+                    0,
+                    renderDrumInstrument(
+                        track.drums[track.currentNoteEvent.getNote(i)],
+                        music.volume()
+                    )
+                );
+            }
+        }
+    }
+}