device_home/node_modules/pngjs/lib/bitpacker.js

   1 'use strict';
   2
   3 var constants = require('./constants');
   4
   5 module.exports = function(dataIn, width, height, options) {
   6   var outHasAlpha = [constants.COLORTYPE_COLOR_ALPHA, constants.COLORTYPE_ALPHA].indexOf(options.colorType) !== -1;
   7   if (options.colorType === options.inputColorType) {
   8     var bigEndian = (function() {
   9       var buffer = new ArrayBuffer(2);
  10       new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
  11       // Int16Array uses the platform's endianness.
  12       return new Int16Array(buffer)[0] !== 256;
  13     })();
  14     // If no need to convert to grayscale and alpha is present/absent in both, take a fast route
  15     if (options.bitDepth === 8 || (options.bitDepth === 16 && bigEndian)) {
  16       return dataIn;
  17     }
  18   }
  19
  20   // map to a UInt16 array if data is 16bit, fix endianness below
  21   var data = options.bitDepth !== 16 ? dataIn : new Uint16Array(dataIn.buffer);
  22
  23   var maxValue = 255;
  24   var inBpp = constants.COLORTYPE_TO_BPP_MAP[options.inputColorType];
  25   if (inBpp === 4 && !options.inputHasAlpha) {
  26     inBpp = 3;
  27   }
  28   var outBpp = constants.COLORTYPE_TO_BPP_MAP[options.colorType];
  29   if (options.bitDepth === 16) {
  30     maxValue = 65535;
  31     outBpp *= 2;
  32   }
  33   var outData = new Buffer(width * height * outBpp);
  34
  35   var inIndex = 0;
  36   var outIndex = 0;
  37
  38   var bgColor = options.bgColor || {};
  39   if (bgColor.red === undefined) {
  40     bgColor.red = maxValue;
  41   }
  42   if (bgColor.green === undefined) {
  43     bgColor.green = maxValue;
  44   }
  45   if (bgColor.blue === undefined) {
  46     bgColor.blue = maxValue;
  47   }
  48
  49   function getRGBA() {
  50     var red;
  51     var green;
  52     var blue;
  53     var alpha = maxValue;
  54     switch (options.inputColorType) {
  55       case constants.COLORTYPE_COLOR_ALPHA:
  56         alpha = data[inIndex + 3];
  57         red = data[inIndex];
  58         green = data[inIndex + 1];
  59         blue = data[inIndex + 2];
  60         break;
  61       case constants.COLORTYPE_COLOR:
  62         red = data[inIndex];
  63         green = data[inIndex + 1];
  64         blue = data[inIndex + 2];
  65         break;
  66       case constants.COLORTYPE_ALPHA:
  67         alpha = data[inIndex + 1];
  68         red = data[inIndex];
  69         green = red;
  70         blue = red;
  71         break;
  72       case constants.COLORTYPE_GRAYSCALE:
  73         red = data[inIndex];
  74         green = red;
  75         blue = red;
  76         break;
  77       default:
  78         throw new Error('input color type:' + options.inputColorType + ' is not supported at present');
  79     }
  80
  81     if (options.inputHasAlpha) {
  82       if (!outHasAlpha) {
  83         alpha /= maxValue;
  84         red = Math.min(Math.max(Math.round((1 - alpha) * bgColor.red + alpha * red), 0), maxValue);
  85         green = Math.min(Math.max(Math.round((1 - alpha) * bgColor.green + alpha * green), 0), maxValue);
  86         blue = Math.min(Math.max(Math.round((1 - alpha) * bgColor.blue + alpha * blue), 0), maxValue);
  87       }
  88     }
  89     return { red: red, green: green, blue: blue, alpha: alpha };
  90   }
  91
  92   for (var y = 0; y < height; y++) {
  93     for (var x = 0; x < width; x++) {
  94       var rgba = getRGBA(data, inIndex);
  95
  96       switch (options.colorType) {
  97         case constants.COLORTYPE_COLOR_ALPHA:
  98         case constants.COLORTYPE_COLOR:
  99           if (options.bitDepth === 8) {
 100             outData[outIndex] = rgba.red;
 101             outData[outIndex + 1] = rgba.green;
 102             outData[outIndex + 2] = rgba.blue;
 103             if (outHasAlpha) {
 104               outData[outIndex + 3] = rgba.alpha;
 105             }
 106           }
 107           else {
 108             outData.writeUInt16BE(rgba.red, outIndex);
 109             outData.writeUInt16BE(rgba.green, outIndex + 2);
 110             outData.writeUInt16BE(rgba.blue, outIndex + 4);
 111             if (outHasAlpha) {
 112               outData.writeUInt16BE(rgba.alpha, outIndex + 6);
 113             }
 114           }
 115           break;
 116         case constants.COLORTYPE_ALPHA:
 117         case constants.COLORTYPE_GRAYSCALE:
 118           // Convert to grayscale and alpha
 119           var grayscale = (rgba.red + rgba.green + rgba.blue) / 3;
 120           if (options.bitDepth === 8) {
 121             outData[outIndex] = grayscale;
 122             if (outHasAlpha) {
 123               outData[outIndex + 1] = rgba.alpha;
 124             }
 125           }
 126           else {
 127             outData.writeUInt16BE(grayscale, outIndex);
 128             if (outHasAlpha) {
 129               outData.writeUInt16BE(rgba.alpha, outIndex + 2);
 130             }
 131           }
 132           break;
 133         default:
 134           throw new Error('unrecognised color Type ' + options.colorType);
 135       }
 136
 137       inIndex += inBpp;
 138       outIndex += outBpp;
 139     }
 140   }
 141
 142   return outData;
 143 };