Video Trimmer/Editor

// Reliable Video Trimmer Export System

class VideoTrimmerExporter {
    async reliableExport(video, startTime, endTime, options) {
        const exportMethods = [
            { name: 'WebM Stream Export', handler: () => this.webmStreamExport() },
            { name: 'MediaRecorder Trim', handler: () => this.mediaRecorderTrim() },
            { name: 'Canvas Frame Export', handler: () => this.canvasFrameExport() },
            { name: 'Basic Fallback', handler: () => this.basicFallback() }
        ];

        for (const method of exportMethods) {
            try {
                console.log(`🧪 Trying: ${method.name}`);
                const result = await method.handler();
                
                if (result && result.size > 0) {
                    console.log(`✅ Success with ${method.name}`);
                    return result;
                }
            } catch (error) {
                console.log(`❌ ${method.name} failed: ${error.message}`);
                continue;
            }
        }
        
        throw new Error('All export methods failed');
    }

    async webmStreamExport() {
        // Setup canvas with video dimensions
        this.setupCanvas();
        
        // Create reliable video stream
        const stream = this.canvas.captureStream(20); // 20fps for stability
        
        // Configure MediaRecorder with safe settings
        const recorder = new MediaRecorder(stream, {
            mimeType: 'video/webm',
            videoBitsPerSecond: 1500000 // 1.5 Mbps
        });

        const chunks = [];
        recorder.ondataavailable = e => {
            if (e.data.size > 0) chunks.push(e.data);
        };

        return new Promise((resolve, reject) => {
            recorder.onstop = () => {
                const blob = new Blob(chunks, { type: 'video/webm' });
                resolve(blob);
            };

            recorder.onstart = () => {
                this.renderTrimmedFrames().then(() => {
                    setTimeout(() => recorder.stop(), 500);
                });
            };

            recorder.start(1000); // 1-second chunks for reliability
        });
    }

    async renderTrimmedFrames() {
        const duration = this.endTime - this.startTime;
        const fps = 20;
        const totalFrames = Math.ceil(duration * fps);
        
        for (let i = 0; i < totalFrames; i++) {
            const currentTime = this.startTime + (i / fps);
            
            if (currentTime >= this.endTime) break;
            
            await this.seekToTime(currentTime);
            this.renderFrame();
            
            // Progress callback
            if (this.onProgress) {
                this.onProgress((i / totalFrames) * 100);
            }
            
            // Small delay for frame processing
            await new Promise(resolve => setTimeout(resolve, 50));
        }
    }
}