for testing and deploying your application
for finding and fixing issues
for empowering human code reviews
/*
* Copyright (c) 2017-2018 Rafael da Silva Rocha. MIT License.
* https://github.com/rochars/wavefile
*
*/
/** @private */
const bitDepth_ = require("bitdepth");
const riffChunks_ = require("riff-chunks");
const imaadpcm_ = require("imaadpcm");
const alawmulaw_ = require("alawmulaw");
const byteData_ = require("byte-data");
const encodeBase64 = require("base64-arraybuffer").encode;
const uInt16_ = {"bits": 16};
const uInt32_ = {"bits": 32};
const fourCC_ = {"bits": 32, "char": true};
const chr_ = {"bits": 8, "char": true};
/**
* Class representing a wav file.
class WaveFile {
* @param {Uint8Array|Array<number>} bytes A wave file buffer.
* @throws {Error} If no "RIFF" chunk is found.
* @throws {Error} If no "fmt " chunk is found.
* @throws {Error} If no "fact" chunk is found and "fact" is needed.
* @throws {Error} If no "data" chunk is found.
constructor(bytes) {
* The container identifier.
* Only "RIFF" and "RIFX" are supported.
* @type {!string}
* @export
this.container = "";
* @type {!number}
this.chunkSize = 0;
* The format.
* Always "WAVE".
this.format = "";
* The data of the "fmt" chunk.
* @type {!Object<!string, *>}
this.fmt = {
/** @export @type {!string} */
"chunkId": "",
/** @export @type {!number} */
"chunkSize": 0,
"audioFormat": 0,
"numChannels": 0,
"sampleRate": 0,
"byteRate": 0,
"blockAlign": 0,
"bitsPerSample": 0,
"cbSize": 0,
"validBitsPerSample": 0,
"dwChannelMask": 0,
* 4 32-bit values representing a 128-bit ID
* @export @type {!Array<number>}
"subformat": []
};
* The data of the "fact" chunk.
this.fact = {
"dwSampleLength": 0
* The data of the "cue " chunk.
this.cue = {
"dwCuePoints": 0,
/** @export @type {!Array<Object>} */
"points": [],
* The data of the "bext" chunk.
this.bext = {
"description": "", //256
"originator": "", //32
"originatorReference": "", //32
"originationDate": "", //10
"originationTime": "", //8
* 2 32-bit values, timeReference high and low
"timeReference": [],
"version": 0, //WORD
"UMID": "", // 64 chars
"loudnessValue": 0, //WORD
"loudnessRange": 0, //WORD
"maxTruePeakLevel": 0, //WORD
"maxMomentaryLoudness": 0, //WORD
"maxShortTermLoudness": 0, //WORD
"reserved": "", //180
"codingHistory": "" // string, unlimited
* The data of the "ds64" chunk.
* Used only with RF64 files.
this.ds64 = {
/** @type {!string} */
"riffSizeHigh": 0, // DWORD
"riffSizeLow": 0, // DWORD
"dataSizeHigh": 0, // DWORD
"dataSizeLow": 0, // DWORD
"originationTime": 0, // DWORD
"sampleCountHigh": 0, // DWORD
"sampleCountLow": 0, // DWORD
//"tableLength": 0, // DWORD
/** @export @type {!Array<number>} */
//"table": []
* The data of the "data" chunk.
this.data = {
"samples": []
* The data of the "LIST" chunks.
* Each item in this list must have this signature:
* {
* "chunkId": "",
* "chunkSize": 0,
* "format": "",
* "subChunks": []
* }
* @type {!Array<Object>}
this.LIST = [];
* The data of the "junk" chunk.
this.junk = {
"chunkData": []
* If the data in data.samples is interleaved or not.
* @type {!boolean}
this.isInterleaved = true;
this.bitDepth = "0";
* Audio formats.
* Formats not listed here will be set to 65534
* and treated as WAVE_FORMAT_EXTENSIBLE
* @enum {!number}
* @private
this.audioFormats_ = {
"4": 17,
"8": 1,
"8a": 6,
"8m": 7,
"16": 1,
"24": 1,
"32": 1,
"32f": 3,
"40": 65534,
"48": 65534,
"64": 3
this.head_ = 0;
// Load a file from the buffer if one was passed
// when creating the object
if(bytes) {
this.fromBuffer(bytes);
}
* Set up a WaveFile object based on the arguments passed.
* @param {!number} numChannels The number of channels
* (Integer numbers: 1 for mono, 2 stereo and so on).
* @param {!number} sampleRate The sample rate.
* Integer numbers like 8000, 44100, 48000, 96000, 192000.
* @param {!string} bitDepth The audio bit depth.
* One of "4", "8", "8a", "8m", "16", "24", "32", "32f", "64"
* or any value between "8" and "32".
* @param {!Array<number>} samples Array of samples to be written.
* The samples must be in the correct range according to the
* bit depth.
* @throws {Error} If any argument does not meet the criteria.
fromScratch(numChannels, sampleRate, bitDepth, samples, options={}) {
if (!options["container"]) {
options["container"] = "RIFF";
this.bitDepth = bitDepth;
// interleave the samples if they were passed de-interleaved
this.data.samples = samples;
if (samples.length > 0) {
if (samples[0].constructor === Array) {
this.isInterleaved = false;
this.assureInterleaved_();
// closest nuber of bytes if not / 8
let numBytes = (((parseInt(bitDepth, 10) - 1) | 7) + 1) / 8;
// Normal PCM file header
if (["8","16","24","32","32f","64"].indexOf(bitDepth) > -1) {
this.createPCMHeader_(
bitDepth, numChannels, sampleRate, numBytes, options);
// IMA ADPCM header
} else if (bitDepth == "4") {
this.createADPCMHeader_(
// A-Law and mu-Law header
} else if (bitDepth == "8a" || bitDepth == "8m") {
this.createALawMulawHeader_(
// WAVE_FORMAT_EXTENSIBLE
} else {
this.createExtensibleHeader_(
// the data chunk
this.data.chunkId = "data";
this.data.chunkSize = this.data.samples.length * numBytes;
this.validateHeader_();
this.LEorBE_();
* Create the header of a ADPCM wave file.
* @param {!string} bitDepth The audio bit depth
* @param {!number} numBytes The number of bytes each sample use.
* @param {!Object} options The extra options, like container defintion.
createADPCMHeader_(bitDepth, numChannels, sampleRate, numBytes, options) {
this.chunkSize = 40 + this.data.samples.length;
this.fmt.chunkSize = 20;
this.fmt.byteRate = 4055;
this.fmt.blockAlign = 256;
this.fmt.bitsPerSample = 4;
this.fmt.cbSize = 2;
this.fmt.validBitsPerSample = 505;
this.fact.chunkId = "fact";
this.fact.chunkSize = 4;
this.fact.dwSampleLength = this.data.samples.length * 2;
this.data.chunkSize = this.data.samples.length;
* Create the header of WAVE_FORMAT_EXTENSIBLE file.
createExtensibleHeader_(
bitDepth, numChannels, sampleRate, numBytes, options) {
this.chunkSize = 36 + 24 + this.data.samples.length * numBytes;
this.fmt.chunkSize = 40;
this.fmt.bitsPerSample = ((parseInt(bitDepth, 10) - 1) | 7) + 1;
this.fmt.cbSize = 22;
this.fmt.validBitsPerSample = parseInt(bitDepth, 10);
this.fmt.dwChannelMask = 0;
// subformat 128-bit GUID as 4 32-bit values
// only supports uncompressed integer PCM samples
this.fmt.subformat = [1, 1048576, 2852126848, 1905997824];
* Create the header of mu-Law and A-Law wave files.
createALawMulawHeader_(
this.fmt.validBitsPerSample = 8;
this.fact.dwSampleLength = this.data.samples.length;
* Create the header of a linear PCM wave file.
createPCMHeader_(bitDepth, numChannels, sampleRate, numBytes, options) {
this.clearHeader_();
this.container = options["container"];
this.chunkSize = 36 + this.data.samples.length * numBytes;
this.format = "WAVE";
this.fmt.chunkId = "fmt ";
this.fmt.chunkSize = 16;
this.fmt.byteRate = (numChannels * numBytes) * sampleRate;
this.fmt.blockAlign = numChannels * numBytes;
this.fmt.audioFormat = this.audioFormats_[bitDepth] ?
this.audioFormats_[bitDepth] : 65534;
this.fmt.numChannels = numChannels;
this.fmt.sampleRate = sampleRate;
this.fmt.bitsPerSample = parseInt(bitDepth, 10);
this.fmt.cbSize = 0;
this.fmt.validBitsPerSample = 0;
* Init a WaveFile object from a byte buffer.
* @param {!Uint8Array|!Array<number>} bytes The buffer.
* @throws {Error} If container is not RIFF or RIFX.
fromBuffer(bytes) {
this.readRIFFChunk_(bytes);
let chunk = riffChunks_.read(bytes);
this.readDs64Chunk_(chunk["subChunks"]);
this.readFmtChunk_(chunk["subChunks"]);
this.readFactChunk_(chunk["subChunks"]);
this.readBextChunk_(chunk["subChunks"]);
this.readCueChunk_(chunk["subChunks"]);
this.readDataChunk_(chunk["subChunks"]);
this.readLISTChunk_(chunk["subChunks"]);
this.readJunkChunk_(chunk["subChunks"]);
this.bitDepthFromFmt_();
* Return a byte buffer representig the WaveFile object as a wav file.
* The return value of this method can be written straight to disk.
* @return {!Uint8Array} A .wav file.
* @throws {Error} If any property of the object appears invalid.
toBuffer() {
return this.createWaveFile_();
* Return a base64 string representig the WaveFile object as a wav file.
* @return {string} A .wav file as a base64 string.
toBase64() {
return encodeBase64(this.toBuffer());
* The return of this method can be used to load the audio in browsers.
* @return {string} A .wav file as a DataURI.
toDataURI() {
return "data:audio/wav;base64," + this.toBase64();
* Force a file as RIFF.
toRIFF() {
if (this.container == "RF64") {
this.fromScratch(
this.fmt.numChannels,
this.fmt.sampleRate,
this.bitDepth,
this.data.samples);
this.container = "RIFF";
* Force a file as RIFX.
toRIFX() {
this.data.samples,
{"container": "RIFX"});
this.container = "RIFX";
* Change the bit depth of the samples.
* @param {!string} bitDepth The new bit depth of the samples.
* One of "8" ... "32" (integers), "32f" or "64" (floats)
* @param {!boolean} changeResolution A boolean indicating if the
* resolution of samples should be actually changed or not.
* @throws {Error} If the bit depth is not valid.
toBitDepth(bitDepth, changeResolution=true) {
let toBitDepth = bitDepth;
let thisBitDepth = this.bitDepth;
if (!changeResolution) {
toBitDepth = this.realBitDepth_(bitDepth);
thisBitDepth = this.realBitDepth_(this.bitDepth);
this.assureUncompressed_();
bitDepth_.toBitDepth(this.data.samples, thisBitDepth, toBitDepth);
bitDepth,
{"container": this.correctContainer_()});
* Interleave multi-channel samples.
interleave() {
if (!this.isInterleaved) {
let finalSamples = [];
let numChannels = this.data.samples[0].length;
for (let i = 0; i < numChannels; i++) {
for (let j = 0; j < this.data.samples.length; j++) {
finalSamples.push(this.data.samples[j][i]);
this.data.samples = finalSamples;
* De-interleave samples into multiple channels.
deInterleave() {
if (this.isInterleaved) {
let i;
for (i = 0; i < this.fmt.numChannels; i++) {
finalSamples[i] = [];
i = 0;
let j;
while (i < this.data.samples.length) {
for (j = 0; j < this.fmt.numChannels; j++) {
finalSamples[j].push(this.data.samples[i+j]);
i += j;
* Encode a 16-bit wave file as 4-bit IMA ADPCM.
* @throws {Error} If sample rate is not 8000.
* @throws {Error} If number of channels is not 1.
toIMAADPCM() {
if (this.fmt.sampleRate != 8000) {
throw new Error(
"Only 8000 Hz files can be compressed as IMA-ADPCM.");
} else if(this.fmt.numChannels != 1) {
"Only mono files can be compressed as IMA-ADPCM.");
this.assure16Bit_();
"4",
imaadpcm_.encode(this.data.samples),
* Decode a 4-bit IMA ADPCM wave file as a 16-bit wave file.
* One of "8" ... "32" (integers), "32f" or "64" (floats).
* Optional. Default is 16.
fromIMAADPCM(bitDepth="16") {
"16",
imaadpcm_.decode(this.data.samples, this.fmt.blockAlign),
if (bitDepth != "16") {
this.toBitDepth(bitDepth);
* Encode 16-bit wave file as 8-bit A-Law.
toALaw() {
"8a",
alawmulaw_.alaw.encode(this.data.samples),
* Decode a 8-bit A-Law wave file into a 16-bit wave file.
fromALaw(bitDepth="16") {
alawmulaw_.alaw.decode(this.data.samples),
* Encode 16-bit wave file as 8-bit mu-Law.
toMuLaw() {
"8m",
alawmulaw_.mulaw.encode(this.data.samples),
* Decode a 8-bit mu-Law wave file into a 16-bit wave file.
fromMuLaw(bitDepth="16") {
alawmulaw_.mulaw.decode(this.data.samples),
* Write a RIFF tag in the INFO chunk. If the tag do not exist,
* then it is created. It if exists, it is overwritten.
* @param {!string} tag The tag name.
* @param {!string} value The tag value.
* @return {boolean} True if the tag was set.
* @throws {Error} If the tag name is not valid.
setTag(tag, value) {
tag = this.fixTagName_(tag);
let index = this.getTagIndex_(tag);
if (index.TAG !== null) {
this.LIST[index.LIST]["subChunks"][index.TAG]["chunkSize"] =
value.length + 1;
this.LIST[index.LIST]["subChunks"][index.TAG]["value"] = value;
} else if (index.LIST !== null) {
this.LIST[index.LIST]["subChunks"].push({
"chunkId": tag,
"chunkSize": value.length + 1,
"value": value});
this.LIST.push({
"chunkId": "LIST",
"chunkSize": 8 + value.length + 1,
"format": "INFO",
"chunkData": [],
"subChunks": []});
this.LIST[this.LIST.length - 1]["subChunks"].push({
return true;
* Return the value of a RIFF tag in the INFO chunk.
* @return {!string|null} The value if the tag is found, null otherwise.
getTag(tag) {
return this.LIST[index.LIST]["subChunks"][index.TAG]["value"];
return null;
* Remove a RIFF tag in the INFO chunk.
* @return {boolean} True if a tag was deleted.
deleteTag(tag) {
this.LIST[index.LIST]["subChunks"].splice(index.TAG, 1);
return false;
* Create a cue point in the wave file.
* @param {!number} position The cue point position in milisenconds
* @param {!string} labl The LIST adtl labl text of the marker.
setCuePoint(position, labl) {
this.cue.chunkId = "cue ";
position = (position * this.fmt.sampleRate) / 1000;
let existingPoints = this.getCuePoints_();
this.clearLISTadtl_();
let len = this.cue.points.length;
this.cue.points = [];
let hasSet = false;
if (len == 0) {
this.setCuePoint_(position, 1, labl);
for (let i=0; i<len; i++) {
if (existingPoints[i]["dwPosition"] > position && !hasSet) {
this.setCuePoint_(position, i + 1, labl);
this.setCuePoint_(
existingPoints[i]["dwPosition"],
i + 2,
existingPoints[i]["label"]);
hasSet = true;
i + 1,
if (!hasSet) {
this.setCuePoint_(position, this.cue.points.length + 1, labl);
this.cue.dwCuePoints = this.cue.points.length;
* Create a new "labl" subchunk in a "LIST" chunk of type "adtl".
* @param {!number} dwName The ID of the cue point.
* @param {!string} label The label for the cue point.
setLabl_(dwName, label="") {
let adtlIndex = this.getAdtlChunk_();
if (adtlIndex === null) {
"chunkSize": 4,
"format": "adtl",
adtlIndex = this.getAdtlChunk_();
this.setLabelText_(adtlIndex === null ? 0 : adtlIndex, dwName, label);
* @param {!number} adtlIndex The index of the "adtl" LIST in this.LIST.
setLabelText_(adtlIndex, dwName, label) {
this.LIST[adtlIndex]["subChunks"].push({
"chunkId": "labl",
"chunkSize": label.length,
"dwName": dwName,
"value": label
});
this.LIST[adtlIndex]["chunkSize"] += label.length + 4 + 4 + 4 + 1;
* Return the index of the "adtl" LIST in this.LIST.
* @return {!number|null}
getAdtlChunk_() {
for (let i=0; i<this.LIST.length; i++) {
if(this.LIST[i]["format"] == 'adtl') {
return i;
* Remove a cue point from a wave file.
* @param {!number} index the index of the point. First is 1,
* second is 2, and so on.
deleteCuePoint(index) {
if (i + 1 != index) {
if (this.cue.dwCuePoints) {
this.cue.chunkId = 'cue ';
this.cue.chunkId = '';
* Push a new cue point in this.cue.points.
* @param {!number} position The position in miliseconds
* @param {!number} dwName the dwName of the cue point
setCuePoint_(position, dwName, label) {
this.cue.points.push({
"dwPosition": position,
"fccChunk": "data",
"dwChunkStart": 0,
"dwBlockStart": 0,
"dwSampleOffset": position,
this.setLabl_(dwName, label);
* Return an array with the position of all cue points in the file.
* @return {!Array<number>}
getCuePoints_() {
let points = [];
for (let i=0; i<this.cue.points.length; i++) {
let point = {
'dwPosition': this.cue.points[i]["dwPosition"],
'label': this.getLabelForCuePoint_(
this.cue.points[i]["dwName"])};
points.push(point);
return points;
* Return the label for a cue point.
* @param {!number} pointDwName The ID of the cue point.
* @return {!string}
getLabelForCuePoint_(pointDwName) {
if (adtlIndex !== null) {
for (let i=0; i<this.LIST[adtlIndex]["subChunks"].length; i++) {
if (this.LIST[adtlIndex]["subChunks"][i]["dwName"] ==
pointDwName) {
return this.LIST[adtlIndex]["subChunks"][i]["value"];
return "";
* Clear any LIST chunk labeled as "adtl".
clearLISTadtl_() {
if (this.LIST[i]["format"] == 'adtl') {
this.LIST.splice(i);
* Return the index of a tag in a FILE chunk.
* @return {!Object<string, number|null>}
* Object.LIST is the INFO index in LIST
* Object.TAG is the tag index in the INFO
getTagIndex_(tag) {
let index = {LIST: null, TAG: null};
if (this.LIST[i]["format"] == "INFO") {
index.LIST = i;
for (let j=0; j<this.LIST[i]["subChunks"].length; j++) {
if (this.LIST[i]["subChunks"][j]["chunkId"] == tag) {
index.TAG = j;
break;
return index;
* Fix a RIFF tag format if possible, throw an error otherwise.
* @return {string} The tag name in proper fourCC format.
fixTagName_(tag) {
if (tag.constructor !== String) {
throw new Error("Invalid tag name.");
} else if(tag.length < 4) {
for (let i=0; i<4-tag.length; i++) {
tag += ' ';
return tag;
* Return the closest greater number of bits for a number of bits that
* do not fill a full sequence of bytes.
* @param {!string} bitDepth The bit depth.
realBitDepth_(bitDepth) {
if (bitDepth != "32f") {
bitDepth = (((parseInt(bitDepth, 10) - 1) | 7) + 1).toString();
return bitDepth;
* Validate the header of the file.
validateHeader_() {
this.validateBitDepth_();
this.validateNumChannels_();
this.validateSampleRate_();
* Validate the bit depth.
* @return {!boolean} True is the bit depth is valid.
* @throws {Error} If bit depth is invalid.
validateBitDepth_() {
if (!this.audioFormats_[this.bitDepth]) {
if (parseInt(this.bitDepth, 10) > 8 &&
parseInt(this.bitDepth, 10) < 54) {
throw new Error("Invalid bit depth.");
* Validate the number of channels.
* @return {!boolean} True is the number of channels is valid.
* @throws {Error} If the number of channels is invalid.
validateNumChannels_() {
let blockAlign = this.fmt.numChannels * this.fmt.bitsPerSample / 8;
if (this.fmt.numChannels < 1 || blockAlign > 65535) {
throw new Error("Invalid number of channels.");
* Validate the sample rate value.
* @return {!boolean} True is the sample rate is valid.
* @throws {Error} If the sample rate is invalid.
validateSampleRate_() {
let byteRate = this.fmt.numChannels *
(this.fmt.bitsPerSample / 8) * this.fmt.sampleRate;
if (this.fmt.sampleRate < 1 || byteRate > 4294967295) {
throw new Error("Invalid sample rate.");
* Reset attributes that should emptied when a file is
* created with the fromScratch() or fromBuffer() methods.
clearHeader_() {
this.fact.chunkId = "";
this.ds64.chunkId = "";
* Make the file 16-bit if it is not.
assure16Bit_() {
if (this.bitDepth != "16") {
this.toBitDepth("16");
* Uncompress the samples in case of a compressed file.
assureUncompressed_() {
if (this.bitDepth == "8a") {
this.fromALaw();
} else if(this.bitDepth == "8m") {
this.fromMuLaw();
} else if (this.bitDepth == "4") {
this.fromIMAADPCM();
* Interleave the samples in case they are de-Interleaved.
assureInterleaved_() {
this.interleave();
* Set up to work wih big-endian or little-endian files.
* The types used are changed to LE or BE. If the
* the file is big-endian (RIFX), true is returned.
* @return {!boolean} True if the file is RIFX.
LEorBE_() {
let bigEndian = this.container === "RIFX";
uInt16_["be"] = bigEndian;
uInt32_["be"] = bigEndian;
return bigEndian;
* Find a chunk by its fourCC_ in a array of RIFF chunks.
* @param {!Array<!Object>} chunks The wav file chunks.
* @param {!string} chunkId The chunk fourCC_.
* @param {boolean} multiple True if there may be multiple chunks
* with the same chunkId.
* @return {Object|Array<Object>|null}
findChunk_(chunks, chunkId, multiple=false) {
let chunk = [];
for (let i=0; i<chunks.length; i++) {
if (chunks[i]["chunkId"] == chunkId) {
if (multiple) {
chunk.push(chunks[i]);
return chunks[i];
if (chunkId == "LIST") {
return chunk.length ? chunk : null;
* Read the RIFF chunk a wave file.
* @param {!Uint8Array|!Array<number>} bytes A wav buffer.
readRIFFChunk_(bytes) {
this.container = this.readString_(bytes, 4);
if (["RIFF", "RIFX", "RF64"].indexOf(this.container) === -1) {
throw Error("Not a supported format.");
this.chunkSize = this.read_(bytes, uInt32_);
this.format = this.readString_(bytes, 4);
if (this.format != "WAVE") {
throw Error("Could not find the 'WAVE' format identifier");
* Read the "fmt " chunk of a wave file.
readFmtChunk_(chunks) {
let chunk = this.findChunk_(chunks, "fmt ");
if (chunk) {
let chunkData = chunk["chunkData"];
this.fmt.chunkId = chunk["chunkId"];
this.fmt.chunkSize = chunk["chunkSize"];
this.fmt.audioFormat = this.read_(chunkData, uInt16_);
this.fmt.numChannels = this.read_(chunkData, uInt16_);
this.fmt.sampleRate = this.read_(chunkData, uInt32_);
this.fmt.byteRate = this.read_(chunkData, uInt32_);
this.fmt.blockAlign = this.read_(chunkData, uInt16_);
this.fmt.bitsPerSample = this.read_(chunkData, uInt16_);
this.readFmtExtension_(chunkData);
throw Error("Could not find the 'fmt ' chunk");
* Read the "fmt " chunk extension.
* @param {!Array<number>} chunkData The "fmt " chunk.
readFmtExtension_(chunkData) {
if (this.fmt.chunkSize > 16) {
this.fmt.cbSize = this.read_(
chunkData, uInt16_);
if (this.fmt.chunkSize > 18) {
this.fmt.validBitsPerSample = this.read_(chunkData, uInt16_);
if (this.fmt.chunkSize > 20) {
this.fmt.dwChannelMask = this.read_(chunkData, uInt32_);
this.fmt.subformat = [
this.read_(chunkData, uInt32_),
this.read_(chunkData, uInt32_)];
* Read the "fact" chunk of a wav file.
* @param {!Array<Object>} chunks The wav file chunks.
* @throws {Error} If no "fact" chunk is found.
readFactChunk_(chunks) {
let chunk = this.findChunk_(chunks, "fact");
this.fact.chunkId = chunk["chunkId"];
this.fact.chunkSize = chunk["chunkSize"];
this.fact.dwSampleLength = this.read_(chunk["chunkData"], uInt32_);
* Read the "cue " chunk of a wave file.
* @param {!Array<Object>} chunks The RIFF file chunks.
readCueChunk_(chunks) {
let chunk = this.findChunk_(chunks, "cue ");
this.cue.chunkId = chunk["chunkId"];
this.cue.chunkSize = chunk["chunkSize"];
this.cue.dwCuePoints = this.read_(chunkData, uInt32_);
for (let i=0; i<this.cue.dwCuePoints; i++) {
"dwName": this.read_(chunkData, uInt32_),
"dwPosition": this.read_(chunkData, uInt32_),
"fccChunk": this.readString_(chunkData, 4),
"dwChunkStart": this.read_(chunkData, uInt32_),
"dwBlockStart": this.read_(chunkData, uInt32_),
"dwSampleOffset": this.read_(chunkData, uInt32_),
* Read the "data" chunk of a wave file.
readDataChunk_(chunks) {
let chunk = this.findChunk_(chunks, "data");
this.data.chunkSize = chunk["chunkSize"];
this.samplesFromBytes_(chunk["chunkData"]);
throw Error("Could not find the 'data' chunk");
* Read the "bext" chunk of a wav file.
readBextChunk_(chunks) {
let chunk = this.findChunk_(chunks, "bext");
this.bext.chunkId = chunk["chunkId"];
this.bext.chunkSize = chunk["chunkSize"];
this.bext.description = this.readString_(chunkData, 256);
this.bext.originator = this.readString_(chunkData, 32);
this.bext.originatorReference = this.readString_(chunkData, 32);
this.bext.originationDate = this.readString_(chunkData, 10);
this.bext.originationTime = this.readString_(chunkData, 8);
this.bext.timeReference = [
this.bext.version = this.read_(chunkData, uInt16_);
this.bext.UMID = this.readString_(chunkData, 64);
this.bext.loudnessValue = this.read_(chunkData, uInt16_);
this.bext.loudnessRange = this.read_(chunkData, uInt16_);
this.bext.maxTruePeakLevel = this.read_(chunkData, uInt16_);
this.bext.maxMomentaryLoudness = this.read_(chunkData, uInt16_);
this.bext.maxShortTermLoudness = this.read_(chunkData, uInt16_);
this.bext.reserved = this.readString_(chunkData, 180);
this.bext.codingHistory = this.readString_(
chunkData, this.bext.chunkSize - 602);
* Read the "ds64" chunk of a wave file.
* @throws {Error} If no "ds64" chunk is found and the file is RF64.
readDs64Chunk_(chunks) {
let chunk = this.findChunk_(chunks, "ds64");
this.ds64.chunkId = chunk["chunkId"];
this.ds64.chunkSize = chunk["chunkSize"];
this.ds64.riffSizeHigh = this.read_(chunkData, uInt32_);
this.ds64.riffSizeLow = this.read_(chunkData, uInt32_);
this.ds64.dataSizeHigh = this.read_(chunkData, uInt32_);
this.ds64.dataSizeLow = this.read_(chunkData, uInt32_);
this.ds64.originationTime = this.read_(chunkData, uInt32_);
this.ds64.sampleCountHigh = this.read_(chunkData, uInt32_);
this.ds64.sampleCountLow = this.read_(chunkData, uInt32_);
//if (this.ds64.chunkSize > 28) {
// this.ds64.tableLength = byteData_.unpack(
// chunkData.slice(28, 32), uInt32_);
// this.ds64.table = chunkData.slice(
// 32, 32 + this.ds64.tableLength);
//}
throw Error("Could not find the 'ds64' chunk");
* Read the "LIST" chunks of a wave file.
readLISTChunk_(chunks) {
let listChunks = this.findChunk_(chunks, "LIST", true);
if (listChunks === null) {
return;
for (let j=0; j<listChunks.length; j++) {
let subChunk = listChunks[j];
"chunkId": subChunk["chunkId"],
"chunkSize": subChunk["chunkSize"],
"format": subChunk["format"],
"chunkData": subChunk["chunkData"],
for (let x=0; x<subChunk["subChunks"].length; x++) {
this.readLISTSubChunks_(subChunk["subChunks"][x],
subChunk["format"]);
* Read the sub chunks of a "LIST" chunk.
* @param {!Object} subChunk The "LIST" subchunks.
* @param {!string} format The "LIST" format, "adtl" or "INFO".
readLISTSubChunks_(subChunk, format) {
// 'labl', 'note', 'ltxt', 'file'
if (format == 'adtl') {
if (["labl", "note"].indexOf(subChunk["chunkId"]) > -1) {
"dwName": byteData_.unpack(
subChunk["chunkData"].slice(0, 4),uInt32_),
"value": this.readZSTR_(subChunk["chunkData"].slice(4))
// RIFF 'INFO' tags like ICRD, ISFT, ICMT
// https://sno.phy.queensu.ca/~phil/exiftool/TagNames/RIFF.html#Info
} else if(format == 'INFO') {
"value": this.readZSTR_(subChunk["chunkData"].slice(0))
} //else {
// this.LIST[this.LIST.length - 1]["subChunks"].push({
// "chunkId": subChunk["chunkId"],
// "chunkSize": subChunk["chunkSize"],
// "value": subChunk["chunkData"]
// });
* Read the "junk" chunk of a wave file.
readJunkChunk_(chunks) {
let chunk = this.findChunk_(chunks, "junk");
"chunkId": chunk["chunkId"],
"chunkSize": chunk["chunkSize"],
"chunkData": chunk["chunkData"]
* Read bytes as a ZSTR string.
* @param {!Array<number>|!Uint8Array} bytes The bytes.
* @return {!string} The string.
readZSTR_(bytes) {
let str = "";
for (let i=0; i<bytes.length; i++) {
if (bytes[i] === 0) {
str += byteData_.unpack([bytes[i]], chr_);
return str;
* Read bytes as a string from a RIFF chunk.
* @param {!number} maxSize the max size of the string.
readString_(bytes, maxSize) {
for (let i=0; i<maxSize; i++) {
str += byteData_.unpack([bytes[this.head_]], chr_);
this.head_++;
* Read a number from a chunk.
* @param {!Array<number>|!Uint8Array} bytes The chunk bytes.
* @param {!Object} bdType The type definition.
* @return {number} The number.
read_(bytes, bdType) {
let size = bdType["bits"] / 8;
let value = byteData_.unpack(
bytes.slice(this.head_, this.head_ + size), bdType);
this.head_ += size;
return value;
* Write a variable size string as bytes. If the string is smaller
* than the max size the output array is filled with 0s.
* @param {!string} str The string to be written as bytes.
* @return {!Array<number>} The bytes.
writeString_(str, maxSize, push=true) {
let bytes = byteData_.packArray(str, chr_);
if (push) {
for (let i=bytes.length; i<maxSize; i++) {
bytes.push(0);
return bytes;
* Turn the samples to bytes.
samplesToBytes_() {
let bdType = {
"be": this.container === "RIFX",
"bits": this.fmt.bitsPerSample == 4 ? 8 : this.fmt.bitsPerSample,
"float": this.fmt.audioFormat == 3 ? true : false
bdType["signed"] = bdType["bits"] == 8 ? false : true;
let bytes = byteData_.packArray(this.data.samples, bdType);
* Turn bytes to samples and load them in the data.samples property.
samplesFromBytes_(bytes) {
this.data.samples = byteData_.unpackArray(bytes, bdType);
* Return the bytes of the "bext" chunk.
* @return {!Array<number>} The "bext" chunk bytes.
getBextBytes_() {
let bextBytes = [];
if (this.bext.chunkId) {
return bextBytes.concat(
byteData_.pack(this.bext.chunkId, fourCC_),
byteData_.pack(602 + this.bext.codingHistory.length, uInt32_),
this.writeString_(this.bext.description, 256),
this.writeString_(this.bext.originator, 32),
this.writeString_(this.bext.originatorReference, 32),
this.writeString_(this.bext.originationDate, 10),
this.writeString_(this.bext.originationTime, 8),
byteData_.pack(this.bext.timeReference[0], uInt32_),
byteData_.pack(this.bext.timeReference[1], uInt32_),
byteData_.pack(this.bext.version, uInt16_),
this.writeString_(this.bext.UMID, 64),
byteData_.pack(this.bext.loudnessValue, uInt16_),
byteData_.pack(this.bext.loudnessRange, uInt16_),
byteData_.pack(this.bext.maxTruePeakLevel, uInt16_),
byteData_.pack(this.bext.maxMomentaryLoudness, uInt16_),
byteData_.pack(this.bext.maxShortTermLoudness, uInt16_),
this.writeString_(this.bext.reserved, 180),
this.writeString_(
this.bext.codingHistory, this.bext.codingHistory.length));
return bextBytes;
* Return the bytes of the "ds64" chunk.
* @return {!Array<number>} The "ds64" chunk bytes.
getDs64Bytes_() {
let ds64Bytes = [];
if (this.ds64.chunkId) {
ds64Bytes = ds64Bytes.concat(
byteData_.pack(this.ds64.chunkId, fourCC_),
byteData_.pack(this.ds64.chunkSize, uInt32_), //
byteData_.pack(this.ds64.riffSizeHigh, uInt32_),
byteData_.pack(this.ds64.riffSizeLow, uInt32_),
byteData_.pack(this.ds64.dataSizeHigh, uInt32_),
byteData_.pack(this.ds64.dataSizeLow, uInt32_),
byteData_.pack(this.ds64.originationTime, uInt32_),
byteData_.pack(this.ds64.sampleCountHigh, uInt32_),
byteData_.pack(this.ds64.sampleCountLow, uInt32_));
//if (this.ds64.tableLength) {
// ds64Bytes = ds64Bytes.concat(
// byteData_.pack(this.ds64.tableLength, uInt32_),
// this.ds64.table);
return ds64Bytes;
* Return the bytes of the "cue " chunk.
* @return {!Array<number>} The "cue " chunk bytes.
getCueBytes_() {
let cueBytes = [];
if (this.cue.chunkId) {
let cuePointsBytes = this.getCuePointsBytes_();
return cueBytes.concat(
byteData_.pack(this.cue.chunkId, fourCC_),
byteData_.pack(cuePointsBytes.length + 4, uInt32_),
byteData_.pack(this.cue.dwCuePoints, uInt32_),
cuePointsBytes);
return cueBytes;
* Return the bytes of the "cue " points.
* @return {!Array<number>} The "cue " points as an array of bytes.
getCuePointsBytes_() {
points = points.concat(
byteData_.pack(this.cue.points[i]["dwName"], uInt32_),
byteData_.pack(this.cue.points[i]["dwPosition"], uInt32_),
byteData_.pack(this.cue.points[i]["fccChunk"], fourCC_),
byteData_.pack(this.cue.points[i]["dwChunkStart"], uInt32_),
byteData_.pack(this.cue.points[i]["dwBlockStart"], uInt32_),
byteData_.pack(this.cue.points[i]["dwSampleOffset"], uInt32_));
* Return the bytes of the "fact" chunk.
* @return {!Array<number>} The "fact" chunk bytes.
getFactBytes_() {
let factBytes = [];
if (this.fact.chunkId) {
return factBytes.concat(
byteData_.pack(this.fact.chunkId, fourCC_),
byteData_.pack(this.fact.chunkSize, uInt32_),
byteData_.pack(this.fact.dwSampleLength, uInt32_));
return factBytes;
* Return the bytes of the "fmt " chunk.
* @return {!Array<number>} The "fmt" chunk bytes.
* @throws {Error} if no "fmt " chunk is present.
getFmtBytes_() {
if (this.fmt.chunkId) {
return [].concat(
byteData_.pack(this.fmt.chunkId, fourCC_),
byteData_.pack(this.fmt.chunkSize, uInt32_),
byteData_.pack(this.fmt.audioFormat, uInt16_),
byteData_.pack(this.fmt.numChannels, uInt16_),
byteData_.pack(this.fmt.sampleRate, uInt32_),
byteData_.pack(this.fmt.byteRate, uInt32_),
byteData_.pack(this.fmt.blockAlign, uInt16_),
byteData_.pack(this.fmt.bitsPerSample, uInt16_),
this.getFmtExtensionBytes_()
);
else
if
* Return the bytes of the fmt extension fields.
* @return {!Array<number>} The fmt extension bytes.
getFmtExtensionBytes_() {
let extension = [];
extension = extension.concat(
byteData_.pack(this.fmt.cbSize, uInt16_));
byteData_.pack(this.fmt.validBitsPerSample, uInt16_));
byteData_.pack(this.fmt.dwChannelMask, uInt32_));
if (this.fmt.chunkSize > 24) {
byteData_.pack(this.fmt.subformat[0], uInt32_),
byteData_.pack(this.fmt.subformat[1], uInt32_),
byteData_.pack(this.fmt.subformat[2], uInt32_),
byteData_.pack(this.fmt.subformat[3], uInt32_));
return extension;
* Return the bytes of the "LIST" chunk.
* @return {!Array<number>} The "LIST" chunk bytes.
* @export for tests
getLISTBytes_() {
let bytes = [];
let subChunksBytes = this.getLISTSubChunksBytes_(
this.LIST[i]["subChunks"], this.LIST[i]["format"]);
bytes = bytes.concat(
byteData_.pack(this.LIST[i]["chunkId"], fourCC_),
byteData_.pack(subChunksBytes.length + 4, uInt32_),
byteData_.pack(this.LIST[i]["format"], fourCC_),
subChunksBytes);
* Return the bytes of the sub chunks of a "LIST" chunk.
* @param {!Array<Object>} subChunks The "LIST" sub chunks.
* @param {!string} format The format of the "LIST" chunk.
* Currently supported values are "adtl" or "INFO".
* @return {!Array<number>} The sub chunk bytes.
getLISTSubChunksBytes_(subChunks, format) {
for (let i=0; i<subChunks.length; i++) {
if (format == "INFO") {
byteData_.pack(subChunks[i]["chunkId"], fourCC_),
byteData_.pack(subChunks[i]["value"].length + 1, uInt32_),
subChunks[i]["value"], subChunks[i]["value"].length));
} else if (format == "adtl") {
if (["labl", "note"].indexOf(subChunks[i]["chunkId"]) > -1) {
byteData_.pack(
subChunks[i]["value"].length + 4 + 1, uInt32_),
byteData_.pack(subChunks[i]["dwName"], uInt32_),
subChunks[i]["value"],
subChunks[i]["value"].length));
// bytes = bytes.concat(
// byteData_.pack(
// subChunks[i]["chunkData"].length, uInt32_),
// subChunks[i]["chunkData"]
// );
if (bytes.length % 2) {
* Return the bytes of the "junk" chunk.
* @return {!Array<number>} The "junk" chunk bytes.
getJunkBytes_() {
let junkBytes = [];
if (this.junk.chunkId) {
return junkBytes.concat(
byteData_.pack(this.junk.chunkId, fourCC_),
byteData_.pack(this.junk.chunkData.length, uInt32_),
this.junk.chunkData);
return junkBytes;
* Return "RIFF" if the container is "RF64", the current container name
* otherwise. Used to enforce "RIFF" when RF64 is not allowed.
correctContainer_() {
return this.container == "RF64" ? "RIFF" : this.container;
* Set the string code of the bit depth based on the "fmt " chunk.
bitDepthFromFmt_() {
if (this.fmt.audioFormat == 3 && this.fmt.bitsPerSample == 32) {
this.bitDepth = "32f";
} else if (this.fmt.audioFormat == 6) {
this.bitDepth = "8a";
} else if (this.fmt.audioFormat == 7) {
this.bitDepth = "8m";
this.bitDepth = this.fmt.bitsPerSample.toString();
* Return a .wav file byte buffer with the data from the WaveFile object.
* @return {!Uint8Array} The wav file bytes.
createWaveFile_() {
let samplesBytes = this.samplesToBytes_();
let fileBody = [].concat(
byteData_.pack(this.format, fourCC_),
this.getJunkBytes_(),
this.getDs64Bytes_(),
this.getBextBytes_(),
this.getFmtBytes_(),
this.getFactBytes_(),
byteData_.pack(this.data.chunkId, fourCC_),
byteData_.pack(samplesBytes.length, uInt32_),
samplesBytes,
this.getCueBytes_(),
this.getLISTBytes_());
return new Uint8Array([].concat(
byteData_.pack(this.container, fourCC_),
byteData_.pack(fileBody.length, uInt32_),
fileBody));
module.exports = WaveFile;
rochars /
wavefile
Rafael Rocha
Loading history...