/* global jsPDF */
/** @license
 * jsPDF addImage plugin
 * Copyright (c) 2012 Jason Siefken, https://github.com/siefkenj/
 *               2013 Chris Dowling, https://github.com/gingerchris
 *               2013 Trinh Ho, https://github.com/ineedfat
 *               2013 Edwin Alejandro Perez, https://github.com/eaparango
 *               2013 Norah Smith, https://github.com/burnburnrocket
 *               2014 Diego Casorran, https://github.com/diegocr
 *               2014 James Robb, https://github.com/jamesbrobb
 *
 * 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.
 */
/**
* @name addImage
* @module
*/
(function (jsPDFAPI) {
    'use strict';

    var namespace = 'addImage_';
    jsPDFAPI.__addimage__ = {};

    var UNKNOWN = 'UNKNOWN';

    var imageFileTypeHeaders = {
        PNG: [[0x89, 0x50, 0x4e, 0x47]],
        TIFF: [
            [0x4D, 0x4D, 0x00, 0x2A], //Motorola
            [0x49, 0x49, 0x2A, 0x00]  //Intel
        ],
        JPEG: [
            [0xFF, 0xD8, 0xFF, 0xE0, undefined, undefined, 0x4A, 0x46, 0x49, 0x46, 0x00],      //JFIF
            [0xFF, 0xD8, 0xFF, 0xE1, undefined, undefined, 0x45, 0x78, 0x69, 0x66, 0x00, 0x00], //Exif
            [0xFF, 0xD8, 0xFF, 0xDB], //JPEG RAW
            [0xFF, 0xD8, 0xFF, 0xEE] //EXIF RAW
        ],
        JPEG2000: [[0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20]],
        GIF87a: [[0x47, 0x49, 0x46, 0x38, 0x37, 0x61]],
        GIF89a: [[0x47, 0x49, 0x46, 0x38, 0x39, 0x61]],
        WEBP: [[0x52, 0x49, 0x46, 0x46, undefined, undefined, undefined, undefined, 0x57, 0x45, 0x42, 0x50]],
        BMP: [
            [0x42, 0x4D], //BM - Windows 3.1x, 95, NT, ... etc.
            [0x42, 0x41], //BA - OS/2 struct bitmap array
            [0x43, 0x49], //CI - OS/2 struct color icon
            [0x43, 0x50], //CP - OS/2 const color pointer
            [0x49, 0x43], //IC - OS/2 struct icon
            [0x50, 0x54]  //PT - OS/2 pointer
        ]
    };

    /**
    * Recognize filetype of Image by magic-bytes
    * 
    * https://en.wikipedia.org/wiki/List_of_file_signatures
    *
    * @name getImageFileTypeByImageData
    * @public
    * @function
    * @param {string|arraybuffer} imageData imageData as binary String or arraybuffer
    * @param {string} format format of file if filetype-recognition fails, e.g. 'JPEG'
    * 
    * @returns {string} filetype of Image
    */
    var getImageFileTypeByImageData = jsPDFAPI.__addimage__.getImageFileTypeByImageData = function (imageData, fallbackFormat) {
        fallbackFormat = fallbackFormat || UNKNOWN;
        var i;
        var j;
        var result = UNKNOWN;
        var headerSchemata;
        var compareResult;
        var fileType;

        if (isArrayBufferView(imageData)) {
            for (fileType in imageFileTypeHeaders) {
                headerSchemata = imageFileTypeHeaders[fileType];
                for (i = 0; i < headerSchemata.length; i += 1) {
                    compareResult = true;
                    for (j = 0; j < headerSchemata[i].length; j += 1) {
                        if (headerSchemata[i][j] === undefined) {
                            continue;
                        }
                        if (headerSchemata[i][j] !== imageData[j]) {
                            compareResult = false;
                            break;
                        }
                    }
                    if (compareResult === true) {
                        result = fileType;
                        break;
                    }
                }
            }
        } else {
            for (fileType in imageFileTypeHeaders) {
                headerSchemata = imageFileTypeHeaders[fileType];
                for (i = 0; i < headerSchemata.length; i += 1) {
                    compareResult = true;
                    for (j = 0; j < headerSchemata[i].length; j += 1) {
                        if (headerSchemata[i][j] === undefined) {
                            continue;
                        }
                        if (headerSchemata[i][j] !== imageData.charCodeAt(j)) {
                            compareResult = false;
                            break;
                        }
                    }
                    if (compareResult === true) {
                        result = fileType;
                        break;
                    }
                }
            }
        }

        if (result === UNKNOWN && fallbackFormat !== UNKNOWN) {
            result = fallbackFormat;
        }
        return result;
    };

    // Image functionality ported from pdf.js
    var putImage = function (image) {

        var out = this.internal.write;
        var putStream = this.internal.putStream;
        var getFilters = this.internal.getFilters;

        var filter = getFilters();
        while (filter.indexOf('FlateEncode') !== -1) {
            filter.splice(filter.indexOf('FlateEncode'), 1);
        }

        image.objectId = this.internal.newObject();

        var additionalKeyValues = [];
        additionalKeyValues.push({ key: 'Type', value: '/XObject' });
        additionalKeyValues.push({ key: 'Subtype', value: '/Image' });
        additionalKeyValues.push({ key: 'Width', value: image.width });
        additionalKeyValues.push({ key: 'Height', value: image.height });

        if (image.colorSpace === color_spaces.INDEXED) {
            additionalKeyValues.push({
                key: 'ColorSpace', value: '[/Indexed /DeviceRGB '
                    // if an indexed png defines more than one colour with transparency, we've created a sMask
                    + (image.palette.length / 3 - 1) + ' ' + ('sMask' in image  && typeof image.sMask !== "undefined" ? image.objectId + 2 : image.objectId + 1)
                    + ' 0 R]'
            });
        } else {
            additionalKeyValues.push({ key: 'ColorSpace', value: '/' + image.colorSpace });
            if (image.colorSpace === color_spaces.DEVICE_CMYK) {
                additionalKeyValues.push({ key: 'Decode', value: '[1 0 1 0 1 0 1 0]' });
            }
        }
        additionalKeyValues.push({ key: 'BitsPerComponent', value: image.bitsPerComponent });
        if ('decodeParameters' in image && typeof image.decodeParameters !== "undefined") {
            additionalKeyValues.push({ key: 'DecodeParms', value: '<<' + image.decodeParameters + '>>' });
        }
        if ('transparency' in image && Array.isArray(image.transparency)) {
            var transparency = '',
                i = 0,
                len = image.transparency.length;
            for (; i < len; i++)
                transparency += (image.transparency[i] + ' ' + image.transparency[i] + ' ');

            additionalKeyValues.push({ key: 'Mask', value: '[' + transparency + ']' });
        }
        if (typeof image.sMask !== "undefined") {
            additionalKeyValues.push({ key: 'SMask', value: (image.objectId + 1) + ' 0 R' });
        }

        var alreadyAppliedFilters = (typeof image.filter !== "undefined") ? ['/' + image.filter] : undefined;

        putStream({ data: image.data, additionalKeyValues: additionalKeyValues, alreadyAppliedFilters: alreadyAppliedFilters });

        out('endobj');

        // Soft mask
        if ('sMask' in image && typeof image.sMask !== "undefined") {
            var decodeParameters = '/Predictor ' + image.predictor + ' /Colors 1 /BitsPerComponent ' + image.bitsPerComponent + ' /Columns ' + image.width;
            var sMask = { width: image.width, height: image.height, colorSpace: 'DeviceGray', bitsPerComponent: image.bitsPerComponent, decodeParameters: decodeParameters, data: image.sMask };
            if ('filter' in image) {
                sMask.filter = image.filter;
            }
            putImage.call(this, sMask);
        }

        //Palette
        if (image.colorSpace === color_spaces.INDEXED) {

            this.internal.newObject();
            //out('<< /Filter / ' + img['f'] +' /Length ' + img['pal'].length + '>>');
            //putStream(zlib.compress(img['pal']));
            putStream({ data: arrayBufferToBinaryString(new Uint8Array(image.palette)) });
            out('endobj');
        }
    };
    var putResourcesCallback = function () {
        var images = this.internal.collections[namespace + 'images'];
        for (var i in images) {
            putImage.call(this, images[i]);
        }
    };
    var putXObjectsDictCallback = function () {
        var images = this.internal.collections[namespace + 'images']
            , out = this.internal.write
            , image;
        for (var i in images) {
            image = images[i];
            out(
                '/I' + image.index
                , image.objectId
                , '0'
                , 'R'
            );
        }
    };

    var checkCompressValue = function (value) {
        if (value && typeof value === 'string')
            value = value.toUpperCase();
        return value in jsPDFAPI.image_compression ? value : image_compression.NONE;
    };

    var initialize = function () {
        if (!this.internal.collections[namespace + 'images']) {
            this.internal.collections[namespace + 'images'] = {};
            this.internal.events.subscribe('putResources', putResourcesCallback);
            this.internal.events.subscribe('putXobjectDict', putXObjectsDictCallback);
        }
    };

    var getImages = function () {
        var images = this.internal.collections[namespace + 'images'];
        initialize.call(this);
        return images;
    };
    var getImageIndex = function () {
        return Object.keys(this.internal.collections[namespace + 'images']).length;
    };
    var notDefined = function (value) {
        return typeof value === 'undefined' || value === null || value.length === 0;
    };
    var generateAliasFromImageData = function (imageData) {
        if (typeof imageData === 'string' || isArrayBufferView(imageData)) {
            return sHashCode(imageData);
        }

        return null;
    };

    var isImageTypeSupported = function (type) {
        return (typeof jsPDFAPI["process" + type.toUpperCase()] === "function");
    };

    var isDOMElement = function (object) {
        return typeof object === 'object' && object.nodeType === 1;
    };

    var getImageDataFromElement = function (element, format) {
        //if element is an image which uses data url definition, just return the dataurl
        if (element.nodeName === 'IMG' && element.hasAttribute('src')) {
            var src = '' + element.getAttribute('src');

            //is base64 encoded dataUrl, directly process it
            if (src.indexOf('data:image/') === 0) {
                return atob(unescape(src).split('base64,').pop());
            }

            //it is probably an url, try to load it
            var tmpImageData = jsPDFAPI.loadFile(src, true);
            if (tmpImageData !== undefined) {
                return tmpImageData;
            }
        }

        if (element.nodeName === 'CANVAS') {
            var mimeType;
                switch (format) {
                    case 'PNG':
                        mimeType = 'image/png';
                        break;
                    case 'WEBP':
                        mimeType = 'image/webp';
                        break;
                    case 'JPEG':
                    case 'JPG':
                    default:
                    mimeType = 'image/jpeg';
                        break;
                }
            return atob(element.toDataURL(mimeType, 1.0).split('base64,').pop());
        }
    };

    var checkImagesForAlias = function (alias) {
        var images = this.internal.collections[namespace + 'images'];
        if (images) {
            for (var e in images) {
                if (alias === images[e].alias) {
                    return images[e];
                }
            }
        }
    };

    var determineWidthAndHeight = function (width, height, image) {
        if (!width && !height) {
            width = -96;
            height = -96;
        }
        if (width < 0) {
            width = (-1) * image.width * 72 / width / this.internal.scaleFactor;
        }
        if (height < 0) {
            height = (-1) * image.height * 72 / height / this.internal.scaleFactor;
        }
        if (width === 0) {
            width = height * image.width / image.height;
        }
        if (height === 0) {
            height = width * image.height / image.width;
        }

        return [width, height];
    };

    var writeImageToPDF = function (x, y, width, height, image, rotation) {
        var dims = determineWidthAndHeight.call(this, width, height, image),
            coord = this.internal.getCoordinateString,
            vcoord = this.internal.getVerticalCoordinateString;
        
        var images = getImages.call(this);

        width = dims[0];
        height = dims[1];
        images[image.index] = image;

        if (rotation) {
            rotation *= (Math.PI / 180);
            var c = Math.cos(rotation);
            var s = Math.sin(rotation);
            //like in pdf Reference do it 4 digits instead of 2
            var f4 = function (number) {
                return number.toFixed(4);
            };
            var rotationTransformationMatrix = [f4(c), f4(s), f4(s * -1), f4(c), 0, 0, 'cm'];
        }
        this.internal.write('q'); //Save graphics state
        if (rotation) {
            this.internal.write([1, '0', '0', 1, coord(x), vcoord(y + height), 'cm'].join(' '));  //Translate
            this.internal.write(rotationTransformationMatrix.join(' ')); //Rotate
            this.internal.write([coord(width), '0', '0', coord(height), '0', '0', 'cm'].join(' '));  //Scale
        } else {
            this.internal.write([coord(width), '0', '0', coord(height), coord(x), vcoord(y + height), 'cm'].join(' '));  //Translate and Scale
        }
        this.internal.write('/I' + image.index + ' Do'); //Paint Image
        this.internal.write('Q'); //Restore graphics state
    };

    /**
     * COLOR SPACES
     */
    var color_spaces = jsPDFAPI.color_spaces = {
        DEVICE_RGB: 'DeviceRGB',
        DEVICE_GRAY: 'DeviceGray',
        DEVICE_CMYK: 'DeviceCMYK',
        CAL_GREY: 'CalGray',
        CAL_RGB: 'CalRGB',
        LAB: 'Lab',
        ICC_BASED: 'ICCBased',
        INDEXED: 'Indexed',
        PATTERN: 'Pattern',
        SEPARATION: 'Separation',
        DEVICE_N: 'DeviceN'
    };

    /**
     * DECODE METHODS
     */
    jsPDFAPI.decode = {
        DCT_DECODE: 'DCTDecode',
        FLATE_DECODE: 'FlateDecode',
        LZW_DECODE: 'LZWDecode',
        JPX_DECODE: 'JPXDecode',
        JBIG2_DECODE: 'JBIG2Decode',
        ASCII85_DECODE: 'ASCII85Decode',
        ASCII_HEX_DECODE: 'ASCIIHexDecode',
        RUN_LENGTH_DECODE: 'RunLengthDecode',
        CCITT_FAX_DECODE: 'CCITTFaxDecode'
    };

    /**
     * IMAGE COMPRESSION TYPES
     */
    var image_compression = jsPDFAPI.image_compression = {
        NONE: 'NONE',
        FAST: 'FAST',
        MEDIUM: 'MEDIUM',
        SLOW: 'SLOW'
    };

    /**
    * @name sHashCode
    * @function 
    * @param {string} data
    * @returns {string} 
    */
    var sHashCode = jsPDFAPI.__addimage__.sHashCode = function (data) {
        var hash = 0, i, len;

        if (typeof data === "string") {
            len = data.length;
            for (i = 0; i < len; i++) {
                hash = ((hash << 5) - hash) + data.charCodeAt(i);
                hash |= 0; // Convert to 32bit integer
            }
        } else if (isArrayBufferView(data)) {
            len = data.byteLength / 2;
            for (i = 0; i < len; i++) {
                hash = ((hash << 5) - hash) + data[i];
                hash |= 0; // Convert to 32bit integer
            }
        }
        return hash;
    };

    /**
    * Validates if given String is a valid Base64-String
    *
    * @name validateStringAsBase64
    * @public
    * @function
    * @param {String} possible Base64-String
    * 
    * @returns {boolean}
    */
    var validateStringAsBase64 = jsPDFAPI.__addimage__.validateStringAsBase64 = function (possibleBase64String) {
        possibleBase64String = possibleBase64String || '';
        possibleBase64String.toString().trim();

        var result = true;

        if (possibleBase64String.length === 0) {
            result = false;
        }

        if (possibleBase64String.length % 4 !== 0) {
            result = false;
        }

        if (/^[A-Za-z0-9+/]+$/.test(possibleBase64String.substr(0, possibleBase64String.length - 2)) === false) {
            result = false;
        }


        if (/^[A-Za-z0-9/][A-Za-z0-9+/]|[A-Za-z0-9+/]=|==$/.test(possibleBase64String.substr(-2)) === false) {
            result = false;
        }
        return result;
    };

    /**
     * Strips out and returns info from a valid base64 data URI
     *
     * @name extractImageFromDataUrl
     * @function 
     * @param {string} dataUrl a valid data URI of format 'data:[<MIME-type>][;base64],<data>'
     * @returns {Array}an Array containing the following
     * [0] the complete data URI
     * [1] <MIME-type>
     * [2] format - the second part of the mime-type i.e 'png' in 'image/png'
     * [4] <data>
     */
    var extractImageFromDataUrl = jsPDFAPI.__addimage__.extractImageFromDataUrl = function (dataUrl) {
        dataUrl = dataUrl || '';
        var dataUrlParts = dataUrl.split('base64,');
        var result = null;

        if (dataUrlParts.length === 2) {
            var extractedInfo = /^data:(\w*\/\w*);*(charset=[\w=-]*)*;*$/.exec(dataUrlParts[0]);
            if (Array.isArray(extractedInfo)) {
                result = {
                    mimeType: extractedInfo[1],
                    charset: extractedInfo[2],
                    data: dataUrlParts[1]
                };
            }
        }
        return result;
    };

    /**
     * Check to see if ArrayBuffer is supported
     * 
     * @name supportsArrayBuffer
     * @function
     * @returns {boolean}
     */
    var supportsArrayBuffer = jsPDFAPI.__addimage__.supportsArrayBuffer = function () {
        return typeof ArrayBuffer !== 'undefined' && typeof Uint8Array !== 'undefined';
    };

    /**
     * Tests supplied object to determine if ArrayBuffer
     *
     * @name isArrayBuffer
     * @function 
     * @param {Object} object an Object
     * 
     * @returns {boolean}
     */
    jsPDFAPI.__addimage__.isArrayBuffer = function (object) {
        return supportsArrayBuffer() && object instanceof ArrayBuffer;
    };

    /**
     * Tests supplied object to determine if it implements the ArrayBufferView (TypedArray) interface
     *
     * @name isArrayBufferView
     * @function 
     * @param {Object} object an Object
     * @returns {boolean}
     */
    var isArrayBufferView = jsPDFAPI.__addimage__.isArrayBufferView = function (object) {
        return (supportsArrayBuffer() && typeof Uint32Array !== 'undefined') &&
            (object instanceof Int8Array ||
                object instanceof Uint8Array ||
                (typeof Uint8ClampedArray !== 'undefined' && object instanceof Uint8ClampedArray) ||
                object instanceof Int16Array ||
                object instanceof Uint16Array ||
                object instanceof Int32Array ||
                object instanceof Uint32Array ||
                object instanceof Float32Array ||
                object instanceof Float64Array);
    };


    /**
    * Convert Binary String to ArrayBuffer
    *
    * @name binaryStringToUint8Array
    * @public
    * @function
    * @param {string} BinaryString with ImageData
    * @returns {Uint8Array}
    */
    var binaryStringToUint8Array = jsPDFAPI.__addimage__.binaryStringToUint8Array = function (binary_string) {
        var len = binary_string.length;
        var bytes = new Uint8Array(len);
        for (var i = 0; i < len; i++) {
            bytes[i] = binary_string.charCodeAt(i);
        }
        return bytes;
    };

    /**
    * Convert the Buffer to a Binary String
    *
    * @name arrayBufferToBinaryString
    * @public
    * @function
    * @param {ArrayBuffer} ArrayBuffer with ImageData
    * 
    * @returns {String}
    */
    var arrayBufferToBinaryString = jsPDFAPI.__addimage__.arrayBufferToBinaryString = function (buffer) {
        try {
            return atob(btoa(String.fromCharCode.apply(null, buffer)));
        } catch (e) {
            if (typeof Uint8Array !== 'undefined' && typeof Uint8Array.prototype.reduce !== 'undefined') {
                return new Uint8Array(buffer).reduce(function (data, byte) {
                    return data.push(String.fromCharCode(byte)), data;
                }, []).join('');
            }
        }
    };

    /**
    * Adds an Image to the PDF.
    *
    * @name addImage
    * @public
    * @function
    * @param {string|HTMLImageElement|HTMLCanvasElement|Uint8Array} imageData imageData as base64 encoded DataUrl or Image-HTMLElement or Canvas-HTMLElement
    * @param {string} format format of file if filetype-recognition fails or in case of a Canvas-Element needs to be specified (default for Canvas is JPEG), e.g. 'JPEG', 'PNG', 'WEBP'
    * @param {number} x x Coordinate (in units declared at inception of PDF document) against left edge of the page
    * @param {number} y y Coordinate (in units declared at inception of PDF document) against upper edge of the page
    * @param {number} width width of the image (in units declared at inception of PDF document)
    * @param {number} height height of the Image (in units declared at inception of PDF document)
    * @param {string} alias alias of the image (if used multiple times)
    * @param {string} compression compression of the generated JPEG, can have the values 'NONE', 'FAST', 'MEDIUM' and 'SLOW'
    * @param {number} rotation rotation of the image in degrees (0-359)
    * 
    * @returns jsPDF
    */
    jsPDFAPI.addImage = function () {
        var imageData, format, x, y, w, h, alias, compression, rotation;

        imageData = arguments[0];
        if (typeof  arguments[1] === 'number') {
            format = UNKNOWN;
            x = arguments[1];
            y = arguments[2];
            w = arguments[3];
            h = arguments[4];
            alias = arguments[5];
            compression = arguments[6];
            rotation = arguments[7];
        } else {
            format = arguments[1];
            x = arguments[2];
            y = arguments[3];
            w = arguments[4];
            h = arguments[5];
            alias = arguments[6];
            compression = arguments[7];
            rotation = arguments[8];
            
        }

        if (typeof imageData === 'object' && !isDOMElement(imageData) && "imageData" in imageData) {
            var options = imageData;

            imageData = options.imageData;
            format = options.format || format || UNKNOWN;
            x = options.x || x || 0;
            y = options.y || y || 0;
            w = options.w || options.width  || w;
            h = options.h || options.height || h;
            alias = options.alias || alias;
            compression = options.compression || compression;
            rotation = options.rotation || options.angle || rotation;
        }

        //If compression is not explicitly set, determine if we should use compression
        var filter = this.internal.getFilters();
        if (compression === undefined && filter.indexOf('FlateEncode') !== -1) {
            compression = 'SLOW';
        }

        if (isNaN(x) || isNaN(y)) {
            throw new Error('Invalid coordinates passed to jsPDF.addImage');
        }

        initialize.call(this);

        var image = processImageData.call(this, imageData, format, alias, compression);

        writeImageToPDF.call(this, x, y, w, h, image, rotation);

        return this;
    };

    var processImageData = function (imageData, format, alias, compression) {
        var result, dataAsBinaryString;

        if (typeof imageData === "string" && getImageFileTypeByImageData(imageData) === UNKNOWN) {
            imageData = unescape(imageData);
            var tmpImageData = convertBase64ToBinaryString(imageData, false);

            if (tmpImageData !== '') {
                imageData = tmpImageData;
            } else {
                tmpImageData = jsPDFAPI.loadFile(imageData, true);
                if (tmpImageData !== undefined) {
                    imageData = tmpImageData;
                }
            }
        }

        if (isDOMElement(imageData)) {
            imageData = getImageDataFromElement(imageData, format);
        }

        format = getImageFileTypeByImageData(imageData, format);
        if (!isImageTypeSupported(format)) {
            throw new Error('addImage does not support files of type \'' + format + '\', please ensure that a plugin for \'' + format + '\' support is added.');
        }

        // now do the heavy lifting

        if (notDefined(alias)) {
            alias = generateAliasFromImageData(imageData);
        }
        result = checkImagesForAlias.call(this, alias);

        if (!result) {
            if (supportsArrayBuffer()) {
                // no need to convert if imageData is already uint8array
                if (!(imageData instanceof Uint8Array)) {
                    dataAsBinaryString = imageData;
                    imageData = binaryStringToUint8Array(imageData);
                }
            }

            result = this['process' + format.toUpperCase()](
                imageData,
                getImageIndex.call(this),
                alias,
                checkCompressValue(compression),
                dataAsBinaryString
            );
        }

        if (!result) {
            throw new Error('An unknown error occurred whilst processing the image.');
        }
        return result;
    };

    /**
    * @name convertBase64ToBinaryString
    * @function
    * @param {string} stringData
    * @returns {string} binary string
    */
    var convertBase64ToBinaryString = jsPDFAPI.__addimage__.convertBase64ToBinaryString = function (stringData, throwError) {
        throwError = typeof throwError === "boolean" ? throwError : true;
        var base64Info;
        var imageData = '';
        var rawData;

        if (typeof stringData === 'string') {
            base64Info = extractImageFromDataUrl(stringData);
            rawData = (base64Info !== null) ? base64Info.data : stringData;

            try {
                imageData = atob(rawData);
            } catch (e) {
                if (throwError) {
                    if (!validateStringAsBase64(rawData)) {
                        throw new Error('Supplied Data is not a valid base64-String jsPDF.convertBase64ToBinaryString ');
                    } else {
                        throw new Error('atob-Error in jsPDF.convertBase64ToBinaryString ' + e.message);
                    }
                }
            }
        }
        return imageData;
    };

    /**
    * @name getImageProperties
    * @function
    * @param {Object} imageData
    * @returns {Object}
    */
    jsPDFAPI.getImageProperties = function (imageData) {
        var image;
        var tmpImageData = '';
        var format;

        if (isDOMElement(imageData)) {
            imageData = getImageDataFromElement(imageData);
        }

        if (typeof imageData === "string" && getImageFileTypeByImageData(imageData) === UNKNOWN) {
            tmpImageData = convertBase64ToBinaryString(imageData, false);

            if (tmpImageData === '') {
                tmpImageData = jsPDFAPI.loadFile(imageData) || '';
            }
            imageData = tmpImageData;
        }

        format = getImageFileTypeByImageData(imageData);
        if (!isImageTypeSupported(format)) {
            throw new Error('addImage does not support files of type \'' + format + '\', please ensure that a plugin for \'' + format + '\' support is added.');
        }

        if (supportsArrayBuffer() && !(imageData instanceof Uint8Array)) {
            imageData = binaryStringToUint8Array(imageData);
        }

        image = this['process' + format.toUpperCase()](imageData);

        if (!image) {
            throw new Error('An unknown error occurred whilst processing the image');
        }

        image.fileType = format;

        return image;
    };

})(jsPDF.API);