@blueharford/scrypted-spatial-awareness 0.5.6 → 0.5.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueharford/scrypted-spatial-awareness",
-  "version": "0.5.6",
+  "version": "0.5.8",
   "description": "Cross-camera object tracking for Scrypted NVR with spatial awareness",
   "author": "Joshua Seidel <blueharford>",
   "license": "Apache-2.0",

package/src/core/spatial-reasoning.ts

@@ -84,40 +84,65 @@ export interface ImageData {
  */
 export async function mediaObjectToBase64(mediaObject: MediaObject): Promise<ImageData | null> {
   try {
-    console.log(`[Image] Converting MediaObject, mimeType=${mediaObject?.mimeType}`);
+    const mimeType = mediaObject?.mimeType || 'image/jpeg';
+    console.log(`[Image] Converting MediaObject, mimeType=${mimeType}`);
 
-    // Convert MediaObject to Buffer using mediaManager
-    const buffer = await mediaManager.convertMediaObjectToBuffer(mediaObject, ScryptedMimeTypes.Image);
+    // Use createMediaObject to ensure we have a proper MediaObject with mimeType
+    // Then convert to buffer - this should handle the conversion internally
+    let buffer: Buffer;
 
-    if (!buffer) {
-      console.warn('[Image] convertMediaObjectToBuffer returned null/undefined');
-      return null;
+    try {
+      // Try direct conversion with the source mime type
+      buffer = await mediaManager.convertMediaObjectToBuffer(mediaObject, mimeType);
+    } catch (convErr) {
+      console.warn(`[Image] Direct conversion failed, trying with explicit JPEG:`, convErr);
+
+      // Try creating a new MediaObject with explicit mimeType
+      try {
+        // Get raw data if available
+        const anyMedia = mediaObject as any;
+        if (typeof anyMedia.getData === 'function') {
+          const rawData = await anyMedia.getData();
+          if (rawData && Buffer.isBuffer(rawData) && rawData.length > 1000) {
+            console.log(`[Image] Got raw data: ${rawData.length} bytes`);
+            buffer = rawData;
+          } else {
+            console.warn(`[Image] getData returned invalid data`);
+            return null;
+          }
+        } else {
+          console.warn('[Image] No getData method available');
+          return null;
+        }
+      } catch (dataErr) {
+        console.warn('[Image] Alternate data fetch failed:', dataErr);
+        return null;
+      }
     }
 
-    console.log(`[Image] Buffer received: ${buffer.length} bytes`);
+    // Check if we got an actual Buffer (not a proxy)
+    const isRealBuffer = Buffer.isBuffer(buffer);
+    const bufferLength = isRealBuffer ? buffer.length : 0;
+
+    console.log(`[Image] Buffer: isBuffer=${isRealBuffer}, length=${bufferLength}`);
 
-    if (buffer.length === 0) {
-      console.warn('[Image] Buffer is empty (0 bytes)');
+    if (!isRealBuffer || bufferLength === 0) {
+      console.warn('[Image] Did not receive a valid Buffer');
       return null;
     }
 
     // Check if buffer is too small to be a valid image (< 1KB is suspicious)
-    if (buffer.length < 1000) {
-      // Log what the buffer contains - might be an error message
-      const bufferContent = buffer.toString('utf8').substring(0, 100);
-      console.warn(`[Image] Buffer too small (${buffer.length} bytes), content: ${bufferContent}`);
+    if (bufferLength < 1000) {
+      console.warn(`[Image] Buffer too small: ${bufferLength} bytes`);
       return null;
     }
 
     // Convert buffer to base64 (raw, no data URL prefix)
     const base64 = buffer.toString('base64');
 
-    // Determine MIME type - default to JPEG for camera images
-    const mediaType = mediaObject.mimeType?.split(';')[0] || 'image/jpeg';
-
-    console.log(`[Image] Converted to base64: ${base64.length} chars, type=${mediaType}`);
+    console.log(`[Image] Converted to base64: ${base64.length} chars`);
 
-    return { base64, mediaType };
+    return { base64, mediaType: 'image/jpeg' };
   } catch (e) {
     console.warn('[Image] Failed to convert MediaObject to base64:', e);
     return null;