From e454666a8b2d741db746f96a7650fac6248a0471 Mon Sep 17 00:00:00 2001
From: Dietmar Maurer <dietmar@proxmox.com>
Date: Wed, 2 Apr 2025 09:01:18 +0200
Subject: [PATCH 1/4] rfb: add qemu audio support

Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
---
 app/ui.js         |   6 +++
 core/encodings.js |   1 +
 core/rfb.js       | 121 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 128 insertions(+)

diff --git a/app/ui.js b/app/ui.js
index 51e57bd3..f45a1635 100644
--- a/app/ui.js
+++ b/app/ui.js
@@ -333,6 +333,12 @@ const UI = {
             .addEventListener('click', UI.rejectServer);
         document.getElementById("noVNC_credentials_button")
             .addEventListener('click', UI.setCredentials);
+
+        document.addEventListener('click', function(event) {
+            if (UI.rfb !== undefined) {
+                UI.rfb.allow_audio();
+            }
+        });
     },
 
     addClipboardHandlers() {
diff --git a/core/encodings.js b/core/encodings.js
index 7afcb17f..a69b4315 100644
--- a/core/encodings.js
+++ b/core/encodings.js
@@ -24,6 +24,7 @@ export const encodings = {
     pseudoEncodingLastRect: -224,
     pseudoEncodingCursor: -239,
     pseudoEncodingQEMUExtendedKeyEvent: -258,
+    pseudoEncodingQEMUAudioEvent: -259,
     pseudoEncodingQEMULedEvent: -261,
     pseudoEncodingDesktopName: -307,
     pseudoEncodingExtendedDesktopSize: -308,
diff --git a/core/rfb.js b/core/rfb.js
index e3266cc8..561bc4a7 100644
--- a/core/rfb.js
+++ b/core/rfb.js
@@ -154,6 +154,13 @@ export default class RFB extends EventTargetMixin {
 
         this._qemuExtKeyEventSupported = false;
 
+        this._qemuAudioSupported = false;
+        this._page_had_user_interaction = false;
+        this._audio_next_start = 0;
+        this._audio_sample_rate = 44100;
+        this._audio_channels = 2;
+        this._audio_context = null;
+
         this._extendedPointerEventSupported = false;
 
         this._clipboardText = null;
@@ -2256,6 +2263,7 @@ export default class RFB extends EventTargetMixin {
         encs.push(encodings.pseudoEncodingDesktopSize);
         encs.push(encodings.pseudoEncodingLastRect);
         encs.push(encodings.pseudoEncodingQEMUExtendedKeyEvent);
+        encs.push(encodings.pseudoEncodingQEMUAudioEvent);
         encs.push(encodings.pseudoEncodingQEMULedEvent);
         encs.push(encodings.pseudoEncodingExtendedDesktopSize);
         encs.push(encodings.pseudoEncodingXvp);
@@ -2611,6 +2619,9 @@ export default class RFB extends EventTargetMixin {
             case 250:  // XVP
                 return this._handleXvpMsg();
 
+            case 255: // Qemu Server Message
+                return this._handleQemuAudioEvent();
+
             default:
                 this._fail("Unexpected server message (type " + msgType + ")");
                 Log.Debug("sock.rQpeekBytes(30): " + this._sock.rQpeekBytes(30));
@@ -2683,6 +2694,13 @@ export default class RFB extends EventTargetMixin {
                 this._qemuExtKeyEventSupported = true;
                 return true;
 
+            case encodings.pseudoEncodingQEMUAudioEvent:
+                if (!this._qemuAudioSupported) {
+                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio_channels, this._audio_sample_rate);
+                    this._qemuAudioSupported = true;
+                }
+                return true;
+
             case encodings.pseudoEncodingDesktopName:
                 return this._handleDesktopName();
 
@@ -2705,6 +2723,93 @@ export default class RFB extends EventTargetMixin {
         }
     }
 
+    _handleQemuAudioEvent() {
+        if (this._sock.rQwait("Qemu Audio Event", 3, 1)) {
+            return false;
+        }
+
+        const submsg = this._sock.rQshift8();
+        if (submsg !== 1) {
+            Log.Warn("The given qemu message type " + submsg + " is not supported.");
+            return false;
+        }
+
+        const operation = this._sock.rQshift16();
+
+        switch (operation) {
+            case 0: {
+                this._audio_context = null;
+                this._audio_next_start = 0;
+                return true;
+            }
+            case 1: {
+                this._audio_context = new AudioContext({
+                    latencyHint: "interactive",
+                    sampleRate: this._audio_sample_rate,
+                });
+                this._audio_next_start = 0;
+                return true;
+            }
+            case 2: break;
+            default: {
+                Log.Warn("The given qemu audio opertaion " + opertaion + " is not supported.");
+                return false;
+            }
+        }
+
+        if (this._sock.rQwait("Qemu Audio payload length", 4, 4)) {
+            return false;
+        }
+
+        const length = this._sock.rQshift32();
+
+        if (this._sock.rQwait("audio payload", length, 8)) {
+            return false;
+        }
+
+        if (length !== 0) {
+            let payload = this._sock.rQshiftBytes(length, false);
+
+            if (this._audio_context === null) {
+                return false;
+            }
+
+            let sample_bytes = 2*this._audio_channels;
+            let buffer = this._audio_context.createBuffer(this._audio_channels, length/sample_bytes, this._audio_sample_rate);
+
+            for (let ch = 0; ch < this._audio_channels; ch++) {
+                const channel = buffer.getChannelData(ch);
+                let channel_offset = ch*2;
+                for (let i = 0; i < buffer.length; i++) {
+                    let p = i*sample_bytes + channel_offset;
+                    let value = payload[p] + payload[p+1]*256;
+                    channel[i] = (value / 32768.0) - 1.0;
+                }
+            }
+
+            if (this._page_had_user_interaction) {
+                let ctime = this._audio_context.currentTime;
+                if (ctime > this._audio_next_start) {
+                    this._audio_next_start = ctime;
+                }
+                let start_time = this._audio_next_start;
+
+                this._audio_next_start += buffer.duration;
+
+                let source = this._audio_context.createBufferSource();
+                source.buffer = buffer;
+                source.connect(this._audio_context.destination);
+                source.start(start_time);
+            }
+        }
+
+        return true;
+    }
+
+    allow_audio() {
+        this._page_had_user_interaction = true;
+    }
+
     _handleVMwareCursor() {
         const hotx = this._FBU.x;  // hotspot-x
         const hoty = this._FBU.y;  // hotspot-y
@@ -3314,6 +3419,22 @@ RFB.messages = {
         sock.flush();
     },
 
+    enableQemuAudioUpdates(sock, channels, sample_rate) {
+
+        sock.sQpush8(255); // msg-type
+        sock.sQpush8(1); // submessage-type
+        sock.sQpush16(2); // set sample format
+        sock.sQpush8(2); // format U16
+        sock.sQpush8(channels);
+        sock.sQpush32(sample_rate); // audio frequency
+
+        sock.sQpush8(255); // msg-type
+        sock.sQpush8(1); // submessage-type
+        sock.sQpush16(0); // enable audio
+
+        sock.flush();
+    },
+
     pixelFormat(sock, depth, trueColor) {
         let bpp;
 

From 6f8f4bff62bb693f86a270d6e30a060987807557 Mon Sep 17 00:00:00 2001
From: Dietmar Maurer <dietmar@proxmox.com>
Date: Thu, 3 Apr 2025 10:48:55 +0200
Subject: [PATCH 2/4] app: add enable audio setting

Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
---
 app/ui.js   | 11 +++++++++++
 core/rfb.js | 24 +++++++++++++++++++++++-
 vnc.html    |  7 +++++++
 3 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/app/ui.js b/app/ui.js
index f45a1635..3ecaf7a1 100644
--- a/app/ui.js
+++ b/app/ui.js
@@ -189,6 +189,7 @@ const UI = {
         UI.initSetting('repeaterID', '');
         UI.initSetting('reconnect', false);
         UI.initSetting('reconnect_delay', 5000);
+        UI.initSetting('enable_audio', true);
     },
     // Adds a link to the label elements on the corresponding input elements
     setupSettingLabels() {
@@ -385,6 +386,8 @@ const UI = {
         UI.addSettingChangeHandler('logging', UI.updateLogging);
         UI.addSettingChangeHandler('reconnect');
         UI.addSettingChangeHandler('reconnect_delay');
+        UI.addSettingChangeHandler('enable_audio');
+        UI.addSettingChangeHandler('enable_audio', UI.updateEnableAudio);
     },
 
     addFullscreenHandlers() {
@@ -898,6 +901,7 @@ const UI = {
         UI.updateSetting('logging');
         UI.updateSetting('reconnect');
         UI.updateSetting('reconnect_delay');
+        UI.updateSetting('enable_audio');
 
         document.getElementById('noVNC_settings')
             .classList.add("noVNC_open");
@@ -1109,6 +1113,8 @@ const UI = {
         UI.rfb.showDotCursor = UI.getSetting('show_dot');
 
         UI.updateViewOnly(); // requires UI.rfb
+        UI.updateEnableAudio(); // requires UI.rfb
+
     },
 
     disconnect() {
@@ -1801,6 +1807,11 @@ const UI = {
         selectbox.options.add(optn);
     },
 
+    updateEnableAudio() {
+        if (!UI.rfb) return;
+        UI.rfb.enable_audio(UI.getSetting('enable_audio'));
+    },
+
 /* ------^-------
  *    /MISC
  * ==============
diff --git a/core/rfb.js b/core/rfb.js
index 561bc4a7..4f5a51d2 100644
--- a/core/rfb.js
+++ b/core/rfb.js
@@ -156,6 +156,7 @@ export default class RFB extends EventTargetMixin {
 
         this._qemuAudioSupported = false;
         this._page_had_user_interaction = false;
+        this._audio_enable = false;
         this._audio_next_start = 0;
         this._audio_sample_rate = 44100;
         this._audio_channels = 2;
@@ -2787,7 +2788,7 @@ export default class RFB extends EventTargetMixin {
                 }
             }
 
-            if (this._page_had_user_interaction) {
+            if (this._page_had_user_interaction && this._audio_enable) {
                 let ctime = this._audio_context.currentTime;
                 if (ctime > this._audio_next_start) {
                     this._audio_next_start = ctime;
@@ -2806,6 +2807,19 @@ export default class RFB extends EventTargetMixin {
         return true;
     }
 
+    enable_audio(value) {
+        if (this._audio_enable !== value) {
+            this._audio_enable = value;
+            if (this._qemuAudioSupported) {
+                if (this._audio_enable) {
+                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio_channels, this._audio_sample_rate);
+                } else {
+                    RFB.messages.disableQemuAudioUpdates(this._sock);
+                }
+            }
+        }
+    }
+
     allow_audio() {
         this._page_had_user_interaction = true;
     }
@@ -3419,6 +3433,14 @@ RFB.messages = {
         sock.flush();
     },
 
+    disableQemuAudioUpdates(sock, channels, sample_rate) {
+        sock.sQpush8(255); // msg-type
+        sock.sQpush8(1); // submessage-type
+        sock.sQpush16(1); // disable audio
+
+        sock.flush();
+    },
+
     enableQemuAudioUpdates(sock, channels, sample_rate) {
 
         sock.sQpush8(255); // msg-type
diff --git a/vnc.html b/vnc.html
index 82cacd58..f6cab3f9 100644
--- a/vnc.html
+++ b/vnc.html
@@ -219,6 +219,13 @@
                             View only
                         </label>
                     </li>
+                    <li>
+                        <label>
+                            <input id="noVNC_setting_enable_audio" type="checkbox"
+                                   class="toggle">
+                            Enable Audio
+                        </label>
+                    </li>
                     <li><hr></li>
                     <li>
                         <label>

From 3721da90dccde88f472a568e6b931558e146e679 Mon Sep 17 00:00:00 2001
From: Dietmar Maurer <dietmar@proxmox.com>
Date: Fri, 4 Apr 2025 11:28:37 +0200
Subject: [PATCH 3/4] audio: implement re-sync, move code to separate file

Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
---
 core/audio.js | 170 ++++++++++++++++++++++++++++++++++++++++++++++++++
 core/rfb.js   |  67 +++++---------------
 2 files changed, 187 insertions(+), 50 deletions(-)
 create mode 100644 core/audio.js

diff --git a/core/audio.js b/core/audio.js
new file mode 100644
index 00000000..78992caa
--- /dev/null
+++ b/core/audio.js
@@ -0,0 +1,170 @@
+// The RFB protocol (VNC) is designed for real-time user interactions
+// and allows transferring audio messages together with screen content.
+// It is not possible to use any kind of buffering, because that would
+// introduce large delays between user interaction and content display.
+//
+// This is not really a problem with screen content, because the human
+// brain is quite tolerate about slight speed changes in video content,
+// and we mostly transfer non-video data anyways.
+//
+// With audio, the situation is quite different, as it must be played
+// at a constant speed. Any delay leads to audio distortion, which is
+// unpleasant for humans.
+//
+// Without buffering, it is always possible for audio frames to arrive
+// too late or too early due to changing network speeds.
+//
+// We use the following algorithm:
+//
+// - small Jitter buffer to tolerate small speed changes (20ms)
+// - simply discard late audio frame
+// - Queue early frames with slight speedup (pitch scale) to re-sync audio
+// - if we get to many early frames, skip frames for fast re-sync
+//
+// ## Audio format
+//
+// We use/expect U16 raw audio data.
+
+import * as Log from './util/logging.js';
+
+export default class Audio {
+    constructor(sample_rate, nchannels) {
+        this._next_start = 0;
+        this._context = null;
+        this._jitter = 0.02;
+        this._resample_trigger = 5*this._jitter;
+        this._stable_time = 1.0;
+
+        // ===== PROPERTIES =====
+        this._sample_rate = sample_rate;
+        this._nchannels = nchannels;
+    }
+
+    // ===== PROPERTIES =====
+    get sample_rate() { return this._sample_rate; }
+    get nchannels() { return this._nchannels; }
+
+    // ===== PUBLIC METHODS =====
+
+    // Stop audio playback
+    //
+    // Further audio frames are simply dropped.
+    stop() {
+        this._context = null;
+        this._next_start = 0;
+    }
+
+    start() {
+        this._context = new AudioContext({
+            latencyHint: "interactive",
+            sampleRate: this._sample_rate,
+        });
+        this._next_start = 0;
+    }
+
+    play(payload) {
+        if (this._context === null) {
+            return true;
+        }
+
+        let ctime = this._context.currentTime;
+
+        let time_offset = this._next_start - ctime;
+
+        let sample_bytes = 2*this._nchannels;
+
+        if ((time_offset < this._jitter) && (this._resample_trigger !== 5*this._jitter)) {
+            Log.Debug("Stop resampling because audio is in sync (delay = " + time_offset + " sec)");
+            this._resample_trigger = 5*this._jitter;
+        }
+
+        let buffer = null;
+        if (time_offset > this._resample_trigger && (payload.length > (100*sample_bytes))) {
+            if (this._resample_trigger !== this._jitter) {
+                Log.Debug("Start resampling to re-sync audio (delay = " + time_offset + " sec)");
+                this._resample_trigger = this._jitter;
+            }
+            buffer = this._pitchScale(payload, 1.01); // increase pitch by 1%
+        } else {
+            buffer = this._createBuffer(payload);
+        }
+
+        if (this._next_start > 0) {
+            if (time_offset < -buffer.duration) {
+                Log.Warn("Skip delayed audio frame (delay = " + (-time_offset) + " sec)");
+                this._next_start = ctime + this._jitter;
+                return true; // do not play delayed frame - skip it!
+            }
+            if  (time_offset > 0.5) {
+                Log.Warn("Move fast audio frame (offset = " + time_offset + " sec)");
+                this._stable_time = 0;
+                return true; // skip frame.
+            }
+        }
+
+        this._stable_time += buffer.duration;
+
+        if (this._next_start === 0) {
+            this._next_start = ctime + this._jitter;
+        }
+
+        let start_time = this._next_start;
+        this._next_start += buffer.duration;
+
+        if (this._stable_time >= 1.0) {
+            let source = this._context.createBufferSource();
+            source.buffer = buffer;
+            source.connect(this._context.destination);
+            source.start(start_time);
+        }
+
+        return true;
+    }
+
+    // ===== PRIVATE METHODS =====
+
+    // see: https://en.wikipedia.org/wiki/Audio_time_stretching_and_pitch_scaling
+    _pitchScale(payload, factor) {
+        let sample_bytes = 2*this._nchannels;
+        let new_length = Math.ceil(payload.length/(factor*sample_bytes));
+
+        let buffer = this._context.createBuffer(this._nchannels, new_length, this._sample_rate);
+        for (let ch = 0; ch < this._nchannels; ch++) {
+            const channel = buffer.getChannelData(ch);
+            let channel_offset = ch*2;
+            for (let i = 0; i < buffer.length; i++) {
+                let pos_float = i*factor;
+                let j = Math.trunc(pos_float);
+                let second_weight = pos_float % 1;
+                let first_weight = 1 - second_weight;
+                let p = j*sample_bytes + channel_offset;
+                let value0 = payload[p] + payload[p+1]*256;
+                p += sample_bytes;
+                let value1 = value0;
+                if (p < payload.length) {
+                    value1 = payload[p] + payload[p+1]*256;
+                }
+                let value = (value0*first_weight + value1*second_weight);
+                channel[i] = (value / 32768.0) - 1.0;
+            }
+        }
+        return buffer;
+    }
+
+    _createBuffer(payload) {
+        let sample_bytes = 2*this._nchannels;
+        let buffer = this._context.createBuffer(
+            this._nchannels, payload.length/sample_bytes, this._sample_rate);
+
+        for (let ch = 0; ch < this._nchannels; ch++) {
+            const channel = buffer.getChannelData(ch);
+            let channel_offset = ch*2;
+            for (let i = 0; i < buffer.length; i++) {
+                let p = i*sample_bytes + channel_offset;
+                let value = payload[p] + payload[p+1]*256;
+                channel[i] = (value / 32768.0) - 1.0;
+            }
+        }
+        return buffer;
+    }
+}
diff --git a/core/rfb.js b/core/rfb.js
index 4f5a51d2..5368e52d 100644
--- a/core/rfb.js
+++ b/core/rfb.js
@@ -14,6 +14,7 @@ import { dragThreshold, supportsWebCodecsH264Decode } from './util/browser.js';
 import { clientToElement } from './util/element.js';
 import { setCapture } from './util/events.js';
 import EventTargetMixin from './util/eventtarget.js';
+import Audio from "./audio.js";
 import Display from "./display.js";
 import Inflator from "./inflator.js";
 import Deflator from "./deflator.js";
@@ -157,10 +158,7 @@ export default class RFB extends EventTargetMixin {
         this._qemuAudioSupported = false;
         this._page_had_user_interaction = false;
         this._audio_enable = false;
-        this._audio_next_start = 0;
-        this._audio_sample_rate = 44100;
-        this._audio_channels = 2;
-        this._audio_context = null;
+        this._audio = new Audio(44100, 2);
 
         this._extendedPointerEventSupported = false;
 
@@ -2697,7 +2695,7 @@ export default class RFB extends EventTargetMixin {
 
             case encodings.pseudoEncodingQEMUAudioEvent:
                 if (!this._qemuAudioSupported) {
-                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio_channels, this._audio_sample_rate);
+                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio.nchannels, this._audio.sample_rate);
                     this._qemuAudioSupported = true;
                 }
                 return true;
@@ -2739,16 +2737,11 @@ export default class RFB extends EventTargetMixin {
 
         switch (operation) {
             case 0: {
-                this._audio_context = null;
-                this._audio_next_start = 0;
+                this._audio.stop();
                 return true;
             }
             case 1: {
-                this._audio_context = new AudioContext({
-                    latencyHint: "interactive",
-                    sampleRate: this._audio_sample_rate,
-                });
-                this._audio_next_start = 0;
+                this._audio.start();
                 return true;
             }
             case 2: break;
@@ -2764,47 +2757,21 @@ export default class RFB extends EventTargetMixin {
 
         const length = this._sock.rQshift32();
 
+        if (length === 0) {
+            return false;
+        }
+
         if (this._sock.rQwait("audio payload", length, 8)) {
             return false;
         }
 
-        if (length !== 0) {
-            let payload = this._sock.rQshiftBytes(length, false);
+        let payload = this._sock.rQshiftBytes(length, false);
 
-            if (this._audio_context === null) {
-                return false;
-            }
-
-            let sample_bytes = 2*this._audio_channels;
-            let buffer = this._audio_context.createBuffer(this._audio_channels, length/sample_bytes, this._audio_sample_rate);
-
-            for (let ch = 0; ch < this._audio_channels; ch++) {
-                const channel = buffer.getChannelData(ch);
-                let channel_offset = ch*2;
-                for (let i = 0; i < buffer.length; i++) {
-                    let p = i*sample_bytes + channel_offset;
-                    let value = payload[p] + payload[p+1]*256;
-                    channel[i] = (value / 32768.0) - 1.0;
-                }
-            }
-
-            if (this._page_had_user_interaction && this._audio_enable) {
-                let ctime = this._audio_context.currentTime;
-                if (ctime > this._audio_next_start) {
-                    this._audio_next_start = ctime;
-                }
-                let start_time = this._audio_next_start;
-
-                this._audio_next_start += buffer.duration;
-
-                let source = this._audio_context.createBufferSource();
-                source.buffer = buffer;
-                source.connect(this._audio_context.destination);
-                source.start(start_time);
-            }
+        if (!this._page_had_user_interaction || !this._audio_enable) {
+            return true;
         }
 
-        return true;
+        return this._audio.play(payload);
     }
 
     enable_audio(value) {
@@ -2812,7 +2779,7 @@ export default class RFB extends EventTargetMixin {
             this._audio_enable = value;
             if (this._qemuAudioSupported) {
                 if (this._audio_enable) {
-                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio_channels, this._audio_sample_rate);
+                    RFB.messages.enableQemuAudioUpdates(this._sock, this._audio.nchannels, this._audio.sample_rate);
                 } else {
                     RFB.messages.disableQemuAudioUpdates(this._sock);
                 }
@@ -3433,7 +3400,7 @@ RFB.messages = {
         sock.flush();
     },
 
-    disableQemuAudioUpdates(sock, channels, sample_rate) {
+    disableQemuAudioUpdates(sock, nchannels, sample_rate) {
         sock.sQpush8(255); // msg-type
         sock.sQpush8(1); // submessage-type
         sock.sQpush16(1); // disable audio
@@ -3441,13 +3408,13 @@ RFB.messages = {
         sock.flush();
     },
 
-    enableQemuAudioUpdates(sock, channels, sample_rate) {
+    enableQemuAudioUpdates(sock, nchannels, sample_rate) {
 
         sock.sQpush8(255); // msg-type
         sock.sQpush8(1); // submessage-type
         sock.sQpush16(2); // set sample format
         sock.sQpush8(2); // format U16
-        sock.sQpush8(channels);
+        sock.sQpush8(nchannels);
         sock.sQpush32(sample_rate); // audio frequency
 
         sock.sQpush8(255); // msg-type

From 58c6ad61131325d027c05350b0bb100400fe3979 Mon Sep 17 00:00:00 2001
From: Dietmar Maurer <dietmar@proxmox.com>
Date: Wed, 7 May 2025 12:44:10 +0200
Subject: [PATCH 4/4] audio: cleanup pitch_scale

- use better normalization: (value - 32768) / 32768.0;
- use DataView to access little-endian 16bit raw audio data

Signed-off-by: Dietmar Maurer <dietmar@proxmox.com>
---
 core/audio.js | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/core/audio.js b/core/audio.js
index 78992caa..a2baf1eb 100644
--- a/core/audio.js
+++ b/core/audio.js
@@ -23,7 +23,8 @@
 //
 // ## Audio format
 //
-// We use/expect U16 raw audio data.
+// We use/expect U16, little endian, raw audio data,
+// interleaved channel data:  [L0, R0, L1, R1, ...]
 
 import * as Log from './util/logging.js';
 
@@ -38,6 +39,7 @@ export default class Audio {
         // ===== PROPERTIES =====
         this._sample_rate = sample_rate;
         this._nchannels = nchannels;
+        this._little_endian = true;
     }
 
     // ===== PROPERTIES =====
@@ -127,6 +129,7 @@ export default class Audio {
     _pitchScale(payload, factor) {
         let sample_bytes = 2*this._nchannels;
         let new_length = Math.ceil(payload.length/(factor*sample_bytes));
+        const payload_view = new DataView(payload);
 
         let buffer = this._context.createBuffer(this._nchannels, new_length, this._sample_rate);
         for (let ch = 0; ch < this._nchannels; ch++) {
@@ -138,14 +141,14 @@ export default class Audio {
                 let second_weight = pos_float % 1;
                 let first_weight = 1 - second_weight;
                 let p = j*sample_bytes + channel_offset;
-                let value0 = payload[p] + payload[p+1]*256;
+                let value0 = payload_view.getUint16(p, this._little_endian);
                 p += sample_bytes;
                 let value1 = value0;
                 if (p < payload.length) {
-                    value1 = payload[p] + payload[p+1]*256;
+                    value1 = payload_view.getUint16(p, this._little_endian);
                 }
                 let value = (value0*first_weight + value1*second_weight);
-                channel[i] = (value / 32768.0) - 1.0;
+                channel[i] = (value - 32768) / 32768.0;
             }
         }
         return buffer;