retold-remote 0.0.13 → 0.0.17

package/source/server/RetoldRemote-VideoFrameService.js

@@ -51,6 +51,9 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 
 		this.contentPath = libPath.resolve(this.options.ContentPath);
 
+		// Ultravisor dispatcher — set via setDispatcher()
+		this._dispatcher = null;
+
 		// Apply explorer state persistence mixin (initializeState,
 		// _buildExplorerStateKey, loadExplorerState, saveExplorerState)
 		libExplorerStateMixin.apply(this, EXPLORER_STATE_SOURCE, 'video-explorer');
@@ -62,6 +65,16 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 		this.fable.log.info('Video Frame Service: frames in ParimeBinaryStorage, state in Bibliograph');
 	}
 
+	/**
+	 * Set the Ultravisor dispatcher for offloading heavy processing.
+	 *
+	 * @param {object} pDispatcher - RetoldRemoteUltravisorDispatcher instance
+	 */
+	setDispatcher(pDispatcher)
+	{
+		this._dispatcher = pDispatcher;
+	}
+
 	/**
 	 * Install video-specific explorer state methods that need read-merge-write
 	 * behavior (merging custom frames, preserving selection across saves).
@@ -218,43 +231,76 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 
 	/**
 	 * Probe a video file with ffprobe to get its duration.
+	 * Tries Ultravisor dispatch first, falls back to local execution.
 	 *
 	 * @param {string} pAbsPath - Absolute path to the video
 	 * @param {Function} fCallback - Callback(pError, { duration, width, height, codec })
 	 */
 	_probeVideo(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
+			{
+				tmpRelPath = libPath.relative(this.contentPath, pAbsPath);
+			}
+			catch (pErr)
 			{
-				tmpResult.duration = parseFloat(tmpData.format.duration) || null;
-				tmpResult.bitrate = parseInt(tmpData.format.bit_rate, 10) || null;
-				tmpResult.size = parseInt(tmpData.format.size, 10) || null;
+				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 === 'video')
+					if (!pDispatchError && pResult && pResult.Outputs && pResult.Outputs.StdOut)
 					{
-						tmpResult.width = tmpStream.width;
-						tmpResult.height = tmpStream.height;
-						tmpResult.codec = tmpStream.codec_name;
-						break;
+						try
+						{
+							let tmpData = JSON.parse(pResult.Outputs.StdOut);
+							let tmpParsed = tmpSelf._parseProbeData(tmpData);
+							tmpSelf.fable.log.info(`ffprobe via Ultravisor for ${tmpRelPath}`);
+							return fCallback(null, tmpParsed);
+						}
+						catch (pParseError)
+						{
+							// Fall through to local
+						}
 					}
-				}
+
+					tmpSelf._probeVideoLocal(pAbsPath, fCallback);
+				});
+				return;
 			}
+		}
+
+		return this._probeVideoLocal(pAbsPath, fCallback);
+	}
 
-			return fCallback(null, tmpResult);
+	/**
+	 * Probe a video file locally with ffprobe.
+	 */
+	_probeVideoLocal(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._parseProbeData(tmpData));
 		}
 		catch (pError)
 		{
@@ -262,8 +308,41 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * Parse ffprobe JSON output into a normalized result object.
+	 */
+	_parseProbeData(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;
+		}
+
+		if (pData.streams)
+		{
+			for (let i = 0; i < pData.streams.length; i++)
+			{
+				let tmpStream = pData.streams[i];
+				if (tmpStream.codec_type === 'video')
+				{
+					tmpResult.width = tmpStream.width;
+					tmpResult.height = tmpStream.height;
+					tmpResult.codec = tmpStream.codec_name;
+					break;
+				}
+			}
+		}
+
+		return tmpResult;
+	}
+
 	/**
 	 * Extract a single frame from a video at a given timestamp.
+	 * Synchronous version for backward compatibility.
 	 *
 	 * @param {string} pAbsPath - Absolute path to the video
 	 * @param {number} pTimestamp - Timestamp in seconds
@@ -274,17 +353,18 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 	 * @returns {boolean} True if extraction succeeded
 	 */
 	_extractFrame(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat)
+	{
+		return this._extractFrameLocal(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat);
+	}
+
+	/**
+	 * Extract a single frame locally using ffmpeg (synchronous).
+	 */
+	_extractFrameLocal(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat)
 	{
 		try
 		{
-			// Format timestamp as HH:MM:SS.mmm for ffmpeg
-			let tmpHours = Math.floor(pTimestamp / 3600);
-			let tmpMinutes = Math.floor((pTimestamp % 3600) / 60);
-			let tmpSeconds = pTimestamp % 60;
-			let tmpTimeStr = `${String(tmpHours).padStart(2, '0')}:${String(tmpMinutes).padStart(2, '0')}:${tmpSeconds.toFixed(3).padStart(6, '0')}`;
-
-			let tmpCodec = (pFormat === 'png') ? 'png' : (pFormat === 'webp') ? 'webp' : 'mjpeg';
-
+			let tmpTimeStr = this._formatFfmpegTimestamp(pTimestamp);
 			let tmpMuxer = (pFormat === 'png') ? 'image2' : (pFormat === 'webp') ? 'webp' : 'mjpeg';
 			let tmpCmd = `ffmpeg -ss ${tmpTimeStr} -i "${pAbsPath}" -vframes 1 -vf "scale=${pWidth}:${pHeight}:force_original_aspect_ratio=decrease" -f ${tmpMuxer} -y "${pOutputPath}"`;
 			libChildProcess.execSync(tmpCmd, { stdio: 'ignore', timeout: 30000 });
@@ -297,6 +377,97 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 		}
 	}
 
+	/**
+	 * Extract a single frame asynchronously, trying Ultravisor dispatch first.
+	 *
+	 * @param {string} pAbsPath - Absolute path to the video
+	 * @param {number} pTimestamp - Timestamp in seconds
+	 * @param {string} pOutputPath - Absolute path for the output image
+	 * @param {number} pWidth - Target width
+	 * @param {number} pHeight - Target height
+	 * @param {string} pFormat - Output format (jpg, png, webp)
+	 * @param {Function} fCallback - Callback(pError, pSuccess)
+	 */
+	_extractFrameAsync(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat, 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 tmpTimeStr = this._formatFfmpegTimestamp(pTimestamp);
+				let tmpMuxer = (pFormat === 'png') ? 'image2' : (pFormat === 'webp') ? 'webp' : 'mjpeg';
+				let tmpOutputFilename = libPath.basename(pOutputPath);
+				let tmpCommand = `ffmpeg -ss ${tmpTimeStr} -i "{SourcePath}" -vframes 1 -vf "scale=${pWidth}:${pHeight}:force_original_aspect_ratio=decrease" -f ${tmpMuxer} -y "{OutputPath}"`;
+
+				this._dispatcher.dispatchMediaCommand(
+				{
+					Command: tmpCommand,
+					InputPath: tmpRelPath,
+					OutputFilename: tmpOutputFilename,
+					AffinityKey: tmpRelPath,
+					TimeoutMs: 60000
+				},
+				(pDispatchError, pResult) =>
+				{
+					if (!pDispatchError && pResult && pResult.OutputBuffer)
+					{
+						try
+						{
+							// Write the output buffer to the expected path
+							let tmpDir = libPath.dirname(pOutputPath);
+							if (!libFs.existsSync(tmpDir))
+							{
+								libFs.mkdirSync(tmpDir, { recursive: true });
+							}
+							libFs.writeFileSync(pOutputPath, pResult.OutputBuffer);
+							return fCallback(null, true);
+						}
+						catch (pWriteError)
+						{
+							// Fall through to local
+						}
+					}
+
+					// Fall through to local processing
+					let tmpSuccess = tmpSelf._extractFrameLocal(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat);
+					return fCallback(null, tmpSuccess);
+				});
+				return;
+			}
+		}
+
+		// Local processing
+		let tmpSuccess = this._extractFrameLocal(pAbsPath, pTimestamp, pOutputPath, pWidth, pHeight, pFormat);
+		return fCallback(null, tmpSuccess);
+	}
+
+	/**
+	 * Format a timestamp in seconds to ffmpeg's HH:MM:SS.mmm format.
+	 *
+	 * @param {number} pTimestamp - Timestamp in seconds
+	 * @returns {string}
+	 */
+	_formatFfmpegTimestamp(pTimestamp)
+	{
+		let tmpHours = Math.floor(pTimestamp / 3600);
+		let tmpMinutes = Math.floor((pTimestamp % 3600) / 60);
+		let tmpSeconds = pTimestamp % 60;
+		return `${String(tmpHours).padStart(2, '0')}:${String(tmpMinutes).padStart(2, '0')}:${tmpSeconds.toFixed(3).padStart(6, '0')}`;
+	}
+
 	/**
 	 * Format a timestamp in seconds to a human-readable string.
 	 *
@@ -443,66 +614,127 @@ class RetoldRemoteVideoFrameService extends libFableServiceProviderBase
 
 				tmpSelf.fable.log.info(`Extracting ${tmpTimestamps.length} frames from ${pRelPath} (${tmpDuration.toFixed(1)}s)`);
 
-				for (let i = 0; i < tmpTimestamps.length; i++)
+				// Use async serial extraction when dispatcher is available,
+				// otherwise use synchronous loop for backward compatibility
+				let tmpUseAsync = !!(tmpSelf._dispatcher && tmpSelf._dispatcher.isAvailable());
+
+				let _finishExtraction = () =>
 				{
-					let tmpTimestamp = tmpTimestamps[i];
-					let tmpFrameFilename = `frame_${String(i).padStart(4, '0')}.${tmpFormat}`;
-					let tmpFramePath = libPath.join(tmpCacheDir, tmpFrameFilename);
+					if (tmpExtractedCount === 0)
+					{
+						return fCallback(new Error('Failed to extract any frames from the video.'));
+					}
 
-					let tmpSuccess = tmpSelf._extractFrame(
-						pAbsPath, tmpTimestamp, tmpFramePath, tmpWidth, tmpHeight, tmpFormat);
+					let tmpResult =
+					{
+						Success: true,
+						Path: pRelPath,
+						Duration: tmpDuration,
+						DurationFormatted: tmpSelf._formatTimestamp(tmpDuration),
+						VideoWidth: pVideoInfo.width,
+						VideoHeight: pVideoInfo.height,
+						Codec: pVideoInfo.codec,
+						Bitrate: pVideoInfo.bitrate,
+						FileSize: pVideoInfo.size || tmpStat.size,
+						FrameCount: tmpExtractedCount,
+						FrameWidth: tmpWidth,
+						FrameHeight: tmpHeight,
+						FrameFormat: tmpFormat,
+						CacheKey: libPath.basename(tmpCacheDir),
+						Frames: tmpFrames
+					};
 
-					if (tmpSuccess)
+					// Write manifest to cache
+					try
 					{
-						let tmpFrameStat = libFs.statSync(tmpFramePath);
-						tmpFrames.push(
-						{
-							Index: i,
-							Timestamp: tmpTimestamp,
-							TimestampFormatted: tmpSelf._formatTimestamp(tmpTimestamp),
-							Filename: tmpFrameFilename,
-							Size: tmpFrameStat.size
-						});
-						tmpExtractedCount++;
+						libFs.writeFileSync(tmpManifestPath, JSON.stringify(tmpResult, null, '\t'));
+					}
+					catch (pWriteError)
+					{
+						tmpSelf.fable.log.warn(`Could not write frame manifest: ${pWriteError.message}`);
 					}
-				}
-
-				if (tmpExtractedCount === 0)
-				{
-					return fCallback(new Error('Failed to extract any frames from the video.'));
-				}
 
-				let tmpResult =
-				{
-					Success: true,
-					Path: pRelPath,
-					Duration: tmpDuration,
-					DurationFormatted: tmpSelf._formatTimestamp(tmpDuration),
-					VideoWidth: pVideoInfo.width,
-					VideoHeight: pVideoInfo.height,
-					Codec: pVideoInfo.codec,
-					Bitrate: pVideoInfo.bitrate,
-					FileSize: pVideoInfo.size || tmpStat.size,
-					FrameCount: tmpExtractedCount,
-					FrameWidth: tmpWidth,
-					FrameHeight: tmpHeight,
-					FrameFormat: tmpFormat,
-					CacheKey: libPath.basename(tmpCacheDir),
-					Frames: tmpFrames
+					tmpSelf.fable.log.info(`Extracted ${tmpExtractedCount} frames for ${pRelPath}`);
+					return fCallback(null, tmpResult);
 				};
 
-				// Write manifest to cache
-				try
+				if (tmpUseAsync)
 				{
-					libFs.writeFileSync(tmpManifestPath, JSON.stringify(tmpResult, null, '\t'));
+					// Serial async extraction
+					let tmpFrameIndex = 0;
+
+					let _extractNext = () =>
+					{
+						if (tmpFrameIndex >= tmpTimestamps.length)
+						{
+							return _finishExtraction();
+						}
+
+						let tmpI = tmpFrameIndex;
+						let tmpTimestamp = tmpTimestamps[tmpI];
+						let tmpFrameFilename = `frame_${String(tmpI).padStart(4, '0')}.${tmpFormat}`;
+						let tmpFramePath = libPath.join(tmpCacheDir, tmpFrameFilename);
+						tmpFrameIndex++;
+
+						tmpSelf._extractFrameAsync(
+							pAbsPath, tmpTimestamp, tmpFramePath, tmpWidth, tmpHeight, tmpFormat,
+							(pExtractError, pSuccess) =>
+							{
+								if (pSuccess)
+								{
+									try
+									{
+										let tmpFrameStat = libFs.statSync(tmpFramePath);
+										tmpFrames.push(
+										{
+											Index: tmpI,
+											Timestamp: tmpTimestamp,
+											TimestampFormatted: tmpSelf._formatTimestamp(tmpTimestamp),
+											Filename: tmpFrameFilename,
+											Size: tmpFrameStat.size
+										});
+										tmpExtractedCount++;
+									}
+									catch (pStatErr)
+									{
+										// Frame file disappeared — skip
+									}
+								}
+								_extractNext();
+							});
+					};
+
+					_extractNext();
 				}
-				catch (pWriteError)
+				else
 				{
-					tmpSelf.fable.log.warn(`Could not write frame manifest: ${pWriteError.message}`);
-				}
+					// Synchronous extraction (original behavior)
+					for (let i = 0; i < tmpTimestamps.length; i++)
+					{
+						let tmpTimestamp = tmpTimestamps[i];
+						let tmpFrameFilename = `frame_${String(i).padStart(4, '0')}.${tmpFormat}`;
+						let tmpFramePath = libPath.join(tmpCacheDir, tmpFrameFilename);
+
+						let tmpSuccess = tmpSelf._extractFrame(
+							pAbsPath, tmpTimestamp, tmpFramePath, tmpWidth, tmpHeight, tmpFormat);
+
+						if (tmpSuccess)
+						{
+							let tmpFrameStat = libFs.statSync(tmpFramePath);
+							tmpFrames.push(
+							{
+								Index: i,
+								Timestamp: tmpTimestamp,
+								TimestampFormatted: tmpSelf._formatTimestamp(tmpTimestamp),
+								Filename: tmpFrameFilename,
+								Size: tmpFrameStat.size
+							});
+							tmpExtractedCount++;
+						}
+					}
 
-				tmpSelf.fable.log.info(`Extracted ${tmpExtractedCount} frames for ${pRelPath}`);
-				return fCallback(null, tmpResult);
+					_finishExtraction();
+				}
 			});
 	}
 

package/source/views/PictView-Remote-AudioExplorer.js

@@ -59,6 +59,8 @@ class RetoldRemoteAudioExplorerView extends libPictView
 	{
 		let tmpRemote = this.pict.AppData.RetoldRemote;
 		tmpRemote.ActiveMode = 'audio-explorer';
+		tmpRemote.CurrentViewerFile = pFilePath;
+		tmpRemote.CurrentViewerMediaType = 'audio';
 		this._currentPath = pFilePath;
 		this._waveformData = null;
 		this._peaks = [];
@@ -102,8 +104,12 @@ class RetoldRemoteAudioExplorerView extends libPictView
 
 		// Header
 		tmpHTML += '<div class="retold-remote-aex-header">';
-		tmpHTML += '<button class="retold-remote-aex-nav-btn" onclick="pict.views[\'RetoldRemote-AudioExplorer\'].goBack()" title="Back to audio (Esc)">&larr; Back</button>';
+		tmpHTML += '<button class="retold-remote-aex-nav-btn" onclick="pict.views[\'RetoldRemote-AudioExplorer\'].goBack()" title="Back (Esc)">&larr; Back</button>';
 		tmpHTML += '<div class="retold-remote-aex-title">Audio Explorer &mdash; ' + this.pict.providers['RetoldRemote-FormattingUtilities'].escapeHTML(tmpFileName) + '</div>';
+		tmpHTML += '<div class="retold-remote-aex-actions">';
+		tmpHTML += '<button class="retold-remote-aex-action-btn" onclick="pict.views[\'RetoldRemote-AudioExplorer\'].playInBrowser()" title="Play in browser">&#9654; Play</button>';
+		tmpHTML += '<button class="retold-remote-aex-action-btn" onclick="pict.providers[\'RetoldRemote-GalleryNavigation\']._streamWithVLC()" title="Stream with VLC (v)">&#9654; VLC</button>';
+		tmpHTML += '</div>';
 		tmpHTML += '</div>';
 
 		// Info bar (populated after waveform loads)
@@ -971,7 +977,7 @@ class RetoldRemoteAudioExplorerView extends libPictView
 	}
 
 	/**
-	 * Navigate back to the audio player viewer.
+	 * Navigate back to the gallery / file listing.
 	 */
 	goBack()
 	{
@@ -982,21 +988,29 @@ class RetoldRemoteAudioExplorerView extends libPictView
 			this._resizeObserver = null;
 		}
 
-		if (this._currentPath)
+		let tmpNav = this.pict.providers['RetoldRemote-GalleryNavigation'];
+		if (tmpNav)
 		{
-			let tmpViewer = this.pict.views['RetoldRemote-MediaViewer'];
-			if (tmpViewer)
-			{
-				tmpViewer.showMedia(this._currentPath, 'audio');
-			}
+			tmpNav.closeViewer();
 		}
-		else
+	}
+
+	/**
+	 * Leave the audio explorer and play the file in the browser viewer.
+	 */
+	playInBrowser()
+	{
+		// Clean up resize observer
+		if (this._resizeObserver)
 		{
-			let tmpNav = this.pict.providers['RetoldRemote-GalleryNavigation'];
-			if (tmpNav)
-			{
-				tmpNav.closeViewer();
-			}
+			this._resizeObserver.disconnect();
+			this._resizeObserver = null;
+		}
+
+		let tmpViewer = this.pict.views['RetoldRemote-MediaViewer'];
+		if (tmpViewer)
+		{
+			tmpViewer.showMedia(this._currentPath, 'audio');
 		}
 	}
 

package/source/views/PictView-Remote-ImageExplorer.js

@@ -34,6 +34,8 @@ class RetoldRemoteImageExplorerView extends libPictView
 	{
 		let tmpRemote = this.pict.AppData.RetoldRemote;
 		tmpRemote.ActiveMode = 'image-explorer';
+		tmpRemote.CurrentViewerFile = pFilePath;
+		tmpRemote.CurrentViewerMediaType = 'image';
 		this._currentPath = pFilePath;
 		this._dziData = null;
 		this._loading = false;
@@ -86,6 +88,9 @@ class RetoldRemoteImageExplorerView extends libPictView
 		tmpHTML += '<div class="retold-remote-iex-header">';
 		tmpHTML += '<button class="retold-remote-iex-nav-btn" onclick="pict.views[\'RetoldRemote-ImageExplorer\'].goBack()" title="Back (Esc)">&larr; Back</button>';
 		tmpHTML += '<div class="retold-remote-iex-title">Image Explorer &mdash; ' + tmpFmt.escapeHTML(tmpFileName) + '</div>';
+		tmpHTML += '<div class="retold-remote-iex-actions">';
+		tmpHTML += '<button class="retold-remote-iex-action-btn" onclick="pict.views[\'RetoldRemote-ImageExplorer\'].viewInBrowser()" title="View in standard viewer">&#128444; View</button>';
+		tmpHTML += '</div>';
 		tmpHTML += '</div>';
 
 		// Info bar
@@ -732,7 +737,7 @@ class RetoldRemoteImageExplorerView extends libPictView
 	}
 
 	/**
-	 * Navigate back to the image viewer.
+	 * Navigate back to the gallery / file listing.
 	 */
 	goBack()
 	{
@@ -750,21 +755,36 @@ class RetoldRemoteImageExplorerView extends libPictView
 			this._osdViewer = null;
 		}
 
-		if (this._currentPath)
+		let tmpNav = this.pict.providers['RetoldRemote-GalleryNavigation'];
+		if (tmpNav)
 		{
-			let tmpViewer = this.pict.views['RetoldRemote-MediaViewer'];
-			if (tmpViewer)
-			{
-				tmpViewer.showMedia(this._currentPath, 'image');
-			}
+			tmpNav.closeViewer();
 		}
-		else
+	}
+
+	/**
+	 * Leave the image explorer and view the image in the standard viewer.
+	 */
+	viewInBrowser()
+	{
+		// Destroy the OSD viewer
+		if (this._osdViewer)
 		{
-			let tmpNav = this.pict.providers['RetoldRemote-GalleryNavigation'];
-			if (tmpNav)
+			try
+			{
+				this._osdViewer.destroy();
+			}
+			catch (pErr)
 			{
-				tmpNav.closeViewer();
+				// ignore
 			}
+			this._osdViewer = null;
+		}
+
+		let tmpViewer = this.pict.views['RetoldRemote-MediaViewer'];
+		if (tmpViewer)
+		{
+			tmpViewer.showMedia(this._currentPath, 'image');
 		}
 	}