streamingVideoUpdater.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2025 MAK Technologies
** All rights reserved.
*******************************************************************************/
 
//! \file streamingVideoUpdater.h
//! \brief Component for managing video streaming and screen capture functionality
//! \ingroup vreCommonComponents
 
#pragma once
 
#include "vreCommonComponents/export.h"
#include "vrePlayerStation/playerComponent.h"
#include <vreMessageManager/vreMessage.h>
 
namespace makVre
{
class DtInitTable;
class DtPlayerStation;
} // namespace makVre
 
namespace makVrv
{
class DtChannel;
class DtChannelManager;
class DtVideoStream;
} // namespace makVrv
 
namespace makVre
{
namespace StreamingVideoUpdaterConfig
{
//! \ingroup RoleConfigParams
//! \defgroup StreamingVideoUpdaterRoleParams Streaming Video Updater Role Parameters
//! \roleInherits{PlayerComponentRoleParams}
//! Configuration Options for streaming video updater role.
//! @{
 
//! \vreRoleParam{defaultStreamChannel,string,"Channel 1",streamingVideoUpdater,Default channel name for video streaming output.}
constexpr const char* defaultStreamChannel = "defaultStreamChannel";
 
//! \vreRoleParam{defaultStreamLabel,string,"Main Window",streamingVideoUpdater,Default label for the video stream display.}
constexpr const char* defaultStreamLabel = "defaultStreamLabel";
 
//! \vreRoleParam{defaultStreamWindow,string,"Window 1",streamingVideoUpdater,Default window name for video streaming capture.}
constexpr const char* defaultStreamWindow = "defaultStreamWindow";
 
//! \vreRoleParam{readBuffer,string,"back",streamingVideoUpdater,Buffer selection for video capture (front or back buffer).}
constexpr const char* readBuffer = "readBuffer";
 
//! \vreRoleParam{streamName,string,"",streamingVideoUpdater,Name identifier for the video stream configuration.}
constexpr const char* streamName = "streamName";
 
//! \vreRoleParam{streamOutputFilenameOverride,string,"",streamingVideoUpdater,Override filename for stream output file generation.}
constexpr const char* streamOutputFilenameOverride = "streamOutputFilenameOverride";
 
//! \vreRoleParam{videoStreamAutoStart,bool,false,streamingVideoUpdater,Whether to automatically start video streaming when the component initializes.}
constexpr const char* videoStreamAutoStart = "videoStreamAutoStart";
 
//! @}
} // namespace StreamingVideoUpdaterConfig
}
 
//! \brief Type identifier for DtStreamingVideoUpdater component
constexpr const char* DtStreamingVideoUpdaterType = "DtStreamingVideoUpdater";
 
//! \brief Component for enabling video streaming and screen capture functionality
//!
//! DtStreamingVideoUpdater manages streaming video capture from specified channels
//! to external formats. It supports toggling streams on and off, selecting video sources,
//! capturing screenshots, and automatically starting streams when channels are created.
//! The component maintains state attributes for UI display and responds to messaging
//! system events for control.
class VRECOMMONCOMPONENTS_DLL DtStreamingVideoUpdater : public makVre::DtPlayerComponent
{
public:
   //! \brief Constructor for DtStreamingVideoUpdater
   //!
   //! Initializes the component with default stream settings
   DtStreamingVideoUpdater();
 
   //! \brief Virtual destructor for DtStreamingVideoUpdater
   virtual ~DtStreamingVideoUpdater() override;
 
   //! \brief Initializes the streaming video updater component
   //! \param player Pointer to the player station this component belongs to
   //! \param config Configuration table containing streaming settings
   //! \return True if initialization succeeded, false otherwise
   //!
   //! Reads configuration settings including stream name, read buffer type,
   //! default source channel, and auto-start options. Sets up message handlers
   //! and channel connection signals.
   virtual bool initialize(makVre::DtPlayerStation* player, makVre::DtInitTable& config) override;
   //! \brief Called every frame to update the streaming state
   //! \param dt Delta time since the last frame in seconds
   //!
   //! Attempts auto-start of video streaming if the retry flag is set
   virtual void tick(double dt) override;
   //! \brief Shuts down the streaming video updater component
   //!
   //! Stops active video streams and removes message handlers and channel signals
   virtual void shutdown() override;
 
   //! \brief Returns the type identifier for this component
   //! \return The type string for DtStreamingVideoUpdater
   virtual const char* type() const override;
 
   //! \brief Starts the configured video stream
   //!
   //! Configures and activates the video stream with the current settings,
   //! applying any filename overrides if specified
   virtual void startVideoStream();
 
   //! \brief Stops the active video stream
   //!
   //! Halts the current video stream and updates the stream state attribute
   virtual void stopVideoStream();
 
   //! \brief Toggles the video stream on or off
   //!
   //! Starts the stream if it's stopped or stops it if it's running
   virtual void toggleVideoStream();
 
   //! \brief Selects a new video source for streaming
   //! \param guiText Display name for the source in the UI
   //! \param window Name of the window containing the source channel
   //! \param channel Name of the channel to capture
   //!
   //! Updates the video stream to use a different source channel, handling
   //! stream restart if necessary and updating state attributes
   virtual void selectVideoSource(const std::string& guiText, const std::string& window, const std::string& channel);
 
protected:
   //! \brief Handles toggle video stream messages
   //! \param msg Toggle video stream message
   //! \return Message handling result indicating the message was handled
   //!
   //! Processes messages to toggle the video stream state
   virtual makVre::DtVreMessageResult handleToggleVideoStream(makVre::DtVreMessage* msg);
 
   //! \brief Handles video source selection messages
   //! \param msg Select video source message
   //! \return Message handling result indicating the message was handled
   //!
   //! Processes messages to change the video stream source channel
   virtual makVre::DtVreMessageResult handleSelectVideoStreamChannel(makVre::DtVreMessage* msg);
 
   //! \brief Slot called when a channel is added to the system
   //! \param mgr Pointer to the channel manager
   //! \param channel Pointer to the newly added channel
   //!
   //! Updates stream state when a new channel is added, enabling auto-start
   //! if the channel matches the current stream source
   virtual void slot_channelAdded(makVrv::DtChannelManager* mgr, makVrv::DtChannel* channel);
 
   //! \brief Slot called when a channel is about to be removed
   //! \param mgr Pointer to the channel manager
   //! \param channel Pointer to the channel being removed
   //!
   //! Stops streaming and updates state when the current source channel is removed
   virtual void slot_channelToBeRemoved(makVrv::DtChannelManager* mgr, makVrv::DtChannel* channel);
 
   //! \brief Checks if a specified channel exists
   //! \param windowName Name of the window
   //! \param channelName Name of the channel
   //! \return True if the channel exists, false otherwise
   //!
   //! Verifies whether a specified window and channel combination exists in the system
   virtual bool channelExists(const std::string& windowName, const std::string& channelName);
 
   //! \brief Handles screen capture messages
   //! \param msg Screen capture message
   //! \return Message handling result indicating the message was handled
   //!
   //! Processes messages to capture a screenshot of the current video source
   virtual makVre::DtVreMessageResult handleScreenCapture(makVre::DtVreMessage* msg);
 
   //! \brief Updates the output filename for a video stream
   //! \param stream Pointer to the video stream to update
   //!
   //! Modifies the stream's output filename based on the override setting,
   //! supporting timestamp substitution with [t] in the filename
   virtual void updateStreamFilename(makVrv::DtVideoStream* stream);
 
   //! \brief Name of the video stream configuration to use
   std::string myStreamName;
 
   //! \brief Buffer type to read for streaming (back, front, back_hardware, front_hardware)
   //!
   //! Determines whether to include graphical overlays in the stream
   std::string myReadBuffer;
 
   //! \brief Flag indicating whether to automatically start streaming when the channel appears
   bool myAutoStartStream;
 
   //! \brief Optional override for the stream output filename
   //!
   //! If not empty, replaces the filename in the stream configuration
   std::string myStreamOutputFilenameOverride;
 
   //! \brief Flag indicating to retry auto-starting the stream on the next tick
   bool myRetryAutoStart;
};