amiudmodz 5.0.9 → 5.1.1

package/lib/Utils/messages-media.js

@@ -103,43 +103,52 @@ const extractVideoThumb = async (path, destPath, time, size) => new Promise((res
 });
 const extractImageThumb = async (bufferOrFilePath, width = 32) => {
     var _a, _b;
+    let tmpPath;
     if (bufferOrFilePath instanceof stream_1.Readable) {
-        bufferOrFilePath = await (0, exports.toBuffer)(bufferOrFilePath);
-    }
-    const lib = await getImageProcessingLibrary();
-    if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
-        const img = lib.sharp.default(bufferOrFilePath);
-        const dimensions = await img.metadata();
-        const buffer = await img
-            .resize(width)
-            .jpeg({ quality: 50 })
-            .toBuffer();
-        return {
-            buffer,
-            original: {
-                width: dimensions.width,
-                height: dimensions.height,
-            },
-        };
+        // Spill stream to disk instead of buffering to RAM
+        tmpPath = await spillToDisk(bufferOrFilePath);
+        bufferOrFilePath = tmpPath;
     }
-    else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
-        const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
-        const jimp = await read(bufferOrFilePath);
-        const dimensions = {
-            width: jimp.getWidth(),
-            height: jimp.getHeight()
-        };
-        const buffer = await jimp
-            .quality(50)
-            .resize(width, AUTO, RESIZE_BILINEAR)
-            .getBufferAsync(MIME_JPEG);
-        return {
-            buffer,
-            original: dimensions
-        };
-    }
-    else {
-        throw new boom_1.Boom('No image processing library available');
+    try {
+        const lib = await getImageProcessingLibrary();
+        if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
+            const img = lib.sharp.default(bufferOrFilePath);
+            const dimensions = await img.metadata();
+            const buffer = await img
+                .resize(width)
+                .jpeg({ quality: 50 })
+                .toBuffer();
+            return {
+                buffer,
+                original: {
+                    width: dimensions.width,
+                    height: dimensions.height,
+                    },
+            };
+        }
+        else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
+            const { read, MIME_JPEG, RESIZE_BILINEAR, AUTO } = lib.jimp;
+            const jimp = await read(bufferOrFilePath);
+            const dimensions = {
+                width: jimp.getWidth(),
+                height: jimp.getHeight()
+            };
+            const buffer = await jimp
+                .quality(50)
+                .resize(width, AUTO, RESIZE_BILINEAR)
+                .getBufferAsync(MIME_JPEG);
+            return {
+                buffer,
+                original: dimensions
+            };
+        }
+        else {
+            throw new boom_1.Boom('No image processing library available');
+        }
+    } finally {
+        if (tmpPath) {
+            await fs_1.promises.unlink(tmpPath).catch(() => {});
+        }
     }
 };
 exports.extractImageThumb = extractImageThumb;
@@ -151,6 +160,7 @@ exports.encodeBase64EncodedStringForUpload = encodeBase64EncodedStringForUpload;
 const generateProfilePicture = async (mediaUpload) => {
     var _a, _b;
     let bufferOrFilePath;
+    let tmpPath;
     if (Buffer.isBuffer(mediaUpload)) {
         bufferOrFilePath = mediaUpload;
     }
@@ -158,34 +168,41 @@ const generateProfilePicture = async (mediaUpload) => {
         bufferOrFilePath = mediaUpload.url.toString();
     }
     else {
-        bufferOrFilePath = await (0, exports.toBuffer)(mediaUpload.stream);
-    }
-    const lib = await getImageProcessingLibrary();
-    let img;
-    if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
-        img = lib.sharp.default(bufferOrFilePath)
-            .resize(640, 640)
-            .jpeg({
-                quality: 50,
-            })
-            .toBuffer();
-    }
-    else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
-        const { read, MIME_JPEG, RESIZE_BILINEAR } = lib.jimp;
-        const jimp = await read(bufferOrFilePath);
-        const min = Math.min(jimp.getWidth(), jimp.getHeight());
-        const cropped = jimp.crop(0, 0, min, min);
-        img = cropped
-            .quality(50)
-            .resize(640, 640, RESIZE_BILINEAR)
-            .getBufferAsync(MIME_JPEG);
+        tmpPath = await spillToDisk(mediaUpload.stream);
+        bufferOrFilePath = tmpPath;
     }
-    else {
-        throw new boom_1.Boom('No image processing library available');
+    try {
+        const lib = await getImageProcessingLibrary();
+        let img;
+        if ('sharp' in lib && typeof ((_a = lib.sharp) === null || _a === void 0 ? void 0 : _a.default) === 'function') {
+            img = lib.sharp.default(bufferOrFilePath)
+                .resize(640, 640)
+                .jpeg({
+                    quality: 50,
+                })
+                .toBuffer();
+        }
+        else if ('jimp' in lib && typeof ((_b = lib.jimp) === null || _b === void 0 ? void 0 : _b.read) === 'function') {
+            const { read, MIME_JPEG, RESIZE_BILINEAR } = lib.jimp;
+            const jimp = await read(bufferOrFilePath);
+            const min = Math.min(jimp.getWidth(), jimp.getHeight());
+            const cropped = jimp.crop(0, 0, min, min);
+            img = cropped
+                .quality(50)
+                .resize(640, 640, RESIZE_BILINEAR)
+                .getBufferAsync(MIME_JPEG);
+        }
+        else {
+            throw new boom_1.Boom('No image processing library available');
+        }
+        return {
+            img: await img,
+        };
+    } finally {
+        if (tmpPath) {
+            await fs_1.promises.unlink(tmpPath).catch(() => {});
+        }
     }
-    return {
-        img: await img,
-    };
 };
 exports.generateProfilePicture = generateProfilePicture;
 /** gets the SHA256 of the given media message */
@@ -239,19 +256,15 @@ async function getAudioWaveform(buffer, logger) {
         const { PassThrough } = require('stream');
         const ff = require('fluent-ffmpeg');
 
-        let audioData;
+        const inputStream = new PassThrough();
         if (Buffer.isBuffer(buffer)) {
-            audioData = buffer;
+            inputStream.end(buffer);
         } else if (typeof buffer === 'string') {
-            const rStream = require('fs').createReadStream(buffer);
-            audioData = await exports.toBuffer(rStream);
+            (0, fs_1.createReadStream)(buffer).pipe(inputStream);
         } else {
-            audioData = await exports.toBuffer(buffer);
+            buffer.pipe(inputStream);
         }
-
         return await new Promise((resolve, reject) => {
-            const inputStream = new PassThrough();
-            inputStream.end(audioData);
             const chunks = [];
             const bars = 64;
 
@@ -280,7 +293,7 @@ async function getAudioWaveform(buffer, logger) {
                     const normalized = avg.map(v => Math.floor((v / max) * 100));
                     resolve(new Uint8Array(normalized));
                 })
-                .pipe()
+                .pipe(new PassThrough(), { end: true })
                 .on('data', chunk => chunks.push(chunk));
         });
     } catch (e) {
@@ -504,17 +517,40 @@ const encryptedStream = async (media, mediaType, { logger, saveOriginalFileIfReq
     const { stream, type, spilledPath } = await (0, exports.getStream)(media, opts);
     let finalStream = stream;
     let opusConverted = false;
-    // Track temp files created for spill-to-disk of audio opus conversion
     let opusSpillPath;
     if (mediaType === 'audio' && (isPtt === true || forceOpus === true)) {
         try {
             // Write audio to temp file, convert via ffmpeg, write result to another temp file
             const audioTmpPath = await spillToDisk(stream);
             try {
-                const opusBuffer = await exports.convertToOpusBuffer(
-                    await fs_1.promises.readFile(audioTmpPath), logger
-                );
-                opusSpillPath = await spillToDisk(opusBuffer);
+                const ff = require('fluent-ffmpeg');
+                opusSpillPath = (0, path_1.join)(getTmpFilesDirectory(), `opus-${(0, generics_1.generateMessageID)()}`);
+                const opusWriteStream = (0, fs_1.createWriteStream)(opusSpillPath);
+
+                await new Promise((resolve, reject) => {
+                    ff(audioTmpPath)
+                        .noVideo()
+                        .audioCodec('libopus')
+                        .format('ogg')
+                        .audioBitrate('48k')
+                        .audioChannels(1)
+                        .audioFrequency(48000)
+                        .outputOptions([
+                            '-vn',
+                            '-b:a 64k',
+                            '-ac 2',
+                            '-ar 48000',
+                            '-map_metadata', '-1',
+                            '-application', 'voip'
+                        ])
+                        .on('error', (err) => {
+                            opusWriteStream.destroy();
+                            reject(err);
+                        })
+                        .on('end', resolve)
+                        .pipe(opusWriteStream);
+                });
+
                 finalStream = (0, fs_1.createReadStream)(opusSpillPath);
                 opusConverted = true;
             } finally {
@@ -799,6 +835,7 @@ const getWAUploadToServer = ({ customUploadHosts, fetchAgent, logger, options },
                     headers: {
                         ...options.headers || {},
                         'Content-Type': 'application/octet-stream',
+                        'Content-Length': bodyLength.toString(),
                         'Origin': Defaults_1.DEFAULT_ORIGIN
                     },
                     httpsAgent: fetchAgent,

package/lib/Utils/messages.js

@@ -157,6 +157,9 @@ const prepareWAMessageMedia = async (message, options) => {
         forceOpus: (mediaType === "audio" && uploadData.mimetype && uploadData.mimetype.includes('opus'))
     });
 
+    // Nullify the media reference to help GC free the memory if it's a large Buffer
+    uploadData.media = undefined;
+
     if (mediaType === 'audio' && opusConverted) {
         uploadData.mimetype = 'audio/ogg; codecs=opus';
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "amiudmodz",
-    "version": "5.0.9",
+    "version": "5.1.1",
     "description": "WhatsApp Baileys mod Powered by UDMODZ",
     "keywords": [
         "whatsapp",