AI slop

Author: oscartbeaumont

packages/utils/src/media-processor.ts

@@ -69,6 +69,7 @@ export interface MediaProcessor {
 	getMetadata(): Promise<MediaMetadata>;
 	convert(options: ConversionOptions): Promise<Uint8Array>;
 	dispose(): void;
+	isReady(): boolean;
 }
 
 // Formats that Mediabunny typically supports well
@@ -202,16 +203,66 @@ async function loadFFmpegWasm() {
 class MediabunnyProcessor implements MediaProcessor {
 	private input: MediabunnyInput | null = null;
 	private file: File | null = null;
+	private mediabunny: any = null;
+
+	isReady(): boolean {
+		return (
+			this.input !== null && this.file !== null && this.mediabunny !== null
+		);
+	}
 
 	async loadFile(file: File): Promise<void> {
-		const mediabunny = await loadMediabunny();
-		const { Input, BlobSource, ALL_FORMATS } = mediabunny;
+		console.debug("MediabunnyProcessor: Starting loadFile", {
+			fileName: file.name,
+			fileSize: file.size,
+			fileType: file.type,
+		});
 
-		this.file = file;
-		this.input = new Input({
-			source: new BlobSource(file),
-			formats: ALL_FORMATS,
+		this.mediabunny = await loadMediabunny();
+		const { Input, BlobSource, ALL_FORMATS } = this.mediabunny;
+
+		console.debug("MediabunnyProcessor: Mediabunny loaded successfully", {
+			hasInput: !!Input,
+			hasBlobSource: !!BlobSource,
+			hasFormats: !!ALL_FORMATS,
 		});
+
+		this.file = file;
+
+		try {
+			const blobSource = new BlobSource(file);
+			console.debug("MediabunnyProcessor: BlobSource created");
+
+			this.input = new Input({
+				source: blobSource,
+				formats: ALL_FORMATS,
+			});
+
+			console.debug("MediabunnyProcessor: Input created", {
+				inputType: typeof this.input,
+				inputConstructor: this.input?.constructor?.name,
+				hasInput: !!this.input,
+			});
+
+			// Validate that the input was created properly
+			if (!this.input || typeof this.input !== "object") {
+				throw new Error("Failed to create valid Input object");
+			}
+
+			// Additional validation - check if input has expected methods
+			if (
+				typeof this.input.getVideoTracks !== "function" ||
+				typeof this.input.getAudioTracks !== "function"
+			) {
+				throw new Error("Input object missing expected methods");
+			}
+		} catch (error) {
+			console.error("MediabunnyProcessor: Failed to create input", error);
+			this.input = null;
+			throw new Error(
+				`Failed to create media input: ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
 	}
 
 	async getMetadata(): Promise<MediaMetadata> {
@@ -248,15 +299,40 @@ class MediabunnyProcessor implements MediaProcessor {
 	}
 
 	async convert(options: ConversionOptions): Promise<Uint8Array> {
+		console.debug("MediabunnyProcessor: Starting convert", {
+			outputFormat: options.outputFormat,
+			hasInput: !!this.input,
+			inputType: typeof this.input,
+			inputConstructor: this.input?.constructor?.name,
+		});
+
 		if (!this.input) {
 			throw new Error("No file loaded");
 		}
 
-		const mediabunny = await loadMediabunny();
-		const { Output, Conversion, BufferTarget } = mediabunny;
+		if (!this.mediabunny) {
+			throw new Error("Mediabunny not initialized");
+		}
+
+		// Additional validation to ensure input is proper
+		if (typeof this.input !== "object" || this.input === null) {
+			throw new Error(
+				"Invalid input object - media file may not be properly loaded",
+			);
+		}
+		const { Output, Conversion, BufferTarget } = this.mediabunny;
+
+		console.debug("MediabunnyProcessor: Mediabunny classes available", {
+			hasOutput: !!Output,
+			hasConversion: !!Conversion,
+			hasBufferTarget: !!BufferTarget,
+		});
 
 		// Get appropriate output format
-		const outputFormat = this.getOutputFormat(options.outputFormat, mediabunny);
+		const outputFormat = this.getOutputFormat(
+			options.outputFormat,
+			this.mediabunny,
+		);
 
 		const target = new BufferTarget();
 		const output = new Output({
@@ -271,7 +347,36 @@ class MediabunnyProcessor implements MediaProcessor {
 			output.setVideoSize(options.width, options.height);
 		if (options.frameRate) output.setVideoFrameRate(options.frameRate);
 
-		const conversion = new Conversion(this.input, output);
+		// Final validation before creating Conversion
+		if (!this.input || this.input === null || this.input === undefined) {
+			throw new Error("Input is null or undefined");
+		}
+
+		// Check if input has the expected structure for mediabunny
+		if (typeof this.input !== "object") {
+			throw new Error(`Input is not an object, got: ${typeof this.input}`);
+		}
+
+		// Create conversion with proper error handling
+		let conversion: any;
+		try {
+			console.debug("MediabunnyProcessor: Creating Conversion with", {
+				inputConstructor: this.input.constructor?.name,
+				outputConstructor: output.constructor?.name,
+			});
+			conversion = new Conversion(this.input, output);
+		} catch (conversionError) {
+			console.error("MediabunnyProcessor: Conversion creation failed", {
+				error: conversionError,
+				inputType: typeof this.input,
+				inputConstructor: this.input?.constructor?.name,
+				outputType: typeof output,
+				outputConstructor: output?.constructor?.name,
+			});
+			throw new Error(
+				`Failed to create conversion: ${conversionError instanceof Error ? conversionError.message : String(conversionError)}. Input type: ${typeof this.input}, Input constructor: ${this.input?.constructor?.name}`,
+			);
+		}
 
 		// Handle progress updates
 		if (options.onProgress) {
@@ -336,6 +441,7 @@ class MediabunnyProcessor implements MediaProcessor {
 	dispose(): void {
 		this.input = null;
 		this.file = null;
+		this.mediabunny = null;
 	}
 }
 
@@ -345,6 +451,10 @@ class FFmpegProcessor implements MediaProcessor {
 	private file: File | null = null;
 	private metadata: MediaMetadata | null = null;
 
+	isReady(): boolean {
+		return this.ffmpeg !== null && this.file !== null;
+	}
+
 	async loadFile(file: File): Promise<void> {
 		const { FFmpeg, fetchFile, toBlobURL } = await loadFFmpegWasm();
 
@@ -588,6 +698,12 @@ export async function createMediaProcessor(
 		try {
 			const processor = new MediabunnyProcessor();
 			await processor.loadFile(file);
+
+			// Validate processor is properly initialized
+			if (!processor.isReady()) {
+				throw new Error("MediabunnyProcessor not properly initialized");
+			}
+
 			return processor;
 		} catch (error) {
 			console.warn("Mediabunny failed, falling back to FFmpeg:", error);
@@ -624,6 +740,55 @@ export async function convertMedia(
 	}
 }
 
+// Debug helper function for troubleshooting media processing issues
+export async function debugMediaFile(file: File): Promise<{
+	fileInfo: {
+		name: string;
+		size: number;
+		type: string;
+	};
+	mediabunnyAvailable: boolean;
+	mediabunnyError?: string;
+	processorCreated: boolean;
+	processorError?: string;
+}> {
+	const result = {
+		fileInfo: {
+			name: file.name,
+			size: file.size,
+			type: file.type,
+		},
+		mediabunnyAvailable: false,
+		processorCreated: false,
+	} as any;
+
+	// Test mediabunny availability
+	try {
+		const mediabunny = await loadMediabunny();
+		result.mediabunnyAvailable = true;
+		console.log("Mediabunny loaded successfully:", {
+			hasInput: !!mediabunny.Input,
+			hasBlobSource: !!mediabunny.BlobSource,
+			hasFormats: !!mediabunny.ALL_FORMATS,
+		});
+	} catch (error) {
+		result.mediabunnyError =
+			error instanceof Error ? error.message : String(error);
+	}
+
+	// Test processor creation
+	try {
+		const processor = await createMediaProcessor(file);
+		result.processorCreated = processor.isReady();
+		processor.dispose();
+	} catch (error) {
+		result.processorError =
+			error instanceof Error ? error.message : String(error);
+	}
+
+	return result;
+}
+
 // Check if a format combination is supported
 export function isFormatSupported(
 	inputFormat: string,