modules/addimage.js

  1. /* global jsPDF */
  2. /** @license
  3.  * jsPDF addImage plugin
  4.  * Copyright (c) 2012 Jason Siefken, https://github.com/siefkenj/
  5.  *               2013 Chris Dowling, https://github.com/gingerchris
  6.  *               2013 Trinh Ho, https://github.com/ineedfat
  7.  *               2013 Edwin Alejandro Perez, https://github.com/eaparango
  8.  *               2013 Norah Smith, https://github.com/burnburnrocket
  9.  *               2014 Diego Casorran, https://github.com/diegocr
  10.  *               2014 James Robb, https://github.com/jamesbrobb
  11.  *
  12.  * Permission is hereby granted, free of charge, to any person obtaining
  13.  * a copy of this software and associated documentation files (the
  14.  * "Software"), to deal in the Software without restriction, including
  15.  * without limitation the rights to use, copy, modify, merge, publish,
  16.  * distribute, sublicense, and/or sell copies of the Software, and to
  17.  * permit persons to whom the Software is furnished to do so, subject to
  18.  * the following conditions:
  19.  *
  20.  * The above copyright notice and this permission notice shall be
  21.  * included in all copies or substantial portions of the Software.
  22.  *
  23.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  24.  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25.  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  26.  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  27.  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  28.  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  29.  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30.  */
  31. /**
  32. * @name addImage
  33. * @module
  34. */
  35. (function (jsPDFAPI) {
  36.     'use strict'
  38.     var namespace = 'addImage_';
  39.     jsPDFAPI.__addimage__ = {};
  41.     var UNKNOWN = 'UNKNOWN';
  43.     var imageFileTypeHeaders = {
  44.         PNG: [[0x89, 0x50, 0x4e, 0x47]],
  45.         TIFF: [
  46.             [0x4D, 0x4D, 0x00, 0x2A], //Motorola
  47.             [0x49, 0x49, 0x2A, 0x00]  //Intel
  48.         ],
  49.         JPEG: [
  50.             [0xFF, 0xD8, 0xFF, 0xE0, undefined, undefined, 0x4A, 0x46, 0x49, 0x46, 0x00],      //JFIF
  51.             [0xFF, 0xD8, 0xFF, 0xE1, undefined, undefined, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00], //Exif
  52.             [0xFF, 0xD8, 0xFF, 0xDB], //JPEG RAW
  53.             [0xFF, 0xD8, 0xFF, 0xEE] //EXIF RAW
  54.         ],
  55.         JPEG2000: [[0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20]],
  56.         GIF87a: [[0x47, 0x49, 0x46, 0x38, 0x37, 0x61]],
  57.         GIF89a: [[0x47, 0x49, 0x46, 0x38, 0x39, 0x61]],
  58.         WEBP: [[0x52, 0x49, 0x46, 0x46, undefined, undefined, undefined, undefined, 0x57, 0x45, 0x42, 0x50]],
  59.         BMP: [
  60.             [0x42, 0x4D], //BM - Windows 3.1x, 95, NT, ... etc.
  61.             [0x42, 0x41], //BA - OS/2 struct bitmap array
  62.             [0x43, 0x49], //CI - OS/2 struct color icon
  63.             [0x43, 0x50], //CP - OS/2 const color pointer
  64.             [0x49, 0x43], //IC - OS/2 struct icon
  65.             [0x50, 0x54]  //PT - OS/2 pointer
  66.         ]
  67.     };
  69.     /**
  70.     * Recognize filetype of Image by magic-bytes
  71.     * 
  72.     * https://en.wikipedia.org/wiki/List_of_file_signatures
  73.     *
  74.     * @name getImageFileTypeByImageData
  75.     * @public
  76.     * @function
  77.     * @param {string|arraybuffer} imageData imageData as binary String or arraybuffer
  78.     * @param {string} format format of file if filetype-recognition fails, e.g. 'JPEG'
  79.     * 
  80.     * @returns {string} filetype of Image
  81.     */
  82.     var getImageFileTypeByImageData = jsPDFAPI.__addimage__.getImageFileTypeByImageData = function (imageData, fallbackFormat) {
  83.         fallbackFormat = fallbackFormat || UNKNOWN;
  84.         var i;
  85.         var j;
  86.         var result = UNKNOWN;
  87.         var headerSchemata;
  88.         var compareResult;
  89.         var fileType;
  91.         if (isArrayBufferView(imageData)) {
  92.             for (fileType in imageFileTypeHeaders) {
  93.                 headerSchemata = imageFileTypeHeaders[fileType];
  94.                 for (i = 0; i < headerSchemata.length; i += 1) {
  95.                     compareResult = true;
  96.                     for (j = 0; j < headerSchemata[i].length; j += 1) {
  97.                         if (headerSchemata[i][j] === undefined) {
  98.                             continue;
  99.                         }
  100.                         if (headerSchemata[i][j] !== imageData[j]) {
  101.                             compareResult = false;
  102.                             break;
  103.                         }
  104.                     }
  105.                     if (compareResult === true) {
  106.                         result = fileType;
  107.                         break;
  108.                     }
  109.                 }
  110.             }
  111.         } else {
  112.             for (fileType in imageFileTypeHeaders) {
  113.                 headerSchemata = imageFileTypeHeaders[fileType];
  114.                 for (i = 0; i < headerSchemata.length; i += 1) {
  115.                     compareResult = true;
  116.                     for (j = 0; j < headerSchemata[i].length; j += 1) {
  117.                         if (headerSchemata[i][j] === undefined) {
  118.                             continue;
  119.                         }
  120.                         if (headerSchemata[i][j] !== imageData.charCodeAt(j)) {
  121.                             compareResult = false;
  122.                             break;
  123.                         }
  124.                     }
  125.                     if (compareResult === true) {
  126.                         result = fileType;
  127.                         break;
  128.                     }
  129.                 }
  130.             }
  131.         }
  133.         if (result === UNKNOWN && fallbackFormat !== UNKNOWN) {
  134.             result = fallbackFormat;
  135.         }
  136.         return result;
  137.     };
  139.     // Image functionality ported from pdf.js
  140.     var putImage = function (image) {
  142.         var out = this.internal.write;
  143.         var putStream = this.internal.putStream;
  144.         var getFilters = this.internal.getFilters;
  146.         var filter = getFilters();
  147.         while (filter.indexOf('FlateEncode') !== -1) {
  148.             filter.splice(filter.indexOf('FlateEncode'), 1);
  149.         }
  151.         image.objectId = this.internal.newObject()
  153.         var additionalKeyValues = [];
  154.         additionalKeyValues.push({ key: 'Type', value: '/XObject' });
  155.         additionalKeyValues.push({ key: 'Subtype', value: '/Image' });
  156.         additionalKeyValues.push({ key: 'Width', value: image.width });
  157.         additionalKeyValues.push({ key: 'Height', value: image.height });
  159.         if (image.colorSpace === color_spaces.INDEXED) {
  160.             additionalKeyValues.push({
  161.                 key: 'ColorSpace', value: '[/Indexed /DeviceRGB '
  162.                     // if an indexed png defines more than one colour with transparency, we've created a sMask
  163.                     + (image.palette.length / 3 - 1) + ' ' + ('sMask' in image  && typeof image.sMask !== "undefined" ? image.objectId + 2 : image.objectId + 1)
  164.                     + ' 0 R]'
  165.             });
  166.         } else {
  167.             additionalKeyValues.push({ key: 'ColorSpace', value: '/' + image.colorSpace });
  168.             if (image.colorSpace === color_spaces.DEVICE_CMYK) {
  169.                 additionalKeyValues.push({ key: 'Decode', value: '[1 0 1 0 1 0 1 0]' });
  170.             }
  171.         }
  172.         additionalKeyValues.push({ key: 'BitsPerComponent', value: image.bitsPerComponent });
  173.         if ('decodeParameters' in image && typeof image.decodeParameters !== "undefined") {
  174.             additionalKeyValues.push({ key: 'DecodeParms', value: '<<' + image.decodeParameters + '>>' });
  175.         }
  176.         if ('transparency' in image && Array.isArray(image.transparency)) {
  177.             var transparency = '',
  178.                 i = 0,
  179.                 len = image.transparency.length;
  180.             for (; i < len; i++)
  181.                 transparency += (image.transparency[i] + ' ' + image.transparency[i] + ' ');
  183.             additionalKeyValues.push({ key: 'Mask', value: '[' + transparency + ']' });
  184.         }
  185.         if (typeof image.sMask !== "undefined") {
  186.             additionalKeyValues.push({ key: 'SMask', value: (image.objectId + 1) + ' 0 R' });
  187.         }
  189.         var alreadyAppliedFilters = (typeof image.filter !== "undefined") ? ['/' + image.filter] : undefined;
  191.         putStream({ data: image.data, additionalKeyValues: additionalKeyValues, alreadyAppliedFilters: alreadyAppliedFilters });
  193.         out('endobj');
  195.         // Soft mask
  196.         if ('sMask' in image && typeof image.sMask !== "undefined") {
  197.             var decodeParameters = '/Predictor ' + image.predictor + ' /Colors 1 /BitsPerComponent ' + image.bitsPerComponent + ' /Columns ' + image.width;
  198.             var sMask = { width: image.width, height: image.height, colorSpace: 'DeviceGray', bitsPerComponent: image.bitsPerComponent, decodeParameters: decodeParameters, data: image.sMask };
  199.             if ('filter' in image) {
  200.                 sMask.filter = image.filter;
  201.             }
  202.             putImage.call(this, sMask);
  203.         }
  205.         //Palette
  206.         if (image.colorSpace === color_spaces.INDEXED) {
  208.             this.internal.newObject();
  209.             //out('<< /Filter / ' + img['f'] +' /Length ' + img['pal'].length + '>>');
  210.             //putStream(zlib.compress(img['pal']));
  211.             putStream({ data: arrayBufferToBinaryString(new Uint8Array(image.palette)) });
  212.             out('endobj');
  213.         }
  214.     };
  215.     var putResourcesCallback = function () {
  216.         var images = this.internal.collections[namespace + 'images'];
  217.         for (var i in images) {
  218.             putImage.call(this, images[i]);
  219.         }
  220.     };
  221.     var putXObjectsDictCallback = function () {
  222.         var images = this.internal.collections[namespace + 'images']
  223.             , out = this.internal.write
  224.             , image;
  225.         for (var i in images) {
  226.             image = images[i];
  227.             out(
  228.                 '/I' + image.index
  229.                 , image.objectId
  230.                 , '0'
  231.                 , 'R'
  232.             );
  233.         }
  234.     };
  236.     var checkCompressValue = function (value) {
  237.         if (value && typeof value === 'string')
  238.             value = value.toUpperCase();
  239.         return value in jsPDFAPI.image_compression ? value : image_compression.NONE;
  240.     };
  242.     var initialize = function () {
  243.         if (!this.internal.collections[namespace + 'images']) {
  244.             this.internal.collections[namespace + 'images'] = {};
  245.             this.internal.events.subscribe('putResources', putResourcesCallback);
  246.             this.internal.events.subscribe('putXobjectDict', putXObjectsDictCallback);
  247.         }
  248.     };
  250.     var getImages = function () {
  251.         var images = this.internal.collections[namespace + 'images'];
  252.         initialize.call(this);
  253.         return images;
  254.     };
  255.     var getImageIndex = function () {
  256.         return Object.keys(this.internal.collections[namespace + 'images']).length;
  257.     };
  258.     var notDefined = function (value) {
  259.         return typeof value === 'undefined' || value === null || value.length === 0;
  260.     };
  261.     var generateAliasFromImageData = function (imageData) {
  262.         if (typeof imageData === 'string' || isArrayBufferView(imageData)) {
  263.             return sHashCode(imageData);
  264.         }
  266.         return null;
  267.     };
  269.     var isImageTypeSupported = function (type) {
  270.         return (typeof jsPDFAPI["process" + type.toUpperCase()] === "function");
  271.     };
  273.     var isDOMElement = function (object) {
  274.         return typeof object === 'object' && object.nodeType === 1;
  275.     };
  277.     var getImageDataFromElement = function (element) {
  278.         //if element is an image which uses data url definition, just return the dataurl
  279.         if (element.nodeName === 'IMG' && element.hasAttribute('src')) {
  280.             var src = '' + element.getAttribute('src');
  282.             //is base64 encoded dataUrl, directly process it
  283.             if (src.indexOf('data:image/') === 0) {
  284.                 return atob(unescape(src).split('base64,').pop());
  285.             }
  287.             //it is probably an url, try to load it
  288.             var tmpImageData = jsPDFAPI.loadFile(src, true);
  289.             if (tmpImageData !== undefined) {
  290.                 return tmpImageData
  291.             }
  292.         }
  294.         if (element.nodeName === 'CANVAS') {
  295.             return atob(element.toDataURL('image/jpeg', 1.0).split('base64,').pop());
  296.         }
  297.     };
  299.     var checkImagesForAlias = function (alias) {
  300.         var images = this.internal.collections[namespace + 'images'];
  301.         if (images) {
  302.             for (var e in images) {
  303.                 if (alias === images[e].alias) {
  304.                     return images[e];
  305.                 }
  306.             }
  307.         }
  308.     };
  310.     var determineWidthAndHeight = function (width, height, image) {
  311.         if (!width && !height) {
  312.             width = -96;
  313.             height = -96;
  314.         }
  315.         if (width < 0) {
  316.             width = (-1) * image.width * 72 / width / this.internal.scaleFactor;
  317.         }
  318.         if (height < 0) {
  319.             height = (-1) * image.height * 72 / height / this.internal.scaleFactor;
  320.         }
  321.         if (width === 0) {
  322.             width = height * image.width / image.height;
  323.         }
  324.         if (height === 0) {
  325.             height = width * image.height / image.width;
  326.         }
  328.         return [width, height];
  329.     };
  331.     var writeImageToPDF = function (x, y, width, height, image, rotation) {
  332.         var dims = determineWidthAndHeight.call(this, width, height, image),
  333.             coord = this.internal.getCoordinateString,
  334.             vcoord = this.internal.getVerticalCoordinateString;
  335.         
  336.         var images = getImages.call(this);
  338.         width = dims[0];
  339.         height = dims[1];
  340.         images[image.index] = image;
  342.         if (rotation) {
  343.             rotation *= (Math.PI / 180);
  344.             var c = Math.cos(rotation);
  345.             var s = Math.sin(rotation);
  346.             //like in pdf Reference do it 4 digits instead of 2
  347.             var f4 = function (number) {
  348.                 return number.toFixed(4);
  349.             }
  350.             var rotationTransformationMatrix = [f4(c), f4(s), f4(s * -1), f4(c), 0, 0, 'cm'];
  351.         }
  352.         this.internal.write('q'); //Save graphics state
  353.         if (rotation) {
  354.             this.internal.write([1, '0', '0', 1, coord(x), vcoord(y + height), 'cm'].join(' '));  //Translate
  355.             this.internal.write(rotationTransformationMatrix.join(' ')); //Rotate
  356.             this.internal.write([coord(width), '0', '0', coord(height), '0', '0', 'cm'].join(' '));  //Scale
  357.         } else {
  358.             this.internal.write([coord(width), '0', '0', coord(height), coord(x), vcoord(y + height), 'cm'].join(' '));  //Translate and Scale
  359.         }
  360.         this.internal.write('/I' + image.index + ' Do'); //Paint Image
  361.         this.internal.write('Q'); //Restore graphics state
  362.     };
  364.     /**
  365.      * COLOR SPACES
  366.      */
  367.     var color_spaces = jsPDFAPI.color_spaces = {
  368.         DEVICE_RGB: 'DeviceRGB',
  369.         DEVICE_GRAY: 'DeviceGray',
  370.         DEVICE_CMYK: 'DeviceCMYK',
  371.         CAL_GREY: 'CalGray',
  372.         CAL_RGB: 'CalRGB',
  373.         LAB: 'Lab',
  374.         ICC_BASED: 'ICCBased',
  375.         INDEXED: 'Indexed',
  376.         PATTERN: 'Pattern',
  377.         SEPARATION: 'Separation',
  378.         DEVICE_N: 'DeviceN'
  379.     };
  381.     /**
  382.      * DECODE METHODS
  383.      */
  384.     jsPDFAPI.decode = {
  385.         DCT_DECODE: 'DCTDecode',
  386.         FLATE_DECODE: 'FlateDecode',
  387.         LZW_DECODE: 'LZWDecode',
  388.         JPX_DECODE: 'JPXDecode',
  389.         JBIG2_DECODE: 'JBIG2Decode',
  390.         ASCII85_DECODE: 'ASCII85Decode',
  391.         ASCII_HEX_DECODE: 'ASCIIHexDecode',
  392.         RUN_LENGTH_DECODE: 'RunLengthDecode',
  393.         CCITT_FAX_DECODE: 'CCITTFaxDecode'
  394.     };
  396.     /**
  397.      * IMAGE COMPRESSION TYPES
  398.      */
  399.     var image_compression = jsPDFAPI.image_compression = {
  400.         NONE: 'NONE',
  401.         FAST: 'FAST',
  402.         MEDIUM: 'MEDIUM',
  403.         SLOW: 'SLOW'
  404.     };
  406.     /**
  407.     * @name sHashCode
  408.     * @function 
  409.     * @param {string} data
  410.     * @returns {string} 
  411.     */
  412.     var sHashCode = jsPDFAPI.__addimage__.sHashCode = function (data) {
  413.         var hash = 0, i, chr, len;
  415.         if (typeof data === "string") {
  416.             len = data.length;
  417.             for (i = 0; i < len; i++) {
  418.                 chr = data.charCodeAt(i);
  419.                 hash = ((hash << 5) - hash) + chr;
  420.                 hash |= 0; // Convert to 32bit integer
  421.             }
  422.         } else if (isArrayBufferView(data)) {
  423.             len = data.byteLength / 2;
  424.             for (i = 0; i < len; i++) {
  425.                 chr = data[i];
  426.                 hash = ((hash << 5) - hash) + chr;
  427.                 hash |= 0; // Convert to 32bit integer
  428.             }
  429.         }
  430.         return hash;
  431.     };
  433.     /**
  434.     * Validates if given String is a valid Base64-String
  435.     *
  436.     * @name validateStringAsBase64
  437.     * @public
  438.     * @function
  439.     * @param {String} possible Base64-String
  440.     * 
  441.     * @returns {boolean}
  442.     */
  443.     var validateStringAsBase64 = jsPDFAPI.__addimage__.validateStringAsBase64 = function (possibleBase64String) {
  444.         possibleBase64String = possibleBase64String || '';
  445.         possibleBase64String.toString().trim();
  447.         var result = true;
  449.         if (possibleBase64String.length === 0) {
  450.             result = false;
  451.         }
  453.         if (possibleBase64String.length % 4 !== 0) {
  454.             result = false;
  455.         }
  457.         if (/^[A-Za-z0-9+/]+$/.test(possibleBase64String.substr(0, possibleBase64String.length - 2)) === false) {
  458.             result = false;
  459.         }
  462.         if (/^[A-Za-z0-9/][A-Za-z0-9+/]|[A-Za-z0-9+/]=|==$/.test(possibleBase64String.substr(-2)) === false) {
  463.             result = false;
  464.         }
  465.         return result;
  466.     };
  468.     /**
  469.      * Strips out and returns info from a valid base64 data URI
  470.      *
  471.      * @name extractImageFromDataUrl
  472.      * @function 
  473.      * @param {string} dataUrl a valid data URI of format 'data:[<MIME-type>][;base64],<data>'
  474.      * @returns {Array}an Array containing the following
  475.      * [0] the complete data URI
  476.      * [1] <MIME-type>
  477.      * [2] format - the second part of the mime-type i.e 'png' in 'image/png'
  478.      * [4] <data>
  479.      */
  480.     var extractImageFromDataUrl = jsPDFAPI.__addimage__.extractImageFromDataUrl = function (dataUrl) {
  481.         dataUrl = dataUrl || '';
  482.         var dataUrlParts = dataUrl.split('base64,');
  483.         var result = null;
  485.         if (dataUrlParts.length === 2) {
  486.             var extractedInfo = /^data:(\w*\/\w*);*(charset=[\w=-]*)*;*$/.exec(dataUrlParts[0]);
  487.             if (Array.isArray(extractedInfo)) {
  488.                 result = {
  489.                     mimeType: extractedInfo[1],
  490.                     charset: extractedInfo[2],
  491.                     data: dataUrlParts[1]
  492.                 };
  493.             }
  494.         }
  495.         return result;
  496.     };
  498.     /**
  499.      * Check to see if ArrayBuffer is supported
  500.      * 
  501.      * @name supportsArrayBuffer
  502.      * @function
  503.      * @returns {boolean}
  504.      */
  505.     var supportsArrayBuffer = jsPDFAPI.__addimage__.supportsArrayBuffer = function () {
  506.         return typeof ArrayBuffer !== 'undefined' && typeof Uint8Array !== 'undefined';
  507.     };
  509.     /**
  510.      * Tests supplied object to determine if ArrayBuffer
  511.      *
  512.      * @name isArrayBuffer
  513.      * @function 
  514.      * @param {Object} object an Object
  515.      * 
  516.      * @returns {boolean}
  517.      */
  518.     jsPDFAPI.__addimage__.isArrayBuffer = function (object) {
  519.         return supportsArrayBuffer() && object instanceof ArrayBuffer;
  520.     };
  522.     /**
  523.      * Tests supplied object to determine if it implements the ArrayBufferView (TypedArray) interface
  524.      *
  525.      * @name isArrayBufferView
  526.      * @function 
  527.      * @param {Object} object an Object
  528.      * @returns {boolean}
  529.      */
  530.     var isArrayBufferView = jsPDFAPI.__addimage__.isArrayBufferView = function (object) {
  531.         return (supportsArrayBuffer() && typeof Uint32Array !== 'undefined') &&
  532.             (object instanceof Int8Array ||
  533.                 object instanceof Uint8Array ||
  534.                 (typeof Uint8ClampedArray !== 'undefined' && object instanceof Uint8ClampedArray) ||
  535.                 object instanceof Int16Array ||
  536.                 object instanceof Uint16Array ||
  537.                 object instanceof Int32Array ||
  538.                 object instanceof Uint32Array ||
  539.                 object instanceof Float32Array ||
  540.                 object instanceof Float64Array);
  541.     };
  544.     /**
  545.     * Convert Binary String to ArrayBuffer
  546.     *
  547.     * @name binaryStringToUint8Array
  548.     * @public
  549.     * @function
  550.     * @param {string} BinaryString with ImageData
  551.     * @returns {Uint8Array}
  552.     */
  553.     var binaryStringToUint8Array = jsPDFAPI.__addimage__.binaryStringToUint8Array = function (binary_string) {
  554.         var len = binary_string.length;
  555.         var bytes = new Uint8Array(len);
  556.         for (var i = 0; i < len; i++) {
  557.             bytes[i] = binary_string.charCodeAt(i);
  558.         }
  559.         return bytes;
  560.     };
  562.     /**
  563.     * Convert the Buffer to a Binary String
  564.     *
  565.     * @name arrayBufferToBinaryString
  566.     * @public
  567.     * @function
  568.     * @param {ArrayBuffer} ArrayBuffer with ImageData
  569.     * 
  570.     * @returns {String}
  571.     */
  572.     var arrayBufferToBinaryString = jsPDFAPI.__addimage__.arrayBufferToBinaryString = function (buffer) {
  573.         try {
  574.             return atob(btoa(String.fromCharCode.apply(null, buffer)));
  575.         } catch (e) {
  576.             if (typeof Uint8Array !== 'undefined' && typeof Uint8Array.prototype.reduce !== 'undefined') {
  577.                 return new Uint8Array(buffer).reduce(function (data, byte) {
  578.                     return data.push(String.fromCharCode(byte)), data;
  579.                 }, []).join('');
  580.             }
  581.         }
  582.     };
  584.     /**
  585.     * Adds an Image to the PDF.
  586.     *
  587.     * @name addImage
  588.     * @public
  589.     * @function
  590.     * @param {string|HTMLImageElement|HTMLCanvasElement|Uint8Array} imageData imageData as base64 encoded DataUrl or Image-HTMLElement or Canvas-HTMLElement
  591.     * @param {string} format format of file if filetype-recognition fails, e.g. 'JPEG'
  592.     * @param {number} x x Coordinate (in units declared at inception of PDF document) against left edge of the page
  593.     * @param {number} y y Coordinate (in units declared at inception of PDF document) against upper edge of the page
  594.     * @param {number} width width of the image (in units declared at inception of PDF document)
  595.     * @param {number} height height of the Image (in units declared at inception of PDF document)
  596.     * @param {string} alias alias of the image (if used multiple times)
  597.     * @param {string} compression compression of the generated JPEG, can have the values 'NONE', 'FAST', 'MEDIUM' and 'SLOW'
  598.     * @param {number} rotation rotation of the image in degrees (0-359)
  599.     * 
  600.     * @returns jsPDF
  601.     */
  602.     jsPDFAPI.addImage = function (imageData, format, x, y, w, h, alias, compression, rotation) {
  603.         // backwards compatibility
  604.         if (typeof format !== 'string') {
  605.             var tmp = h;
  606.             h = w;
  607.             w = y;
  608.             y = x;
  609.             x = format;
  610.             format = tmp;
  611.         }
  613.         if (typeof imageData === 'object' && !isDOMElement(imageData) && "imageData" in imageData) {
  614.             var options = imageData;
  616.             imageData = options.imageData;
  617.             format = options.format || format || UNKNOWN;
  618.             x = options.x || x || 0;
  619.             y = options.y || y || 0;
  620.             w = options.w || options.width  || w;
  621.             h = options.h || options.height || h;
  622.             alias = options.alias || alias;
  623.             compression = options.compression || compression;
  624.             rotation = options.rotation || options.angle || rotation;
  625.         }
  627.         //If compression is not explicitly set, determine if we should use compression
  628.         var filter = this.internal.getFilters();
  629.         if (compression === undefined && filter.indexOf('FlateEncode') !== -1) {
  630.             compression = 'SLOW';
  631.         }
  633.         if (isNaN(x) || isNaN(y)) {
  634.             throw new Error('Invalid coordinates passed to jsPDF.addImage');
  635.         }
  637.         initialize.call(this);
  639.         var image = processImageData.call(this, imageData, format, alias, compression);
  641.         writeImageToPDF.call(this, x, y, w, h, image, rotation);
  643.         return this;
  644.     };
  646.     var processImageData = function (imageData, format, alias, compression) {
  647.         var result, dataAsBinaryString;
  649.         if (typeof imageData === "string" && getImageFileTypeByImageData(imageData) === UNKNOWN) {
  650.             imageData = unescape(imageData);
  651.         }
  653.         if (typeof imageData === 'string') {
  654.             var tmpImageData = convertBase64ToBinaryString(imageData, false);
  656.             if (tmpImageData !== '') {
  657.                 imageData = tmpImageData;
  658.             } else {
  659.                 tmpImageData = jsPDFAPI.loadFile(imageData, true);
  660.                 if (tmpImageData !== undefined) {
  661.                     imageData = tmpImageData;
  662.                 }
  663.             }
  664.         }
  666.         if (isDOMElement(imageData)) {
  667.             imageData = getImageDataFromElement(imageData);
  668.         }
  670.         format = getImageFileTypeByImageData(imageData, format);
  671.         if (!isImageTypeSupported(format)) {
  672.             throw new Error('addImage does not support files of type \'' + format + '\', please ensure that a plugin for \'' + format + '\' support is added.');
  673.         }
  675.         // now do the heavy lifting
  677.         if (notDefined(alias)) {
  678.             alias = generateAliasFromImageData(imageData);
  679.         }
  680.         result = checkImagesForAlias.call(this, alias);
  682.         if (!result) {
  683.             if (supportsArrayBuffer()) {
  684.                 // no need to convert if imageData is already uint8array
  685.                 if (!(imageData instanceof Uint8Array)) {
  686.                     dataAsBinaryString = imageData;
  687.                     imageData = binaryStringToUint8Array(imageData);
  688.                 }
  689.             }
  691.             result = this['process' + format.toUpperCase()](
  692.                 imageData,
  693.                 getImageIndex.call(this),
  694.                 alias,
  695.                 checkCompressValue(compression),
  696.                 dataAsBinaryString
  697.             );
  698.         }
  700.         if (!result) {
  701.             throw new Error('An unknown error occurred whilst processing the image.');
  702.         }
  703.         return result;
  704.     };
  706.     /**
  707.     * @name convertBase64ToBinaryString
  708.     * @function
  709.     * @param {string} stringData
  710.     * @returns {string} binary string
  711.     */
  712.     var convertBase64ToBinaryString = jsPDFAPI.__addimage__.convertBase64ToBinaryString = function (stringData, throwError) {
  713.         throwError = typeof throwError === "boolean" ? throwError : true;
  714.         var base64Info;
  715.         var imageData = '';
  716.         var rawData;
  718.         if (typeof stringData === 'string') {
  719.             base64Info = extractImageFromDataUrl(stringData);
  720.             rawData = (base64Info !== null) ? base64Info.data : stringData;
  722.             try {
  723.                 imageData = atob(rawData);
  724.             } catch (e) {
  725.                 if (throwError) {
  726.                     if (!validateStringAsBase64(rawData)) {
  727.                         throw new Error('Supplied Data is not a valid base64-String jsPDF.convertBase64ToBinaryString ');
  728.                     } else {
  729.                         throw new Error('atob-Error in jsPDF.convertBase64ToBinaryString ' + e.message);
  730.                     }
  731.                 }
  732.             }
  733.         }
  734.         return imageData;
  735.     };
  737.     /**
  738.     * @name getImageProperties
  739.     * @function
  740.     * @param {Object} imageData
  741.     * @returns {Object}
  742.     */
  743.     jsPDFAPI.getImageProperties = function (imageData) {
  744.         var image;
  745.         var tmpImageData = '';
  746.         var format;
  748.         if (isDOMElement(imageData)) {
  749.             imageData = getImageDataFromElement(imageData);
  750.         }
  752.         if (typeof imageData === "string" && getImageFileTypeByImageData(imageData) === UNKNOWN) {
  753.             tmpImageData = convertBase64ToBinaryString(imageData, false);
  755.             if (tmpImageData === '') {
  756.                 tmpImageData = jsPDFAPI.loadFile(imageData) || '';
  757.             }
  758.             imageData = tmpImageData;
  759.         }
  761.         format = getImageFileTypeByImageData(imageData);
  762.         if (!isImageTypeSupported(format)) {
  763.             throw new Error('addImage does not support files of type \'' + format + '\', please ensure that a plugin for \'' + format + '\' support is added.');
  764.         }
  766.         if (supportsArrayBuffer() && !(imageData instanceof Uint8Array)) {
  767.             imageData = binaryStringToUint8Array(imageData);
  768.         }
  770.         image = this['process' + format.toUpperCase()](imageData);
  772.         if (!image) {
  773.             throw new Error('An unknown error occurred whilst processing the image');
  774.         }
  776.         image.fileType = format;
  778.         return image;
  779.     };
  781. })(jsPDF.API);