mes-engine 0.0.2 → 1.0.0

package/examples/full-demo/backend/package.json

@@ -0,0 +1,22 @@
+{
+    "name": "mes-engine-demo-backend",
+    "version": "1.0.0",
+    "type": "module",
+    "scripts": {
+        "start": "node src/server.js",
+        "dev": "nodemon src/server.js"
+    },
+    "dependencies": {
+        "express": "^4.18.2",
+        "mes-engine": "file:../../..",
+        "ffmpeg-static": "^5.2.0",
+        "ffprobe-static": "^3.1.0",
+        "multer": "^2.0.2",
+        "cors": "^2.8.5",
+        "dotenv": "^16.3.1",
+        "socket.io": "^4.6.1"
+    },
+    "devDependencies": {
+        "nodemon": "^3.0.1"
+    }
+}

package/examples/full-demo/backend/src/routes/video.js

@@ -0,0 +1,92 @@
+import express from 'express';
+import multer from 'multer';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import videoProcessorService from '../services/videoProcessor.js';
+import { dirname } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const router = express.Router();
+
+// Configure multer for file upload
+const storage = multer.diskStorage({
+    destination: (req, file, cb) => {
+        cb(null, path.join(__dirname, '../../uploads'));
+    },
+    filename: (req, file, cb) => {
+        const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
+        cb(null, uniqueSuffix + path.extname(file.originalname));
+    }
+});
+
+const upload = multer({
+    storage,
+    limits: {
+        fileSize: parseInt(process.env.MAX_FILE_SIZE) || 500 * 1024 * 1024
+    },
+    fileFilter: (req, file, cb) => {
+        const allowedTypes = /mp4|mov|avi|mkv|webm/;
+        const extname = allowedTypes.test(path.extname(file.originalname).toLowerCase());
+        const mimetype = allowedTypes.test(file.mimetype);
+
+        if (extname && mimetype) {
+            return cb(null, true);
+        }
+        cb(new Error('Only video files are allowed!'));
+    }
+});
+
+// Upload and process video
+router.post('/upload', upload.single('video'), async (req, res) => {
+    try {
+        if (!req.file) {
+            return res.status(400).json({ error: 'No video file uploaded' });
+        }
+
+        const socketId = req.body.socketId;
+        const io = req.app.get('io');
+
+        // Start processing asynchronously
+        videoProcessorService.processVideo(req.file.path, socketId, io)
+            .catch(error => {
+                console.error('Processing error:', error);
+            });
+
+        res.json({
+            message: 'Video uploaded successfully. Processing started.',
+            filename: req.file.filename,
+            size: req.file.size
+        });
+    } catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+
+// Get video manifest
+router.get('/manifest/:videoId', async (req, res) => {
+    try {
+        const manifest = await videoProcessorService.getManifest(req.params.videoId);
+        res.json(manifest);
+    } catch (error) {
+        res.status(404).json({ error: 'Manifest not found' });
+    }
+});
+
+// Stream video chunk
+router.get('/stream/:videoId/:quality/:chunk', async (req, res) => {
+    try {
+        const { videoId, quality, chunk } = req.params;
+        const stream = await videoProcessorService.streamChunk(
+            videoId,
+            parseInt(quality),
+            parseInt(chunk)
+        );
+
+        res.setHeader('Content-Type', 'video/mp4');
+        stream.pipe(res);
+    } catch (error) {
+        res.status(404).json({ error: 'Chunk not found' });
+    }
+});
+
+export default router;

package/examples/full-demo/backend/src/server.js

@@ -0,0 +1,43 @@
+import express from 'express';
+import cors from 'cors';
+import { createServer } from 'http';
+import { Server } from 'socket.io';
+import dotenv from 'dotenv';
+import videoRoutes from './routes/video.js';
+
+dotenv.config();
+
+const app = express();
+const httpServer = createServer(app);
+const io = new Server(httpServer, {
+    cors: {
+        origin: "http://localhost:5173",
+        methods: ["GET", "POST"]
+    }
+});
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+app.use(express.static('processed'));
+
+// Make io available to routes
+app.set('io', io);
+
+// Routes
+app.use('/api/video', videoRoutes);
+
+// Socket.io connection
+io.on('connection', (socket) => {
+    console.log('Client connected:', socket.id);
+
+    socket.on('disconnect', () => {
+        console.log('Client disconnected:', socket.id);
+    });
+});
+
+const PORT = process.env.PORT || 3001;
+
+httpServer.listen(PORT, () => {
+    console.log(`Server running on port ${PORT}`);
+});

package/examples/full-demo/backend/src/services/videoProcessor.js

@@ -0,0 +1,85 @@
+import {
+    VideoProcessor,
+    FFmpegEngine,
+    FileSystemStorage,
+    InternalCache
+} from 'mes-engine';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+export class VideoProcessorService {
+    constructor() {
+        this.processor = new VideoProcessor(
+            new FFmpegEngine(),
+            new FileSystemStorage(path.join(__dirname, '../../processed')),
+            {
+                chunkSize: 10, // 10 seconds
+                cacheDir: path.join(__dirname, '../../processed'),
+                maxCacheSize: parseInt(process.env.CACHE_SIZE) || 100 * 1024 * 1024, // 100MB
+                defaultQualities: [
+                    { height: 1080, bitrate: '5000k' },
+                    { height: 720, bitrate: '2500k' },
+                    { height: 480, bitrate: '1000k' },
+                    { height: 360, bitrate: '500k' }
+                ]
+            }
+        );
+
+        this.setupEventListeners();
+    }
+
+    setupEventListeners() {
+        // The current VideoProcessor doesn't emit 'progress',
+        // it emits CHUNK_PROCESSED, QUALITY_PROCESSED, etc.
+        this.processor.on('chunkProcessed', (data) => {
+            console.log('Chunk processed:', data);
+        });
+
+        this.processor.on('processingComplete', (data) => {
+            console.log('Processing complete:', data);
+        });
+
+        this.processor.on('error', (error) => {
+            console.error('Processing error:', error);
+        });
+    }
+
+    async processVideo(filePath, socketId, io) {
+        try {
+            // Emit processing started
+            io.to(socketId).emit('processing:started', { filePath });
+
+            // Process video
+            // Note: VideoProcessor.processVideo(inputPath, options)
+            const manifest = await this.processor.processVideo(filePath, {
+                title: path.basename(filePath)
+            });
+
+            // Emit processing complete
+            io.to(socketId).emit('processing:complete', { manifest });
+
+            return manifest;
+        } catch (error) {
+            io.to(socketId).emit('processing:error', { error: error.message });
+            throw error;
+        }
+    }
+
+    async streamChunk(videoId, quality, chunkNumber) {
+        return await this.processor.streamChunk(videoId, quality, chunkNumber);
+    }
+
+    async getManifest(videoId) {
+        // In actual implementation, we'd read from disk or memory.
+        // For the demo, let's assume we can fetch it.
+        // The VideoProcessor doesn't have a getManifest method.
+        const manifestPath = path.join(__dirname, '../../processed', videoId, 'manifest.json');
+        const data = await fs.promises.readFile(manifestPath, 'utf8');
+        return JSON.parse(data);
+    }
+}
+
+import fs from 'fs';
+export default new VideoProcessorService();

package/examples/full-demo/frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>MES-Engine Demo</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>