246 lines
9.2 KiB
TypeScript
246 lines
9.2 KiB
TypeScript
// Module ID: 4714
|
|
// Function ID: 41008
|
|
// Name: _shouldConvertToWebP
|
|
// Dependencies: [5, 3, 4715, 1193, 2]
|
|
// Exports: maybeConvertToWebP
|
|
|
|
// Module 4714 (_shouldConvertToWebP)
|
|
import asyncGeneratorStep from "asyncGeneratorStep";
|
|
import importDefaultResult from "createBuffer";
|
|
|
|
const require = arg1;
|
|
function _shouldConvertToWebP() {
|
|
return _shouldConvertToWebP2(...arguments);
|
|
}
|
|
async function _shouldConvertToWebP2(arg0, arg1) {
|
|
let obj = arg0;
|
|
let closure_0 = arg0;
|
|
if ("image/webp" === arg0.type) {
|
|
outer2_4.verbose("[WebP] File already WebP format");
|
|
return outer2_5.ALREADY_WEBP;
|
|
} else {
|
|
const items = ["image/png"];
|
|
if (items.includes(obj.type)) {
|
|
if ("function" === typeof obj.arrayBuffer) {
|
|
const tmp15 = yield obj.arrayBuffer();
|
|
const DiscordImageFactory = outer2_0(outer2_2[2]).DiscordImageFactory;
|
|
obj = DiscordImageFactory.create(tmp15);
|
|
if (null == obj) {
|
|
const _Error = Error;
|
|
let error = new Error("DiscordImage.create returned null");
|
|
throw error;
|
|
} else if (obj2.hasTransparency()) {
|
|
outer2_4.verbose("[webp] png uses actual transparency - skipping conversion");
|
|
return outer2_5.HAS_TRANSPARENCY;
|
|
} else if (obj2.isAnimated()) {
|
|
outer2_4.verbose("[webp] png is animated (apng) - skipping conversion");
|
|
return outer2_5.ANIMATED_IMAGE;
|
|
} else if (obj2.isPng8()) {
|
|
outer2_4.verbose("[webp] png is PNG8 format (indexed color) - skipping conversion");
|
|
return outer2_5.PNG8_FORMAT;
|
|
} else if (yield obj2.hasSrgbIccProfile()) {
|
|
return null;
|
|
} else {
|
|
return outer2_5.ICC_NON_SRGB_PROFILE;
|
|
}
|
|
const tmp16 = tmp15;
|
|
} else {
|
|
const promise = new Promise((closure_0) => {
|
|
let closure_1 = arg1;
|
|
const fileReader = new FileReader();
|
|
fileReader.onload = () => callback(fileReader.result);
|
|
fileReader.onerror = () => {
|
|
const error = new Error("Failed to read file as ArrayBuffer");
|
|
return callback2(error);
|
|
};
|
|
const asArrayBuffer = fileReader.readAsArrayBuffer(closure_0);
|
|
});
|
|
const tmp11 = yield promise;
|
|
return tmp11;
|
|
}
|
|
} else {
|
|
const _HermesInternal = HermesInternal;
|
|
outer2_4.verbose("[WebP] Unsupported format: " + obj.type);
|
|
return outer2_5.UNSUPPORTED_FORMAT;
|
|
}
|
|
}
|
|
}
|
|
function hashImageData(data) {
|
|
const uint8Array = new Uint8Array(data.data.buffer);
|
|
return importDefault(1193)(uint8Array).toString(16);
|
|
}
|
|
async function _performWebPConversion(arg0, arg1) {
|
|
let height;
|
|
let width;
|
|
let size;
|
|
let image;
|
|
let objectURL;
|
|
let image1;
|
|
objectURL = undefined;
|
|
size = <canvas />;
|
|
const size2 = size;
|
|
const context = size.getContext("2d");
|
|
let obj = context;
|
|
if (null == context) {
|
|
const _Error2 = Error;
|
|
let error = new Error("could not get canvas context");
|
|
throw error;
|
|
} else {
|
|
const prototype6 = globalThis.Image.prototype;
|
|
image = new globalThis.Image();
|
|
const _URL4 = URL;
|
|
objectURL = URL.createObjectURL(arg0);
|
|
yield new Promise((arg0, arg1) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
closure_1.onload = () => callback();
|
|
closure_1.onerror = () => {
|
|
const error = new Error("failed to load image");
|
|
return callback2(error);
|
|
};
|
|
closure_1.src = objectURL;
|
|
});
|
|
({ width: size2.width, height: size2.height } = image);
|
|
obj.drawImage(image, 0, 0);
|
|
const _URL = URL;
|
|
URL.revokeObjectURL(objectURL);
|
|
const tmp10 = yield new Promise((arg0) => {
|
|
size.toBlob(arg0, "image/webp", 1);
|
|
});
|
|
if (null == tmp10) {
|
|
const _Error = Error;
|
|
const error1 = new Error("failed to convert to webp");
|
|
throw error1;
|
|
} else {
|
|
const _performance2 = performance;
|
|
const tmp75 = yield obj.getImageData(0, 0, size2.width, size2.height);
|
|
obj.clearRect(0, 0, size2.width, size2.height);
|
|
const prototype2 = globalThis.Image.prototype;
|
|
image1 = new globalThis.Image();
|
|
const _URL2 = URL;
|
|
objectURL = URL.createObjectURL(tmp11);
|
|
yield new Promise((arg0, arg1) => {
|
|
let closure_0 = arg0;
|
|
let closure_1 = arg1;
|
|
image1.onload = () => callback();
|
|
image1.onerror = () => {
|
|
const error = new Error("failed to load image");
|
|
return callback2(error);
|
|
};
|
|
image1.src = objectURL;
|
|
});
|
|
obj.drawImage(image1, 0, 0);
|
|
const _URL3 = URL;
|
|
URL.revokeObjectURL(objectURL);
|
|
const nowResult = performance.now();
|
|
const tmp21 = image1;
|
|
const tmp24 = objectURL;
|
|
const tmp37 = outer2_8(tmp75);
|
|
const tmp38 = outer2_8(yield obj.getImageData(0, 0, size.width, size.height));
|
|
const _performance = performance;
|
|
const diff = performance.now() - nowResult;
|
|
const name = arg0.name;
|
|
const _Math = Math;
|
|
({ width, height } = image1);
|
|
const _HermesInternal = HermesInternal;
|
|
outer2_4.verbose("[WebP] Pixel hash results: fileName=" + name + " fileLength={" + arg0.size + "} width=" + width + " height=" + height + " pixelHash=" + tmp37 + " mezzanineFileLength={" + tmp11.size + "} mezzaninePixelHash=" + tmp38 + " match=" + tmp37 === tmp38 + " elapsed_ms=" + Math.round(diff));
|
|
obj = {};
|
|
if (tmp37 === tmp38) {
|
|
obj.success = true;
|
|
obj.webpBlob = tmp10;
|
|
obj.pixelHashTimeMs = diff;
|
|
let tmp51 = obj;
|
|
} else {
|
|
obj.success = false;
|
|
obj.reason = outer2_5.PIXEL_HASH_MISMATCH;
|
|
obj.pixelHashTimeMs = diff;
|
|
tmp51 = obj;
|
|
}
|
|
return tmp51;
|
|
}
|
|
const tmp63 = image;
|
|
const tmp67 = objectURL;
|
|
}
|
|
}
|
|
async function _maybeConvertToWebP(arg0, arg1) {
|
|
let closure_0 = arg0;
|
|
let c1;
|
|
function createFailedResult(INSUFFICIENT_SAVINGS, size) {
|
|
if (size === undefined) {
|
|
size = closure_0.size;
|
|
}
|
|
const obj = { success: false, originalFile: closure_0, sizeBefore: closure_0.size, sizeAfter: size };
|
|
let num = 1;
|
|
if (closure_0.size > 0) {
|
|
num = size / closure_0.size;
|
|
}
|
|
obj.compressionRatio = num;
|
|
obj.reason = INSUFFICIENT_SAVINGS;
|
|
obj.compressTimeMs = Math.round(performance.now() - c1);
|
|
return obj;
|
|
}
|
|
if (null == arg0) {
|
|
const _Error = Error;
|
|
const error = new Error("file is null or undefined");
|
|
throw error;
|
|
} else {
|
|
const _HermesInternal3 = HermesInternal;
|
|
outer2_4.verbose("[WebP] Starting conversion for: " + tmp.name);
|
|
const _performance = performance;
|
|
const nowResult = performance.now();
|
|
c1 = nowResult;
|
|
const tmp36 = yield outer2_6(tmp);
|
|
if (null != tmp36) {
|
|
const _HermesInternal2 = HermesInternal;
|
|
outer2_4.verbose("[WebP] Conversion rejected: " + tmp2);
|
|
return createFailedResult(tmp2);
|
|
} else {
|
|
const tmp38 = yield (function performWebPConversion(arg0) {
|
|
return outer3_9(...arguments);
|
|
})(tmp);
|
|
if (tmp38.success) {
|
|
if (null != tmp3.webpBlob) {
|
|
const webpBlob = tmp3.webpBlob;
|
|
let num = 1;
|
|
if (tmp.size > 0) {
|
|
num = webpBlob.size / tmp.size;
|
|
}
|
|
const diff = 1 - num;
|
|
if (diff < 0) {
|
|
const _Math = Math;
|
|
const _HermesInternal = HermesInternal;
|
|
outer2_4.verbose("[WebP] Insufficient savings: " + Math.round(100 * tmp9) + "% < 0% (" + tmp.size + " -> " + webpBlob.size + " bytes)");
|
|
let failedResult = createFailedResult(outer2_5.INSUFFICIENT_SAVINGS, webpBlob.size);
|
|
} else {
|
|
const _performance2 = performance;
|
|
const diff1 = performance.now() - nowResult;
|
|
const name = tmp.name;
|
|
const _Math2 = Math;
|
|
const _HermesInternal4 = HermesInternal;
|
|
outer2_4.verbose("[WebP] Conversion successful: " + name + " to WebP in " + Math.round(diff1) + "ms");
|
|
failedResult = { success: true, originalFile: tmp, convertedBlob: webpBlob, sizeBefore: tmp.size, sizeAfter: webpBlob.size, compressionRatio: num, hashTimeMs: tmp3.pixelHashTimeMs };
|
|
const _Math3 = Math;
|
|
failedResult.compressTimeMs = Math.round(diff1);
|
|
}
|
|
return failedResult;
|
|
}
|
|
}
|
|
const reason = tmp38.reason;
|
|
if (null != reason) {
|
|
let UNKNOWN_ERROR = reason;
|
|
} else {
|
|
UNKNOWN_ERROR = outer2_5.UNKNOWN_ERROR;
|
|
}
|
|
return createFailedResult(UNKNOWN_ERROR);
|
|
}
|
|
}
|
|
}
|
|
importDefaultResult = new importDefaultResult("WebP");
|
|
let obj = { ALREADY_WEBP: "already_webp", UNSUPPORTED_FORMAT: "unsupported_format", ANIMATED_IMAGE: "animated_image", HAS_TRANSPARENCY: "has_transparency", PNG8_FORMAT: "png8_format", INSUFFICIENT_SAVINGS: "insufficient_savings", CONVERSION_FAILED: "conversion_failed", CORRUPTED_FILE: "corrupted_file", PIXEL_HASH_MISMATCH: "pixel_hash_mismatch", ICC_NON_SRGB_PROFILE: "icc_non_srgb_profile", ICC_DETECTION_FAILED: "icc_detection_failed", UNKNOWN_ERROR: "unknown_error" };
|
|
const result = require("DiscordImageFactory").fileFinishedImporting("lib/uploader/webpConversion.tsx");
|
|
|
|
export const ConversionFailureReason = obj;
|
|
export { _shouldConvertToWebP };
|
|
export const maybeConvertToWebP = function maybeConvertToWebP(size) {
|
|
return _maybeConvertToWebP(...arguments);
|
|
};
|