comparison js/core.js @ 2575:249a1152e525

Merge branch 'master' into Dev_main

# Conflicts:
#	interfaces/AB.js
#	js/core.js
#	js/specification.js

         this.currentIndex++;
         if (this.currentIndex < this.popupOptions.length) {
             this.postNode();
         } else {
             // Reached the end of the popupOptions
-            this.popupContent.innerHTML = "";
+            this.popupTitle.textContent = "";
+            this.popupResponse.innerHTML = "";
             this.hidePopup();
             for (var node of this.popupOptions) {
                 this.store.postResult(node);
             }
             this.store.complete();

     // Output gain is default to 1 and any items for playback route here
     // Foo gain is used for analysis to ensure paths get processed, but are not heard
     // because web audio will optimise and any route which does not go to the destination gets ignored.
     this.outputGain = audioContext.createGain();
     this.fooGain = audioContext.createGain();
-    this.fooGain.gain = 0;
+    this.fooGain.gain.value = 0;
 
     // Use this to detect playback state: 0 - stopped, 1 - playing
     this.status = 0;
 
     // Connect both gains to output

     this.loopPlayback = false;
     this.synchPlayback = false;
     this.pageSpecification = null;
 
     this.pageStore = null;
+
+    // Chrome 53+ Error solution
+    // Empty buffer for keep-alive
+    var nullBuffer = audioContext.createBuffer(1, audioContext.sampleRate, audioContext.sampleRate);
+    this.nullBufferSource = audioContext.createBufferSource();
+    this.nullBufferSource.buffer = nullBuffer;
+    this.nullBufferSource.loop = true;
+    this.nullBufferSource.start(0);
 
     // Create store for new audioObjects
     this.audioObjects = [];
 
     this.buffers = [];

                 if (typeof copybuffer.copyToChannel == "function") {
                     copybuffer.copyToChannel(sub_frame, c);
                 } else {
                     var dst = copybuffer.getChannelData(c);
                     for (var n = 0; n < newLength; n++)
-                        dst[n] = src[n + start_sample];
+                        dst[n] = buffer[n + start_sample];
                 }
             }
             return copybuffer;
         }
     };

 
     this.onplayGain = 1.0;
 
     // Connect buffer to the audio graph
     this.outputGain.connect(audioEngineContext.outputGain);
+    audioEngineContext.nullBufferSource.connect(this.outputGain);
 
     // the audiobuffer is not designed for multi-start playback
     // When stopeed, the buffer node is deleted and recreated with the stored buffer.
     this.buffer;
 

         var preSilenceTime = this.specification.preSilence || this.specification.parent.preSilence || specification.preSilence || 0.0;
         var postSilenceTime = this.specification.postSilence || this.specification.parent.postSilence || specification.postSilence || 0.0;
         var startTime = this.specification.startTime;
         var stopTime = this.specification.stopTime;
         var copybuffer = new callee.constructor();
-        if (isFinite(startTime) || isFinite(stopTime)) {
-            copybuffer.buffer = callee.cropBuffer(startTime, stopTime);
-        }
+
+        copybuffer.buffer = callee.cropBuffer(startTime || 0, stopTime || callee.buffer.duration);
         if (preSilenceTime != 0 || postSilenceTime != 0) {
-            if (copybuffer.buffer == undefined) {
-                copybuffer.buffer = callee.copyBuffer(preSilenceTime, postSilenceTime);
-            } else {
-                copybuffer.buffer = copybuffer.copyBuffer(preSilenceTime, postSilenceTime);
-            }
-        }
+            copybuffer.buffer = copybuffer.copyBuffer(preSilenceTime, postSilenceTime);
+        }
+
+        copybuffer.lufs = callee.buffer.lufs;
+        this.buffer = copybuffer;
 
         var targetLUFS = this.specification.parent.loudness || specification.loudness;
         if (typeof targetLUFS === "number" && isFinite(targetLUFS)) {
             this.buffer.buffer.playbackGain = decibelToLinear(targetLUFS - this.buffer.buffer.lufs);
         } else {

                 //event.currentTarget.owner.metric.stopListening(audioEngineContext.timer.getTestTime(),event.currentTarget.owner.getCurrentPosition());
                 if (event.currentTarget != null) {
                     event.currentTarget.owner.stop(audioContext.currentTime + 1);
                 }
             };
+            this.outputGain.gain.cancelScheduledValues(audioContext.currentTime);
             if (!audioEngineContext.loopPlayback || !audioEngineContext.synchPlayback) {
                 this.metric.startListening(audioEngineContext.timer.getTestTime());
-                this.outputGain.gain.setValueAtTime(this.onplayGain, 0.0);
+                this.outputGain.gain.setValueAtTime(this.onplayGain, startTime);
                 this.interfaceDOM.startPlayback();
             } else {
                 this.outputGain.gain.setValueAtTime(0.0, startTime);
             }
-            this.bufferNode.start(startTime, this.specification.startTime || 0, this.specification.stopTime - this.specification.startTime || this.buffer.buffer.duration);
+            if (audioEngineContext.loopPlayback) {
+                this.bufferNode.loopStart = this.specification.startTime || 0;
+                this.bufferNode.loopEnd = this.specification.stopTime - this.specification.startTime || this.buffer.buffer.duration;
+                this.bufferNode.start(startTime);
+            } else {
+                this.bufferNode.start(startTime, this.specification.startTime || 0, this.specification.stopTime - this.specification.startTime || this.buffer.buffer.duration);
+            }
             this.bufferNode.playbackStartTime = audioEngineContext.timer.getTestTime();
         }
     };
 
     this.stop = function (stopTime) {

         if (this.bufferNode != undefined) {
             this.metric.stopListening(audioEngineContext.timer.getTestTime(), this.getCurrentPosition());
             this.bufferNode.stop(stopTime);
             this.bufferNode = undefined;
         }
-        this.outputGain.gain.value = 0.0;
+        this.outputGain.gain.setValueAtTime(0.0, stopTime);
         this.interfaceDOM.stopPlayback();
     };
 
     this.getCurrentPosition = function () {
         var time = audioEngineContext.timer.getTestTime();