Repro steps:

1. Choose a generator (e.g. square osc.)
2. Add an echo effect with some delay and gain 0

Expected: the note sound reproduces only ONE time and then silence
Got: we got the sound reproduced ONE time and then the echo effect with arbitrary gain value (the default?)

This:

var stopC =  MUSIC.Curve.Ramp(1260, 1260/2, 100).during(0.2);
...
.oscillator({type: 'sine', frequency: stopC}
...

Should result in on sine sound doing dropoff from freq 1260 to 1260/2

See https://developer.mozilla.org/en-US/docs/Web/API/OscillatorNode/setPeriodicWave for more info

For example, echo nodes should default to delay=0.4 and gain=0.5

Automatic type conversion to prevent user to have to worry about what wrapper should be used on each situation. For example, you should be able to use a simple playable (e.g. a sound) as instrument

iseq("A A A   A", music.sound("src/sound/Kick 1.wav"));

Only need TWO params: base and top
Linear scale from [-1, 1] to [base, top]

Currently, sequences doesnt respond to stop. e.g. arpeggiators can't be silenced in the middle of an iteration

Implement record capability for all nodes, record of any playable

var gainNode = music.gain(1.0)
...
...
var playable = gainNode.
        ..
        ...

playable.record(gainNode, "filename.wav")
...

nseq("*CDE")

Would stretch "CDE" sequence to fill four pulses

Examples:
*On echo node, delay should be a value between 0 and 1, gain should be a value between 0 and 0.99

Steps to reproduce:

1. Add oscillator of type square
2. Add envelop
3. Arpeggiate on keyboard using the mouse as quick as you can

Get:

• From time to time, you will hear a note without attack phase

Expected:

• ALL notes plays with adsr envelope including attack phase

Use gulp-connect

NOTE: Use bootstrap template (see http://startbootstrap.com/template-categories/all/)

This pattern is repeated a lot:

      return baseGainNode
              .noise()
              .onStop(function(){baseGainNode.dispose(); }) // dispose gain node
              .stopDelay(100)
              .onStop(function(){ baseGainNode .setParam('gain', stopCurve); }); // set gain curve

notes: use ui-sortable (https://github.com/angular-ui/ui-sortable)

Using pipe character "|", this character should be ignored on string, so:

"C4D4E4C4|D4C4====|....A#4=|F4==...." produces the same result as
"C4D4E4C4D4C4====....A#4=F4==...."

Starting with multi-instrument component, nested components should be added through special directives for list of inner components

NOTE: at first, separate multiple-components using tabs

See http://www.phy.mtu.edu/~suits/notefreqs.html

Use grunt, bower or whatever we need to generate "music.js" and "music.min.js" with only one command

Sample count is particular to webaudio curve parameters

Example: drag an "fx" from left panel to instrument composition

Two modes:

1. Waveform
   Options:

• Period:
• Automatic
• Fixed
• Period multiplier (X1,X2,X3,X4,etc,,,) , only integer values

2. frequency map (center main frequency)

Repro steps:

1. Choose a generator (e.g. square osc.)
2. Add an echo effect with some delay and gain 0.001 (0 will NOT work because of another bug :P )

Expected: the note sound reproduces only ONE time
Got: we got the sound reproduced TWO times at equal volume level separated by delay

Backward compatibility with examples if possible

Desirable features:

• Espatial-temporal relation, for example four characters equal one beat, flexible according user needs
• Notes are named CDEFGAB and can be altered using # and b and the octave number. So
  F
  F#
  F#4
  F 4
  ...Are all valid notes

Capital letters should act as separators and spaces are silence, example
"A B C=F#4FFF"
It plays:
A semiquaver,
silence semiquaver
B semiquaver
silence semiquaver
C quaver
F# octave 4 quaver + semiquaver duration note
and finally three F semiquavers

REmember on any situation the duration of the note is proportional to the lenght of the notation on character string plus the = extension

• Insert of any playable object using aliases, for example
  seq("ABCDXAAAX", {X: snareSound});
• Key Signature allowing alteration of any note, notes can be de-altered on notation using dash, example:

"F=F=F-F-"
It should play two sustained F and then two unaltered F

Allow trigger ADSR start using noteOn events to allow reusable adsr modulations (alternative to notesplit)

By implemented component basic system. Could be angular-bound

Components of music.js has TWO main parts:

• Template to edit data objects (HTML/Angular including needed CSS and other assets)
• Script to make live objects (e.g. instruments, sounds, songs, wave forms, etc...) from data objects

Accessory:

• javascript function to initialize objects to default state
• Manifest on json format

Allow applying ADSR envelope on any pipeline, there is three main parametric numeric values:

• Attack time (time taken to rise volume from zero to max)
• Decay time (time taken to down volume from max to sustain volume)
• Release time (time taken to down volumen from sustain level to zero after key is released)

More info: http://en.wikipedia.org/wiki/Synthesizer#ADSR_envelope

For example, you can modulate the frequency or detune of an oscillator with another periodic wave to generate a vibrato effect. Or you can modulate a gain node to generate ADSR effect

Example:

// create the sound generator
var soundGenerator = {
  freq: function(fr) {
    var osc = music.oscillator({type: 'square', detune: MUSIC.modulator(function(p) {
      return p.gain(50).oscillator({type: "sine", frequency: 1.0});
    }));
  }
};

// add instrument to show on UI
return new MUSIC.Instrument(soundGenerator);

Cannot play two notes at the same time due a recent fix (0ea334e)

This would serve to reuse a single component for many effects, etc...

NOTE: define a new angular directive

It should simply return ONE object and should not requires any structure, array or plain object wrapping the result of the script

Example:

// create the sound generator
var soundGenerator = {
  freq: function(fr) {
    return music.
            ADSR({
              node: function(node) {
                return node.oscillator({type: 'square', frequency: fr});
              }, 
              attackTime: 0.2,
              decayTime: 0.2,
              releaseTime: 0.2,
              sustainLevel: 0.8
            });
  }
};

// create the instrument from sound generator
return new MUSIC.Instrument(soundGenerator)
                .mapNote(function(n) { return n + 36; });

On script component implementation:

module.export = function(MusicContext) {
    return function(object){
        var results = MusicContext.run(object.code);
        if (results.error) {
            object.codeError = results.error;
        } else {
            object.codeError = null;
        }
        return results.returnedObject;
    };
};

parameters

• Scale (minor and major scale)
• Note duration
• Note count