mes-engine 0.0.3 → 1.0.1

package/src/processor.ts

@@ -1,15 +1,18 @@
-
-// processor.ts
+// src/processor.ts
 import { VideoEngine } from './core/VideoEngine';
 import { EventEmitter } from 'events';
 import { StorageProvider } from './storage/StorageProvider';
 import { StreamManager } from './streaming/StreamManager';
-import { VideoConfig, VideoManifest } from './core/types';
-import { join } from 'path';
+import { VideoConfig, VideoManifest, VideoChunk, ProcessingOptions } from './core/types';
+import { join, dirname } from 'path';
 import { promises as fs } from 'fs';
 import { Readable } from 'stream';
 import { VideoEvent } from './core/events';
 
+/**
+ * Main orchestrator for video processing.
+ * Handles chunking, transcoding (via engines), and manifest generation.
+ */
 export class VideoProcessor extends EventEmitter {
     private engine: VideoEngine;
     private streamManager: StreamManager;
@@ -26,49 +29,125 @@ export class VideoProcessor extends EventEmitter {
         this.config = config;
     }
 
-    async processVideo(inputPath: string): Promise<VideoManifest> {
+    /**
+     * Processes an input video file into multiple quality levels and chunks.
+     * Generates HLS playlists and a JSON manifest.
+     * 
+     * @param inputPath - Absolute path to the source video file
+     * @param options - Optional metadata and processing instructions
+     * @returns Promise resolving to the generated VideoManifest
+     * @throws Error if processing fails at any stage
+     */
+    async processVideo(
+        inputPath: string,
+        options?: ProcessingOptions
+    ): Promise<VideoManifest> {
         const videoId = await this.generateVideoId(inputPath);
         const manifest: VideoManifest = {
-        videoId,
-        qualities: this.config.defaultQualities,
-        chunks: []
+            videoId,
+            qualities: this.config.defaultQualities,
+            chunks: [],
+            metadata: {
+                title: options?.title,
+                description: options?.overallDescription,
+                createdAt: new Date().toISOString()
+            }
         };
 
+        // Create base directory structure
+        const baseDir = join(this.config.cacheDir, videoId);
+        const screenshotDir = join(baseDir, 'screenshots');
+        await fs.mkdir(baseDir, { recursive: true });
+        await fs.mkdir(screenshotDir, { recursive: true });
+
         const duration = await this.engine.getDuration(inputPath);
         const chunks = Math.ceil(duration / this.config.chunkSize);
 
         for (const quality of this.config.defaultQualities) {
-        for (let i = 0; i < chunks; i++) {
-            const chunkPath = this.getChunkPath(videoId, quality.height, i);
-
-            try {
-            await this.engine.processChunk(
-                inputPath,
-                chunkPath,
-                i * this.config.chunkSize,
-                quality
-            );
-
-            manifest.chunks.push({
-                quality: quality.height,
-                number: i,
-                path: chunkPath
-            });
-
-            this.emit(VideoEvent.CHUNK_PROCESSED, { quality, chunkNumber: i });
-            } catch (error) {
-            this.emit(VideoEvent.ERROR, error);
-            throw error;
+            // Create quality-specific directory
+            const qualityDir = join(baseDir, `${quality.height}p`);
+            await fs.mkdir(qualityDir, { recursive: true });
+
+            let m3u8Content = '#EXTM3U\n#EXT-X-VERSION:3\n#EXT-X-TARGETDURATION:' + this.config.chunkSize + '\n#EXT-X-MEDIA-SEQUENCE:0\n#EXT-X-PLAYLIST-TYPE:VOD\n';
+
+            for (let i = 0; i < chunks; i++) {
+                const chunkPath = this.getChunkPath(videoId, quality.height, i);
+                const screenshotPath = this.getScreenshotPath(videoId, i);
+
+                try {
+                    // Process chunk
+                    await this.engine.processChunk(
+                        inputPath,
+                        chunkPath,
+                        i * this.config.chunkSize,
+                        quality
+                    );
+
+                    // Extract screenshot (only once per chunk number, e.g., for the first quality)
+                    if (quality.height === this.config.defaultQualities[0].height) {
+                        await this.engine.extractScreenshot(
+                            inputPath,
+                            screenshotPath,
+                            i * this.config.chunkSize + 1 // 1 second into the chunk
+                        );
+                    }
+
+                    const chunk: VideoChunk = {
+                        quality: quality.height,
+                        number: i,
+                        path: chunkPath,
+                        screenshotPath: screenshotPath,
+                        description: options?.descriptions?.[i]
+                    };
+
+                    manifest.chunks.push(chunk);
+
+                    // Add to M3U8
+                    m3u8Content += `#EXTINF:${this.config.chunkSize}.0,\nchunk_${i}.mp4\n`;
+
+                    this.emit(VideoEvent.CHUNK_PROCESSED, { quality, chunkNumber: i });
+                } catch (error) {
+                    this.emit(VideoEvent.ERROR, error);
+                    throw error;
+                }
             }
+            m3u8Content += '#EXT-X-ENDLIST';
+
+            // Save M3U8 for this quality
+            const m3u8Path = join(qualityDir, 'playlist.m3u8');
+            await fs.writeFile(m3u8Path, m3u8Content);
+
+            this.emit(VideoEvent.QUALITY_PROCESSED, quality);
         }
 
-        this.emit(VideoEvent.QUALITY_PROCESSED, quality);
+        // Generate Master M3U8
+        if (this.config.defaultQualities.length > 1) {
+            let masterM3u8 = '#EXTM3U\n';
+            for (const quality of this.config.defaultQualities) {
+                masterM3u8 += `#EXT-X-STREAM-INF:BANDWIDTH=${quality.bitrate.replace('k', '000')},RESOLUTION=-1x${quality.height}\n${quality.height}p/playlist.m3u8\n`;
+            }
+            const masterPath = join(baseDir, 'master.m3u8');
+            await fs.writeFile(masterPath, masterM3u8);
         }
 
+        // Save JSON Manifest
+        const manifestPath = join(baseDir, 'manifest.json');
+        await fs.writeFile(manifestPath, JSON.stringify(manifest, null, 2));
+
         this.emit(VideoEvent.PROCESSING_COMPLETE, manifest);
         return manifest;
     }
 
+    /**
+     * Creates a readable stream for a specific video chunk.
+     * Supported for on-demand delivery of processed segments.
+     * 
+     * @param videoId - ID of the processed video
+     * @param quality - Target quality (height)
+     * @param chunkNumber - Sequential index of the chunk
+     * @param range - Optional byte range for partial content
+     * @returns Promise resolving to a Readable stream
+     */
     async streamChunk(
         videoId: string,
         quality: number,
@@ -83,8 +162,13 @@ export class VideoProcessor extends EventEmitter {
         return join(this.config.cacheDir, videoId, `${quality}p`, `chunk_${chunkNumber}.mp4`);
     }
 
+    private getScreenshotPath(videoId: string, chunkNumber: number): string {
+        return join(this.config.cacheDir, videoId, 'screenshots', `chunk_${chunkNumber}.jpg`);
+    }
+
     private async generateVideoId(inputPath: string): Promise<string> {
         const stats = await fs.stat(inputPath);
-        return `${inputPath.split('/').pop()?.split('.')[0]}_${stats.mtimeMs}`;
+        const fileName = inputPath.split(/[\\/]/).pop()?.split('.')[0];
+        return `${fileName}_${Math.floor(stats.mtimeMs)}`;
     }
 }

package/src/storage/FileSystemStorage.ts

@@ -1,6 +1,4 @@
-
-
-// storage/FileSystemStorage.ts
+// src/storage/FileSystemStorage.ts
 import { promises as fs } from 'fs';
 import { StorageProvider } from './StorageProvider';
 

package/src/storage/StorageProvider.ts

@@ -1,7 +1,12 @@
-
-// storage/StorageProvider.ts
+// src/storage/StorageProvider.ts
+/**
+ * Interface for storage backends (e.g., Local File System, S3, Cloud Storage).
+ */
 export abstract class StorageProvider {
+    /** Saves a video chunk to storage */
     abstract saveChunk(chunkPath: string, data: Buffer): Promise<void>;
+    /** Retrieves a video chunk from storage */
     abstract getChunk(chunkPath: string): Promise<Buffer>;
+    /** Deletes a video chunk from storage */
     abstract deleteChunk(chunkPath: string): Promise<void>;
 }

package/src/streaming/StreamManager.ts

@@ -1,5 +1,4 @@
-
-// streaming/StreamManager.ts
+// src/streaming/StreamManager.ts
 import { Readable } from 'stream';
 import { StorageProvider } from '../storage/StorageProvider';
 
@@ -15,9 +14,9 @@ export class StreamManager {
         const stream = new Readable();
 
         if (range) {
-        stream.push(data.slice(range.start, range.end + 1));
+            stream.push(data.slice(range.start, range.end + 1));
         } else {
-        stream.push(data);
+            stream.push(data);
         }
 
         stream.push(null);

package/tests/video-processor.test.ts

@@ -12,6 +12,13 @@ import { VideoEvent } from '../src/core/events';
 
 // Mock implementation of a custom engine to test modularity
 class CustomVideoEngine extends VideoEngine {
+    private storage: StorageProvider;
+
+    constructor(storage: StorageProvider) {
+        super();
+        this.storage = storage;
+    }
+
     async processChunk(
         inputPath: string,
         outputPath: string,
@@ -19,22 +26,31 @@ class CustomVideoEngine extends VideoEngine {
         quality: QualityLevel
     ): Promise<void> {
         // Create the directory path for the chunk if it doesn't exist
-        const chunkDir = outputPath.substring(0, outputPath.lastIndexOf('/'));
         await fs.mkdir(dirname(outputPath), { recursive: true });
 
         const chunkData = Buffer.from('test'); // Mock chunk data
 
-        // Mock implementation
+        // Mock implementation - write to file system
         await fs.writeFile(outputPath, chunkData);
 
-        // Save to storage
-        const storage = new CustomStorageProvider();
-        await storage.saveChunk(outputPath, chunkData);
+        // Also save to the shared storage provider
+        await this.storage.saveChunk(outputPath, chunkData);
     }
 
     async getDuration(inputPath: string): Promise<number> {
         return 30; // Mock duration
     }
+
+    async extractScreenshot(
+        inputPath: string,
+        outputPath: string,
+        time: number
+    ): Promise<void> {
+        // Create the directory path for the screenshot if it doesn't exist
+        await fs.mkdir(dirname(outputPath), { recursive: true });
+        // Mock implementation - write an empty file to simulate screenshot
+        await fs.writeFile(outputPath, Buffer.from('mock-screenshot'));
+    }
 }
 
 // Mock implementation of a custom storage provider
@@ -84,11 +100,15 @@ describe('Video Processing Framework', () => {
     beforeEach(async () => {
         // Create test cache directory
         await fs.mkdir(testConfig.cacheDir, { recursive: true });
+        // Create a mock test video file so fs.stat() works in generateVideoId
+        await fs.writeFile('test-video.mp4', Buffer.from('mock-video-data'));
     });
 
     afterEach(async () => {
         // Cleanup test cache directory
         await fs.rm(testConfig.cacheDir, { recursive: true, force: true });
+        // Cleanup mock test video file
+        await fs.rm('test-video.mp4', { force: true });
     });
 
     describe('Modular Engine System', () => {
@@ -100,8 +120,8 @@ describe('Video Processing Framework', () => {
         });
 
         it('should work with CustomVideoEngine', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new FileSystemStorage();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
             expect(processor).to.be.instanceOf(VideoProcessor);
         });
@@ -109,15 +129,15 @@ describe('Video Processing Framework', () => {
 
     describe('Abstract Storage Providers', () => {
         it('should work with FileSystemStorage', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new FileSystemStorage();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
             expect(processor).to.be.instanceOf(VideoProcessor);
         });
 
         it('should work with CustomStorageProvider', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new CustomStorageProvider();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
             expect(processor).to.be.instanceOf(VideoProcessor);
         });
@@ -125,8 +145,8 @@ describe('Video Processing Framework', () => {
 
     describe('Stream Management', () => {
         it('should create readable stream for chunk', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new CustomStorageProvider();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
 
             // Mock a video file for testing
@@ -174,8 +194,8 @@ describe('Video Processing Framework', () => {
         });
 
         it('should support range requests', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new CustomStorageProvider();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
 
             const manifest = await processor.processVideo('test-video.mp4');
@@ -191,8 +211,8 @@ describe('Video Processing Framework', () => {
 
     describe('Event System', () => {
         it('should emit events during processing', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new CustomStorageProvider();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
 
             const events: string[] = [];
@@ -211,8 +231,8 @@ describe('Video Processing Framework', () => {
 
     describe('Configurable Quality Levels', () => {
         it('should process video in configured quality levels', async () => {
-            const engine = new CustomVideoEngine();
             const storage = new CustomStorageProvider();
+            const engine = new CustomVideoEngine(storage);
             const processor = new VideoProcessor(engine, storage, testConfig);
 
             const manifest = await processor.processVideo('test-video.mp4');

package/tsconfig.json

@@ -2,15 +2,29 @@
     "compilerOptions": {
         "target": "ES2020",
         "module": "ESNext",
-        "moduleResolution": "node",
+        "moduleResolution": "bundler",
         "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
         "strict": true,
         "skipLibCheck": true,
         "resolveJsonModule": true,
         "outDir": "./dist",
-        "types": ["node", "mocha", "chai"],
-        "lib": ["dom", "es2015"]
+        "types": [
+            "node",
+            "mocha",
+            "chai"
+        ],
+        "lib": [
+            "dom",
+            "es2015"
+        ]
     },
-    "include": ["src/**/*", "tests/**/*"],
-    "exclude": ["node_modules", "dist"]
+    "include": [
+        "src/**/*",
+        "tests/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
 }

package/tsconfig.test.json

@@ -8,9 +8,22 @@
         "skipLibCheck": true,
         "resolveJsonModule": true,
         "outDir": "./dist",
-        "types": ["node", "mocha", "chai"],
-        "lib": ["dom", "es2015"]
+        "types": [
+            "node",
+            "mocha",
+            "chai"
+        ],
+        "lib": [
+            "dom",
+            "es2015"
+        ]
     },
-    "include": ["src/**/*", "tests/**/*"],
-    "exclude": ["node_modules", "dist"]
+    "include": [
+        "src/**/*",
+        "tests/**/*"
+    ],
+    "exclude": [
+        "node_modules",
+        "dist"
+    ]
 }

package/dist/types/index.d.ts

@@ -1,10 +0,0 @@
-export * from './core/types';
-export * from './core/events';
-export * from './core/VideoEngine';
-export * from './engines/FFmpegEngine';
-export * from './storage/StorageProvider';
-export * from './storage/FileSystemStorage';
-export * from './cache/cacheStrategy';
-export * from './cache/internalCache';
-export * from './cache/ExternalCache';
-export * from './processor';

package/dist/{types → src}/cache/LRU.d.ts

@@ -1,8 +1,8 @@
 export declare class LRU<T> {
-    private cache;
     private maxSize;
+    private cache;
     constructor(maxSize: number);
-    get(key: string): T | undefined;
     set(key: string, value: T): void;
+    get(key: string): T | undefined;
     clear(): void;
 }