yeet

node_modules/bmp-js/.npmignore

@@ -0,0 +1,2 @@
+node_modules
+.idea

node_modules/bmp-js/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 @丝刀口
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

node_modules/bmp-js/README.md

@@ -0,0 +1,44 @@
+bmp-js
+======
+
+A pure javascript Bmp encoder and decoder for node.js
+
+Supports all bits decoding(1,4,8,16,24,32) and encoding with 24bit.
+
+##Install
+
+	$ npm install bmp-js
+
+
+How to use?
+---
+###Decode BMP
+```js
+var bmp = require("bmp-js");
+var bmpBuffer = fs.readFileSync('bit24.bmp');
+var bmpData = bmp.decode(bmpBuffer);
+
+```
+
+`bmpData` has all properties includes:
+
+1. fileSize,reserved,offset
+
+2. headerSize,width,height,planes,bitPP,compress,rawSize,hr,vr,colors,importantColors
+
+3. palette
+
+4. data-------byte array order by ABGR ABGR ABGR,4 bytes per pixel
+
+
+###Encode RGB
+```js
+var bmp = require("bmp-js");
+//bmpData={data:Buffer,width:Number,height:Height}
+var rawData = bmp.encode(bmpData);//default no compression,write rawData to .bmp file
+
+```
+
+License
+---
+U can use on free with [MIT License](https://github.com/shaozilee/bmp-js/blob/master/LICENSE)

node_modules/bmp-js/bmp-js.iml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

node_modules/bmp-js/index.js

@@ -0,0 +1,15 @@
+/**
+ * @author shaozilee
+ *
+ * support 1bit 4bit 8bit 24bit decode
+ * encode with 24bit
+ * 
+ */
+
+var encode = require('./lib/encoder'),
+    decode = require('./lib/decoder');
+
+module.exports = {
+  encode: encode,
+  decode: decode
+};

node_modules/bmp-js/lib/decoder.js

@@ -0,0 +1,485 @@
+/**
+ * @author shaozilee
+ *
+ * Bmp format decoder,support 1bit 4bit 8bit 24bit bmp
+ *
+ */
+
+function BmpDecoder(buffer,is_with_alpha) {
+  this.pos = 0;
+  this.buffer = buffer;
+  this.is_with_alpha = !!is_with_alpha;
+  this.bottom_up = true;
+  this.flag = this.buffer.toString("utf-8", 0, this.pos += 2);
+  if (this.flag != "BM") throw new Error("Invalid BMP File");
+  this.parseHeader();
+  this.parseRGBA();
+}
+
+BmpDecoder.prototype.parseHeader = function() {
+  this.fileSize = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.reserved = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.offset = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.headerSize = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.width = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.height = this.buffer.readInt32LE(this.pos);
+  this.pos += 4;
+  this.planes = this.buffer.readUInt16LE(this.pos);
+  this.pos += 2;
+  this.bitPP = this.buffer.readUInt16LE(this.pos);
+  this.pos += 2;
+  this.compress = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.rawSize = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.hr = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.vr = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.colors = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+  this.importantColors = this.buffer.readUInt32LE(this.pos);
+  this.pos += 4;
+
+  if(this.bitPP === 16 && this.is_with_alpha){
+    this.bitPP = 15
+  }
+  if (this.bitPP < 15) {
+    var len = this.colors === 0 ? 1 << this.bitPP : this.colors;
+    this.palette = new Array(len);
+    for (var i = 0; i < len; i++) {
+      var blue = this.buffer.readUInt8(this.pos++);
+      var green = this.buffer.readUInt8(this.pos++);
+      var red = this.buffer.readUInt8(this.pos++);
+      var quad = this.buffer.readUInt8(this.pos++);
+      this.palette[i] = {
+        red: red,
+        green: green,
+        blue: blue,
+        quad: quad
+      };
+    }
+  }
+  if(this.height < 0) {
+    this.height *= -1;
+    this.bottom_up = false;
+  }
+
+}
+
+BmpDecoder.prototype.parseRGBA = function() {
+    var bitn = "bit" + this.bitPP;
+    var len = this.width * this.height * 4;
+    this.data = new Buffer(len);
+    this[bitn]();
+};
+
+BmpDecoder.prototype.bit1 = function() {
+  var xlen = Math.ceil(this.width / 8);
+  var mode = xlen%4;
+  var y = this.height >= 0 ? this.height - 1 : -this.height
+  for (var y = this.height - 1; y >= 0; y--) {
+    var line = this.bottom_up ? y : this.height - 1 - y
+    for (var x = 0; x < xlen; x++) {
+      var b = this.buffer.readUInt8(this.pos++);
+      var location = line * this.width * 4 + x*8*4;
+      for (var i = 0; i < 8; i++) {
+        if(x*8+i<this.width){
+          var rgb = this.palette[((b>>(7-i))&0x1)];
+
+          this.data[location+i*4] = 0;
+          this.data[location+i*4 + 1] = rgb.blue;
+          this.data[location+i*4 + 2] = rgb.green;
+          this.data[location+i*4 + 3] = rgb.red;
+
+        }else{
+          break;
+        }
+      }
+    }
+
+    if (mode != 0){
+      this.pos+=(4 - mode);
+    }
+  }
+};
+
+BmpDecoder.prototype.bit4 = function() {
+    //RLE-4
+    if(this.compress == 2){
+        this.data.fill(0xff);
+
+        var location = 0;
+        var lines = this.bottom_up?this.height-1:0;
+        var low_nibble = false;//for all count of pixel
+
+        while(location<this.data.length){
+            var a = this.buffer.readUInt8(this.pos++);
+            var b = this.buffer.readUInt8(this.pos++);
+            //absolute mode
+            if(a == 0){
+                if(b == 0){//line end
+                    if(this.bottom_up){
+                        lines--;
+                    }else{
+                        lines++;
+                    }
+                    location = lines*this.width*4;
+                    low_nibble = false;
+                    continue;
+                }else if(b == 1){//image end
+                    break;
+                }else if(b ==2){
+                    //offset x,y
+                    var x = this.buffer.readUInt8(this.pos++);
+                    var y = this.buffer.readUInt8(this.pos++);
+                    if(this.bottom_up){
+                        lines-=y;
+                    }else{
+                        lines+=y;
+                    }
+
+                    location +=(y*this.width*4+x*4);
+                }else{
+                    var c = this.buffer.readUInt8(this.pos++);
+                    for(var i=0;i<b;i++){
+                        if (low_nibble) {
+                            setPixelData.call(this, (c & 0x0f));
+                        } else {
+                            setPixelData.call(this, (c & 0xf0)>>4);
+                        }
+
+                        if ((i & 1) && (i+1 < b)){
+                            c = this.buffer.readUInt8(this.pos++);
+                        }
+
+                        low_nibble = !low_nibble;
+                    }
+
+                    if ((((b+1) >> 1) & 1 ) == 1){
+                        this.pos++
+                    }
+                }
+
+            }else{//encoded mode
+                for (var i = 0; i < a; i++) {
+                    if (low_nibble) {
+                        setPixelData.call(this, (b & 0x0f));
+                    } else {
+                        setPixelData.call(this, (b & 0xf0)>>4);
+                    }
+                    low_nibble = !low_nibble;
+                }
+            }
+
+        }
+
+
+
+
+        function setPixelData(rgbIndex){
+            var rgb = this.palette[rgbIndex];
+            this.data[location] = 0;
+            this.data[location + 1] = rgb.blue;
+            this.data[location + 2] = rgb.green;
+            this.data[location + 3] = rgb.red;
+            location+=4;
+        }
+    }else{
+
+      var xlen = Math.ceil(this.width/2);
+      var mode = xlen%4;
+      for (var y = this.height - 1; y >= 0; y--) {
+        var line = this.bottom_up ? y : this.height - 1 - y
+        for (var x = 0; x < xlen; x++) {
+          var b = this.buffer.readUInt8(this.pos++);
+          var location = line * this.width * 4 + x*2*4;
+
+          var before = b>>4;
+          var after = b&0x0F;
+
+          var rgb = this.palette[before];
+          this.data[location] = 0;
+          this.data[location + 1] = rgb.blue;
+          this.data[location + 2] = rgb.green;
+          this.data[location + 3] = rgb.red;
+
+
+          if(x*2+1>=this.width)break;
+
+          rgb = this.palette[after];
+
+          this.data[location+4] = 0;
+          this.data[location+4 + 1] = rgb.blue;
+          this.data[location+4 + 2] = rgb.green;
+          this.data[location+4 + 3] = rgb.red;
+
+        }
+
+        if (mode != 0){
+          this.pos+=(4 - mode);
+        }
+      }
+
+    }
+
+};
+
+BmpDecoder.prototype.bit8 = function() {
+    //RLE-8
+    if(this.compress == 1){
+        this.data.fill(0xff);
+
+        var location = 0;
+        var lines = this.bottom_up?this.height-1:0;
+
+        while(location<this.data.length){
+            var a = this.buffer.readUInt8(this.pos++);
+            var b = this.buffer.readUInt8(this.pos++);
+            //absolute mode
+            if(a == 0){
+                if(b == 0){//line end
+                    if(this.bottom_up){
+                        lines--;
+                    }else{
+                        lines++;
+                    }
+                    location = lines*this.width*4;
+                    continue;
+                }else if(b == 1){//image end
+                    break;
+                }else if(b ==2){
+                    //offset x,y
+                    var x = this.buffer.readUInt8(this.pos++);
+                    var y = this.buffer.readUInt8(this.pos++);
+                    if(this.bottom_up){
+                        lines-=y;
+                    }else{
+                        lines+=y;
+                    }
+
+                    location +=(y*this.width*4+x*4);
+                }else{
+                    for(var i=0;i<b;i++){
+                        var c = this.buffer.readUInt8(this.pos++);
+                        setPixelData.call(this, c);
+                    }
+                    if(b&1 == 1){
+                        this.pos++;
+                    }
+
+                }
+
+            }else{//encoded mode
+                for (var i = 0; i < a; i++) {
+                    setPixelData.call(this, b);
+                }
+            }
+
+        }
+
+
+
+
+        function setPixelData(rgbIndex){
+            var rgb = this.palette[rgbIndex];
+            this.data[location] = 0;
+            this.data[location + 1] = rgb.blue;
+            this.data[location + 2] = rgb.green;
+            this.data[location + 3] = rgb.red;
+            location+=4;
+        }
+    }else {
+        var mode = this.width % 4;
+        for (var y = this.height - 1; y >= 0; y--) {
+            var line = this.bottom_up ? y : this.height - 1 - y
+            for (var x = 0; x < this.width; x++) {
+                var b = this.buffer.readUInt8(this.pos++);
+                var location = line * this.width * 4 + x * 4;
+                if (b < this.palette.length) {
+                    var rgb = this.palette[b];
+
+                    this.data[location] = 0;
+                    this.data[location + 1] = rgb.blue;
+                    this.data[location + 2] = rgb.green;
+                    this.data[location + 3] = rgb.red;
+
+                } else {
+                    this.data[location] = 0;
+                    this.data[location + 1] = 0xFF;
+                    this.data[location + 2] = 0xFF;
+                    this.data[location + 3] = 0xFF;
+                }
+            }
+            if (mode != 0) {
+                this.pos += (4 - mode);
+            }
+        }
+    }
+};
+
+BmpDecoder.prototype.bit15 = function() {
+  var dif_w =this.width % 3;
+  var _11111 = parseInt("11111", 2),_1_5 = _11111;
+  for (var y = this.height - 1; y >= 0; y--) {
+    var line = this.bottom_up ? y : this.height - 1 - y
+    for (var x = 0; x < this.width; x++) {
+
+      var B = this.buffer.readUInt16LE(this.pos);
+      this.pos+=2;
+      var blue = (B & _1_5) / _1_5 * 255 | 0;
+      var green = (B >> 5 & _1_5 ) / _1_5 * 255 | 0;
+      var red = (B >> 10 & _1_5) / _1_5 * 255 | 0;
+      var alpha = (B>>15)?0xFF:0x00;
+
+      var location = line * this.width * 4 + x * 4;
+
+      this.data[location] = alpha;
+      this.data[location + 1] = blue;
+      this.data[location + 2] = green;
+      this.data[location + 3] = red;
+    }
+    //skip extra bytes
+    this.pos += dif_w;
+  }
+};
+
+BmpDecoder.prototype.bit16 = function() {
+  var dif_w =(this.width % 2)*2;
+  //default xrgb555
+  this.maskRed = 0x7C00;
+  this.maskGreen = 0x3E0;
+  this.maskBlue =0x1F;
+  this.mask0 = 0;
+
+  if(this.compress == 3){
+    this.maskRed = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.maskGreen = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.maskBlue = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.mask0 = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+  }
+
+
+  var ns=[0,0,0];
+  for (var i=0;i<16;i++){
+    if ((this.maskRed>>i)&0x01) ns[0]++;
+    if ((this.maskGreen>>i)&0x01) ns[1]++;
+    if ((this.maskBlue>>i)&0x01) ns[2]++;
+  }
+  ns[1]+=ns[0]; ns[2]+=ns[1];	ns[0]=8-ns[0]; ns[1]-=8; ns[2]-=8;
+
+  for (var y = this.height - 1; y >= 0; y--) {
+    var line = this.bottom_up ? y : this.height - 1 - y;
+    for (var x = 0; x < this.width; x++) {
+
+      var B = this.buffer.readUInt16LE(this.pos);
+      this.pos+=2;
+
+      var blue = (B&this.maskBlue)<<ns[0];
+      var green = (B&this.maskGreen)>>ns[1];
+      var red = (B&this.maskRed)>>ns[2];
+
+      var location = line * this.width * 4 + x * 4;
+
+      this.data[location] = 0;
+      this.data[location + 1] = blue;
+      this.data[location + 2] = green;
+      this.data[location + 3] = red;
+    }
+    //skip extra bytes
+    this.pos += dif_w;
+  }
+};
+
+BmpDecoder.prototype.bit24 = function() {
+  for (var y = this.height - 1; y >= 0; y--) {
+    var line = this.bottom_up ? y : this.height - 1 - y
+    for (var x = 0; x < this.width; x++) {
+      //Little Endian rgb
+      var blue = this.buffer.readUInt8(this.pos++);
+      var green = this.buffer.readUInt8(this.pos++);
+      var red = this.buffer.readUInt8(this.pos++);
+      var location = line * this.width * 4 + x * 4;
+      this.data[location] = 0;
+      this.data[location + 1] = blue;
+      this.data[location + 2] = green;
+      this.data[location + 3] = red;
+    }
+    //skip extra bytes
+    this.pos += (this.width % 4);
+  }
+
+};
+
+/**
+ * add 32bit decode func
+ * @author soubok
+ */
+BmpDecoder.prototype.bit32 = function() {
+  //BI_BITFIELDS
+  if(this.compress == 3){
+    this.maskRed = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.maskGreen = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.maskBlue = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+    this.mask0 = this.buffer.readUInt32LE(this.pos);
+    this.pos+=4;
+      for (var y = this.height - 1; y >= 0; y--) {
+          var line = this.bottom_up ? y : this.height - 1 - y;
+          for (var x = 0; x < this.width; x++) {
+              //Little Endian rgba
+              var alpha = this.buffer.readUInt8(this.pos++);
+              var blue = this.buffer.readUInt8(this.pos++);
+              var green = this.buffer.readUInt8(this.pos++);
+              var red = this.buffer.readUInt8(this.pos++);
+              var location = line * this.width * 4 + x * 4;
+              this.data[location] = alpha;
+              this.data[location + 1] = blue;
+              this.data[location + 2] = green;
+              this.data[location + 3] = red;
+          }
+      }
+
+  }else{
+      for (var y = this.height - 1; y >= 0; y--) {
+          var line = this.bottom_up ? y : this.height - 1 - y;
+          for (var x = 0; x < this.width; x++) {
+              //Little Endian argb
+              var blue = this.buffer.readUInt8(this.pos++);
+              var green = this.buffer.readUInt8(this.pos++);
+              var red = this.buffer.readUInt8(this.pos++);
+              var alpha = this.buffer.readUInt8(this.pos++);
+              var location = line * this.width * 4 + x * 4;
+              this.data[location] = alpha;
+              this.data[location + 1] = blue;
+              this.data[location + 2] = green;
+              this.data[location + 3] = red;
+          }
+      }
+
+  }
+
+
+
+
+};
+
+BmpDecoder.prototype.getData = function() {
+  return this.data;
+};
+
+module.exports = function(bmpData) {
+  var decoder = new BmpDecoder(bmpData);
+  return decoder;
+};

node_modules/bmp-js/lib/encoder.js

@@ -0,0 +1,81 @@
+/**
+ * @author shaozilee
+ *
+ * BMP format encoder,encode 24bit BMP
+ * Not support quality compression
+ *
+ */
+
+function BmpEncoder(imgData){
+	this.buffer = imgData.data;
+	this.width = imgData.width;
+	this.height = imgData.height;
+	this.extraBytes = this.width%4;
+	this.rgbSize = this.height*(3*this.width+this.extraBytes);
+	this.headerInfoSize = 40;
+
+	this.data = [];
+	/******************header***********************/
+	this.flag = "BM";
+	this.reserved = 0;
+	this.offset = 54;
+	this.fileSize = this.rgbSize+this.offset;
+	this.planes = 1;
+	this.bitPP = 24;
+	this.compress = 0;
+	this.hr = 0;
+	this.vr = 0;
+	this.colors = 0;
+	this.importantColors = 0;
+}
+
+BmpEncoder.prototype.encode = function() {
+	var tempBuffer = new Buffer(this.offset+this.rgbSize);
+	this.pos = 0;
+	tempBuffer.write(this.flag,this.pos,2);this.pos+=2;
+	tempBuffer.writeUInt32LE(this.fileSize,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.reserved,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.offset,this.pos);this.pos+=4;
+
+	tempBuffer.writeUInt32LE(this.headerInfoSize,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.width,this.pos);this.pos+=4;
+	tempBuffer.writeInt32LE(-this.height,this.pos);this.pos+=4;
+	tempBuffer.writeUInt16LE(this.planes,this.pos);this.pos+=2;
+	tempBuffer.writeUInt16LE(this.bitPP,this.pos);this.pos+=2;
+	tempBuffer.writeUInt32LE(this.compress,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.rgbSize,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.hr,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.vr,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.colors,this.pos);this.pos+=4;
+	tempBuffer.writeUInt32LE(this.importantColors,this.pos);this.pos+=4;
+
+	var i=0;
+	var rowBytes = 3*this.width+this.extraBytes;
+
+	for (var y = 0; y <this.height; y++){
+		for (var x = 0; x < this.width; x++){
+			var p = this.pos+y*rowBytes+x*3;
+			i++;//a
+			tempBuffer[p]= this.buffer[i++];//b
+			tempBuffer[p+1] = this.buffer[i++];//g
+			tempBuffer[p+2]  = this.buffer[i++];//r
+		}
+		if(this.extraBytes>0){
+			var fillOffset = this.pos+y*rowBytes+this.width*3;
+			tempBuffer.fill(0,fillOffset,fillOffset+this.extraBytes);
+		}
+	}
+
+	return tempBuffer;
+};
+
+module.exports = function(imgData, quality) {
+  if (typeof quality === 'undefined') quality = 100;
+ 	var encoder = new BmpEncoder(imgData);
+	var data = encoder.encode();
+  return {
+    data: data,
+    width: imgData.width,
+    height: imgData.height
+  };
+};

node_modules/bmp-js/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "bmp-js",
+  "version": "0.1.0",
+  "description": "A pure javascript BMP encoder and decoder",
+  "main": "index.js",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/shaozilee/bmp-js"
+  },
+  "keywords": [
+    "bmp",
+    "1bit",
+    "4bit",
+    "8bit",
+    "16bit",
+    "24bit",
+    "32bit",
+    "encoder",
+    "decoder",
+    "image",
+    "javascript",
+    "js"
+  ],
+  "author": {
+    "name": "shaozilee",
+    "email": "shaozilee@gmail.com"
+  },
+  "license": "MIT",
+  "dependencies": {},
+  "devDependencies": {
+  }
+}

node_modules/bmp-js/test/test.js

@@ -0,0 +1,33 @@
+var fs = require("fs");
+
+var coder = require("../index.js");
+var bmps = ["./bit1", "./bit4", "./bit4_RLE", "./bit8", "./bit8_RLE", "./bit16_565", "./bit16_a444", "./bit16_a555", "./bit16_x444", "./bit16_x555", "./bit24", "./bit32", "./bit32_alpha"];
+
+console.log("test bmp decoding and encoding...");
+
+for(var b=0; b<bmps.length;b++){
+    var src =bmps[b];
+    console.log("----------------"+src+".bmp");
+    var bufferData = fs.readFileSync(src+".bmp");
+    var decoder = coder.decode(bufferData);
+    console.log("width:",decoder.width);
+    console.log("height",decoder.height);
+    console.log("fileSize:",decoder.fileSize);
+
+
+    //encode with 24bit
+    var encodeData = coder.encode(decoder);
+    fs.writeFileSync(src+"_out.bmp", encodeData.data);
+}
+
+console.log("test bmp success!");
+
+
+
+
+
+
+
+
+
+