retold-remote 0.0.13 → 0.0.17

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)
 		{
@@ -608,7 +752,11 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 
 		if (!this._sharp && !this._capabilities.imagemagick)
 		{
-			return fCallback(new Error('Neither sharp nor ImageMagick is available.'));
+			// Neither Sharp nor ImageMagick available locally — check for Ultravisor
+			if (!(this._dispatcher && this._dispatcher.isAvailable()))
+			{
+				return fCallback(new Error('Neither sharp nor ImageMagick is available.'));
+			}
 		}
 
 		let tmpMaxDim = pMaxDimension || this.options.DefaultMaxPreviewDimension;
@@ -682,11 +830,20 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 		{
 			this._doGeneratePreview(pAbsPath, pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, false, fCallback);
 		}
-		else
+		else if (this._capabilities.imagemagick)
 		{
 			// No Sharp available — use ImageMagick for standard images too
 			this._doGeneratePreviewWithImageMagick(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpManifestPath, tmpOutputPath, tmpStat, false, fCallback);
 		}
+		else if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			// No local tools available — dispatch to Ultravisor beacon
+			this._doGeneratePreviewWithDispatcher(pAbsPath, pRelPath, tmpMaxDim, tmpCacheKey, tmpOutputFilename, tmpCacheDir, tmpManifestPath, tmpOutputPath, tmpStat, tmpIsRaw, fCallback);
+		}
+		else
+		{
+			return fCallback(new Error('No preview tools available.'));
+		}
 	}
 
 	/**
@@ -943,6 +1100,101 @@ class RetoldRemoteImageService extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * Generate a preview by dispatching to an Ultravisor beacon.
+	 * Uses the MediaConversion capability (ImageResize) with a shell
+	 * convert fallback. The result is written to the cache directory.
+	 *
+	 * @param {string}   pInputPath      - Absolute path to the source image
+	 * @param {string}   pRelPath        - Relative path (for response/logging)
+	 * @param {number}   pMaxDim         - Max dimension
+	 * @param {string}   pCacheKey       - Cache key
+	 * @param {string}   pOutputFilename - Output filename
+	 * @param {string}   pCacheDir       - Cache directory path
+	 * @param {string}   pManifestPath   - Manifest file path
+	 * @param {string}   pOutputPath     - Output file path
+	 * @param {object}   pStat           - Original file stat
+	 * @param {boolean}  pIsRaw          - Whether this is a raw camera format
+	 * @param {Function} fCallback       - Callback(pError, pResult)
+	 */
+	_doGeneratePreviewWithDispatcher(pInputPath, pRelPath, pMaxDim, pCacheKey, pOutputFilename, pCacheDir, pManifestPath, pOutputPath, pStat, pIsRaw, fCallback)
+	{
+		let tmpSelf = this;
+		let tmpRelPath;
+
+		try
+		{
+			tmpRelPath = libPath.relative(this.contentPath, pInputPath);
+		}
+		catch (pErr)
+		{
+			return fCallback(new Error('Could not resolve relative path for dispatch.'));
+		}
+
+		if (!tmpRelPath || tmpRelPath.startsWith('..'))
+		{
+			return fCallback(new Error('File is outside content root.'));
+		}
+
+		this._dispatcher.dispatchConversion(
+		{
+			Action: 'ImageResize',
+			InputPath: tmpRelPath,
+			OutputFilename: pOutputFilename,
+			Width: pMaxDim,
+			Height: pMaxDim,
+			Format: 'jpeg',
+			Quality: this.options.PreviewQuality || 85,
+			AffinityKey: tmpRelPath,
+			TimeoutMs: 120000,
+			FallbackCommand: `convert "{SourcePath}"[0] -auto-orient -resize ${pMaxDim}x${pMaxDim} -quality ${this.options.PreviewQuality || 85} "{OutputPath}"`
+		},
+		(pDispatchError, pResult) =>
+		{
+			if (pDispatchError || !pResult || !pResult.OutputBuffer)
+			{
+				return fCallback(new Error('Ultravisor preview generation failed: ' + (pDispatchError ? pDispatchError.message : 'no output')));
+			}
+
+			try
+			{
+				libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
+			}
+			catch (pWriteError)
+			{
+				return fCallback(new Error('Failed to write preview output: ' + pWriteError.message));
+			}
+
+			let tmpResult =
+			{
+				Success: true,
+				SourcePath: pRelPath,
+				CacheKey: pCacheKey,
+				OutputFilename: pOutputFilename,
+				Width: pMaxDim,
+				Height: pMaxDim,
+				OrigWidth: 0,
+				OrigHeight: 0,
+				FileSize: pResult.OutputBuffer.length,
+				NeedsPreview: true,
+				IsRawFormat: pIsRaw,
+				GeneratedAt: new Date().toISOString()
+			};
+
+			try
+			{
+				libFs.writeFileSync(pManifestPath, JSON.stringify(tmpResult, null, '\t'));
+			}
+			catch (pWriteError)
+			{
+				tmpSelf.fable.log.warn(`Could not write preview manifest: ${pWriteError.message}`);
+			}
+
+			tmpSelf.fable.log.info(`Generated image preview (Ultravisor): ${pRelPath}`);
+			return fCallback(null, tmpResult);
+		});
+	}
+
 	// ---------------------------------------------------------------
 	// DZI tile generation
 	// ---------------------------------------------------------------

package/source/server/RetoldRemote-MediaService.js

@@ -52,9 +52,22 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 		this.thumbnailCache = new libThumbnailCache(this.fable);
 		this.pathRegistry = this.options.PathRegistry || null;
 
+		// Ultravisor dispatcher — set via setDispatcher()
+		this._dispatcher = null;
+
 		this.fable.log.info(`Media Service: capabilities = ${JSON.stringify(this.capabilities)}`);
 	}
 
+	/**
+	 * Set the Ultravisor dispatcher for offloading heavy processing.
+	 *
+	 * @param {object} pDispatcher - RetoldRemoteUltravisorDispatcher instance
+	 */
+	setDispatcher(pDispatcher)
+	{
+		this._dispatcher = pDispatcher;
+	}
+
 	/**
 	 * Sanitize a file path to prevent directory traversal.
 	 *
@@ -483,6 +496,53 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 			}
 		}
 
+		// Try Ultravisor dispatch as last resort for image thumbnails.
+		// Uses structured MediaConversion capability (orator-conversion beacon)
+		// with shell convert fallback if MediaConversion is not available.
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pFullPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpOutputFormat = pFormat === 'webp' ? 'webp' : 'jpeg';
+				let tmpOutputFilename = `thumbnail.${pFormat === 'webp' ? 'webp' : 'jpg'}`;
+
+				this._dispatcher.dispatchConversion(
+				{
+					Action: 'ImageResize',
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					Width: pWidth,
+					Height: pHeight,
+					Format: tmpOutputFormat,
+					Quality: 80,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 30000,
+					FallbackCommand: `convert "{SourcePath}" -thumbnail ${pWidth}x${pHeight} -auto-orient ${tmpOutputFormat}:"{OutputPath}"`
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						this.fable.log.info(`Image thumbnail generated via Ultravisor for ${tmpRelPath}`);
+						return fCallback(null, pResult.OutputBuffer);
+					}
+
+					return fCallback(new Error('No image thumbnail tools available.'));
+				});
+				return;
+			}
+		}
+
 		return fCallback(new Error('No image thumbnail tools available.'));
 	}
 
@@ -623,10 +683,11 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 	}
 
 	/**
-	 * Fallback raw thumbnail generation: ImageMagick → exifr embedded preview.
+	 * Fallback raw thumbnail generation: ImageMagick → Ultravisor MediaConversion → exifr embedded preview.
 	 */
 	_generateRawThumbnailFallback(pFullPath, pWidth, pHeight, pFormat, fCallback)
 	{
+		let tmpSelf = this;
 		let tmpOutputFormat = pFormat === 'webp' ? 'webp' : 'jpeg';
 
 		// Strategy 2: ImageMagick (may have dcraw delegate)
@@ -640,11 +701,67 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 			}
 			catch (pError)
 			{
-				// Fall through to exifr
+				// Fall through to Ultravisor
+			}
+		}
+
+		// Strategy 2.5: Try Ultravisor MediaConversion (beacon may have Sharp
+		// even if local machine does not have ImageMagick)
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pFullPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpOutputFilename = `thumbnail.${pFormat === 'webp' ? 'webp' : 'jpg'}`;
+
+				this._dispatcher.dispatchConversion(
+				{
+					Action: 'ImageResize',
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					Width: pWidth,
+					Height: pHeight,
+					Format: tmpOutputFormat,
+					Quality: 80,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 60000,
+					FallbackCommand: `convert "{SourcePath}" -thumbnail ${pWidth}x${pHeight} -auto-orient ${tmpOutputFormat}:"{OutputPath}"`
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						tmpSelf.fable.log.info(`Raw thumbnail generated via Ultravisor for ${tmpRelPath}`);
+						return fCallback(null, pResult.OutputBuffer);
+					}
+
+					// Fall through to exifr embedded preview
+					tmpSelf._generateRawThumbnailExifr(pFullPath, pWidth, pHeight, pFormat, fCallback);
+				});
+				return;
 			}
 		}
 
-		// Strategy 3: Extract embedded JPEG preview via exifr, resize with sharp
+		return this._generateRawThumbnailExifr(pFullPath, pWidth, pHeight, pFormat, fCallback);
+	}
+
+	/**
+	 * Strategy 3 for raw thumbnails: extract embedded JPEG preview via exifr,
+	 * resize with sharp. Most cameras embed a full-size JPEG preview in the raw file.
+	 */
+	_generateRawThumbnailExifr(pFullPath, pWidth, pHeight, pFormat, fCallback)
+	{
+		let tmpOutputFormat = pFormat === 'webp' ? 'webp' : 'jpeg';
+
 		if (this.capabilities.sharp)
 		{
 			let tmpSharp = this.capabilities.sharpModule;
@@ -743,8 +860,62 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 
 	/**
 	 * Generate a video thumbnail by extracting a frame with ffmpeg.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 */
 	_generateVideoThumbnail(pFullPath, pWidth, pHeight, pFormat, fCallback)
+	{
+		let tmpSelf = this;
+		let tmpOutputFormat = pFormat === 'webp' ? 'webp' : 'mjpeg';
+
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pFullPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				let tmpOutputFilename = `thumbnail.${pFormat === 'webp' ? 'webp' : 'jpg'}`;
+				let tmpCommand = `ffmpeg -ss 00:00:02 -i "{SourcePath}" -vframes 1 -vf "scale=${pWidth}:${pHeight}:force_original_aspect_ratio=decrease" -f ${tmpOutputFormat} "{OutputPath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 60000
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						tmpSelf.fable.log.info(`Video thumbnail generated via Ultravisor for ${tmpRelPath}`);
+						return fCallback(null, pResult.OutputBuffer);
+					}
+
+					// Fall through to local processing
+					tmpSelf.fable.log.info(`Ultravisor dispatch failed for video thumbnail, falling back to local: ${pDispatchError ? pDispatchError.message : 'no output'}`);
+					tmpSelf._generateVideoThumbnailLocal(pFullPath, pWidth, pHeight, pFormat, fCallback);
+				});
+				return;
+			}
+		}
+
+		return this._generateVideoThumbnailLocal(pFullPath, pWidth, pHeight, pFormat, fCallback);
+	}
+
+	/**
+	 * Generate a video thumbnail locally using ffmpeg.
+	 */
+	_generateVideoThumbnailLocal(pFullPath, pWidth, pHeight, pFormat, fCallback)
 	{
 		try
 		{
@@ -799,60 +970,126 @@ class RetoldRemoteMediaService extends libFableServiceProviderBase
 
 	/**
 	 * Run ffprobe and parse the output.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 */
 	_ffprobe(pFullPath, fCallback)
+	{
+		let tmpSelf = this;
+
+		// Try Ultravisor dispatch first
+		if (this._dispatcher && this._dispatcher.isAvailable())
+		{
+			let tmpRelPath;
+			try
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pFullPath);
+			}
+			catch (pErr)
+			{
+				tmpRelPath = null;
+			}
+
+			if (tmpRelPath && !tmpRelPath.startsWith('..'))
+			{
+				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) =>
+				{
+					if (!pDispatchError && pResult && pResult.Outputs && pResult.Outputs.StdOut)
+					{
+						try
+						{
+							let tmpData = JSON.parse(pResult.Outputs.StdOut);
+							let tmpParsed = tmpSelf._parseFfprobeData(tmpData);
+							tmpSelf.fable.log.info(`ffprobe via Ultravisor for ${tmpRelPath}`);
+							return fCallback(null, tmpParsed);
+						}
+						catch (pParseError)
+						{
+							// Fall through to local
+						}
+					}
+
+					// Fall through to local processing
+					tmpSelf._ffprobeLocal(pFullPath, fCallback);
+				});
+				return;
+			}
+		}
+
+		return this._ffprobeLocal(pFullPath, fCallback);
+	}
+
+	/**
+	 * Run ffprobe locally and parse the output.
+	 */
+	_ffprobeLocal(pFullPath, fCallback)
 	{
 		try
 		{
 			let tmpCmd = `ffprobe -v quiet -print_format json -show_format -show_streams "${pFullPath}"`;
 			let tmpOutput = libChildProcess.execSync(tmpCmd, { maxBuffer: 1024 * 1024, timeout: 10000 });
 			let tmpData = JSON.parse(tmpOutput.toString());
+			return fCallback(null, this._parseFfprobeData(tmpData));
+		}
+		catch (pError)
+		{
+			return fCallback(pError);
+		}
+	}
 
-			let tmpResult = {};
+	/**
+	 * Parse ffprobe JSON output into a normalized result object.
+	 */
+	_parseFfprobeData(pData)
+	{
+		let tmpResult = {};
 
-			if (tmpData.format)
-			{
-				tmpResult.duration = parseFloat(tmpData.format.duration) || null;
-				tmpResult.bitrate = parseInt(tmpData.format.bit_rate, 10) || null;
+		if (pData.format)
+		{
+			tmpResult.duration = parseFloat(pData.format.duration) || null;
+			tmpResult.bitrate = parseInt(pData.format.bit_rate, 10) || null;
 
-				// Extract format-level tags (ID3, Vorbis comments, etc.)
-				if (tmpData.format.tags)
+			// Extract format-level tags (ID3, Vorbis comments, etc.)
+			if (pData.format.tags)
+			{
+				tmpResult.tags = {};
+				let tmpTagKeys = Object.keys(pData.format.tags);
+				for (let t = 0; t < tmpTagKeys.length; t++)
 				{
-					tmpResult.tags = {};
-					let tmpTagKeys = Object.keys(tmpData.format.tags);
-					for (let t = 0; t < tmpTagKeys.length; t++)
-					{
-						tmpResult.tags[tmpTagKeys[t].toLowerCase()] = tmpData.format.tags[tmpTagKeys[t]];
-					}
+					tmpResult.tags[tmpTagKeys[t].toLowerCase()] = pData.format.tags[tmpTagKeys[t]];
 				}
 			}
+		}
 
-			// Find video stream for dimensions
-			if (tmpData.streams)
+		// Find video stream for dimensions
+		if (pData.streams)
+		{
+			for (let i = 0; i < pData.streams.length; i++)
 			{
-				for (let i = 0; i < tmpData.streams.length; i++)
+				let tmpStream = pData.streams[i];
+				if (tmpStream.codec_type === 'video')
 				{
-					let tmpStream = tmpData.streams[i];
-					if (tmpStream.codec_type === 'video')
-					{
-						tmpResult.width = tmpStream.width;
-						tmpResult.height = tmpStream.height;
-						tmpResult.codec = tmpStream.codec_name;
-						break;
-					}
-					if (tmpStream.codec_type === 'audio' && !tmpResult.codec)
-					{
-						tmpResult.codec = tmpStream.codec_name;
-					}
+					tmpResult.width = tmpStream.width;
+					tmpResult.height = tmpStream.height;
+					tmpResult.codec = tmpStream.codec_name;
+					break;
+				}
+				if (tmpStream.codec_type === 'audio' && !tmpResult.codec)
+				{
+					tmpResult.codec = tmpStream.codec_name;
 				}
 			}
-
-			return fCallback(null, tmpResult);
-		}
-		catch (pError)
-		{
-			return fCallback(pError);
 		}
+
+		return tmpResult;
 	}
 }