wavesurfer 0.0.1

data/vendor/assets/javascripts/src/webaudio.js

@@ -0,0 +1,385 @@
+'use strict';
+
+WaveSurfer.WebAudio = {
+    scriptBufferSize: 256,
+    PLAYING_STATE: 0,
+    PAUSED_STATE: 1,
+    FINISHED_STATE: 2,
+
+    supportsWebAudio: function () {
+        return !!(window.AudioContext || window.webkitAudioContext);
+    },
+
+    getAudioContext: function () {
+        if (!WaveSurfer.WebAudio.audioContext) {
+            WaveSurfer.WebAudio.audioContext = new (
+                window.AudioContext || window.webkitAudioContext
+            );
+        }
+        return WaveSurfer.WebAudio.audioContext;
+    },
+
+    getOfflineAudioContext: function (sampleRate) {
+        if (!WaveSurfer.WebAudio.offlineAudioContext) {
+            WaveSurfer.WebAudio.offlineAudioContext = new (
+                window.OfflineAudioContext || window.webkitOfflineAudioContext
+            )(1, 2, sampleRate);
+        }
+        return WaveSurfer.WebAudio.offlineAudioContext;
+    },
+
+    init: function (params) {
+        this.params = params;
+        this.ac = params.audioContext || this.getAudioContext();
+
+        this.lastPlay = this.ac.currentTime;
+        this.startPosition = 0;
+        this.scheduledPause = null;
+
+        this.states = [
+            Object.create(WaveSurfer.WebAudio.state.playing),
+            Object.create(WaveSurfer.WebAudio.state.paused),
+            Object.create(WaveSurfer.WebAudio.state.finished)
+        ];
+
+        this.setState(this.PAUSED_STATE);
+
+        this.createVolumeNode();
+        this.createScriptNode();
+        this.createAnalyserNode();
+        this.setPlaybackRate(this.params.audioRate);
+    },
+
+    disconnectFilters: function () {
+        if (this.filters) {
+            this.filters.forEach(function (filter) {
+                filter && filter.disconnect();
+            });
+            this.filters = null;
+            // Reconnect direct path
+            this.analyser.connect(this.gainNode);
+        }
+    },
+
+    setState: function (state) {
+        if (this.state !== this.states[state]) {
+            this.state = this.states[state];
+            this.state.init.call(this);
+        }
+    },
+
+    // Unpacked filters
+    setFilter: function () {
+        this.setFilters([].slice.call(arguments));
+    },
+
+    /**
+     * @param {Array} filters Packed ilters array
+     */
+    setFilters: function (filters) {
+        // Remove existing filters
+        this.disconnectFilters();
+
+        // Insert filters if filter array not empty
+        if (filters && filters.length) {
+            this.filters = filters;
+
+            // Disconnect direct path before inserting filters
+            this.analyser.disconnect();
+
+            // Connect each filter in turn
+            filters.reduce(function (prev, curr) {
+                prev.connect(curr);
+                return curr;
+            }, this.analyser).connect(this.gainNode);
+        }
+
+    },
+
+    createScriptNode: function () {
+        var my = this;
+        var bufferSize = this.scriptBufferSize;
+        if (this.ac.createScriptProcessor) {
+            this.scriptNode = this.ac.createScriptProcessor(bufferSize);
+        } else {
+            this.scriptNode = this.ac.createJavaScriptNode(bufferSize);
+        }
+        this.scriptNode.connect(this.ac.destination);
+
+        this.scriptNode.onaudioprocess = function () {
+            var time = my.getCurrentTime();
+
+            if (my.buffer && time >= my.getDuration()) {
+                my.setState(my.FINISHED_STATE);
+            } else if (my.buffer && time >= my.scheduledPause) {
+                my.setState(my.PAUSED_STATE);
+            } else if (my.state === my.states[my.PLAYING_STATE]) {
+                my.fireEvent('audioprocess', time);
+            }
+        };
+    },
+
+    createAnalyserNode: function () {
+        this.analyser = this.ac.createAnalyser();
+        this.analyser.connect(this.gainNode);
+    },
+
+    /**
+     * Create the gain node needed to control the playback volume.
+     */
+    createVolumeNode: function () {
+        // Create gain node using the AudioContext
+        if (this.ac.createGain) {
+            this.gainNode = this.ac.createGain();
+        } else {
+            this.gainNode = this.ac.createGainNode();
+        }
+        // Add the gain node to the graph
+        this.gainNode.connect(this.ac.destination);
+    },
+
+    /**
+     * Set the gain to a new value.
+     *
+     * @param {Number} newGain The new gain, a floating point value
+     * between 0 and 1. 0 being no gain and 1 being maximum gain.
+     */
+    setVolume: function (newGain) {
+        this.gainNode.gain.value = newGain;
+    },
+
+    /**
+     * Get the current gain.
+     *
+     * @returns {Number} The current gain, a floating point value
+     * between 0 and 1. 0 being no gain and 1 being maximum gain.
+     */
+    getVolume: function () {
+        return this.gainNode.gain.value;
+    },
+
+    decodeArrayBuffer: function (arraybuffer, callback, errback) {
+        if (!this.offlineAc) {
+            this.offlineAc = this.getOfflineAudioContext(this.ac ? this.ac.sampleRate : 44100);
+        }
+        this.offlineAc.decodeAudioData(arraybuffer, (function (data) {
+            callback(data);
+        }).bind(this), errback);
+    },
+
+    /**
+     * @returns {Array} Array of peaks or array of arrays of peaks.
+     */
+    getPeaks: function (length) {
+        var sampleSize = this.buffer.length / length;
+        var sampleStep = ~~(sampleSize / 10) || 1;
+        var channels = this.buffer.numberOfChannels;
+        var splitPeaks = [];
+        var mergedPeaks = [];
+
+        for (var c = 0; c < channels; c++) {
+            var peaks = splitPeaks[c] = [];
+            var chan = this.buffer.getChannelData(c);
+
+            for (var i = 0; i < length; i++) {
+                var start = ~~(i * sampleSize);
+                var end = ~~(start + sampleSize);
+                var max = 0;
+                for (var j = start; j < end; j += sampleStep) {
+                    var value = chan[j];
+                    if (value > max) {
+                        max = value;
+                    // faster than Math.abs
+                    } else if (-value > max) {
+                        max = -value;
+                    }
+                }
+                peaks[i] = max;
+
+                if (c == 0 || max > mergedPeaks[i]) {
+                    mergedPeaks[i] = max;
+                }
+            }
+        }
+
+        return this.params.splitChannels ? splitPeaks : mergedPeaks;
+    },
+
+    getPlayedPercents: function () {
+        return this.state.getPlayedPercents.call(this);
+    },
+
+    disconnectSource: function () {
+        if (this.source) {
+            this.source.disconnect();
+        }
+    },
+
+    destroy: function () {
+        if (!this.isPaused()) {
+            this.pause();
+        }
+        this.unAll();
+        this.buffer = null;
+        this.disconnectFilters();
+        this.disconnectSource();
+        this.gainNode.disconnect();
+        this.scriptNode.disconnect();
+        this.analyser.disconnect();
+    },
+
+    load: function (buffer) {
+        this.startPosition = 0;
+        this.lastPlay = this.ac.currentTime;
+        this.buffer = buffer;
+        this.createSource();
+    },
+
+    createSource: function () {
+        this.disconnectSource();
+        this.source = this.ac.createBufferSource();
+
+        //adjust for old browsers.
+        this.source.start = this.source.start || this.source.noteGrainOn;
+        this.source.stop = this.source.stop || this.source.noteOff;
+
+        this.source.playbackRate.value = this.playbackRate;
+        this.source.buffer = this.buffer;
+        this.source.connect(this.analyser);
+    },
+
+    isPaused: function () {
+        return this.state !== this.states[this.PLAYING_STATE];
+    },
+
+    getDuration: function () {
+        if (!this.buffer) {
+            return 0;
+        }
+        return this.buffer.duration;
+    },
+
+    seekTo: function (start, end) {
+        this.scheduledPause = null;
+
+        if (start == null) {
+            start = this.getCurrentTime();
+            if (start >= this.getDuration()) {
+                start = 0;
+            }
+        }
+        if (end == null) {
+            end = this.getDuration();
+        }
+
+        this.startPosition = start;
+        this.lastPlay = this.ac.currentTime;
+
+        if (this.state === this.states[this.FINISHED_STATE]) {
+            this.setState(this.PAUSED_STATE);
+        }
+
+        return { start: start, end: end };
+    },
+
+    getPlayedTime: function () {
+        return (this.ac.currentTime - this.lastPlay) * this.playbackRate;
+    },
+
+    /**
+     * Plays the loaded audio region.
+     *
+     * @param {Number} start Start offset in seconds,
+     * relative to the beginning of a clip.
+     * @param {Number} end When to stop
+     * relative to the beginning of a clip.
+     */
+    play: function (start, end) {
+        // need to re-create source on each playback
+        this.createSource();
+
+        var adjustedTime = this.seekTo(start, end);
+
+        start = adjustedTime.start;
+        end = adjustedTime.end;
+
+        this.scheduledPause = end;
+
+        this.source.start(0, start, end - start);
+
+        this.setState(this.PLAYING_STATE);
+    },
+
+    /**
+     * Pauses the loaded audio.
+     */
+    pause: function () {
+        this.scheduledPause = null;
+
+        this.startPosition += this.getPlayedTime();
+        this.source && this.source.stop(0);
+
+        this.setState(this.PAUSED_STATE);
+    },
+
+    /**
+    *   Returns the current time in seconds relative to the audioclip's duration.
+    */
+    getCurrentTime: function () {
+        return this.state.getCurrentTime.call(this);
+    },
+
+    /**
+     * Set the audio source playback rate.
+     */
+    setPlaybackRate: function (value) {
+        value = value || 1;
+        if (this.isPaused()) {
+            this.playbackRate = value;
+        } else {
+            this.pause();
+            this.playbackRate = value;
+            this.play();
+        }
+    }
+};
+
+WaveSurfer.WebAudio.state = {};
+
+WaveSurfer.WebAudio.state.playing = {
+    init: function () {
+    },
+    getPlayedPercents: function () {
+        var duration = this.getDuration();
+        return (this.getCurrentTime() / duration) || 0;
+    },
+    getCurrentTime: function () {
+        return this.startPosition + this.getPlayedTime();
+    }
+};
+
+WaveSurfer.WebAudio.state.paused = {
+    init: function () {
+    },
+    getPlayedPercents: function () {
+        var duration = this.getDuration();
+        return (this.getCurrentTime() / duration) || 0;
+    },
+    getCurrentTime: function () {
+        return this.startPosition;
+    }
+};
+
+WaveSurfer.WebAudio.state.finished = {
+    init: function () {
+        this.fireEvent('finish');
+    },
+    getPlayedPercents: function () {
+        return 1;
+    },
+    getCurrentTime: function () {
+        return this.getDuration();
+    }
+};
+
+WaveSurfer.util.extend(WaveSurfer.WebAudio, WaveSurfer.Observer);

data/vendor/assets/javascripts/wavesurfer-plugins.js

@@ -0,0 +1,6 @@
+//= require plugin/wavesurfer.elan
+//= require plugin/wavesurfer.microphone
+//= require plugin/wavesurfer.minimap
+//= require plugin/wavesurfer.regions
+//= require plugin/wavesurfer.spectrogram
+//= require plugin/wavesurfer.timeline

data/vendor/assets/javascripts/wavesurfer.js

@@ -0,0 +1,6 @@
+//= require src/wavesurfer
+//= require src/util
+//= require src/webaudio
+//= require src/mediaelement
+//= require src/drawer
+//= require src/drawer.canvas

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: wavesurfer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Viktor Oleksyn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: wavesurfer.js for the Rails asset pipeline
+email:
+- bartezic@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wavesurfer.rb
+- lib/wavesurfer/version.rb
+- vendor/assets/javascripts/plugin/wavesurfer.elan.js
+- vendor/assets/javascripts/plugin/wavesurfer.microphone.js
+- vendor/assets/javascripts/plugin/wavesurfer.minimap.js
+- vendor/assets/javascripts/plugin/wavesurfer.regions.js
+- vendor/assets/javascripts/plugin/wavesurfer.spectrogram.js
+- vendor/assets/javascripts/plugin/wavesurfer.timeline.js
+- vendor/assets/javascripts/src/drawer.canvas.js
+- vendor/assets/javascripts/src/drawer.js
+- vendor/assets/javascripts/src/mediaelement.js
+- vendor/assets/javascripts/src/util.js
+- vendor/assets/javascripts/src/wavesurfer.js
+- vendor/assets/javascripts/src/webaudio.js
+- vendor/assets/javascripts/wavesurfer-plugins.js
+- vendor/assets/javascripts/wavesurfer.js
+homepage: https://github.com/bartezic/wavesurfer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: wavesurfer.js for the Rails asset pipeline.
+test_files: []