@openclaw/whatsapp 2026.5.31-beta.2 → 2026.5.31-beta.4

package/node_modules/node-wav/index.js

@@ -0,0 +1,291 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+'use strict';
+
+const data_decoders = {
+  pcm8: (buffer, offset, output, channels, samples) => {
+    let input = new Uint8Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let data = input[pos++] - 128;
+        output[ch][i] = data < 0 ? data / 128 : data / 127;
+      }
+    }
+  },
+  pcm16: (buffer, offset, output, channels, samples) => {
+    let input = new Int16Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let data = input[pos++];
+        output[ch][i] = data < 0 ? data / 32768 : data / 32767;
+      }
+    }
+  },
+  pcm24: (buffer, offset, output, channels, samples) => {
+    let input = new Uint8Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let x0 = input[pos++];
+        let x1 = input[pos++];
+        let x2 = input[pos++];
+        let xx = (x0 + (x1 << 8) + (x2 << 16));
+        let data = xx > 0x800000 ? xx - 0x1000000 : xx;
+        output[ch][i] = data < 0 ? data / 8388608 : data / 8388607;
+      }
+    }
+  },
+  pcm32: (buffer, offset, output, channels, samples) => {
+    let input = new Int32Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let data = input[pos++];
+        output[ch][i] = data < 0 ? data / 2147483648 : data / 2147483647;
+      }
+    }
+  },
+  pcm32f: (buffer, offset, output, channels, samples) => {
+    let input = new Float32Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch)
+        output[ch][i] = input[pos++];
+    }
+  },
+  pcm64f: (buffer, offset, output, channels, samples) => {
+    let input = new Float64Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch)
+        output[ch][i] = input[pos++];
+    }
+  },
+};
+
+const data_encoders = {
+  pcm8: (buffer, offset, input, channels, samples) => {
+    let output = new Uint8Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));
+        v = ((v * 0.5 + 0.5) * 255) | 0;
+        output[pos++] = v;
+      }
+    }
+  },
+  pcm16: (buffer, offset, input, channels, samples) => {
+    let output = new Int16Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));
+        v = ((v < 0) ? v * 32768 : v * 32767) | 0;
+        output[pos++] = v;
+      }
+    }
+  },
+  pcm24: (buffer, offset, input, channels, samples) => {
+    let output = new Uint8Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));
+        v = ((v < 0) ? 0x1000000 + v * 8388608 : v * 8388607) | 0;
+        output[pos++] = (v >> 0) & 0xff;
+        output[pos++] = (v >> 8) & 0xff;
+        output[pos++] = (v >> 16) & 0xff;
+      }
+    }
+  },
+  pcm32: (buffer, offset, input, channels, samples) => {
+    let output = new Int32Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));
+        v = ((v < 0) ? v * 2147483648 : v * 2147483647) | 0;
+        output[pos++] = v;
+      }
+    }
+  },
+  pcm32f: (buffer, offset, input, channels, samples) => {
+    let output = new Float32Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));        
+        output[pos++] = v;
+      }
+    }
+  },
+  pcm64f: (buffer, offset, input, channels, samples) => {
+    let output = new Float64Array(buffer, offset);
+    let pos = 0;
+    for (let i = 0; i < samples; ++i) {
+      for (let ch = 0; ch < channels; ++ch) {
+        let v = Math.max(-1, Math.min(input[ch][i], 1));        
+        output[pos++] = v;
+      }
+    }
+  },
+};
+
+function lookup(table, bitDepth, floatingPoint) {
+  let name = 'pcm' + bitDepth + (floatingPoint ? 'f' : '');
+  let fn = table[name];
+  if (!fn)
+    throw new TypeError('Unsupported data format: ' + name);
+  return fn;
+}
+
+function decode(buffer) {
+  let pos = 0, end = 0;
+  if (buffer.buffer) {
+    // If we are handed a typed array or a buffer, then we have to consider the
+    // offset and length into the underlying array buffer.
+    pos = buffer.byteOffset;
+    end = buffer.length;
+    buffer = buffer.buffer;
+  } else {
+    // If we are handed a straight up array buffer, start at offset 0 and use
+    // the full length of the buffer.
+    pos = 0;
+    end = buffer.byteLength;
+  }
+
+  let v = new DataView(buffer);
+
+  function u8() {
+    let x = v.getUint8(pos);
+    pos++;
+    return x;
+  }
+
+  function u16() {
+    let x = v.getUint16(pos, true);
+    pos += 2;
+    return x;
+  }
+
+  function u32() {
+    let x = v.getUint32(pos, true);
+    pos += 4;
+    return x;
+  }
+
+  function string(len) {
+    let str = '';
+    for (let i = 0; i < len; ++i)
+      str += String.fromCharCode(u8());
+    return str;
+  }
+
+  if (string(4) !== 'RIFF')
+    throw new TypeError('Invalid WAV file');
+  u32();
+  if (string(4) !== 'WAVE')
+    throw new TypeError('Invalid WAV file');
+
+  let fmt;
+  
+  while (pos < end) {
+    let type = string(4);
+    let size = u32();
+    let next = pos + size;
+    switch (type) {
+    case 'fmt ':
+      let formatId = u16();
+      if (formatId !== 0x0001 && formatId !== 0x0003)
+        throw new TypeError('Unsupported format in WAV file: ' + formatId.toString(16));
+      fmt = {
+        format: 'lpcm',
+        floatingPoint: formatId === 0x0003,
+        channels: u16(),
+        sampleRate: u32(),
+        byteRate: u32(),
+        blockSize: u16(),
+        bitDepth: u16(),
+      };
+      break;
+    case 'data':
+      if (!fmt)
+        throw new TypeError('Missing "fmt " chunk.');
+      let samples = Math.floor(size / fmt.blockSize);
+      let channels = fmt.channels;
+      let sampleRate = fmt.sampleRate;
+      let channelData = [];
+      for (let ch = 0; ch < channels; ++ch)
+        channelData[ch] = new Float32Array(samples);
+      lookup(data_decoders, fmt.bitDepth, fmt.floatingPoint)(buffer, pos, channelData, channels, samples);
+      return {
+        sampleRate: sampleRate,
+        channelData: channelData
+      };
+      break;
+    }
+    pos = next;
+  }
+}
+
+function encode(channelData, opts) {
+  let sampleRate = opts.sampleRate || 16000;
+  let floatingPoint = !!(opts.float || opts.floatingPoint);
+  let bitDepth = floatingPoint ? 32 : ((opts.bitDepth | 0) || 16);
+  let channels = channelData.length;
+  let samples = channelData[0].length;
+  let buffer = new ArrayBuffer(44 + (samples * channels * (bitDepth >> 3)));
+
+  let v = new DataView(buffer);
+  let pos = 0;
+
+  function u8(x) {
+    v.setUint8(pos++, x);
+  }
+
+  function u16(x) {
+    v.setUint16(pos, x, true);
+    pos += 2;
+  }
+
+  function u32(x) {
+    v.setUint32(pos, x, true);
+    pos += 4;
+  }
+  
+  function string(s) {
+    for (var i = 0; i < s.length; ++i)
+      u8(s.charCodeAt(i));
+  }
+
+  // write header
+  string('RIFF');
+  u32(buffer.byteLength - 8);
+  string('WAVE');
+
+  // write 'fmt ' chunk
+  string('fmt ');
+  u32(16);
+  u16(floatingPoint ? 0x0003 : 0x0001);
+  u16(channels);
+  u32(sampleRate);
+  u32(sampleRate * channels * (bitDepth >> 3));
+  u16(channels * (bitDepth >> 3));
+  u16(bitDepth);
+
+  // write 'data' chunk
+  string('data');
+  u32(buffer.byteLength - 44);
+  lookup(data_encoders, bitDepth, floatingPoint)(buffer, pos, channelData, channels, samples);
+
+  return Buffer(buffer);
+}
+
+module.exports = {
+  decode: decode,
+  encode: encode,
+};

package/node_modules/node-wav/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "node-wav",
+  "version": "0.0.2",
+  "description": "High performance WAV file decoder and encoder",
+  "main": "./index.js",
+  "scripts": {
+    "test": "./node_modules/nodeunit/bin/nodeunit ./tests/test.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/andreasgal/node-wav.git"
+  },
+  "keywords": [
+    "wav",
+    "decode"
+  ],
+  "author": "Andreas Gal",
+  "license": "MIT",
+  "homepage": "https://github.com/andreasgal/node-wav",
+  "engines": {
+    "node": ">=4.4.0"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "nodeunit": "^0.9.1",
+    "wav-decoder": "^1.1.0",
+    "wav-encoder": "^1.1.0"
+  }
+}

package/node_modules/node-wav/tests/test.js

@@ -0,0 +1,66 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+"use strict";
+
+const fs = require('fs');
+const encoder = require('wav-encoder');
+const decoder = require('wav-decoder');
+const wav = require('../index');
+
+function make_test_data(channels, samples) {
+  let data = [];
+  for (let ch = 0; ch < channels; ++ch) {
+    data[ch] = new Float32Array(samples);
+    for (let n = 0; n < samples; ++n)
+      data[ch][n] = Math.random();
+  }
+  return data;
+}
+
+exports.test_wav = test => {
+  test.expect(25);
+  let samples = 10;
+  let channels = 2;
+  let data = make_test_data(channels, samples);
+  Promise.all([8, 16, 24, 32, '32f'].map(bitDepth => new Promise((resolve, reject) => {
+    let floatingPoint = false;
+    if (bitDepth == '32f') {
+      bitDepth = 32;
+      floatingPoint = true;
+    }
+    let audioData = {
+      length: samples,
+      numberOfChannels: channels,
+      sampleRate: 16000,
+      channelData: data
+    };
+    let opts = {
+      floatingPoint: floatingPoint,
+      bitDepth: bitDepth,
+    };
+    encoder.encode(audioData, opts).then(buffer => {
+      let encoded = wav.encode(audioData.channelData, opts);
+      test.equal(new Buffer(buffer).toString('hex'), encoded.toString('hex'), 'our encoder should match wav-encoder');
+      let decoded = wav.decode(buffer);
+      decoder.decode(buffer).then(reference => {
+        test.equal(reference.length, decoded.channelData[0].length, 'number of samples should match');
+        test.equal(reference.numberOfChannels, decoded.channelData.length, 'number of channels should match');
+        test.equal(reference.sampleRate, decoded.sampleRate, 'sample rate should match');
+        test.deepEqual(reference.channelData, decoded.channelData, 'data should match');
+        resolve();
+      });
+    });
+  }))).then(() => test.done());
+};
+
+exports.test_buffer_offset = test => {
+  test.expect(1);
+  let files = ["./tests/file1.wav"];
+  files.forEach(file => {
+    let buffer = fs.readFileSync(file);
+    let decoded = wav.decode(buffer);
+    test.equal(decoded.sampleRate, 16000);
+    test.done();
+  });
+};

package/node_modules/node-wav/x.js

@@ -0,0 +1,12 @@
+let fs = require('fs');
+let wav = require('./index');
+
+//let files = JSON.parse(fs.readFileSync('x.json'));
+
+let files = ["../train/data//other/0005932e-db17-4a21-b99f-5e10f84a9e74.wav"];
+
+files.forEach(file => {
+  console.log(file);
+  let buffer = fs.readFileSync(file);
+  let w = wav.decode(buffer);  
+});