bitdepth - npm Package Compare versions

Comparing version 1.0.2 to 1.0.3

dist/bitdepth-min.js

 /*
  bitdepth
- Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit..
+ Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit.
  Copyright (c) 2017 Rafael da Silva Rocha.
@@ -8,3 +8,6 @@ https://github.com/rochars/bitdepth
 */
-(function(g){function d(a){if(e[a])return e[a].a;var c=e[a]={m:a,f:!1,a:{}};g[a].call(c.a,c,c.a,d);c.f=!0;return c.a}var e={};d.l=g;d.h=e;d.b=function(a,c){d.c(a)||Object.defineProperty(a,"a",{configurable:!1,enumerable:!0,get:c})};d.i=function(a){var c=a&&a.g?function(){return a["default"]}:function(){return a};d.b(c,c);return c};d.c=function(a){return Object.prototype.hasOwnProperty.call(a,"a")};d.j="";return d(d.o=0)})([function(){var g={8:256,16:65536,24:16777216,32:4294967296};window.toBitDepth=
-function(d,e,a){var c="8 16 24 32 32f 64".split(" ");if(-1==c.indexOf(e)||-1==c.indexOf(a))throw Error("Invalid bit depth.");c=d.length;for(var h=0;h<c;h++){var b=d[h];"8"==e&&(b-=128);if("32f"==a||"64"==a){var f=parseInt(g[e]/2,10);"32f"!=e&&"64"!=e&&(b=0<b?b/(f-1):b/f)}else{f=b;b=parseInt(g[a]/2,10);if("32f"==e||"64"==e)b=0<f?f*(b-1):f*b;else{var k=parseInt(g[e]/2,10);b=f=0<f?parseInt(f/(k-1)*b-1,10):parseInt(f/k*b,10)}b=f=b;"8"==a&&(b+=128)}d[h]=b}};window.BitDepthMaxValues=g}]);
+var l="function"==typeof Object.defineProperties?Object.defineProperty:function(d,c,e){d!=Array.prototype&&d!=Object.prototype&&(d[c]=e.value)},m="undefined"!=typeof window&&window===this?this:"undefined"!=typeof global&&null!=global?global:this;function n(d,c){if(c){var e=m;d=d.split(".");for(var a=0;a<d.length-1;a++){var b=d[a];b in e||(e[b]={});e=e[b]}d=d[d.length-1];a=e[d];c=c(a);c!=a&&null!=c&&l(e,d,{configurable:!0,writable:!0,value:c})}}
+n("Object.is",function(d){return d?d:function(c,e){return c===e?0!==c||1/c===1/e:c!==c&&e!==e}});n("Array.prototype.includes",function(d){return d?d:function(c,e){var a=this;a instanceof String&&(a=String(a));var b=a.length;for(e=e||0;e<b;e++)if(a[e]==c||Object.is(a[e],c))return!0;return!1}});
+(function(d){function c(a){if(e[a])return e[a].a;var b=e[a]={v:a,h:!1,a:{}};d[a].call(b.a,b,b.a,c);b.h=!0;return b.a}var e={};c.u=d;c.j=e;c.f=function(a,b){c.g(a)||Object.defineProperty(a,"a",{configurable:!1,enumerable:!0,get:b})};c.l=function(a){var b=a&&a.i?function(){return a["default"]}:function(){return a};c.f(b,b);return b};c.g=function(a){return Object.prototype.hasOwnProperty.call(a,"a")};c.s="";return c(c.B=0)})([function(){var d=new Float32Array(1),c={8:256,16:65536,24:16777216,32:4294967296,
+"32f":1,64:1},e={A:function(a,b){return a=0<a?parseInt(a/(b.c-1)*b.b-1,10):parseInt(a/b.c*b.b,10)},o:function(a,b){return a=0<a?a*(b.b-1):a*b.b},w:function(a,b){return a=0<a?a/(b.c-1):a/b.c},m:function(a,b){"64"==b.C&&"32f"==b.target&&(d[0]=a,a=d[0]);return a}};window.toBitDepth=function(a,b,d){var g="8 16 24 32 32f 64".split(" ");if(-1==g.indexOf(b)||-1==g.indexOf(d))throw Error("Invalid bit depth.");g=["32f","64"].includes(b)?"float":"int";var k=["32f","64"].includes(d)?"Float":"Int";g=e[g+"To"+
+k];k=a.length;for(var f=0;f<k;f++){var h=a[f];"8"==b&&(h-=128);a[f]=h;a[f]=g(a[f],{old:c[b]/2,"new":c[d]/2,original:b,target:d});h=a[f];"8"==d&&(h+=128);a[f]=h}};window.BitDepthMaxValues=c}]);

dist/bitdepth.js

@@ -72,3 +72,3 @@ /******/ (function(modules) { // webpackBootstrap
  * bitdepth
- * Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit..
+ * Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit.
  * Copyright (c) 2017 Rafael da Silva Rocha.
@@ -79,2 +79,4 @@ * https://github.com/rochars/bitdepth
 
+const f64f32 = new Float32Array(1);
+
 /**
@@ -85,91 +87,105 @@ * Max number of different values for each bit depth.
 const BitDepthMaxValues = {
-    8: 256,
-    16: 65536,
-    24: 16777216,
-    32: 4294967296
+    "8": 256,
+    "16": 65536,
+    "24": 16777216,
+    "32": 4294967296,
+    "32f": 1,
+    "64": 1
 };
 
 /**
- * Change the bit depth of the data.
- * The input array is modified in-place.
- * @param {!Array<number>} samples The samples.
- * @param {string} originalBitDepth The original bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- * @param {string} targetBitDepth The new bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
+ * Functions to change the bit depth of a sample.
  */
-function toBitDepth(samples, originalBitDepth, targetBitDepth) {
-    validateBitDepths(originalBitDepth, targetBitDepth);
-    let len = samples.length;
-    for (let i=0; i<len; i++) {        
-        let sample = samples[i];
-        
-        // 8-bit samples are unsigned;
-        // They are signed here before conversion
-        // (other bit depths are all signed)
-        sample = sign8Bit(sample, originalBitDepth);
+const BitDepthFunctions = {
 
-        // If it is a float-to-float or int-to-float conversion then
-        // the samples in the target bit depth need to be normalized in the
-        // -1.0 to 1.0 range; there is no need to multiply
-        if (targetBitDepth == "32f" || targetBitDepth == "64") {
-            sample = toFloat(sample, originalBitDepth);
+    /**
+     * Change the bit depth from int to int.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    intToInt(sample, args) {
+        if (sample > 0) {
+            sample = parseInt((sample / (args.old - 1)) * args.new - 1, 10);
+        } else {
+            sample = parseInt((sample / args.old) * args.new, 10);
+        }
+        return sample;
+    },
 
-        // If it is a float-to-int or int-to-int conversion then the
-        // samples need to be de-normalized according to the bit depth
+    /**
+     * Change the bit depth from float to int.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    floatToInt(sample, args) {
+        if (sample > 0) {
+            sample = sample * (args.new - 1);
         } else {
-            sample = toInt(sample, originalBitDepth, targetBitDepth);
+            sample = sample * args.new;
         }
-        samples[i] = sample;
-    }
-}
+        return sample;
+    },
 
-/**
- * Sign unsigned 8-bit data.
- * @param {number} sample The sample.
- * @param {string} originalBitDepth The original bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- */
-function sign8Bit(sample, originalBitDepth) {
-    if (originalBitDepth == "8") {
-        sample -= 128;
-    }
-    return sample;
-}
+    /**
+     * Change the bit depth from int to float.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    intToFloat(sample, args) {
+        if (sample > 0) {
+            sample = sample / (args.old - 1);
+        } else {
+            sample = sample / args.old;
+        }
+        return sample;
+    },
 
-/**
- * Unsign signed 8-bit data.
- * @param {number} sample The sample.
- * @param {string} targetBitDepth The target bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- */
-function unsign8Bit(sample, targetBitDepth) {
-    if (targetBitDepth == "8") {
-        sample += 128;
+    /**
+     * Change the bit depth from float to float.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    floatToFloat(sample, args) {
+        if (args.original == "64" && args.target == "32f") {
+            f64f32[0] = sample;
+            sample = f64f32[0];
+        }
+        return sample;
     }
-    return sample;
-}
+};
 
 /**
- * Change the bit depth of a sample to a new floating point bit depth.
+ * Change the bit depth of the data in a sample array.
  * The input array is modified in-place.
- * @param {number} sample The sample.
+ * @param {!Array<number>} samples The samples.
  * @param {string} originalBitDepth The original bit depth of the data.
  *      One of "8", "16", "24", "32", "32f", "64"
+ * @param {string} targetBitDepth The new bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  */
-function toFloat(sample, originalBitDepth) {
-    let oldMaxValue = parseInt((BitDepthMaxValues[originalBitDepth]) / 2, 10);
-    if (originalBitDepth != "32f" && originalBitDepth != "64") {
-        if (sample > 0) {
-            sample = sample / (oldMaxValue - 1);
-        } else {
-            sample = sample / oldMaxValue;
-        }
+function toBitDepth(samples, originalBitDepth, targetBitDepth) {
+    validateBitDepths(originalBitDepth, targetBitDepth);
+    let toFunction = getBitDepthFunction(originalBitDepth, targetBitDepth);
+    let len = samples.length;
+    for (let i=0; i<len; i++) {        
+        samples[i] = sign8Bit(samples[i], originalBitDepth);
+        samples[i] = toFunction(
+                samples[i],
+                {
+                    "old": BitDepthMaxValues[originalBitDepth] / 2,
+                    "new": BitDepthMaxValues[targetBitDepth] / 2,
+                    "original": originalBitDepth,
+                    "target": targetBitDepth
+                }
+            );
+        samples[i] = unsign8Bit(samples[i], targetBitDepth);
     }
-    return sample;
 }
 
 /**
- * Change the bit depth of a sample to a new integer bit depth.
- * @param {number} sample The sample.
+ * Get the function to change the bit depth of a sample.
  * @param {string} originalBitDepth The original bit depth of the data.
@@ -179,38 +195,30 @@ *      One of "8", "16", "24", "32", "32f", "64"
  *      One of "8", "16", "24", "32", "32f", "64"
+ * @return {Function}
  */
-function toInt(sample, originalBitDepth, targetBitDepth) {
-    // If the original samples are float, then they are already
-    // normalized between -1.0 and 1.0; All that is need is to
-    // multiply the sample values by the new bit depth max value
-    let newMaxValue = parseInt((BitDepthMaxValues[targetBitDepth]) / 2, 10);
-    if (originalBitDepth == "32f" || originalBitDepth == "64" ) {
-        sample = floatToInt(sample, newMaxValue);
-    // If the original samples are integers, then they need to be
-    // divided by the maximum values of its original bit depth
-    // (to normalize them between -1.0 and .10) and then multiplied
-    // by the new bit depth max value
+function getBitDepthFunction(originalBitDepth, targetBitDepth) {
+    let prefix;
+    let suffix;
+    if (["32f", "64"].includes(originalBitDepth)) {
+        prefix = "float";
     } else {
-        sample = intToInt(
-                sample,
-                parseInt((BitDepthMaxValues[originalBitDepth]) / 2, 10),
-                newMaxValue
-            );
+        prefix = "int";
     }
-    // Make the samples unsigned if the target bit depth is "8"
-    return unsign8Bit(sample, targetBitDepth);
+    if (["32f", "64"].includes(targetBitDepth)) {
+        suffix = "Float";
+    } else {
+        suffix = "Int";
+    }
+    return BitDepthFunctions[prefix + "To" + suffix];
 }
 
 /**
- * Perform a int-to-int conversion.
+ * Sign unsigned 8-bit data.
  * @param {number} sample The sample.
- * @param {number} oldMaxValue The max value for the original bit depth.
- * @param {number} newMaxValue The max value for the target bit depth.
+ * @param {string} originalBitDepth The original bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  * @return {number}
  */
-function intToInt(sample, oldMaxValue, newMaxValue) {
-    if (sample > 0) {
-        sample =
-            parseInt((sample / (oldMaxValue - 1)) * newMaxValue - 1, 10);
-    } else {
-        sample = parseInt((sample / oldMaxValue) * newMaxValue, 10);
+function sign8Bit(sample, originalBitDepth) {
+    if (originalBitDepth == "8") {
+        sample -= 128;
     }
@@ -221,12 +229,11 @@ return sample;
 /**
- * Perform a float-to-int conversion.
+ * Unsign signed 8-bit data.
  * @param {number} sample The sample.
- * @param {number} newMaxValue The max value for the target bit depth.
+ * @param {string} targetBitDepth The target bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  * @return {number}
  */
-function floatToInt(sample, newMaxValue) {
-    if (sample > 0) {
-        sample = sample * (newMaxValue - 1);
-    } else {
-        sample = sample * newMaxValue;
+function unsign8Bit(sample, targetBitDepth) {
+    if (targetBitDepth == "8") {
+        sample += 128;
     }
@@ -243,2 +250,3 @@ return sample;
  * @throws {Error} If any argument does not meet the criteria.
+ * @return {boolean}
  */
@@ -245,0 +253,0 @@ function validateBitDepths(originalBitDepth, targetBitDepth) {

index.js

 /*!
  * bitdepth
- * Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit..
+ * Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit.
  * Copyright (c) 2017 Rafael da Silva Rocha.
@@ -9,2 +9,4 @@ * https://github.com/rochars/bitdepth
 
+const f64f32 = new Float32Array(1);
+
 /**
@@ -15,91 +17,105 @@ * Max number of different values for each bit depth.
 const BitDepthMaxValues = {
-    8: 256,
-    16: 65536,
-    24: 16777216,
-    32: 4294967296
+    "8": 256,
+    "16": 65536,
+    "24": 16777216,
+    "32": 4294967296,
+    "32f": 1,
+    "64": 1
 };
 
 /**
- * Change the bit depth of the data.
- * The input array is modified in-place.
- * @param {!Array<number>} samples The samples.
- * @param {string} originalBitDepth The original bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- * @param {string} targetBitDepth The new bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
+ * Functions to change the bit depth of a sample.
  */
-function toBitDepth(samples, originalBitDepth, targetBitDepth) {
-    validateBitDepths(originalBitDepth, targetBitDepth);
-    let len = samples.length;
-    for (let i=0; i<len; i++) {        
-        let sample = samples[i];
-        
-        // 8-bit samples are unsigned;
-        // They are signed here before conversion
-        // (other bit depths are all signed)
-        sample = sign8Bit(sample, originalBitDepth);
+const BitDepthFunctions = {
 
-        // If it is a float-to-float or int-to-float conversion then
-        // the samples in the target bit depth need to be normalized in the
-        // -1.0 to 1.0 range; there is no need to multiply
-        if (targetBitDepth == "32f" || targetBitDepth == "64") {
-            sample = toFloat(sample, originalBitDepth);
+    /**
+     * Change the bit depth from int to int.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    intToInt(sample, args) {
+        if (sample > 0) {
+            sample = parseInt((sample / (args.old - 1)) * args.new - 1, 10);
+        } else {
+            sample = parseInt((sample / args.old) * args.new, 10);
+        }
+        return sample;
+    },
 
-        // If it is a float-to-int or int-to-int conversion then the
-        // samples need to be de-normalized according to the bit depth
+    /**
+     * Change the bit depth from float to int.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    floatToInt(sample, args) {
+        if (sample > 0) {
+            sample = sample * (args.new - 1);
         } else {
-            sample = toInt(sample, originalBitDepth, targetBitDepth);
+            sample = sample * args.new;
         }
-        samples[i] = sample;
-    }
-}
+        return sample;
+    },
 
-/**
- * Sign unsigned 8-bit data.
- * @param {number} sample The sample.
- * @param {string} originalBitDepth The original bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- */
-function sign8Bit(sample, originalBitDepth) {
-    if (originalBitDepth == "8") {
-        sample -= 128;
-    }
-    return sample;
-}
+    /**
+     * Change the bit depth from int to float.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    intToFloat(sample, args) {
+        if (sample > 0) {
+            sample = sample / (args.old - 1);
+        } else {
+            sample = sample / args.old;
+        }
+        return sample;
+    },
 
-/**
- * Unsign signed 8-bit data.
- * @param {number} sample The sample.
- * @param {string} targetBitDepth The target bit depth of the data.
- *      One of "8", "16", "24", "32", "32f", "64"
- */
-function unsign8Bit(sample, targetBitDepth) {
-    if (targetBitDepth == "8") {
-        sample += 128;
+    /**
+     * Change the bit depth from float to float.
+     * @param {number} sample The sample.
+     * @param {Object} args Data about the original and target bit depths.
+     * @return {number}
+     */
+    floatToFloat(sample, args) {
+        if (args.original == "64" && args.target == "32f") {
+            f64f32[0] = sample;
+            sample = f64f32[0];
+        }
+        return sample;
     }
-    return sample;
-}
+};
 
 /**
- * Change the bit depth of a sample to a new floating point bit depth.
+ * Change the bit depth of the data in a sample array.
  * The input array is modified in-place.
- * @param {number} sample The sample.
+ * @param {!Array<number>} samples The samples.
  * @param {string} originalBitDepth The original bit depth of the data.
  *      One of "8", "16", "24", "32", "32f", "64"
+ * @param {string} targetBitDepth The new bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  */
-function toFloat(sample, originalBitDepth) {
-    let oldMaxValue = parseInt((BitDepthMaxValues[originalBitDepth]) / 2, 10);
-    if (originalBitDepth != "32f" && originalBitDepth != "64") {
-        if (sample > 0) {
-            sample = sample / (oldMaxValue - 1);
-        } else {
-            sample = sample / oldMaxValue;
-        }
+function toBitDepth(samples, originalBitDepth, targetBitDepth) {
+    validateBitDepths(originalBitDepth, targetBitDepth);
+    let toFunction = getBitDepthFunction(originalBitDepth, targetBitDepth);
+    let len = samples.length;
+    for (let i=0; i<len; i++) {        
+        samples[i] = sign8Bit(samples[i], originalBitDepth);
+        samples[i] = toFunction(
+                samples[i],
+                {
+                    "old": BitDepthMaxValues[originalBitDepth] / 2,
+                    "new": BitDepthMaxValues[targetBitDepth] / 2,
+                    "original": originalBitDepth,
+                    "target": targetBitDepth
+                }
+            );
+        samples[i] = unsign8Bit(samples[i], targetBitDepth);
     }
-    return sample;
 }
 
 /**
- * Change the bit depth of a sample to a new integer bit depth.
- * @param {number} sample The sample.
+ * Get the function to change the bit depth of a sample.
  * @param {string} originalBitDepth The original bit depth of the data.
@@ -109,38 +125,30 @@ *      One of "8", "16", "24", "32", "32f", "64"
  *      One of "8", "16", "24", "32", "32f", "64"
+ * @return {Function}
  */
-function toInt(sample, originalBitDepth, targetBitDepth) {
-    // If the original samples are float, then they are already
-    // normalized between -1.0 and 1.0; All that is need is to
-    // multiply the sample values by the new bit depth max value
-    let newMaxValue = parseInt((BitDepthMaxValues[targetBitDepth]) / 2, 10);
-    if (originalBitDepth == "32f" || originalBitDepth == "64" ) {
-        sample = floatToInt(sample, newMaxValue);
-    // If the original samples are integers, then they need to be
-    // divided by the maximum values of its original bit depth
-    // (to normalize them between -1.0 and .10) and then multiplied
-    // by the new bit depth max value
+function getBitDepthFunction(originalBitDepth, targetBitDepth) {
+    let prefix;
+    let suffix;
+    if (["32f", "64"].includes(originalBitDepth)) {
+        prefix = "float";
     } else {
-        sample = intToInt(
-                sample,
-                parseInt((BitDepthMaxValues[originalBitDepth]) / 2, 10),
-                newMaxValue
-            );
+        prefix = "int";
     }
-    // Make the samples unsigned if the target bit depth is "8"
-    return unsign8Bit(sample, targetBitDepth);
+    if (["32f", "64"].includes(targetBitDepth)) {
+        suffix = "Float";
+    } else {
+        suffix = "Int";
+    }
+    return BitDepthFunctions[prefix + "To" + suffix];
 }
 
 /**
- * Perform a int-to-int conversion.
+ * Sign unsigned 8-bit data.
  * @param {number} sample The sample.
- * @param {number} oldMaxValue The max value for the original bit depth.
- * @param {number} newMaxValue The max value for the target bit depth.
+ * @param {string} originalBitDepth The original bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  * @return {number}
  */
-function intToInt(sample, oldMaxValue, newMaxValue) {
-    if (sample > 0) {
-        sample =
-            parseInt((sample / (oldMaxValue - 1)) * newMaxValue - 1, 10);
-    } else {
-        sample = parseInt((sample / oldMaxValue) * newMaxValue, 10);
+function sign8Bit(sample, originalBitDepth) {
+    if (originalBitDepth == "8") {
+        sample -= 128;
     }
@@ -151,12 +159,11 @@ return sample;
 /**
- * Perform a float-to-int conversion.
+ * Unsign signed 8-bit data.
  * @param {number} sample The sample.
- * @param {number} newMaxValue The max value for the target bit depth.
+ * @param {string} targetBitDepth The target bit depth of the data.
+ *      One of "8", "16", "24", "32", "32f", "64"
  * @return {number}
  */
-function floatToInt(sample, newMaxValue) {
-    if (sample > 0) {
-        sample = sample * (newMaxValue - 1);
-    } else {
-        sample = sample * newMaxValue;
+function unsign8Bit(sample, targetBitDepth) {
+    if (targetBitDepth == "8") {
+        sample += 128;
     }
@@ -173,2 +180,3 @@ return sample;
  * @throws {Error} If any argument does not meet the criteria.
+ * @return {boolean}
  */
@@ -175,0 +183,0 @@ function validateBitDepths(originalBitDepth, targetBitDepth) {

package.json

 {
   "name": "bitdepth",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Change the bit depth of samples to and from 8, 16, 24, 32 & 64-bit.",
@@ -5,0 +5,0 @@ "homepage": "https://github.com/rochars/bitdepth",

README.md

@@ -6,3 +6,3 @@ # bitdepth
 
-[![Build Status](https://travis-ci.org/rochars/bitdepth.svg?branch=master)](https://travis-ci.org/rochars/bitdepth) [![Build status](https://ci.appveyor.com/api/projects/status/rxyv4w8yo5ny97w0?svg=true)](https://ci.appveyor.com/project/rochars/bitdepth) [![codecov](https://codecov.io/gh/rochars/bitdepth/branch/master/graph/badge.svg)](https://codecov.io/gh/rochars/bitdepth) [![NPM version](https://img.shields.io/npm/v/bitdepth.svg?style=flat)](https://www.npmjs.com/package/bitdepth) [![NPM downloads](https://img.shields.io/npm/dm/bitdepth.svg?style=flat)](https://www.npmjs.com/package/bitdepth)
+[![Travis](https://img.shields.io/travis/rochars/bitdepth.svg?style=for-the-badge)](https://travis-ci.org/rochars/bitdepth) [![AppVeyor](https://img.shields.io/appveyor/ci/rochars/bitdepth.svg?style=for-the-badge&logo=appveyor)](https://ci.appveyor.com/project/rochars/bitdepth) [![Codecov](https://img.shields.io/codecov/c/github/rochars/bitdepth.svg?style=for-the-badge)](https://codecov.io/gh/rochars/bitdepth) [![NPM version](https://img.shields.io/npm/v/bitdepth.svg?style=for-the-badge)](https://www.npmjs.com/package/bitdepth)
 
@@ -17,6 +17,8 @@ ## Install
 
-**64-bit** is always float.
+- **16-bit** is always int
+- **32-bit** can be int or float
+- **64-bit** is always float.
 
 ```javascript
-let bitDepth = require("../index.js");
+let bitDepth = require("bitdepth");
 
@@ -36,3 +38,3 @@ // 8 bit samples
 /**
- * Change the bit depth of the data.
+ * Change the bit depth of the data in a sample array.
  * The input array is modified in-place.
@@ -45,3 +47,3 @@ * @param {!Array<number>} samples The samples.
  */
-function toBitDepth(samples, originalBitDepth, targetBitDepth) {
+function toBitDepth(samples, originalBitDepth, targetBitDepth) {}
 ```
@@ -48,0 +50,0 @@

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Lines of code

1026

increased by2.09%

Number of lines in readme file

68

increased by3.03%

Worsened metrics

Total package byte prevSize

1059966

decreased by-0.45%

No dependency changes