mes-engine 0.0.1

package/src/engines/FFmpegEngine.ts

@@ -0,0 +1,51 @@
+
+// engines/FFmpegEngine.ts
+import { spawn } from 'child_process';
+import { VideoEngine } from '../core/VideoEngine';
+import { QualityLevel } from '../core/types';
+
+export class FFmpegEngine extends VideoEngine {
+    async processChunk(
+        inputPath: string,
+        outputPath: string,
+        startTime: number,
+        quality: QualityLevel
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+        const ffmpeg = spawn('ffmpeg', [
+            '-i', inputPath,
+            '-ss', startTime.toString(),
+            '-t', '10',
+            '-vf', `scale=-1:${quality.height}`,
+            '-c:v', 'libx264',
+            '-b:v', quality.bitrate,
+            '-c:a', 'aac',
+            '-b:a', '128k',
+            '-preset', 'fast',
+            '-y',
+            outputPath
+        ]);
+
+        ffmpeg.on('close', code => {
+            code === 0 ? resolve() : reject(new Error(`FFmpeg error: ${code}`));
+        });
+        });
+    }
+
+    async getDuration(inputPath: string): Promise<number> {
+        return new Promise((resolve, reject) => {
+        const ffprobe = spawn('ffprobe', [
+            '-v', 'error',
+            '-show_entries', 'format=duration',
+            '-of', 'default=noprint_wrappers=1:nokey=1',
+            inputPath
+        ]);
+
+        let output = '';
+        ffprobe.stdout.on('data', data => output += data);
+        ffprobe.on('close', code => {
+            code === 0 ? resolve(parseFloat(output)) : reject(new Error(`FFprobe error: ${code}`));
+        });
+        });
+    }
+}

package/src/engines/GStreamerEngine.ts

@@ -0,0 +1,45 @@
+// engines/GStreamerEngine.ts
+import { spawn } from 'child_process';
+import { VideoEngine } from '../core/VideoEngine';
+import { QualityLevel } from '../core/types';
+
+export class GStreamerEngine extends VideoEngine {
+    async processChunk(
+        inputPath: string,
+        outputPath: string,
+        startTime: number,
+        quality: QualityLevel
+    ): Promise<void> {
+        return new Promise((resolve, reject) => {
+            const gst = spawn('gst-launch-1.0', [
+                'filesrc', `location=${inputPath}`,
+                '!', 'decodebin',
+                '!', 'videoconvert',
+                '!', 'videoscale',
+                '!', `video/x-raw,width=-1,height=${quality.height}`,
+                '!', 'x264enc', `bitrate=${quality.bitrate}`,
+                '!', 'mp4mux', '!', 'filesink', `location=${outputPath}`
+            ]);
+
+            gst.on('close', code => {
+                code === 0 ? resolve() : reject(new Error(`GStreamer error: ${code}`));
+            });
+        });
+    }
+
+    async getDuration(inputPath: string): Promise<number> {
+        return new Promise((resolve, reject) => {
+            const gst = spawn('gst-launch-1.0', [
+                'filesrc', `location=${inputPath}`,
+                '!', 'decodebin',
+                '!', 'identity', '-debug', 'duration'
+            ]);
+
+            let output = '';
+            gst.stdout.on('data', data => output += data);
+            gst.on('close', code => {
+                code === 0 ? resolve(parseFloat(output)) : reject(new Error(`GStreamer error: ${code}`));
+            });
+        });
+    }
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+// index.ts
+export * from './core/types';
+export * from './core/events';
+export * from './core/VideoEngine';
+export * from './engines/FFmpegEngine';
+export * from './streaming/StreamManager';
+export * from './engines/GStreamerEngine';
+export * from './storage/StorageProvider';
+export * from './storage/FileSystemStorage';
+export * from './cache/cacheStrategy';
+export * from './cache/internalCache';
+export * from './cache/ExternalCache';
+export * from './processor';

package/src/processor.ts

@@ -0,0 +1,90 @@
+
+// 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 { promises as fs } from 'fs';
+import { Readable } from 'stream';
+import { VideoEvent } from './core/events';
+
+export class VideoProcessor extends EventEmitter {
+    private engine: VideoEngine;
+    private streamManager: StreamManager;
+    private config: VideoConfig;
+
+    constructor(
+        engine: VideoEngine,
+        storage: StorageProvider,
+        config: VideoConfig
+    ) {
+        super();
+        this.engine = engine;
+        this.streamManager = new StreamManager(storage);
+        this.config = config;
+    }
+
+    async processVideo(inputPath: string): Promise<VideoManifest> {
+        const videoId = await this.generateVideoId(inputPath);
+        const manifest: VideoManifest = {
+        videoId,
+        qualities: this.config.defaultQualities,
+        chunks: []
+        };
+
+        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;
+            }
+        }
+
+        this.emit(VideoEvent.QUALITY_PROCESSED, quality);
+        }
+
+        this.emit(VideoEvent.PROCESSING_COMPLETE, manifest);
+        return manifest;
+    }
+
+    async streamChunk(
+        videoId: string,
+        quality: number,
+        chunkNumber: number,
+        range?: { start: number; end: number }
+    ): Promise<Readable> {
+        const chunkPath = this.getChunkPath(videoId, quality, chunkNumber);
+        return this.streamManager.createStream(chunkPath, range);
+    }
+
+    private getChunkPath(videoId: string, quality: number, chunkNumber: number): string {
+        return join(this.config.cacheDir, videoId, `${quality}p`, `chunk_${chunkNumber}.mp4`);
+    }
+
+    private async generateVideoId(inputPath: string): Promise<string> {
+        const stats = await fs.stat(inputPath);
+        return `${inputPath.split('/').pop()?.split('.')[0]}_${stats.mtimeMs}`;
+    }
+}

package/src/storage/FileSystemStorage.ts

@@ -0,0 +1,19 @@
+
+
+// storage/FileSystemStorage.ts
+import { promises as fs } from 'fs';
+import { StorageProvider } from './StorageProvider';
+
+export class FileSystemStorage extends StorageProvider {
+    async saveChunk(chunkPath: string, data: Buffer): Promise<void> {
+        await fs.writeFile(chunkPath, data);
+    }
+
+    async getChunk(chunkPath: string): Promise<Buffer> {
+        return fs.readFile(chunkPath);
+    }
+
+    async deleteChunk(chunkPath: string): Promise<void> {
+        await fs.unlink(chunkPath);
+    }
+}

package/src/storage/StorageProvider.ts

@@ -0,0 +1,7 @@
+
+// storage/StorageProvider.ts
+export abstract class StorageProvider {
+    abstract saveChunk(chunkPath: string, data: Buffer): Promise<void>;
+    abstract getChunk(chunkPath: string): Promise<Buffer>;
+    abstract deleteChunk(chunkPath: string): Promise<void>;
+}

package/src/streaming/StreamManager.ts

@@ -0,0 +1,26 @@
+
+// streaming/StreamManager.ts
+import { Readable } from 'stream';
+import { StorageProvider } from '../storage/StorageProvider';
+
+export class StreamManager {
+    private storage: StorageProvider;
+
+    constructor(storage: StorageProvider) {
+        this.storage = storage;
+    }
+
+    async createStream(chunkPath: string, range?: { start: number; end: number }): Promise<Readable> {
+        const data = await this.storage.getChunk(chunkPath);
+        const stream = new Readable();
+
+        if (range) {
+        stream.push(data.slice(range.start, range.end + 1));
+        } else {
+        stream.push(data);
+        }
+
+        stream.push(null);
+        return stream;
+    }
+}

package/tests/video-processor.test.ts

@@ -0,0 +1,247 @@
+import { expect } from 'chai';
+import { VideoProcessor } from '../src/processor';
+import { FFmpegEngine } from '../src/engines/FFmpegEngine';
+import { FileSystemStorage } from '../src/storage/FileSystemStorage';
+import { VideoConfig, QualityLevel } from '../src/core/types';
+import { StorageProvider } from '../src/storage/StorageProvider';
+import { VideoEngine } from '../src/core/VideoEngine';
+import { promises as fs } from 'fs';
+import { join, dirname } from 'path';
+import { Readable } from 'stream';
+import { VideoEvent } from '../src/core/events';
+
+// Mock implementation of a custom engine to test modularity
+class CustomVideoEngine extends VideoEngine {
+    async processChunk(
+        inputPath: string,
+        outputPath: string,
+        startTime: number,
+        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
+        await fs.writeFile(outputPath, chunkData);
+
+        // Save to storage
+        const storage = new CustomStorageProvider();
+        await storage.saveChunk(outputPath, chunkData);
+    }
+
+    async getDuration(inputPath: string): Promise<number> {
+        return 30; // Mock duration
+    }
+}
+
+// Mock implementation of a custom storage provider
+class CustomStorageProvider extends StorageProvider {
+    private static storage = new Map<string, Buffer>();
+
+    async saveChunk(chunkPath: string, data: Buffer): Promise<void> {
+        console.log(`Saving chunk at: ${chunkPath}`);
+        CustomStorageProvider.storage.set(chunkPath, data);
+    }
+
+    async getChunk(chunkPath: string): Promise<Buffer> {
+        console.log(`Fetching chunk at: ${chunkPath}`);
+        const data = CustomStorageProvider.storage.get(chunkPath);
+        if (!data) throw new Error('Chunk not found');
+        return data;
+    }
+
+    async deleteChunk(chunkPath: string): Promise<void> {
+        CustomStorageProvider.storage.delete(chunkPath);
+    }
+
+    // Add a public method to clear the storage
+    public clearStorage(): void {
+        CustomStorageProvider.storage.clear();
+    }
+}
+
+const globalStorage = new CustomStorageProvider();
+
+beforeEach(() => {
+    // Optional: Reset storage if needed
+    globalStorage.clearStorage();
+});
+
+describe('Video Processing Framework', () => {
+    const testConfig: VideoConfig = {
+        chunkSize: 10,
+        cacheDir: './test-cache',
+        maxCacheSize: 1024 * 1024 * 100, // 100MB
+        defaultQualities: [
+            { height: 720, bitrate: '2000k' },
+            { height: 480, bitrate: '1000k' }
+        ]
+    };
+
+    beforeEach(async () => {
+        // Create test cache directory
+        await fs.mkdir(testConfig.cacheDir, { recursive: true });
+    });
+
+    afterEach(async () => {
+        // Cleanup test cache directory
+        await fs.rm(testConfig.cacheDir, { recursive: true, force: true });
+    });
+
+    describe('Modular Engine System', () => {
+        it('should work with FFmpegEngine', async () => {
+            const engine = new FFmpegEngine();
+            const storage = new FileSystemStorage();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+            expect(processor).to.be.instanceOf(VideoProcessor);
+        });
+
+        it('should work with CustomVideoEngine', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new FileSystemStorage();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+            expect(processor).to.be.instanceOf(VideoProcessor);
+        });
+    });
+
+    describe('Abstract Storage Providers', () => {
+        it('should work with FileSystemStorage', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new FileSystemStorage();
+            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 processor = new VideoProcessor(engine, storage, testConfig);
+            expect(processor).to.be.instanceOf(VideoProcessor);
+        });
+    });
+
+    describe('Stream Management', () => {
+        it('should create readable stream for chunk', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new CustomStorageProvider();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+
+            // Mock a video file for testing
+            const videoId = 'test-video_12345';
+            const quality = 720;
+            const chunkNumber = 0;
+            const chunkData = Buffer.from('test');
+
+            // Simulate chunk processing and saving
+            const chunkPath = join(
+                testConfig.cacheDir,
+                videoId,
+                `${quality}p`,
+                `chunk_${chunkNumber}.mp4`
+            );
+            await storage.saveChunk(chunkPath, chunkData);
+
+            // Process a test video first
+            const manifest = await processor.processVideo('test-video.mp4');
+            console.log('Manifest:', manifest); // Debugging
+
+            expect(manifest.chunks).to.have.length.greaterThan(0); // Ensure chunks exist
+
+            // Test streaming a chunk
+            const stream = await processor.streamChunk(
+                manifest.videoId,
+                720,
+                0
+            );
+
+            // Verify the stream is a readable stream
+            expect(stream).to.be.instanceOf(Readable);
+
+            // Read from the stream to validate its content
+            const data = await new Promise<Buffer>((resolve, reject) => {
+                const chunks: Buffer[] = [];
+                stream.on('data', (chunk) => chunks.push(chunk));
+                stream.on('end', () => resolve(Buffer.concat(chunks)));
+                stream.on('error', reject);
+            });
+
+            expect(data.toString()).to.equal(chunkData.toString());
+
+            expect(stream).to.be.instanceOf(Readable);
+        });
+
+        it('should support range requests', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new CustomStorageProvider();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+
+            const manifest = await processor.processVideo('test-video.mp4');
+            const stream = await processor.streamChunk(
+                manifest.videoId,
+                720,
+                0,
+                { start: 0, end: 100 }
+            );
+            expect(stream).to.be.instanceOf(Readable);
+        });
+    });
+
+    describe('Event System', () => {
+        it('should emit events during processing', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new CustomStorageProvider();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+
+            const events: string[] = [];
+
+            processor.on(VideoEvent.CHUNK_PROCESSED, () => events.push('chunk'));
+            processor.on(VideoEvent.QUALITY_PROCESSED, () => events.push('quality'));
+            processor.on(VideoEvent.PROCESSING_COMPLETE, () => events.push('complete'));
+
+            await processor.processVideo('test-video.mp4');
+
+            expect(events).to.include('chunk');
+            expect(events).to.include('quality');
+            expect(events).to.include('complete');
+        });
+    });
+
+    describe('Configurable Quality Levels', () => {
+        it('should process video in configured quality levels', async () => {
+            const engine = new CustomVideoEngine();
+            const storage = new CustomStorageProvider();
+            const processor = new VideoProcessor(engine, storage, testConfig);
+
+            const manifest = await processor.processVideo('test-video.mp4');
+
+            expect(manifest.qualities).to.deep.equal(testConfig.defaultQualities);
+            expect(manifest.chunks).to.have.length.greaterThan(0);
+
+            // Verify chunks exist for each quality
+            const qualities = new Set(manifest.chunks.map(chunk => chunk.quality));
+            expect(qualities.size).to.equal(testConfig.defaultQualities.length);
+        });
+    });
+
+    describe('TypeScript Interfaces', () => {
+        it('should validate type safety of configuration', () => {
+            const config: VideoConfig = {
+                chunkSize: 10,
+                cacheDir: './test-cache',
+                maxCacheSize: 1024 * 1024 * 100,
+                defaultQualities: [
+                    { height: 720, bitrate: '2000k' }
+                ]
+            };
+            expect(config).to.have.all.keys([
+                'chunkSize',
+                'cacheDir',
+                'maxCacheSize',
+                'defaultQualities'
+            ]);
+        });
+    });
+});

package/tsconfig.json

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

package/tsconfig.test.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+        "target": "ES2020",
+        "module": "CommonJS",
+        "moduleResolution": "node",
+        "esModuleInterop": true,
+        "strict": true,
+        "skipLibCheck": true,
+        "resolveJsonModule": true,
+        "outDir": "./dist",
+        "types": ["node", "mocha", "chai"],
+        "lib": ["dom", "es2015"]
+    },
+    "include": ["src/**/*", "tests/**/*"],
+    "exclude": ["node_modules", "dist"]
+}