node-red-contrib-hik-media-buffer 1.1.91 → 1.1.92

package/hik-media-buffer.js

@@ -183,7 +183,6 @@ module.exports = function(RED) {
                         const rawUri = uriMatch[1].replace(/&/g, '&');
                         const downXml = `<?xml version="1.0" encoding="UTF-8"?><downloadRequest><playbackURI>${rawUri.replace(/&/g, '&amp;')}</playbackURI></downloadRequest>`.trim();
                         
-                        // Facciamo lo stesso giochetto del file temporaneo anche per il download
                         const tempDownXmlPath = path.join(baseStorage, `down_${t.id}_${timestamp}.xml`);
                         fs.writeFileSync(tempDownXmlPath, downXml, 'utf8');
 
@@ -194,12 +193,11 @@ module.exports = function(RED) {
                         const downUrl = `${node.protocol}://${node.host}:${node.port}/ISAPI/ContentMgmt/download`;
                         const curlDownCommand = `curl -s -X POST --digest -u "${node.user}:${node.pass}" -H "Content-Type: application/xml; charset=UTF-8" -d "@${tempDownXmlPath}" "${downUrl}" -o "${targetFilePath}"`;
 
-                        node.warn(`[DEBUG] Eseguo download traccia ${t.id} tramite cURL via file temporaneo...`);
+                        node.warn(`[DEBUG] Eseguo download traccia ${t.id} tramite cURL...`);
                         await new Promise((resolve) => {
                             exec(curlDownCommand, () => resolve());
                         });
 
-                        // Cancelliamo il file XML del download
                         try { if (fs.existsSync(tempDownXmlPath)) fs.unlinkSync(tempDownXmlPath); } catch(e){}
 
                         if (fs.existsSync(targetFilePath) && fs.statSync(targetFilePath).size > 0) {
@@ -208,18 +206,31 @@ module.exports = function(RED) {
                                 fileDaCancellare.push(fullImgPath);
                             } else {
                                 const fixedPath = path.join(baseStorage, `hik_v_${channelID}_${timestamp}.mp4`);
-                                let videoBuffer = fs.readFileSync(rawPath);
-                                if (videoBuffer.slice(0, 4).toString() === 'IMKH') {
-                                    try { fs.writeFileSync(rawPath, videoBuffer.slice(40)); } catch(e){}
+                                
+                                // Tagliamo via l'header proprietario IMKH se presente
+                                let fileStats = fs.statSync(rawPath);
+                                if (fileStats.size > 40) {
+                                    let fd = fs.openSync(rawPath, 'r');
+                                    let magicBuffer = Buffer.alloc(4);
+                                    fs.readSync(fd, magicBuffer, 0, 4, 0);
+                                    fs.closeSync(fd);
+                                    
+                                    if (magicBuffer.toString() === 'IMKH') {
+                                        // Taglio dell'header senza leggere tutto in memoria (evita crash su file giganti)
+                                        exec(`ffmpeg -y -ss 00:00:00 -i "${rawPath}" -c copy -map 0 -an "${fixedPath}"`, () => {}); 
+                                    }
                                 }
 
+                                node.warn(`[DEBUG] Ritaglio il video dell'evento a 10 secondi per non saturare la memoria...`);
+                                // USIAMO FFMPEG PER PRENDERE SOLO GLI ULTIMI 10 SECONDI ED EVITARE IL FILE DA 1GB IN BASE64
                                 await new Promise((resolve) => {
-                                    exec(`ffmpeg -y -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
-                                        if (!err && fs.existsSync(fixedPath)) {
+                                    exec(`ffmpeg -y -sseof -10 -i "${rawPath}" -c copy -movflags +faststart "${fixedPath}"`, (err) => {
+                                        if (!err && fs.existsSync(fixedPath) && fs.statSync(fixedPath).size > 0) {
+                                            // Leggiamo il file tagliato che ora peserà pochissimo!
                                             output.video_base64 = fs.readFileSync(fixedPath, { encoding: 'base64' });
                                             fileDaCancellare.push(fixedPath);
                                         } else {
-                                            output.video_base64 = fs.readFileSync(rawPath, { encoding: 'base64' });
+                                            node.error(`[DEBUG FFMPEG] Impossibile tagliare il video, traccia troppo pesante.`);
                                         }
                                         fileDaCancellare.push(rawPath);
                                         resolve();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-red-contrib-hik-media-buffer",
-  "version": "1.1.91",
+  "version": "1.1.92",
   "description": "Ottiene buffer video e immagine da camere Hikvision via ISAPI",
   "keywords": [
     "node-red",