tphim 2.2.2 → 2.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tphim",
-  "version": "2.2.2",
+  "version": "2.3.1",
   "description": "TPHIM - Ultimate Video Pipeline: Download, Transcode HLS, AI Subtitles (with skip option), Resume Upload, and Cloud Upload.",
   "main": "index.js",
   "type": "module",
@@ -49,6 +49,7 @@
   "homepage": "https://film.nrotxa.online",
   "dependencies": {
     "@aws-sdk/client-s3": "^3.999.0",
+    "@aws-sdk/lib-storage": "^3.1008.0",
     "@clack/prompts": "^1.0.1",
     "chalk": "^5.6.2",
     "cli-progress": "^3.12.0",
@@ -67,4 +68,4 @@
   "engines": {
     "node": ">=18.0.0"
   }
-}
+}

package/pipeline.mjs

@@ -133,7 +133,7 @@ function generateDualPreviewSprites(mp4Path, outputDir) {
         const highResPath = path.join(outputDir, 'preview.jpg');
         const lowResPath = path.join(outputDir, 'preview_low.jpg');
 
-        console.log('   📸 [2.5/5] Generating Dual Preview Sprites (High-Res + Low-Res)...');
+        console.log('   📸 [2.5/5] Generating Dual Preview Sprites (Legacy format)...');
 
         // Complex filter để tạo cả 2 phiên bản từ 1 luồng
         const complexFilter = [
@@ -173,7 +173,7 @@ function generateDualPreviewSprites(mp4Path, outputDir) {
 
         ffmpeg.on('close', (code) => {
             if (code === 0) {
-                console.log('   ✅ Dual Preview Sprites ready (High-Res + Low-Res).');
+                console.log('   ✅ Dual Preview Sprites ready.');
                 resolve({ highResPath, lowResPath });
             } else {
                 console.error('   ⚠ Dual sprite generation failed:', stderr);
@@ -188,6 +188,60 @@ function generateDualPreviewSprites(mp4Path, outputDir) {
     });
 }
 
+// [TURBO MODE] Combine L1, L2, L3 into ONE single pass for 20x-50x speed
+async function generateStoryboards(mp4Path, outputDir) {
+    console.log(`   🚀 [Turbo-Storyboard] Generating ALL levels in ONE pass from: ${path.basename(mp4Path)}`);
+
+    const args = [
+        '-skip_frame', 'nokey', // Essential for 20x speed
+        '-threads', '0',
+        '-an', '-sn', '-dn',
+        '-i', mp4Path,
+        '-filter_complex', [
+            // Split video into 3 branches for L1, L2, L3
+            '[0:v]split=3[v1][v2][v3]',
+            // L1: 160x90, 10s interval, 10x10 tile
+            '[v1]fps=1/10,scale=160:90,tile=10x10[out1]',
+            // L2: 240x135, 30s interval, 5x5 tile
+            '[v2]fps=1/30,scale=240:135,tile=5x5[out2]',
+            // L3: 320x180, 60s interval, 3x3 tile
+            '[v3]fps=1/60,scale=320:180,tile=3x3[out3]'
+        ].join(';'),
+        '-map', '[out1]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L1_M%d.jpg'),
+        '-map', '[out2]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L2_M%d.jpg'),
+        '-map', '[out3]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L3_M%d.jpg')
+    ];
+
+    await new Promise((resolve, reject) => {
+        const proc = spawn(FFMPEG_BIN, args, { shell: false });
+        // proc.stderr.on('data', d => console.log(d.toString())); // Debug speed
+        proc.on('close', code => code === 0 ? resolve() : reject(new Error(`Turbo-Storyboard failed with code ${code}`)));
+        proc.on('error', reject);
+    });
+
+    console.log('   ✅ Turbo Storyboard ready (Pass 1/1).');
+}
+
+// Function to find the highest resolution MP4 in a directory or a list of files
+function selectHighestQualityVideo(files) {
+    if (!files || files.length === 0) return null;
+
+    // Sort by resolution labels in filename (YouTube style)
+    const resMap = { '4k': 2160, '1080p': 1080, '720p': 720, '480p': 480, '360p': 360, '240p': 240, '144p': 144 };
+
+    return files.sort((a, b) => {
+        const getRes = (name) => {
+            const m = name.match(/(\d{3,4}p|4[kK])/);
+            if (m) return resMap[m[1].toLowerCase()] || parseInt(m[1]);
+            return 0;
+        };
+        const resA = getRes(a);
+        const resB = getRes(b);
+        if (resA !== resB) return resB - resA;
+        return 0; // Fallback to original order
+    })[0];
+}
+
 function formatDuration(ms) {
     const seconds = Math.floor((ms / 1000) % 60);
     const minutes = Math.floor((ms / (1000 * 60)) % 60);
@@ -236,10 +290,41 @@ export async function executePipeline({ input, slug, title, langArg = 'vi' }) {
 
     let startTime = Date.now();
     // ─── BƯỚC 1: Download ─────────────────────────────────────────
-    const mp4Path = existsSync(input) && input.toLowerCase().endsWith('.mp4')
+    let mp4Path = existsSync(input) && input.toLowerCase().endsWith('.mp4')
         ? input
         : path.join('downloads', `${slug}.mp4`);
 
+    if (!existsSync(mp4Path)) {
+        // If input is a directory, find the highest quality video
+        if (existsSync(input) && !input.toLowerCase().endsWith('.mp4')) {
+            const files = execSync(IS_WIN ? `dir /b "${input}"` : `ls "${input}"`, { encoding: 'utf8' })
+                .split(/\r?\n/)
+                .filter(f => f.toLowerCase().endsWith('.mp4'))
+                .map(f => path.join(input, f));
+
+            const bestFile = selectHighestQualityVideo(files);
+            if (bestFile) {
+                console.log(`   ✨ Found multiple files in source. Selected highest quality: ${path.basename(bestFile)}`);
+                mp4Path = bestFile;
+            }
+        } else {
+            // Check downloads folder for any files matching slug (e.g. 1080p - slug.mp4)
+            const downloadsDir = 'downloads';
+            if (existsSync(downloadsDir)) {
+                const files = execSync(IS_WIN ? `dir /b "${downloadsDir}"` : `ls "${downloadsDir}"`, { encoding: 'utf8' })
+                    .split(/\r?\n/)
+                    .filter(f => f.toLowerCase().endsWith('.mp4') && f.toLowerCase().includes(slug.toLowerCase()))
+                    .map(f => path.join(downloadsDir, f));
+
+                const bestFile = selectHighestQualityVideo(files);
+                if (bestFile) {
+                    console.log(`   ✨ Found existing files in downloads. Selected highest quality: ${path.basename(bestFile)}`);
+                    mp4Path = bestFile;
+                }
+            }
+        }
+    }
+
     if (!existsSync(mp4Path)) {
         console.log('\n🔽 [1/5] Downloading video...');
 
@@ -370,32 +455,36 @@ export async function executePipeline({ input, slug, title, langArg = 'vi' }) {
 
         const outDir = path.join('hls', slug);
 
-        // Xây dựng ffmpeg command động
-        let maps = '';
+        // [TURBO HLS] Build dynamic filter chain for sequential scaling
+        // Scaling from previously scaled version (e.g. 1080 -> 720) is much faster
+        let filterParts = [`[0:v]split=${selectedQualities.length}`];
+        let splitLabels = selectedQualities.map((_, i) => `[v_raw${i}]`);
+        filterParts[0] += splitLabels.join('');
+
         let outputs = '';
+        let maps = '';
         let varStreamMapArr = [];
 
         selectedQualities.forEach((q, i) => {
-            maps += `-map 0:v -map 0:a `;
-            outputs += `-c:v:${i} libx264 -preset ${vpsOpt.preset} -tune ${vpsOpt.tune} -b:v:${i} ${q.bv} -s:v:${i} ${q.w}x${q.h} -c:a:${i} aac -b:a:${i} ${q.ba} -movflags +faststart `;
+            filterParts.push(`[v_raw${i}]scale=${q.w}:${q.h},format=yuv420p[v${i}]`);
+            maps += `-map "[v${i}]" -map 0:a `;
+            outputs += `-c:v:${i} libx264 -preset ultrafast -tune fastdecode -b:v:${i} ${q.bv} -c:a:${i} aac -b:a:${i} ${q.ba} -movflags +faststart `;
             varStreamMapArr.push(`v:${i},a:${i}`);
         });
 
-        // Generate encoded segment name with timestamp
         const timestamp = Date.now();
         const encodedPrefix = Buffer.from(`txa_${timestamp}`).toString('base64').replace(/[^a-zA-Z0-9]/g, '').substring(0, 8);
-
-        // Optimize thread count based on CPU cores
-        const threadCount = vpsOpt.isVPS ? Math.min(vpsOpt.cpuCores, 8) : 0; // 0 = auto, but limit on VPS
+        const threadCount = vpsOpt.isVPS ? Math.min(vpsOpt.cpuCores * 2, 16) : 0; // Oversubscribe for maximum saturation
 
         const ffmpegCmd = [
             `"${FFMPEG_BIN}"`, '-i', `"${mp4Path}"`,
-            `-threads ${threadCount}`, `-preset ${vpsOpt.preset}`, `-tune ${vpsOpt.tune}`,
+            `-threads ${threadCount}`,
+            '-filter_complex', `"${filterParts.join(';')}"`,
             maps,
             outputs,
             '-var_stream_map', `"${varStreamMapArr.join(' ')}"`,
             '-master_pl_name', `"${masterName}"`,
-            '-f hls -hls_time 4 -hls_list_size 0 -hls_segment_type mpegts',
+            '-f hls -hls_time 6 -hls_list_size 0 -hls_segment_type mpegts', // 6s segments are faster to write than 4s
             '-hls_segment_filename', `"${outDir}/%v/${encodedPrefix}_%04d.ts"`,
             `"${outDir}/%v/index.m3u8"`
         ].join(' ');
@@ -417,12 +506,26 @@ export async function executePipeline({ input, slug, title, langArg = 'vi' }) {
         console.log(`\n⏭  [2/5] HLS đã có sẵn`);
     }
 
-    // --- STEP 2.5: PREVIEW SPRITE --- (Independent check)
+    // --- STEP 2.5: PREVIEW SPRITE & STORYBOARD --- (Independent check)
     const spriteLowPath = path.join('hls', slug, 'preview_low.jpg');
+    const storyboardCheckPath = path.join('hls', slug, 'L1_M0.jpg');
+
+    const outDir = path.join('hls', slug);
+
+    // 1. New Storyboard format (L1, L2, L3)
+    if (!existsSync(storyboardCheckPath)) {
+        try {
+            await generateStoryboards(mp4Path, outDir);
+        } catch (e) {
+            console.log('   ⚠ Storyboard generation failed:', e.message);
+        }
+    } else {
+        console.log(`   ⏭  Storyboard levels already exist`);
+    }
 
+    // 2. Legacy Dual Sprite format (for backward compatibility)
     if (!existsSync(spritePath) || !existsSync(spriteLowPath)) {
         try {
-            const outDir = path.join('hls', slug);
             const { highResPath, lowResPath } = await generateDualPreviewSprites(mp4Path, outDir);
             console.log('   ✅ Dual Preview Sprites generated successfully.');
         } catch (e) {

package/scripts/direct-process.mjs

@@ -0,0 +1,150 @@
+
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from "@aws-sdk/lib-storage";
+import { spawn } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import 'dotenv/config';
+import ffmpeg from 'ffmpeg-static';
+import { lookup } from 'mime-types';
+
+const FFMPEG_BIN = ffmpeg || 'ffmpeg';
+const s3 = new S3Client({
+    region: 'us-east-1',
+    endpoint: process.env.TEBI_ENDPOINT,
+    credentials: {
+        accessKeyId: process.env.TEBI_ACCESS_KEY_ID,
+        secretAccessKey: process.env.TEBI_SECRET_ACCESS_KEY,
+    },
+    forcePathStyle: true,
+});
+
+const slug = "ninh-an-nhu-mong-direct";
+const bucket = process.env.TEBI_BUCKET;
+const desktop = "C:\\Users\\TXA3000\\Desktop";
+
+const filesToUpload = [
+    { local: path.join(desktop, "360p - NINH AN NHƯ MỘNG - TM.mp4"), remote: `movies/${slug}/360p.mp4` },
+    { local: path.join(desktop, "144p - Ninh An Như Mộng - TM.mp4"), remote: `movies/${slug}/144p.mp4` },
+    { local: path.join(desktop, "720p Thuyết Minh_Ninh An Như Mộng.mp4"), remote: `movies/${slug}/720p.mp4` }
+];
+
+async function uploadFile(localPath, remotePath) {
+    if (!fs.existsSync(localPath)) {
+        console.log(`\n⚠️ Skip: ${path.basename(localPath)} (Not found)`);
+        return;
+    }
+    console.log(`\n📡 Uploading: ${path.basename(localPath)} -> ${remotePath}`);
+    const stream = fs.createReadStream(localPath);
+    try {
+        const uploader = new Upload({
+            client: s3,
+            params: {
+                Bucket: bucket,
+                Key: remotePath,
+                Body: stream,
+                ContentType: lookup(localPath) || 'video/mp4',
+                ACL: 'public-read',
+            },
+            queueSize: 4, 
+            partSize: 5 * 1024 * 1024,
+        });
+
+        uploader.on("httpUploadProgress", (progress) => {
+            const pct = Math.round((progress.loaded / (progress.total || 1)) * 100);
+            process.stdout.write(`\r   ⚡ Progress: ${pct}% (${(progress.loaded / 1024 / 1024).toFixed(1)} MB)`);
+        });
+
+        await uploader.done();
+        console.log(`\n✅ Done: ${path.basename(localPath)}`);
+    } catch (e) {
+        console.error(`\n❌ Upload failed for ${path.basename(localPath)}:`, e.message);
+    }
+}
+
+async function captureStoryboards(inputPath, outputDir) {
+    if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
+    console.log(`\n🚀 Capturing Storyboards from ${path.basename(inputPath)} (Turbo Mode)...`);
+    
+    const args = [
+        '-skip_frame', 'nokey', '-threads', '0', '-i', inputPath,
+        '-filter_complex', [
+            '[0:v]split=3[v1][v2][v3]',
+            '[v1]fps=1/10,scale=160:90,tile=10x10[out1]',
+            '[v2]fps=1/30,scale=240:135,tile=5x5[out2]',
+            '[v3]fps=1/60,scale=320:180,tile=3x3[out3]'
+        ].join(';'),
+        '-map', '[out1]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L1_M%d.jpg'),
+        '-map', '[out2]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L2_M%d.jpg'),
+        '-map', '[out3]', '-q:v', '4', '-start_number', '0', '-vsync', '0', path.join(outputDir, 'L3_M%d.jpg'),
+        '-y'
+    ];
+
+    return new Promise((resolve, reject) => {
+        const proc = spawn(FFMPEG_BIN, args, { shell: false });
+        proc.on('close', code => code === 0 ? resolve() : reject(new Error('FFmpeg failed')));
+    });
+}
+
+async function uploadFolder(localDir, remotePrefix) {
+    console.log(`\n📡 Batch uploading storyboards...`);
+    const files = fs.readdirSync(localDir);
+    for (const file of files) {
+        const fullPath = path.join(localDir, file);
+        if (fs.statSync(fullPath).isFile()) {
+            await uploadFile(fullPath, `${remotePrefix}/${file}`);
+        }
+    }
+}
+
+async function main() {
+    const reportPath = path.join(desktop, "NINH_AN_NHU_MONG_LINKS.txt");
+    try {
+        // 1. Upload MP4s
+        for (const f of filesToUpload) {
+            await uploadFile(f.local, f.remote);
+        }
+
+        // 2. Capture Storyboard (from 720p)
+        const hqFile = filesToUpload[2].local; 
+        const storyboardDir = path.join(process.cwd(), 'temp_storyboard');
+        if (fs.existsSync(hqFile)) {
+            await captureStoryboards(hqFile, storyboardDir);
+            
+            // 3. Upload Storyboards
+            await uploadFolder(storyboardDir, `movies/${slug}/storyboard`);
+        }
+
+        // 4. Generate Report
+        const report = `
+========================================
+REPORT: NINH AN NHƯ MỘNG DIRECT LINKS
+========================================
+
+🎬 MP4 DIRECT LINKS:
+- 720p: https://s3.tebi.io/${bucket}/movies/${slug}/720p.mp4
+- 360p: https://s3.tebi.io/${bucket}/movies/${slug}/360p.mp4
+- 144p: https://s3.tebi.io/${bucket}/movies/${slug}/144p.mp4
+
+📸 STORYBOARD LINKS (L1, L2, L3):
+- Base Path: https://s3.tebi.io/${bucket}/movies/${slug}/storyboard/
+- Example L1: https://s3.tebi.io/${bucket}/movies/${slug}/storyboard/L1_M0.jpg
+- Example L2: https://s3.tebi.io/${bucket}/movies/${slug}/storyboard/L2_M0.jpg
+- Example L3: https://s3.tebi.io/${bucket}/movies/${slug}/storyboard/L3_M0.jpg
+
+🚀 Player usage: 
+   Sử dụng link MP4 ở trên. Player sẽ tự động tìm 
+   thông tin storyboard nếu được cập nhật theo TXA_AI_GUIDE.
+========================================
+`;
+        fs.writeFileSync(reportPath, report);
+        console.log(`\n✨ ALL DONE! Report saved to: ${reportPath}`);
+
+        // Cleanup
+        if (fs.existsSync(storyboardDir)) fs.rmSync(storyboardDir, { recursive: true, force: true });
+    } catch (err) {
+        console.error("❌ Error:", err);
+    }
+}
+
+main();

package/scripts/upload-tebi.mjs

@@ -16,12 +16,14 @@ const s3 = new S3Client({
     forcePathStyle: true,              // Tebi cần pathStyle, không dùng subdomain
 });
 
+import { Upload } from "@aws-sdk/lib-storage";
+import { createReadStream, statSync } from 'fs';
+
 export async function uploadHLSFolder(slug) {
     const localDir = join('hls', slug);
     const files = getAllFiles(localDir);
     const progressFile = join('hls', slug, '.upload-progress.json');
     
-    // Load existing progress
     let uploadedFiles = [];
     if (existsSync(progressFile)) {
         try {
@@ -33,57 +35,66 @@ export async function uploadHLSFolder(slug) {
         }
     }
 
-    // Filter files that haven't been uploaded yet
     const filesToUpload = files.filter(file => !uploadedFiles.includes(relative('.', file).replace(/\\/g, '/')));
     
-    console.log(`\n☁️  Uploading ${filesToUpload.length} files to Tebi.io... (${files.length - filesToUpload.length} already uploaded)`);
+    console.log(`\n☁️  Uploading ${filesToUpload.length} files to Tebi.io (Turbo Mode)...`);
     let uploaded = uploadedFiles.length;
+    const total = files.length;
+
+    const cacheMap = {
+        '.ts': 'public, max-age=31536000',
+        '.jpg': 'public, max-age=31536000',
+        '.m3u8': 'public, max-age=300',
+        '.vtt': 'public, max-age=86400',
+        '.txt': 'no-cache',
+    };
 
-    for (const filePath of filesToUpload) {
+    // Hàm upload từng file đơn lẻ sử dụng lib-storage
+    const uploadSingleFile = async (filePath) => {
         const s3Key = relative('.', filePath).replace(/\\/g, '/');
         const ext = extname(filePath).toLowerCase();
-
-        // Check if file already exists on cloud
+        
         try {
-            await s3.send(new HeadObjectCommand({
-                Bucket: process.env.TEBI_BUCKET,
-                Key: s3Key
-            }));
-            console.log(`\n   ⏭ Skipping ${s3Key} (already exists on cloud)`);
+            const stream = createReadStream(filePath);
+            const size = statSync(filePath).size;
+            
+            const uploader = new Upload({
+                client: s3,
+                params: {
+                    Bucket: process.env.TEBI_BUCKET,
+                    Key: s3Key,
+                    Body: stream,
+                    ACL: 'public-read',
+                    ContentType: lookup(filePath) || 'application/octet-stream',
+                    CacheControl: cacheMap[ext] || 'public, max-age=3600',
+                },
+                queueSize: 1, // Sẽ điều khiển concurrency ở cấp độ folder
+                partSize: 5 * 1024 * 1024,
+            });
+
+            await uploader.done();
+            
             uploaded++;
             uploadedFiles.push(s3Key);
-            continue;
+            
+            // Lưu progress
+            writeFileSync(progressFile, JSON.stringify({
+                uploadedFiles,
+                totalFiles: total,
+                lastUpdate: new Date().toISOString()
+            }));
+            
+            process.stdout.write(`\r   ↳ Progress: ${uploaded}/${total} files...`);
         } catch (e) {
-            // File doesn't exist, proceed with upload
+            console.error(`\n❌ Lỗi upload ${s3Key}:`, e.message);
         }
+    };
 
-        const cacheMap = {
-            '.ts': 'public, max-age=31536000',
-            '.m3u8': 'public, max-age=300',
-            '.vtt': 'public, max-age=86400',
-            '.txt': 'no-cache',
-        };
-
-        await s3.send(new PutObjectCommand({
-            Bucket: process.env.TEBI_BUCKET,
-            Key: s3Key,
-            Body: readFileSync(filePath),
-            ACL: 'public-read', // Mở khóa file công khai ngay khi upload
-            ContentType: lookup(filePath) || 'application/octet-stream',
-            CacheControl: cacheMap[ext] || 'public, max-age=3600',
-        }));
-
-        uploaded++;
-        uploadedFiles.push(s3Key);
-        
-        // Save progress after each successful upload
-        writeFileSync(progressFile, JSON.stringify({
-            uploadedFiles,
-            totalFiles: files.length,
-            lastUpdate: new Date().toISOString()
-        }));
-        
-        process.stdout.write(`\r   ↳ ${uploaded}/${files.length} files...`);
+    // Chạy song song với concurrency limit (ví dụ: 10 file cùng lúc)
+    const CONCURRENCY = 10;
+    for (let i = 0; i < filesToUpload.length; i += CONCURRENCY) {
+        const chunk = filesToUpload.slice(i, i + CONCURRENCY);
+        await Promise.all(chunk.map(file => uploadSingleFile(file)));
     }
 
     // Clean up progress file when complete