retold-remote 0.0.13 → 0.0.15

package/source/cli/RetoldRemote-Server-Setup.js

@@ -48,6 +48,7 @@ const libRetoldRemoteMetadataCache = require('../server/RetoldRemote-MetadataCac
 const libRetoldRemoteFileOperationService = require('../server/RetoldRemote-FileOperationService.js');
 const libRetoldRemoteAISortService = require('../server/RetoldRemote-AISortService.js');
 const libRetoldRemoteImageService = require('../server/RetoldRemote-ImageService.js');
+const libRetoldRemoteUltravisorDispatcher = require('../server/RetoldRemote-UltravisorDispatcher.js');
 const libUrl = require('url');
 
 function setupRetoldRemoteServer(pOptions, fCallback)
@@ -83,6 +84,16 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 		tmpSettings.ParimeCacheServer = pOptions.CacheServer;
 	}
 
+	// If an Ultravisor URL is specified, offload heavy processing to beacons
+	if (pOptions.UltravisorURL)
+	{
+		tmpSettings.UltravisorURL = pOptions.UltravisorURL;
+	}
+	if (pOptions.ContentAPIURL)
+	{
+		tmpSettings.ContentAPIURL = pOptions.ContentAPIURL;
+	}
+
 	let tmpFable = new libFable(tmpSettings);
 
 	// Ensure the content directory exists
@@ -201,6 +212,16 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 				PathRegistry: tmpPathRegistry
 			});
 
+			// Set up the Ultravisor dispatcher for offloading heavy processing
+			let tmpDispatcher = new libRetoldRemoteUltravisorDispatcher(tmpFable, {});
+
+			// Wire the dispatcher to services that can offload processing
+			tmpMediaService.setDispatcher(tmpDispatcher);
+			tmpVideoFrameService.setDispatcher(tmpDispatcher);
+			tmpAudioWaveformService.setDispatcher(tmpDispatcher);
+			tmpEbookService.setDispatcher(tmpDispatcher);
+			tmpImageService.setDispatcher(tmpDispatcher);
+
 			// Share tool capabilities with the image service so it can
 			// use dcraw and ImageMagick for raw camera format conversion.
 			// Also provides the centrally-verified sharp module reference.
@@ -458,6 +479,10 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 			{
 				tmpFable.log.info('EPUB metadata service initialized.');
 			});
+			tmpDispatcher.checkConnection(() =>
+			{
+				// Non-fatal — if Ultravisor is down, processing stays local
+			});
 
 			// --- GET /api/media/metadata ---
 			// Get cached metadata (with ID3/format tags) for a single file.
@@ -2114,6 +2139,7 @@ function setupRetoldRemoteServer(pOptions, fCallback)
 						ParimeCache: tmpParimeCache,
 						MetadataCache: tmpMetadataCache,
 						FileOperationService: tmpFileOperationService,
+						UltravisorDispatcher: tmpDispatcher,
 						Port: tmpPort
 					});
 				});

package/source/providers/Pict-Provider-GalleryNavigation.js

@@ -563,6 +563,12 @@ class GalleryNavigationProvider extends libPictProvider
 		let tmpGalleryContainer = document.getElementById('RetoldRemote-Gallery-Container');
 		let tmpViewerContainer = document.getElementById('RetoldRemote-Viewer-Container');
 
+		// Stop any playing video/audio and release resources before hiding the viewer
+		let tmpVideo = document.querySelector('#RetoldRemote-Viewer-Container video');
+		let tmpAudio = document.querySelector('#RetoldRemote-Viewer-Container audio');
+		if (tmpVideo) { tmpVideo.pause(); tmpVideo.removeAttribute('src'); tmpVideo.load(); }
+		if (tmpAudio) { tmpAudio.pause(); tmpAudio.removeAttribute('src'); tmpAudio.load(); }
+
 		if (tmpGalleryContainer) tmpGalleryContainer.style.display = '';
 		if (tmpViewerContainer) tmpViewerContainer.style.display = 'none';
 
@@ -1380,14 +1386,16 @@ class GalleryNavigationProvider extends libPictProvider
 			// iOS/iPadOS: use vlc-x-callback for reliable app launching
 			tmpVLCURL = 'vlc-x-callback://x-callback-url/stream?url=' + encodeURIComponent(tmpStreamURL);
 		}
-		else if (tmpIsWindows || tmpIsAndroid)
+		else if (tmpIsAndroid)
 		{
-			// Windows and Android: VLC handles the raw URL natively
+			// Android: VLC app handles the raw URL natively via intent
 			tmpVLCURL = 'vlc://' + tmpStreamURL;
 		}
 		else
 		{
-			// macOS/Linux: our custom handlers URL-decode, so we encode
+			// Windows, macOS, Linux: encode the URL so the custom protocol
+			// handler can decode it.  On Windows this is required because the
+			// shell strips the colon from nested http:// URLs.
 			tmpVLCURL = 'vlc://' + encodeURIComponent(tmpStreamURL);
 		}
 

package/source/providers/keyboard-handlers/KeyHandler-AudioExplorer.js

@@ -94,6 +94,11 @@ function handleAudioExplorerKey(pGalleryNav, pEvent)
 				}
 			}
 			break;
+
+		case 'v':
+			pEvent.preventDefault();
+			pGalleryNav._streamWithVLC();
+			break;
 	}
 }
 

package/source/providers/keyboard-handlers/KeyHandler-VideoExplorer.js

@@ -133,6 +133,22 @@ function handleVideoExplorerKey(pGalleryNav, pEvent)
 				}
 			}
 			break;
+
+		case 'v':
+			pEvent.preventDefault();
+			pGalleryNav._streamWithVLC();
+			break;
+
+		case ' ':
+			pEvent.preventDefault();
+			{
+				let tmpPlayVEX = pGalleryNav.pict.views['RetoldRemote-VideoExplorer'];
+				if (tmpPlayVEX)
+				{
+					tmpPlayVEX.playInBrowser();
+				}
+			}
+			break;
 	}
 }
 

package/source/server/RetoldRemote-AudioWaveformService.js

@@ -51,6 +51,9 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
+		// Ultravisor dispatcher — set via setDispatcher()
+		this._dispatcher = null;
+
 		// Detect audiowaveform availability
 		this.hasAudiowaveform = this._detectCommand('audiowaveform --version');
 
@@ -61,6 +64,16 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 		this.fable.log.info(`  audiowaveform tool: ${this.hasAudiowaveform ? 'available' : 'not found (using ffprobe fallback)'}`);
 	}
 
+	/**
+	 * Set the Ultravisor dispatcher for offloading heavy processing.
+	 *
+	 * @param {object} pDispatcher - RetoldRemoteUltravisorDispatcher instance
+	 */
+	setDispatcher(pDispatcher)
+	{
+		this._dispatcher = pDispatcher;
+	}
+
 	/**
 	 * Check if a command-line tool is available.
 	 *
@@ -114,45 +127,76 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 
 	/**
 	 * Probe an audio file with ffprobe to get metadata.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 *
 	 * @param {string} pAbsPath - Absolute path to the audio file
 	 * @param {Function} fCallback - Callback(pError, { duration, sampleRate, channels, codec, bitrate, size })
 	 */
 	_probeAudio(pAbsPath, fCallback)
 	{
-		try
-		{
-			let tmpCmd = `ffprobe -v quiet -print_format json -show_format -show_streams "${pAbsPath}"`;
-			let tmpOutput = libChildProcess.execSync(tmpCmd, { maxBuffer: 1024 * 1024, timeout: 15000 });
-			let tmpData = JSON.parse(tmpOutput.toString());
-
-			let tmpResult = {};
+		let tmpSelf = this;
 
-			if (tmpData.format)
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
 			{
-				tmpResult.duration = parseFloat(tmpData.format.duration) || null;
-				tmpResult.bitrate = parseInt(tmpData.format.bit_rate, 10) || null;
-				tmpResult.size = parseInt(tmpData.format.size, 10) || null;
-				tmpResult.formatName = tmpData.format.format_name || null;
+				tmpRelPath = libPath.relative(this.contentPath, pAbsPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
 			}
 
-			if (tmpData.streams)
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
 			{
-				for (let i = 0; i < tmpData.streams.length; i++)
+				let tmpCommand = `ffprobe -v quiet -print_format json -show_format -show_streams "{SourcePath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 30000
+				},
+				(pDispatchError, pResult) =>
 				{
-					let tmpStream = tmpData.streams[i];
-					if (tmpStream.codec_type === 'audio')
+					if (!pDispatchError && pResult && pResult.Outputs && pResult.Outputs.StdOut)
 					{
-						tmpResult.sampleRate = parseInt(tmpStream.sample_rate, 10) || null;
-						tmpResult.channels = tmpStream.channels || null;
-						tmpResult.codec = tmpStream.codec_name || null;
-						tmpResult.channelLayout = tmpStream.channel_layout || null;
-						break;
+						try
+						{
+							let tmpData = JSON.parse(pResult.Outputs.StdOut);
+							let tmpParsed = tmpSelf._parseAudioProbeData(tmpData);
+							tmpSelf.fable.log.info(`ffprobe (audio) via Ultravisor for ${tmpRelPath}`);
+							return fCallback(null, tmpParsed);
+						}
+						catch (pParseError)
+						{
+							// Fall through to local
+						}
 					}
-				}
+
+					tmpSelf._probeAudioLocal(pAbsPath, fCallback);
+				});
+				return;
 			}
+		}
+
+		return this._probeAudioLocal(pAbsPath, fCallback);
+	}
 
-			return fCallback(null, tmpResult);
+	/**
+	 * Probe an audio file locally with ffprobe.
+	 */
+	_probeAudioLocal(pAbsPath, fCallback)
+	{
+		try
+		{
+			let tmpCmd = `ffprobe -v quiet -print_format json -show_format -show_streams "${pAbsPath}"`;
+			let tmpOutput = libChildProcess.execSync(tmpCmd, { maxBuffer: 1024 * 1024, timeout: 15000 });
+			let tmpData = JSON.parse(tmpOutput.toString());
+			return fCallback(null, this._parseAudioProbeData(tmpData));
 		}
 		catch (pError)
 		{
@@ -160,6 +204,40 @@ class RetoldRemoteAudioWaveformService extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * Parse ffprobe JSON output for audio metadata.
+	 */
+	_parseAudioProbeData(pData)
+	{
+		let tmpResult = {};
+
+		if (pData.format)
+		{
+			tmpResult.duration = parseFloat(pData.format.duration) || null;
+			tmpResult.bitrate = parseInt(pData.format.bit_rate, 10) || null;
+			tmpResult.size = parseInt(pData.format.size, 10) || null;
+			tmpResult.formatName = pData.format.format_name || null;
+		}
+
+		if (pData.streams)
+		{
+			for (let i = 0; i < pData.streams.length; i++)
+			{
+				let tmpStream = pData.streams[i];
+				if (tmpStream.codec_type === 'audio')
+				{
+					tmpResult.sampleRate = parseInt(tmpStream.sample_rate, 10) || null;
+					tmpResult.channels = tmpStream.channels || null;
+					tmpResult.codec = tmpStream.codec_name || null;
+					tmpResult.channelLayout = tmpStream.channel_layout || null;
+					break;
+				}
+			}
+		}
+
+		return tmpResult;
+	}
+
 	/**
 	 * Extract waveform peaks using BBC audiowaveform tool.
 	 * Generates a JSON file with min/max peak pairs.

package/source/server/RetoldRemote-EbookService.js

@@ -59,9 +59,22 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
+		// Ultravisor dispatcher — set via setDispatcher()
+		this._dispatcher = null;
+
 		this.fable.log.info('Ebook Service: using ParimeBinaryStorage (category: ebook-cache)');
 	}
 
+	/**
+	 * Set the Ultravisor dispatcher for offloading heavy processing.
+	 *
+	 * @param {object} pDispatcher - RetoldRemoteUltravisorDispatcher instance
+	 */
+	setDispatcher(pDispatcher)
+	{
+		this._dispatcher = pDispatcher;
+	}
+
 	/**
 	 * Check if a file extension is convertible to EPUB.
 	 *
@@ -146,25 +159,125 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 
 		this.fable.log.info(`Converting ebook: ${pRelPath} -> EPUB`);
 
+		let _finishConversion = (pOutputPath, pOutputFilename, pCacheDir, pManifestPath) =>
+		{
+			if (!libFs.existsSync(pOutputPath))
+			{
+				return fCallback(new Error('Conversion completed but output file not found.'));
+			}
+
+			let tmpOutputStat = libFs.statSync(pOutputPath);
+
+			let tmpResult =
+			{
+				Success: true,
+				SourcePath: pRelPath,
+				CacheKey: libPath.basename(pCacheDir),
+				OutputFilename: pOutputFilename,
+				FileSize: tmpOutputStat.size,
+				ConvertedAt: new Date().toISOString()
+			};
+
+			// Write manifest to cache
+			try
+			{
+				libFs.writeFileSync(pManifestPath, JSON.stringify(tmpResult, null, '\t'));
+			}
+			catch (pWriteError)
+			{
+				tmpSelf.fable.log.warn(`Could not write ebook manifest: ${pWriteError.message}`);
+			}
+
+			tmpSelf.fable.log.info(`Converted ebook: ${pRelPath} (${tmpOutputStat.size} bytes)`);
+			return fCallback(null, tmpResult);
+		};
+
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pAbsPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpCommand = `ebook-convert "{SourcePath}" "{OutputPath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 180000
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						try
+						{
+							libFs.writeFileSync(tmpOutputPath, pResult.OutputBuffer);
+							tmpSelf.fable.log.info(`Ebook converted via Ultravisor for ${tmpRelPath}`);
+							return _finishConversion(tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath);
+						}
+						catch (pWriteError)
+						{
+							// Fall through to local
+						}
+					}
+
+					// Fall through to local processing
+					tmpSelf.fable.log.info(`Ultravisor dispatch failed for ebook conversion, falling back to local: ${pDispatchError ? pDispatchError.message : 'no output'}`);
+					tmpSelf._convertToEpubLocal(pAbsPath, tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, fCallback);
+				});
+				return;
+			}
+		}
+
+		this._convertToEpubLocal(pAbsPath, tmpOutputPath, tmpOutputFilename, tmpCacheDir, tmpManifestPath, pRelPath, fCallback);
+	}
+
+	/**
+	 * Convert an ebook to EPUB locally using ebook-convert.
+	 *
+	 * @param {string}   pAbsPath        - Absolute path to the source ebook
+	 * @param {string}   pOutputPath     - Absolute path for the output EPUB
+	 * @param {string}   pOutputFilename - Output filename
+	 * @param {string}   pCacheDir       - Cache directory path
+	 * @param {string}   pManifestPath   - Manifest file path
+	 * @param {string}   pRelPath        - Relative path (for logging)
+	 * @param {Function} fCallback       - Callback(pError, pResult)
+	 */
+	_convertToEpubLocal(pAbsPath, pOutputPath, pOutputFilename, pCacheDir, pManifestPath, pRelPath, fCallback)
+	{
+		let tmpSelf = this;
+
 		try
 		{
 			// ebook-convert input.mobi output.epub
-			let tmpCmd = `ebook-convert "${pAbsPath}" "${tmpOutputPath}"`;
+			let tmpCmd = `ebook-convert "${pAbsPath}" "${pOutputPath}"`;
 			libChildProcess.execSync(tmpCmd, { stdio: 'ignore', timeout: 120000 });
 
-			if (!libFs.existsSync(tmpOutputPath))
+			if (!libFs.existsSync(pOutputPath))
 			{
 				return fCallback(new Error('Conversion completed but output file not found.'));
 			}
 
-			let tmpOutputStat = libFs.statSync(tmpOutputPath);
+			let tmpOutputStat = libFs.statSync(pOutputPath);
 
 			let tmpResult =
 			{
 				Success: true,
 				SourcePath: pRelPath,
-				CacheKey: libPath.basename(tmpCacheDir),
-				OutputFilename: tmpOutputFilename,
+				CacheKey: libPath.basename(pCacheDir),
+				OutputFilename: pOutputFilename,
 				FileSize: tmpOutputStat.size,
 				ConvertedAt: new Date().toISOString()
 			};
@@ -172,7 +285,7 @@ class RetoldRemoteEbookService extends libFableServiceProviderBase
 			// Write manifest to cache
 			try
 			{
-				libFs.writeFileSync(tmpManifestPath, JSON.stringify(tmpResult, null, '\t'));
+				libFs.writeFileSync(pManifestPath, JSON.stringify(tmpResult, null, '\t'));
 			}
 			catch (pWriteError)
 			{

package/source/server/RetoldRemote-ImageService.js

@@ -78,6 +78,19 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 		// Tool capabilities — set by MediaService after ToolDetector runs
 		this._capabilities = {};
+
+		// Ultravisor dispatcher — set via setDispatcher()
+		this._dispatcher = null;
+	}
+
+	/**
+	 * Set the Ultravisor dispatcher for offloading heavy processing.
+	 *
+	 * @param {object} pDispatcher - RetoldRemoteUltravisorDispatcher instance
+	 */
+	setDispatcher(pDispatcher)
+	{
+		this._dispatcher = pDispatcher;
 	}
 
 	/**
@@ -336,6 +349,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 	/**
 	 * Convert a raw image to JPEG using dcraw piped through Sharp.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 * dcraw outputs PPM to stdout; Sharp converts to JPEG.
 	 *
 	 * @param {string}   pAbsPath        - Raw file path
@@ -344,6 +358,71 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 	 * @param {Function} fCallback       - Callback(pError)
 	 */
 	_convertWithDcraw(pAbsPath, pOutputPath, pFullResolution, fCallback)
+	{
+		let tmpSelf = this;
+
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pAbsPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpHalfFlag = pFullResolution ? '' : ' -h';
+				let tmpOutputFilename = libPath.basename(pOutputPath);
+				let tmpCommand = `dcraw -c -w${tmpHalfFlag} "{SourcePath}" | convert ppm:- jpeg:"{OutputPath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 180000
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						try
+						{
+							let tmpDir = libPath.dirname(pOutputPath);
+							if (!libFs.existsSync(tmpDir))
+							{
+								libFs.mkdirSync(tmpDir, { recursive: true });
+							}
+							libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
+							tmpSelf.fable.log.info(`Raw conversion via Ultravisor (dcraw) for ${tmpRelPath}`);
+							return fCallback(null);
+						}
+						catch (pWriteError)
+						{
+							// Fall through to local
+						}
+					}
+
+					// Fall through to local processing
+					tmpSelf._convertWithDcrawLocal(pAbsPath, pOutputPath, pFullResolution, fCallback);
+				});
+				return;
+			}
+		}
+
+		return this._convertWithDcrawLocal(pAbsPath, pOutputPath, pFullResolution, fCallback);
+	}
+
+	/**
+	 * Convert a raw image to JPEG locally using dcraw piped through Sharp.
+	 */
+	_convertWithDcrawLocal(pAbsPath, pOutputPath, pFullResolution, fCallback)
 	{
 		if (!this._capabilities.dcraw || !this._sharp)
 		{
@@ -413,6 +492,7 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 	/**
 	 * Convert a raw image to JPEG using ImageMagick's convert command.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 * Works if ImageMagick has the dcraw/ufraw delegate installed.
 	 *
 	 * @param {string}   pAbsPath    - Raw file path
@@ -420,6 +500,70 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 	 * @param {Function} fCallback   - Callback(pError)
 	 */
 	_convertWithImageMagick(pAbsPath, pOutputPath, fCallback)
+	{
+		let tmpSelf = this;
+
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pAbsPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpOutputFilename = libPath.basename(pOutputPath);
+				let tmpCommand = `convert "{SourcePath}" -auto-orient -quality 92 "{OutputPath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 180000
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						try
+						{
+							let tmpDir = libPath.dirname(pOutputPath);
+							if (!libFs.existsSync(tmpDir))
+							{
+								libFs.mkdirSync(tmpDir, { recursive: true });
+							}
+							libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
+							tmpSelf.fable.log.info(`Raw conversion via Ultravisor (ImageMagick) for ${tmpRelPath}`);
+							return fCallback(null);
+						}
+						catch (pWriteError)
+						{
+							// Fall through to local
+						}
+					}
+
+					// Fall through to local processing
+					tmpSelf._convertWithImageMagickLocal(pAbsPath, pOutputPath, fCallback);
+				});
+				return;
+			}
+		}
+
+		return this._convertWithImageMagickLocal(pAbsPath, pOutputPath, fCallback);
+	}
+
+	/**
+	 * Convert a raw image to JPEG locally using ImageMagick's convert command.
+	 */
+	_convertWithImageMagickLocal(pAbsPath, pOutputPath, fCallback)
 	{
 		if (!this._capabilities.imagemagick)
 		{