601 lines
21 KiB
C++
601 lines
21 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// The copyright to the contents herein is the property of Valve, L.L.C.
|
|
// The contents may be used and/or copied only with the written permission of
|
|
// Valve, L.L.C., or in accordance with the terms and conditions stipulated in
|
|
// the agreement/contract under which the contents have been supplied.
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef IVIDEOSERVICES_H
|
|
#define IVIDEOSERVICES_H
|
|
|
|
#if defined(WIN32)
|
|
#pragma once
|
|
#endif
|
|
|
|
#include <math.h>
|
|
#include "../appframework/IAppSystem.h"
|
|
#include "../tier0/platform.h"
|
|
|
|
#include <stdint.h>
|
|
#ifndef _STDINT_H
|
|
#define _STDINT_H
|
|
#endif
|
|
#ifndef _STDINT
|
|
#define _STDINT
|
|
#endif
|
|
|
|
#ifndef nullptr
|
|
#define nullptr(0)
|
|
#endif
|
|
#ifndef INT32_MAX
|
|
#define INT32_MAX (0x7FFFFFFF)
|
|
#endif
|
|
#ifndef UINT32_MAX
|
|
#define UINT32_MAX (0xFFFFFFFFu)
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Forward declarations
|
|
//-----------------------------------------------------------------------------
|
|
class IMaterial;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Types used when dealing with video services
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#define FILE_EXTENSION_ANY_MATCHING_VIDEO ".vid"
|
|
|
|
//#define ENABLE_EXTERNAL_ENCODER_LOGGING
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// enums used when dealing with video services
|
|
//-----------------------------------------------------------------------------
|
|
|
|
// ==============================================
|
|
// various general video system enumerations
|
|
|
|
namespace VideoResult {
|
|
enum EVideoResult_t {
|
|
SUCCESS = 0,
|
|
|
|
SYSTEM_NOT_AVAILABLE,
|
|
CODEC_NOT_AVAILABLE,
|
|
FEATURE_NOT_AVAILABLE,
|
|
|
|
UNKNOWN_OPERATION,
|
|
ILLEGAL_OPERATION,
|
|
OPERATION_NOT_SUPPORTED,
|
|
|
|
BAD_INPUT_PARAMETERS,
|
|
OPERATION_ALREADY_PERFORMED,
|
|
OPERATION_OUT_OF_SEQUENCE,
|
|
|
|
VIDEO_ERROR_OCCURED,
|
|
FILE_ERROR_OCCURED,
|
|
AUDIO_ERROR_OCCURED,
|
|
SYSTEM_ERROR_OCCURED,
|
|
INITIALIZATION_ERROR_OCCURED,
|
|
SHUTDOWN_ERROR_OCCURED,
|
|
|
|
MATERIAL_NOT_FOUND,
|
|
RECORDER_NOT_FOUND,
|
|
VIDEO_FILE_NOT_FOUND,
|
|
VIDEO_SYSTEM_NOT_FOUND,
|
|
};
|
|
};
|
|
typedef VideoResult::EVideoResult_t VideoResult_t;
|
|
|
|
namespace VideoSystem {
|
|
enum EVideoSystem_t {
|
|
ALL_VIDEO_SYSTEMS = -2,
|
|
DETERMINE_FROM_FILE_EXTENSION = -1,
|
|
NONE = 0,
|
|
|
|
BINK,
|
|
AVI,
|
|
WMV,
|
|
QUICKTIME,
|
|
WEBM,
|
|
|
|
VIDEO_SYSTEM_COUNT,
|
|
VIDEO_SYSTEM_FIRST = 1,
|
|
};
|
|
};
|
|
typedef VideoSystem::EVideoSystem_t VideoSystem_t;
|
|
|
|
namespace VideoSystemStatus {
|
|
enum EVideoSystemStatus_t {
|
|
OK = 0,
|
|
NOT_INSTALLED,
|
|
NOT_CURRENT_VERSION,
|
|
NOT_INITIALIZED,
|
|
INITIALIZATION_ERROR,
|
|
};
|
|
};
|
|
typedef VideoSystemStatus::EVideoSystemStatus_t VideoSystemStatus_t;
|
|
|
|
namespace VideoSystemFeature {
|
|
enum EVideoSystemFeature_t {
|
|
NO_FEATURES = 0x00000000,
|
|
PLAY_VIDEO_FILE_FULL_SCREEN = 0x00000001,
|
|
PLAY_VIDEO_FILE_IN_MATERIAL = 0x00000002,
|
|
ENCODE_VIDEO_TO_FILE = 0x00000004,
|
|
ENCODE_AUDIO_TO_FILE = 0x00000008,
|
|
|
|
FULL_PLAYBACK = PLAY_VIDEO_FILE_FULL_SCREEN | PLAY_VIDEO_FILE_IN_MATERIAL,
|
|
FULL_ENCODE = ENCODE_VIDEO_TO_FILE | ENCODE_AUDIO_TO_FILE,
|
|
ALL_VALID_FEATURES = FULL_PLAYBACK | FULL_ENCODE,
|
|
|
|
ESF_FORCE_UINT32 = UINT32_MAX,
|
|
};
|
|
|
|
DEFINE_ENUM_BITWISE_OPERATORS(EVideoSystemFeature_t);
|
|
}; // namespace VideoSystemFeature
|
|
typedef VideoSystemFeature::EVideoSystemFeature_t VideoSystemFeature_t;
|
|
|
|
namespace VideoSoundDeviceOperation {
|
|
enum EVideoSoundDeviceOperation_t {
|
|
SET_DIRECT_SOUND_DEVICE = 0, // Windows option
|
|
SET_MILES_SOUND_DEVICE, // Supported by RAD
|
|
HOOK_X_AUDIO, // Xbox Option
|
|
SET_SOUND_MANAGER_DEVICE, // OSX Option
|
|
SET_LIB_AUDIO_DEVICE, // PS3 Option
|
|
SET_SDL_SOUND_DEVICE, // SDL Audio
|
|
SET_SDL_PARAMS, // SDL Audio params
|
|
SDLMIXER_CALLBACK, // SDLMixer callback
|
|
|
|
OPERATION_COUNT
|
|
};
|
|
};
|
|
typedef VideoSoundDeviceOperation::EVideoSoundDeviceOperation_t
|
|
VideoSoundDeviceOperation_t;
|
|
|
|
// ==============================================
|
|
// Video Encoding related settings
|
|
|
|
namespace VideoEncodeCodec {
|
|
//
|
|
// NOTE: NEW CODECS SHOULD BE ADDED TO THE END OF THIS LIST.
|
|
//
|
|
enum EVideoEncodeCodec_t {
|
|
MPEG2_CODEC,
|
|
MPEG4_CODEC,
|
|
H261_CODEC,
|
|
H263_CODEC,
|
|
H264_CODEC,
|
|
MJPEG_A_CODEC,
|
|
MJPEG_B_CODEC,
|
|
SORENSON3_CODEC,
|
|
CINEPACK_CODEC,
|
|
WEBM_CODEC,
|
|
|
|
//
|
|
// NOTE: ADD NEW CODECS HERE.
|
|
//
|
|
|
|
CODEC_COUNT,
|
|
|
|
DEFAULT_CODEC = H264_CODEC,
|
|
};
|
|
}; // namespace VideoEncodeCodec
|
|
typedef VideoEncodeCodec::EVideoEncodeCodec_t VideoEncodeCodec_t;
|
|
|
|
namespace VideoEncodeQuality {
|
|
enum EVideoEncodeQuality_t { MIN_QUALITY = 0, MAX_QUALITY = 100 };
|
|
};
|
|
typedef VideoEncodeQuality::EVideoEncodeQuality_t VideoEncodeQuality_t;
|
|
|
|
namespace VideoEncodeSourceFormat {
|
|
enum EVideoEncodeSourceFormat_t // Image source format for frames to encoded
|
|
{ BGRA_32BIT = 0,
|
|
BGR_24BIT,
|
|
RGB_24BIT,
|
|
RGBA_32BIT,
|
|
|
|
VIDEO_FORMAT_COUNT,
|
|
VIDEO_FORMAT_FIRST = 0 };
|
|
};
|
|
typedef VideoEncodeSourceFormat::EVideoEncodeSourceFormat_t
|
|
VideoEncodeSourceFormat_t;
|
|
|
|
namespace VideoEncodeGamma {
|
|
enum EVideoEncodeGamma_t {
|
|
NO_GAMMA_ADJUST = 0,
|
|
PLATFORM_STANDARD_GAMMA,
|
|
GAMMA_1_8,
|
|
GAMMA_2_2,
|
|
GAMMA_2_5,
|
|
|
|
GAMMA_COUNT
|
|
};
|
|
};
|
|
typedef VideoEncodeGamma::EVideoEncodeGamma_t VideoEncodeGamma_t;
|
|
|
|
namespace VideoPlaybackGamma {
|
|
enum EVideoPlaybackGamma_t {
|
|
USE_GAMMA_CONVAR = -1,
|
|
NO_GAMMA_ADJUST = 0,
|
|
PLATFORM_DEFAULT_GAMMMA,
|
|
GAMMA_1_8,
|
|
GAMMA_2_2,
|
|
GAMMA_2_5,
|
|
|
|
GAMMA_COUNT
|
|
};
|
|
};
|
|
typedef VideoPlaybackGamma::EVideoPlaybackGamma_t VideoPlaybackGamma_t;
|
|
|
|
// ==============================================
|
|
// Video Playback related settings
|
|
|
|
namespace VideoPlaybackFlags {
|
|
enum EVideoPlaybackFlags_t // Options when playing a video file
|
|
{ NO_PLAYBACK_OPTIONS = 0x00000000,
|
|
|
|
// Full Screen Playback Options
|
|
FILL_WINDOW = 0x00000001, // force video fill entire window
|
|
LOCK_ASPECT_RATIO = 0x00000002, // preserve aspect ratio when scaling
|
|
INTEGRAL_SCALE = 0x00000004, // scale video only by integral amounts
|
|
CENTER_VIDEO_IN_WINDOW = 0x00000008, // center output video in window
|
|
|
|
FORCE_MIN_PLAY_TIME = 0x00000010, // play for a minimum amount of time before
|
|
// allowing skip or abort
|
|
|
|
ABORT_ON_SPACE = 0x00000100, // Keys to abort fullscreen playback on
|
|
ABORT_ON_ESC = 0x00000200,
|
|
ABORT_ON_RETURN = 0x00000400,
|
|
ABORT_ON_ANY_KEY = 0x00000700,
|
|
|
|
PAUSE_ON_SPACE = 0x00001000, // Keys to pause fullscreen playback on
|
|
PAUSE_ON_ESC = 0x00002000,
|
|
PAUSE_ON_RETURN = 0x00004000,
|
|
PAUSE_ON_ANY_KEY = 0x00007000,
|
|
|
|
LOOP_VIDEO = 0x00010000, // Full Screen and Video material
|
|
NO_AUDIO = 0x00020000,
|
|
PRELOAD_VIDEO = 0x00040000,
|
|
|
|
DONT_AUTO_START_VIDEO =
|
|
0x00100000, // Don't begin playing until told to do so.
|
|
TEXTURES_ACTUAL_SIZE =
|
|
0x00200000, // Try and use textures the same size as the video frame
|
|
|
|
VALID_FULLSCREEN_FLAGS = 0x0007771F, // Playback Flags that are valid for
|
|
// playing videos fullscreen
|
|
VALID_MATERIAL_FLAGS = 0x00370000, // Playback Flags that are valid for
|
|
// playing videos in a material
|
|
|
|
DEFAULT_MATERIAL_OPTIONS = NO_PLAYBACK_OPTIONS,
|
|
DEFAULT_FULLSCREEN_OPTIONS =
|
|
CENTER_VIDEO_IN_WINDOW | LOCK_ASPECT_RATIO | ABORT_ON_ANY_KEY,
|
|
|
|
EVPF_FORCE_UINT32 = UINT32_MAX,
|
|
};
|
|
|
|
DEFINE_ENUM_BITWISE_OPERATORS(EVideoPlaybackFlags_t);
|
|
} // namespace VideoPlaybackFlags
|
|
typedef VideoPlaybackFlags::EVideoPlaybackFlags_t VideoPlaybackFlags_t;
|
|
|
|
namespace AudioEncodeSourceFormat {
|
|
enum EAudioEncodeSourceFormat_t // Audio source format to encode
|
|
{ AUDIO_NONE = 0,
|
|
AUDIO_16BIT_PCMStereo,
|
|
|
|
AUDIO_FORMAT_COUNT };
|
|
};
|
|
typedef AudioEncodeSourceFormat::EAudioEncodeSourceFormat_t
|
|
AudioEncodeSourceFormat_t;
|
|
|
|
namespace AudioEncodeOptions {
|
|
enum EAudioEncodeOptions_t // Options to control audio encoding
|
|
{ NO_AUDIO_OPTIONS = 0x00000000,
|
|
|
|
USE_AUDIO_ENCODE_GROUP_SIZE = 0x00000001, // When adding to the video media,
|
|
// use fixed size sample groups
|
|
GROUP_SIZE_IS_VIDEO_FRAME =
|
|
0x00000002, // use a group size equal to one video frame in duration
|
|
LIMIT_AUDIO_TRACK_TO_VIDEO_DURATION =
|
|
0x00000004, // Don't let the Audio Track exceed the video track in
|
|
// duration
|
|
PAD_AUDIO_WITH_SILENCE = 0x00000008, // If Audio track duration is less than
|
|
// video track's, pad with silence
|
|
|
|
AEO_FORCE_UINT32 = UINT32_MAX,
|
|
};
|
|
DEFINE_ENUM_BITWISE_OPERATORS(EAudioEncodeOptions_t);
|
|
} // namespace AudioEncodeOptions
|
|
typedef AudioEncodeOptions::EAudioEncodeOptions_t AudioEncodeOptions_t;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Frame Rate Class
|
|
//-----------------------------------------------------------------------------
|
|
class VideoFrameRate_t {
|
|
public:
|
|
inline VideoFrameRate_t()
|
|
: m_TimeUnitsPerSecond(0), m_TimeUnitsPerFrame(1000){};
|
|
|
|
inline VideoFrameRate_t(int FPS, bool NTSC) { SetFPS(FPS, NTSC); }
|
|
inline explicit VideoFrameRate_t(float FPS) { SetFPS(FPS); };
|
|
|
|
inline VideoFrameRate_t &operator=(const VideoFrameRate_t &rhs) {
|
|
m_TimeUnitsPerSecond = rhs.m_TimeUnitsPerSecond;
|
|
m_TimeUnitsPerFrame = rhs.m_TimeUnitsPerFrame;
|
|
return *this;
|
|
}
|
|
inline VideoFrameRate_t(const VideoFrameRate_t &rhs) { *this = rhs; };
|
|
|
|
inline void SetRaw(int timeUnitsPerSecond, int TimeUnitsPerFrame) {
|
|
m_TimeUnitsPerSecond = timeUnitsPerSecond;
|
|
m_TimeUnitsPerFrame = TimeUnitsPerFrame;
|
|
}
|
|
|
|
inline float GetFPS() const {
|
|
return (float)m_TimeUnitsPerSecond / (float)m_TimeUnitsPerFrame;
|
|
}
|
|
inline int GetIntFPS() const {
|
|
return (int)((float)m_TimeUnitsPerSecond / (float)m_TimeUnitsPerFrame +
|
|
0.5f);
|
|
}
|
|
inline bool IsNTSCRate() const { return (m_TimeUnitsPerFrame == 1001); }
|
|
inline int GetUnitsPerSecond() const { return m_TimeUnitsPerSecond; }
|
|
inline int GetUnitsPerFrame() const { return m_TimeUnitsPerFrame; }
|
|
|
|
inline void SetFPS(int FPS, bool NTSC) {
|
|
m_TimeUnitsPerSecond = FPS * 1000;
|
|
m_TimeUnitsPerFrame = 1000 + (uint)NTSC;
|
|
}
|
|
inline void SetFPS(float FPS) {
|
|
m_TimeUnitsPerSecond = (uint)(FPS * 1000.0f);
|
|
m_TimeUnitsPerFrame = 1000;
|
|
}
|
|
|
|
static inline bool IsNTSC(float FPS) {
|
|
float diff = ceil(FPS) - FPS;
|
|
return (diff > 0.02f && diff < 0.05f);
|
|
}
|
|
|
|
inline void Clear() {
|
|
m_TimeUnitsPerSecond = 0;
|
|
m_TimeUnitsPerFrame = 1000;
|
|
}
|
|
inline bool IsValid() { return (m_TimeUnitsPerSecond != 0); }
|
|
|
|
private:
|
|
uint32 m_TimeUnitsPerSecond;
|
|
uint32 m_TimeUnitsPerFrame;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// specific interfaces returned and managed by video services
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Video Material interface - manages the playing back of a video to a
|
|
// a material / texture combo
|
|
//-----------------------------------------------------------------------------
|
|
class IVideoMaterial : public IBaseInterface {
|
|
public:
|
|
// Video information functions
|
|
virtual const char *
|
|
GetVideoFileName() = 0; // Gets the file name of the video this material is
|
|
// playing
|
|
virtual VideoResult_t
|
|
GetLastResult() = 0; // Gets detailed info on the last operation
|
|
|
|
virtual VideoFrameRate_t &
|
|
GetVideoFrameRate() = 0; // Returns the frame rate of the associated video
|
|
// in FPS
|
|
|
|
// Audio Functions
|
|
virtual bool HasAudio() = 0; // Query if the video has an audio track
|
|
|
|
virtual bool SetVolume(float fVolume) = 0; // Adjust the playback volume
|
|
virtual float GetVolume() = 0; // Query the current volume
|
|
|
|
virtual void SetMuted(
|
|
bool bMuteState) = 0; // Mute/UnMutes the audio playback
|
|
virtual bool IsMuted() = 0; // Query muted status
|
|
|
|
virtual VideoResult_t SoundDeviceCommand(
|
|
VideoSoundDeviceOperation_t operation, void *pDevice = nullptr,
|
|
void *pData =
|
|
nullptr) = 0; // Assign Sound Device for this Video Material
|
|
|
|
// Video playback state functions
|
|
virtual bool
|
|
IsVideoReadyToPlay() = 0; // Queries if the video material was initialized
|
|
// successfully and is ready for playback, but
|
|
// not playing or finished
|
|
virtual bool
|
|
IsVideoPlaying() = 0; // Is the video currently playing (and needs update
|
|
// calls, etc), or paused while playing?
|
|
virtual bool
|
|
IsNewFrameReady() = 0; // Do we have a new frame to get & display?
|
|
virtual bool
|
|
IsFinishedPlaying() = 0; // Have we reached the end of the movie
|
|
|
|
virtual bool StartVideo() = 0; // Starts the video playing
|
|
virtual bool StopVideo() = 0; // Terminates the video playing
|
|
|
|
virtual void SetLooping(
|
|
bool bLoopVideo) = 0; // Sets the video to loop (or not)
|
|
virtual bool IsLooping() = 0; // Queries if the video is looping
|
|
|
|
virtual void SetPaused(
|
|
bool bPauseState) = 0; // Pauses or Unpauses video playback
|
|
virtual bool IsPaused() = 0; // Queries if the video is paused
|
|
|
|
// Position in playback functions
|
|
virtual float GetVideoDuration() = 0; // Returns the duration of the
|
|
// associated video in seconds
|
|
virtual int GetFrameCount() = 0; // Returns the total number of (unique)
|
|
// frames in the video
|
|
|
|
virtual bool SetFrame(int FrameNum) = 0; // Sets the current frame # in the
|
|
// video to play next
|
|
virtual int GetCurrentFrame() = 0; // Gets the current frame # for the
|
|
// video playback, 0 based
|
|
|
|
virtual bool SetTime(float flTime) = 0; // Sets the video playback to
|
|
// specified time (in seconds)
|
|
virtual float
|
|
GetCurrentVideoTime() = 0; // Gets the current time in the video playback
|
|
|
|
// Update function
|
|
virtual bool Update() = 0; // Updates the video frame to reflect the time
|
|
// passed, true = new frame available
|
|
|
|
// Material / Texture Info functions
|
|
virtual IMaterial *
|
|
GetMaterial() = 0; // Gets the IMaterial associated with an video material
|
|
|
|
virtual void GetVideoTexCoordRange(
|
|
float *pMaxU,
|
|
float *
|
|
pMaxV) = 0; // Returns the max texture coordinate of the video
|
|
// portion of the material surface ( 0.0, 0.0 to U, V )
|
|
virtual void GetVideoImageSize(
|
|
int *pWidth, int *pHeight) = 0; // Returns the frame size of the Video
|
|
// Image Frame in pixels ( the stored
|
|
// in a subrect of the material itself)
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Video Recorder interface - manages the creation of a new video file
|
|
//-----------------------------------------------------------------------------
|
|
class IVideoRecorder : public IBaseInterface {
|
|
public:
|
|
virtual bool EstimateMovieFileSize(
|
|
size_t *pEstSize, int movieWidth, int movieHeight,
|
|
VideoFrameRate_t movieFps, float movieDuration,
|
|
VideoEncodeCodec_t theCodec, int videoQuality,
|
|
AudioEncodeSourceFormat_t srcAudioFormat =
|
|
AudioEncodeSourceFormat::AUDIO_NONE,
|
|
int audioSampleRate = 0) = 0;
|
|
|
|
virtual bool CreateNewMovieFile(const char *pFilename,
|
|
bool hasAudioTrack = false) = 0;
|
|
|
|
virtual bool SetMovieVideoParameters(
|
|
VideoEncodeCodec_t theCodec, int videoQuality, int movieFrameWidth,
|
|
int movieFrameHeight, VideoFrameRate_t movieFPS,
|
|
VideoEncodeGamma_t gamma = VideoEncodeGamma::NO_GAMMA_ADJUST) = 0;
|
|
virtual bool SetMovieSourceImageParameters(
|
|
VideoEncodeSourceFormat_t srcImageFormat, int imgWidth,
|
|
int imgHeight) = 0;
|
|
virtual bool SetMovieSourceAudioParameters(
|
|
AudioEncodeSourceFormat_t srcAudioFormat =
|
|
AudioEncodeSourceFormat::AUDIO_NONE,
|
|
int audioSampleRate = 0,
|
|
AudioEncodeOptions_t audioOptions =
|
|
AudioEncodeOptions::NO_AUDIO_OPTIONS,
|
|
int audioSampleGroupSize = 0) = 0;
|
|
|
|
virtual bool IsReadyToRecord() = 0;
|
|
virtual VideoResult_t GetLastResult() = 0;
|
|
|
|
virtual bool AppendVideoFrame(void *pFrameBuffer,
|
|
int nStrideAdjustBytes = 0) = 0;
|
|
virtual bool AppendAudioSamples(void *pSampleBuffer, size_t sampleSize) = 0;
|
|
|
|
virtual int GetFrameCount() = 0;
|
|
virtual int GetSampleCount() = 0;
|
|
|
|
virtual VideoFrameRate_t GetFPS() = 0;
|
|
virtual int GetSampleRate() = 0;
|
|
|
|
virtual bool AbortMovie() = 0;
|
|
virtual bool FinishMovie(bool SaveMovieToDisk = true) = 0;
|
|
|
|
#ifdef ENABLE_EXTERNAL_ENCODER_LOGGING
|
|
virtual bool LogMessage(const char *msg) = 0;
|
|
#endif
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Main VIDEO_SERVICES interface
|
|
//-----------------------------------------------------------------------------
|
|
#define VIDEO_SERVICES_INTERFACE_VERSION "IVideoServices002"
|
|
|
|
class IVideoServices : public IAppSystem {
|
|
public:
|
|
// Query the available video systems
|
|
virtual int GetAvailableVideoSystemCount() = 0;
|
|
virtual VideoSystem_t GetAvailableVideoSystem(int n) = 0;
|
|
|
|
virtual bool IsVideoSystemAvailable(VideoSystem_t videoSystem) = 0;
|
|
virtual VideoSystemStatus_t GetVideoSystemStatus(
|
|
VideoSystem_t videoSystem) = 0;
|
|
virtual VideoSystemFeature_t GetVideoSystemFeatures(
|
|
VideoSystem_t videoSystem) = 0;
|
|
virtual const char *GetVideoSystemName(VideoSystem_t videoSystem) = 0;
|
|
|
|
virtual VideoSystem_t FindNextSystemWithFeature(
|
|
VideoSystemFeature_t features,
|
|
VideoSystem_t startAfter = VideoSystem::NONE) = 0;
|
|
|
|
virtual VideoResult_t GetLastResult() = 0;
|
|
|
|
// deal with video file extensions and video system mappings
|
|
virtual int GetSupportedFileExtensionCount(VideoSystem_t videoSystem) = 0;
|
|
virtual const char *GetSupportedFileExtension(VideoSystem_t videoSystem,
|
|
int extNum = 0) = 0;
|
|
virtual VideoSystemFeature_t GetSupportedFileExtensionFeatures(
|
|
VideoSystem_t videoSystem, int extNum = 0) = 0;
|
|
|
|
virtual VideoSystem_t LocateVideoSystemForPlayingFile(
|
|
const char *pFileName,
|
|
VideoSystemFeature_t playMode =
|
|
VideoSystemFeature::PLAY_VIDEO_FILE_IN_MATERIAL) = 0;
|
|
virtual VideoResult_t LocatePlayableVideoFile(
|
|
const char *pSearchFileName, const char *pPathID,
|
|
VideoSystem_t *pPlaybackSystem, char *pPlaybackFileName,
|
|
int fileNameMaxLen,
|
|
VideoSystemFeature_t playMode = VideoSystemFeature::FULL_PLAYBACK) = 0;
|
|
|
|
// Create/destroy a video material
|
|
virtual IVideoMaterial *CreateVideoMaterial(
|
|
const char *pMaterialName, const char *pVideoFileName,
|
|
const char *pPathID = nullptr,
|
|
VideoPlaybackFlags_t playbackFlags =
|
|
VideoPlaybackFlags::DEFAULT_MATERIAL_OPTIONS,
|
|
VideoSystem_t videoSystem = VideoSystem::DETERMINE_FROM_FILE_EXTENSION,
|
|
bool PlayAlternateIfNotAvailable = true) = 0;
|
|
|
|
virtual VideoResult_t DestroyVideoMaterial(
|
|
IVideoMaterial *pVideoMaterial) = 0;
|
|
virtual int GetUniqueMaterialID() = 0;
|
|
|
|
// Create/destroy a video encoder
|
|
virtual VideoResult_t IsRecordCodecAvailable(VideoSystem_t videoSystem,
|
|
VideoEncodeCodec_t codec) = 0;
|
|
|
|
virtual IVideoRecorder *CreateVideoRecorder(VideoSystem_t videoSystem) = 0;
|
|
virtual VideoResult_t DestroyVideoRecorder(
|
|
IVideoRecorder *pVideoRecorder) = 0;
|
|
|
|
// Plays a given video file until it completes or the user presses ESC,
|
|
// SPACE, or ENTER
|
|
virtual VideoResult_t PlayVideoFileFullScreen(
|
|
const char *pFileName, const char *pPathID, void *mainWindow,
|
|
int windowWidth, int windowHeight, int desktopWidth, int desktopHeight,
|
|
bool windowed, float forcedMinTime,
|
|
VideoPlaybackFlags_t playbackFlags =
|
|
VideoPlaybackFlags::DEFAULT_FULLSCREEN_OPTIONS,
|
|
VideoSystem_t videoSystem = VideoSystem::DETERMINE_FROM_FILE_EXTENSION,
|
|
bool PlayAlternateIfNotAvailable = true) = 0;
|
|
|
|
// Sets the sound devices that the video will decode to
|
|
virtual VideoResult_t SoundDeviceCommand(
|
|
VideoSoundDeviceOperation_t operation, void *pDevice = nullptr,
|
|
void *pData = nullptr,
|
|
VideoSystem_t videoSystem = VideoSystem::ALL_VIDEO_SYSTEMS) = 0;
|
|
|
|
// Get the (localized) name of a codec as a string
|
|
virtual const wchar_t *GetCodecName(VideoEncodeCodec_t nCodec) = 0;
|
|
};
|
|
|
|
#endif // IVIDEOSERVICES_H
|