HTML5PPM

    createPPM : function(canvas, destFile, usegamma)
    {
        const MAXVAL = 255;

        var width = canvas.width;
        var height = canvas.height;

        var ctx = canvas.getContext("2d");
        var canvasData = ctx.getImageData(0, 0, width, height);

        // build the Bt.709 gamma tables
        if (this.ppmgamma) {
            var rGammaTable = new Array(MAXVAL + 1);
            var gGammaTable = new Array(MAXVAL + 1);
            var bGammaTable = new Array(MAXVAL + 1);

            this.buildBT709GammaTable(rGammaTable, MAXVAL);
            this.buildBT709GammaTable(gGammaTable, MAXVAL);
            this.buildBT709GammaTable(bGammaTable, MAXVAL);
        }

        // build file header
        var fileHeader = "P6\n";
        if (usegamma) {
           fileHeader += "# BT.709 gamma adjustment applied\n";
        } else {
           fileHeader += "# No gamma adjustment applied\n";
        }
        fileHeader += width + " " + height + "\n";
        fileHeader += MAXVAL + "\n";          

        // build data
        var imgData = canvasData.data;
        var pixelData = [];
        for (var i = 0, n = imgData.length; i < n; i += 4) {
            pixelData.push(imgData[i]);                              // red
            pixelData.push(imgData[i+1]);                            // green
            pixelData.push(imgData[i+2]);                            // blue
            // skip alpha channel
        }

        // now fix up gamma values
        if (usegamma) {
            for (var i = 0; i < pixelData.length; i += 3) {
                pixelData[i]   = rGammaTable[pixelData[i]];
                pixelData[i+1] = gGammaTable[pixelData[i+1]];
                pixelData[i+2] = bGammaTable[pixelData[i+2]];
            }
        }

        var file = Components.classes["@mozilla.org/file/local;1"]
                             .createInstance(Components.interfaces.nsILocalFile);
        file.initWithPath(destFile);
        if (file.exists()) {
            file.remove(true);
        }
        file.create(file.NORMAL_FILE_TYPE, 0666);

        var fileStream = Components.classes['@mozilla.org/network/file-output-stream;1']
                                   .createInstance(Components.interfaces.nsIFileOutputStream);
        fileStream.init(file, 2, 0x200, false);

        var binaryStream = Components.classes['@mozilla.org/binaryoutputstream;1']
                                     .createInstance(Components.interfaces.nsIBinaryOutputStream);
        binaryStream.setOutputStream(fileStream);

        binaryStream.write(fileHeader, fileHeader.length);
        binaryStream.writeByteArray(pixelData, pixelData.length);

        binaryStream.close();
        fileStream.close();

    },

    //
    // Note - formulas come from netpbm package
    //
    buildBT709GammaTable : function(table, maxval)
    {
        var i = 0;

        var gamma = 1/0.45;                                          // Per ITU BT.709

        var oneOverGamma = 1/gamma;
        var linearCutoff = maxval * 0.018 + 0.5;
        var linearExpansion = (1.099 * Math.pow(0.018, oneOverGamma) - 0.099) / 0.018;

        for (i = 0; i <= linearCutoff; ++i) {
            table[i] = i * linearExpansion;
        }

        for (; i <= maxval; ++i) {
            var normalized = i / maxval;
            var v = 1.099 * Math.pow(normalized, oneOverGamma) - 0.099;
            table[i] = Math.min((v * maxval + 0.5), maxval);
        }
    }

    //
    // Note -formulas come from netpbm package
    //
    buildSRGBGammaTable : function(table, maxval)
    {
        var i = 0;

        var gamma = 2.4;                                           // per IEC sRGB

        var oneOverGamma = 1/gamma;
        var linearCutoff = maxval * 0.0031208 + 0.5;
        var linearExpansion = (1.055 * Math.pow(0.0031308, oneOverGamma) - 0.055) / 0.031308;

        for (i = 0; i <= linearCutoff; ++i) {
            table[i] = i * linearExpansion + 0.5;
        }

        for (; i <= maxval; ++i) {
            var normalized = i / maxval;
            var v = 1.055 * Math.pow(normalized, oneOverGamma) - 0.055;
            table[i] = Math.min((v * maxval + 0.5), maxval);
        }
    }