static void g_Player_PlayBackStopped(g_Player.MediaType type, int stoptime, string filename)
{
if (type == g_Player.MediaType.TV)
{
SetNewChannel(-1);
}
}
public IPlayer Create(string filename, g_Player.MediaType type)
{
// hack to get around the MP 1.3 Alpha bug with non http URLs
/*if (filename != PreparedUrl)
throw new OnlineVideosException("Cannot play a different url than this PlayerFactory was created with!");
else*/
return PreparedPlayer;
}
public IPlayer Create(string filename, g_Player.MediaType type)
{
/*
if (filename != PreparedUrl)
throw new OnlineVideosException("Cannot play a different url than this PlayerFactory was created with!");
else
*/
return PreparedPlayer;
}
/// <summary>
/// Handles the g_Player.PlayBackEnded event
/// </summary>
/// <param name="type"></param>
/// <param name="s"></param>
public void OnVideoEnded(g_Player.MediaType type, string s)
{
// do not handle e.g. visualization window, last.fm player, etc
if (type == g_Player.MediaType.Music)
{
return;
}
if (currentSettings.verboseLog)
{
Log.Debug("ViewModeSwitcher: On Video Ended");
}
LastSwitchedAspectRatio = 0f;
isPlaying = false;
}
private void OnPlayBackStarted(g_Player.MediaType type, string filename)
{
try
{
if (type == g_Player.MediaType.Music || Util.Utils.IsLastFMStream(filename))
{
Thread stateThread = new Thread(new ParameterizedThreadStart(PlaybackStartedThread));
stateThread.IsBackground = true;
stateThread.Name = "Scrobbler event";
stateThread.Start((object)filename);
Thread LoadThread = new Thread(new ThreadStart(OnSongLoadedThread));
LoadThread.IsBackground = true;
LoadThread.Name = "Scrobbler loader";
LoadThread.Start();
}
}
catch (Exception ex)
{
Log.Error("Audioscrobbler plugin: Error creating threads on playback start - {0}", ex.Message);
}
}
private void OnPlayBackStarted(g_Player.MediaType type, string filename)
{
// when we are watching TV and suddenly decides to watch a audio/video etc., we want to make sure that the TV is stopped on server.
GUIWindow currentWindow = GUIWindowManager.GetWindow(GUIWindowManager.ActiveWindow);
if (type == g_Player.MediaType.Radio || type == g_Player.MediaType.TV)
{
UpdateGUIonPlaybackStateChange(true);
}
if (currentWindow.IsTv && type == g_Player.MediaType.TV)
{
return;
}
if (GUIWindowManager.ActiveWindow == (int)Window.WINDOW_RADIO || GUIWindowManager.ActiveWindow == (int)Window.WINDOW_RADIO_GUIDE)
{
return;
}
//gemx: fix for 0001181: Videoplayback does not work if tvservice.exe is not running
bool isTS = (Card != null && Card.IsTimeShifting);
if (Connected && isTS)
{
Card.StopTimeShifting();
}
}
public IPlayer Create(string fileName, g_Player.MediaType type)
{
IPlayer newPlayer = null;
try
{
g_Player.MediaType? paramType = type as g_Player.MediaType?;
if (paramType.HasValue)
{
newPlayer = Create(fileName, paramType);
}
else
{
newPlayer = Create(fileName, null);
}
}
catch (Exception ex)
{
Log.Error("PlayerFactory: Error creating player instance - {0}", ex.Message);
newPlayer = Create(fileName, null);
}
return newPlayer;
}
private void onPlaybackStarted(g_Player.MediaType type, string filename)
{
if (_playerState == MoviePlayerState.Processing && g_Player.Player.Playing) {
logger.Info("Playback Started: Internal, File={0}", filename);
// get the duration of the media
updateMediaDuration(queuedMedia);
// get the movie
DBMovieInfo movie = queuedMedia.AttachedMovies[0];
// and jump to our resume position if necessary
if (_resumeActive) {
if (g_Player.IsDVD && !movie.LocalMedia[0].IsBluray) {
logger.Debug("Resume: DVD state.");
g_Player.Player.SetResumeState(movie.ActiveUserSettings.ResumeData.Data);
}
else {
logger.Debug("Resume: Time={0}", movie.ActiveUserSettings.ResumeTime);
GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_SEEK_POSITION, 0, 0, 0, 0, 0, null);
msg.Param1 = movie.ActiveUserSettings.ResumeTime;
GUIGraphicsContext.SendMessage(msg);
}
// deactivate resume and force play
_resumeActive = false;
_forcePlay = false;
}
// Trigger Movie started
onMediaStarted(queuedMedia);
}
}
private void DoOnStarted(g_Player.MediaType type, string filename)
{
Log.Debug("GUIMusicPlayingNow: g_Player_PlayBackStarted for {0}", filename);
ImagePathContainer.Clear();
CurrentTrackFileName = filename;
GetTrackTags();
CurrentThumbFileName = GUIMusicBaseWindow.GetCoverArt(false, CurrentTrackFileName, CurrentTrackTag);
if (string.IsNullOrEmpty(CurrentThumbFileName))
// no LOCAL Thumb found because user has bad settings -> check if there is a folder.jpg in the share
{
CurrentThumbFileName = Util.Utils.GetFolderThumb(CurrentTrackFileName);
if (!Util.Utils.FileExistsInCache(CurrentThumbFileName))
{
CurrentThumbFileName = string.Empty;
}
}
if (!string.IsNullOrEmpty(CurrentThumbFileName))
{
// let us test if there is a larger cover art image
string strLarge = Util.Utils.ConvertToLargeCoverArt(CurrentThumbFileName);
if (Util.Utils.FileExistsInCache(strLarge))
{
CurrentThumbFileName = strLarge;
}
AddImageToImagePathContainer(CurrentThumbFileName);
}
UpdateImagePathContainer();
UpdateTrackInfo();
// Do last.fm updates
if (g_Player.IsMusic && _lookupSimilarTracks && g_Player.CurrentPosition >= 10.0 && lstSimilarTracks.Count == 0)
{
Log.Debug("GUIMusicPlayingNow: Do Last.FM lookup for similar trracks");
UpdateSimilarTracks(CurrentTrackFileName);
}
}
private void OnPlayBackStopped(g_Player.MediaType type, int stoptime, string filename)
{
if (!ControlsInitialized || type != g_Player.MediaType.Music)
{
return;
}
if (GUIWindowManager.ActiveWindow == GetID && !_isStopped)
{
_isStopped = true;
Log.Debug("GUIMusicPlayingNow: g_Player_PlayBackStopped for {0} - stoptime: {1}", filename, stoptime);
Action action = new Action();
action.wID = Action.ActionType.ACTION_PREVIOUS_MENU;
GUIGraphicsContext.OnAction(action);
}
}
public OnlineVideosPlayer(g_Player.MediaType type)
: base(type)
{ }
void g_Player_PlayBackEnded(g_Player.MediaType type, string filename)
{
try
{
if (currentPlayingItem != null && currentPlayingItem.Util != null)
{
double percent = g_Player.Duration > 0 ? g_Player.CurrentPosition / g_Player.Duration : 0;
currentPlayingItem.Util.OnPlaybackEnded(currentPlayingItem.Video, currentPlayingItem.FileName, percent, false);
}
}
catch (Exception ex)
{
Log.Instance.Warn("Error on Util.OnPlaybackEnded: {0}", ex);
}
if (currentPlaylist != null)
{
if ((g_Player.Player != null && g_Player.Player.GetType().Assembly == typeof(GUIOnlineVideos).Assembly) ||
g_Player.Player == null && (filename == "http://localhost/OnlineVideo.mp4" || (currentPlayingItem != null && filename == currentPlayingItem.FileName)))
{
PlayNextPlaylistItem();
}
else
{
// some other playback ended, and a playlist is still set here -> clear it
currentPlaylist = null;
currentPlayingItem = null;
}
}
else
{
TrackPlayback();
currentPlayingItem = null;
}
}
public static bool PlayRecording(Recording rec, double startOffset, g_Player.MediaType mediaType)
{
string fileName = GetFileNameForRecording(rec);
bool useRTSP = TVHome.UseRTSP();
string chapters = useRTSP ? TVHome.TvServer.GetChaptersForFileName(rec.IdRecording) : null;
Log.Info("PlayRecording:{0} - using rtsp mode:{1}", fileName, useRTSP);
if (g_Player.Play(fileName, mediaType, chapters, false)) // Force to use TsReader if true it will use Movie Codec and Splitter
{
if (Utils.IsVideo(fileName) && !g_Player.IsRadio)
{
g_Player.ShowFullScreenWindow();
}
if (startOffset > 0)
{
g_Player.SeekAbsolute(startOffset);
}
else if (startOffset == -1)
{
// 5 second margin is used that the TsReader wont stop playback right after it has been started
double dTime = g_Player.Duration - 5;
g_Player.SeekAbsolute(dTime);
}
TvRecorded.SetActiveRecording(rec);
//populates recording metadata to g_player;
g_Player.currentFileName = rec.FileName;
g_Player.currentTitle = GetDisplayTitle(rec);
g_Player.currentDescription = rec.Description;
rec.TimesWatched++;
rec.Persist();
return true;
}
return false;
}
private void OnPlayBackStarted(g_Player.MediaType type, string filename)
{
if (type != g_Player.MediaType.Video)
{
return;
}
AddFileToDatabase(filename);
int idFile = VideoDatabase.GetFileId(filename);
if (idFile != -1)
{
int movieDuration = (int)g_Player.Duration;
VideoDatabase.SetMovieDuration(idFile, movieDuration);
}
}
private void OnPlayBackEnded(g_Player.MediaType type, string filename)
{
if (type != g_Player.MediaType.Video)
{
return;
}
// Handle all movie files from idMovie
ArrayList movies = new ArrayList();
HashSet<string> watchedMovies = new HashSet<string>();
int iidMovie = VideoDatabase.GetMovieId(filename);
if (iidMovie >= 0)
{
VideoDatabase.GetFiles(iidMovie, ref movies);
for (int i = 0; i < movies.Count; i++)
{
string strFilePath = (string)movies[i];
byte[] resumeData = null;
int idFile = VideoDatabase.GetFileId(strFilePath);
if (idFile < 0)
{
break;
}
// Set resumedata to zero
VideoDatabase.GetMovieStopTimeAndResumeData(idFile, out resumeData);
VideoDatabase.SetMovieStopTimeAndResumeData(idFile, 0, resumeData);
watchedMovies.Add(strFilePath);
}
int playTimePercentage = 0;
if (_isStacked && _totalMovieDuration != 0)
{
int duration = 0;
for (int i = 0; i < _stackedMovieFiles.Count; i++)
{
int fileID = VideoDatabase.GetFileId((string)_stackedMovieFiles[i]);
if (filename != (string)_stackedMovieFiles[i])
{
duration += VideoDatabase.GetMovieDuration(fileID);
continue;
}
playTimePercentage = (int)(100 * (duration + g_Player.Player.CurrentPosition) / _totalMovieDuration);
break;
}
}
else
{
playTimePercentage = 100;
}
if (playTimePercentage >= 80)
{
IMDBMovie details = new IMDBMovie();
VideoDatabase.GetMovieInfoById(iidMovie, ref details);
details.Watched = 1;
VideoDatabase.SetWatched(details);
VideoDatabase.SetMovieWatchedStatus(iidMovie, true);
}
}
}
private void OnPlayBackStarted(g_Player.MediaType type, string filename)
{
if (type != g_Player.MediaType.Video)
{
return;
}
if (!Util.Utils.IsRemoteUrl(filename))
{
int idFile = VideoDatabase.GetFileId(filename);
if (idFile == -1)
{
AddFileToDatabase(filename);
idFile = VideoDatabase.GetFileId(filename);
}
if (idFile != -1)
{
int videoDuration = (int) g_Player.Duration;
VideoDatabase.SetVideoDuration(idFile, videoDuration);
}
}
}
public VideoPlayerVMR7(g_Player.MediaType type)
{
_mediaType = type;
}
void g_Player_PlayBackStopped(g_Player.MediaType type, int stoptime, string filename)
{
try
{
if (currentPlayingItem != null && currentPlayingItem.Util != null)
{
double percent = g_Player.Duration > 0 ? g_Player.CurrentPosition / g_Player.Duration : 0;
currentPlayingItem.Util.OnPlaybackEnded(currentPlayingItem.Video, currentPlayingItem.FileName, percent, true);
}
}
catch (Exception ex)
{
Log.Instance.Warn("Error on Util.OnPlaybackEnded: {0}", ex);
}
if (stoptime > 0 && g_Player.Duration > 0 && (stoptime / g_Player.Duration) > 0.8) TrackPlayback();
currentPlayingItem = null;
}
private void DoOnEnded(g_Player.MediaType type, string filename)
{
if (GUIWindowManager.ActiveWindow == GetID)
{
Log.Debug("GUIMusicPlayingNow: g_Player_PlayBackEnded for {0}", filename);
if (!g_Player.Playing && NextTrackTag == null && !_isStopped)
{
_isStopped = true;
Log.Debug("GUIMusicPlayingNow: All playlist items played - returning to previous window");
Action action = new Action();
action.wID = Action.ActionType.ACTION_PREVIOUS_MENU;
GUIGraphicsContext.OnAction(action);
}
}
}
public BDPlayer(g_Player.MediaType mediaType)
{
}
private void OnPlayBackStarted(g_Player.MediaType type, string filename)
{
if (!ControlsInitialized || type != g_Player.MediaType.Music)
{
return;
}
GUIGraphicsContext.form.Invoke(new PlaybackChangedDelegate(DoOnStarted), new object[] {type, filename});
}
private void g_Player_PlayBackChanged(g_Player.MediaType type, int stoptime, string filename)
{
SettingsLoaded = false; // we should reload
}
private void onPlayBackEnded(g_Player.MediaType type, string filename)
{
if (type != g_Player.MediaType.Video || _playerState != MoviePlayerState.Playing)
return;
if (handleCustomIntroEnded())
return;
logger.Debug("OnPlayBackEnded filename={0} currentMovie={1} currentPart={2}", filename, _activeMovie.Title, _activePart);
if (_activeMovie.LocalMedia.Count >= (_activePart + 1)) {
logger.Debug("Goto next part");
_activePart++;
playMovie(_activeMovie, _activePart);
}
else {
onMovieEnded(_activeMovie);
}
}
private void g_Player_PlayBackEnded(g_Player.MediaType type, string filename)
{
SettingsLoaded = false; // we should reload
// playback ended, if we are the current window, close our context menu, so we also get closed
if (type != g_Player.MediaType.Recording && type != g_Player.MediaType.TV) return;
if (GUIWindowManager.ActiveWindow != GetID) return;
if (!_IsClosingDialog)
{
_IsClosingDialog = true;
GUIDialogWindow.CloseRoutedWindow();
_IsClosingDialog = false;
}
}
private void onPlayBackStoppedOrChanged(g_Player.MediaType type, int timeMovieStopped, string filename)
{
if (type != g_Player.MediaType.Video || _playerState != MoviePlayerState.Playing)
return;
if (customIntrosPlayed > 0) return;
logger.Debug("OnPlayBackStoppedOrChanged: File={0}, Movie={1}, Part={2}, TimeStopped={3}", filename, _activeMovie.Title, _activePart, timeMovieStopped);
// Because we can't get duration for DVD's at start like with normal files
// we are getting the duration when the DVD is stopped. If the duration of
// feature is an hour or more it's probably the main feature and we will update
// the database.
if (g_Player.IsDVD && (g_Player.Player.Duration >= 3600)) {
DBLocalMedia playingFile = _activeMovie.LocalMedia[_activePart - 1];
updateMediaDuration(playingFile);
}
int requiredWatchedPercent = MovingPicturesCore.Settings.MinimumWatchPercentage;
int watchedPercentage = _activeMovie.GetPercentage(_activePart, timeMovieStopped);
int resumeTitleBD = g_Player.SetResumeBDTitleState;
logger.Debug("Watched: Percentage=" + watchedPercentage + ", Required=" + requiredWatchedPercent);
// if enough of the movie has been watched
if (watchedPercentage >= requiredWatchedPercent) {
// run movie ended logic
onMovieEnded(_activeMovie);
}
// otherwise, store resume data.
else {
byte[] resumeData = null;
g_Player.Player.GetResumeState(out resumeData);
updateMovieResumeState(_activeMovie, _activePart, timeMovieStopped, resumeData, resumeTitleBD);
// run movie stopped logic
onMovieStopped(_activeMovie);
}
}
private void DoOnPlayBackStoppedOrChanged(g_Player.MediaType type, int timeMovieStopped, string filename,
string caller)
{
if (type != g_Player.MediaType.Video || filename.EndsWith("&txe=.wmv"))
{
return;
}
// BD and IMAGES stop time (change to index.bdmv if mpls file is played or to IMG file)
ISelectBDHandler selectBDHandler = GetSelectBDHandler();
selectBDHandler.IsBDPlayList(ref filename);
// Handle all movie files from idMovie
ArrayList movies = new ArrayList();
int iidMovie = VideoDatabase.GetMovieId(filename);
VideoDatabase.GetFilesForMovie(iidMovie, ref movies);
HashSet<string> watchedMovies = new HashSet<string>();
int playTimePercentage = 0;
// Stacked movies duration
if (IsStacked && TotalMovieDuration != 0)
{
int duration = 0;
for (int i = 0; i < StackedMovieFiles.Count; i++)
{
int fileID = VideoDatabase.GetFileId((string)StackedMovieFiles[i]);
if (g_Player.CurrentFile != (string)StackedMovieFiles[i])
{
duration += VideoDatabase.GetVideoDuration(fileID);
continue;
}
playTimePercentage = (100 * (duration + timeMovieStopped) / TotalMovieDuration);
break;
}
}
else
{
if (g_Player.Player.Duration >= 1)
{
playTimePercentage = (int)Math.Ceiling((timeMovieStopped / g_Player.Player.Duration) * 100);
}
}
if (movies.Count <= 0)
{
return;
}
for (int i = 0; i < movies.Count; i++)
{
string strFilePath = (string)movies[i];
int idFile = VideoDatabase.GetFileId(strFilePath);
int idMovie = VideoDatabase.GetMovieId(strFilePath);
if (idFile < 0)
{
break;
}
if (g_Player.IsDVDMenu)
{
VideoDatabase.SetMovieStopTimeAndResumeData(idFile, 0, null, g_Player.SetResumeBDTitleState);
watchedMovies.Add(strFilePath);
VideoDatabase.SetMovieWatchedStatus(idMovie, true, 100);
VideoDatabase.MovieWatchedCountIncrease(idMovie);
}
else if ((filename.Trim().ToLowerInvariant().Equals(strFilePath.Trim().ToLowerInvariant())) && (timeMovieStopped > 0) && g_Player.SetResumeBDTitleState != -2)
{
byte[] resumeData = null;
g_Player.Player.GetResumeState(out resumeData);
Log.Info("GUIVideoFiles: {0} idFile={1} timeMovieStopped={2} resumeData={3} bdtitle={4}", caller, idFile, timeMovieStopped,
resumeData, g_Player.SetResumeBDTitleState);
VideoDatabase.SetMovieStopTimeAndResumeData(idFile, timeMovieStopped, resumeData, g_Player.SetResumeBDTitleState);
Log.Debug("GUIVideoFiles: {0} store resume time", caller);
//Set file "watched" only if user % value or higher played time (share view)
if (playTimePercentage >= _watchedPercentage)
{
watchedMovies.Add(strFilePath);
VideoDatabase.SetMovieWatchedStatus(idMovie, true, playTimePercentage);
VideoDatabase.MovieWatchedCountIncrease(idMovie);
}
else
{
int iPercent = 0; // Not used, just needed for the watched status call
int iTImesWatched = 0;
bool watched = VideoDatabase.GetmovieWatchedStatus(idMovie, out iPercent,
out iTImesWatched);
if (!watched)
{
VideoDatabase.SetMovieWatchedStatus(idMovie, false, playTimePercentage);
}
else // Update new percentage if already watched
{
VideoDatabase.SetMovieWatchedStatus(idMovie, true, playTimePercentage);
}
}
}
else
{
VideoDatabase.DeleteMovieStopTime(idFile);
}
}
if (_markWatchedFiles)
{
// Update db view watched status for played movie
IMDBMovie movie = new IMDBMovie();
VideoDatabase.GetMovieInfo(filename, ref movie);
if (!movie.IsEmpty)
//Flag movie "watched" status only if user % value or higher played time (database view)
{
if (playTimePercentage >= _watchedPercentage || g_Player.IsDVDMenu)
{
movie.Watched = 1;
}
movie.DateWatched = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
VideoDatabase.SetMovieInfoById(movie.ID, ref movie);
}
if (VideoState.StartWindow != GetID) // Is play initiator dbview?
{
UpdateButtonStates();
}
}
if (SubEngine.GetInstance().IsModified())
{
bool shouldSave = false;
if (SubEngine.GetInstance().AutoSaveType == AutoSaveTypeEnum.ASK)
{
if (!g_Player.Paused)
{
g_Player.Pause();
}
GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_YES_NO);
dlgYesNo.SetHeading(GUILocalizeStrings.Get(1318));// Save subtitle
dlgYesNo.SetLine(1, GUILocalizeStrings.Get(1319)); // Save modified subtitle?
dlgYesNo.SetDefaultToYes(true);
dlgYesNo.DoModal(GUIWindowManager.ActiveWindow);
shouldSave = dlgYesNo.IsConfirmed;
}
if (shouldSave || SubEngine.GetInstance().AutoSaveType == AutoSaveTypeEnum.ALWAYS)
{
SubEngine.GetInstance().SaveToDisk();
}
}
}
/// <summary>
/// We do not want to change neither the enum nor the previous Create overloaded calls to maintain backward compatibility
/// </summary>
/// <param name="fileName"></param>
/// <param name="type"></param>
/// <returns></returns>
private IPlayer Create(string aFileName, g_Player.MediaType? aMediaType)
{
try
{
// Set to anything here as it will only be passed if aMediaType is not null
g_Player.MediaType localType = g_Player.MediaType.Video;
if (aMediaType != null && aMediaType != g_Player.MediaType.Unknown)
{
localType = (g_Player.MediaType)aMediaType;
}
// Get settings only once
using (Settings xmlreader = new MPSettings())
{
string strAudioPlayer = xmlreader.GetValueAsString("audioplayer", "playerId", "0"); // BASS Player
bool Vmr9Enabled = xmlreader.GetValueAsBool("musicvideo", "useVMR9", true);
bool InternalBDPlayer = xmlreader.GetValueAsBool("bdplayer", "useInternalBDPlayer", true);
bool Usemoviecodects = xmlreader.GetValueAsBool("movieplayer", "usemoviecodects", false);
if (aFileName.ToLowerInvariant().IndexOf("rtsp:") >= 0)
{
if (aMediaType != null)
{
return new TSReaderPlayer(localType);
}
else
{
return new TSReaderPlayer();
}
}
if (aFileName.StartsWith("mms:") && aFileName.EndsWith(".ymvp"))
{
if (Vmr9Enabled)
{
return new VideoPlayerVMR9();
}
else
{
return new AudioPlayerWMP9();
}
}
string extension = Path.GetExtension(aFileName).ToLowerInvariant();
if (extension == ".bdmv")
{
if (InternalBDPlayer)
{
return new BDPlayer();
}
else
{
return new VideoPlayerVMR9();
}
}
if (extension != ".tv" && extension != ".sbe" && extension != ".dvr-ms" &&
aFileName.ToLowerInvariant().IndexOf(".tsbuffer") < 0 && aFileName.ToLowerInvariant().IndexOf("radio.tsbuffer") < 0)
{
IPlayer newPlayer = GetExternalPlayer(aFileName);
if (newPlayer != null)
{
Log.Info("PlayerFactory: Disabling DX9 exclusive mode");
GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_SWITCH_FULL_WINDOWED, 0, 0, 0, 0, 0, null);
GUIWindowManager.SendMessage(msg);
return newPlayer;
}
}
if (Util.Utils.IsVideo(aFileName))
{
if (extension == ".tv" || extension == ".sbe" || extension == ".dvr-ms")
{
//if (extension == ".sbe" || extension == ".dvr-ms")
//{
// //GUIMessage msg = new GUIMessage(GUIMessage.MessageType.GUI_MSG_RECORDER_STOP_TIMESHIFT, 0, 0, 0, 0, 0, null);
// //GUIWindowManager.SendMessage(msg);
//}
return new StreamBufferPlayer9();
}
if (extension == ".ifo" || Util.VirtualDirectory.IsImageFile(extension))
{
return new DVDPlayer9();
}
}
// Use TsReader for timeshift buffer file for TvEngine3 & .ts recordings etc.
if (extension == ".tsbuffer" || extension == ".ts" || extension == ".rec")
//new support for Topfield recordings
{
if (aFileName.ToLowerInvariant().IndexOf("radio.tsbuffer") >= 0)
{
if (aMediaType != null)
{
return new BaseTSReaderPlayer(localType);
}
else
{
return new BaseTSReaderPlayer();
}
}
if (aMediaType != null)
{
if (
(GUIWindow.Window)
(Enum.Parse(typeof(GUIWindow.Window), GUIWindowManager.ActiveWindow.ToString())) ==
GUIWindow.Window.WINDOW_VIDEOS && Usemoviecodects || (g_Player.IsExtTS && Usemoviecodects))
{
return new VideoPlayerVMR9(localType);
}
else
{
return new TSReaderPlayer(localType);
}
}
else
{
return new TSReaderPlayer();
}
}
if (!Util.Utils.IsAVStream(aFileName) && Util.Utils.IsVideo(aFileName) && localType != g_Player.MediaType.Music)
{
if (aMediaType != null)
{
return new VideoPlayerVMR9(localType);
}
else
{
return new VideoPlayerVMR9();
}
}
if (Util.Utils.IsCDDA(aFileName))
{
// Check if, we should use BASS for CD Playback
if ((AudioPlayer)Enum.Parse(typeof(AudioPlayer), strAudioPlayer) != AudioPlayer.DShow)
{
if (BassMusicPlayer.BassFreed)
{
BassMusicPlayer.Player.InitBass();
}
return BassMusicPlayer.Player;
}
else
{
return new AudioPlayerWMP9();
}
}
if (Util.Utils.IsAudio(aFileName) || localType == g_Player.MediaType.Music)
{
if ((AudioPlayer)Enum.Parse(typeof(AudioPlayer), strAudioPlayer) != AudioPlayer.DShow)
{
if (BassMusicPlayer.BassFreed)
{
BassMusicPlayer.Player.InitBass();
}
return BassMusicPlayer.Player;
}
else if (String.Compare(strAudioPlayer, "Windows Media Player 9", true) == 0)
{
return new AudioPlayerWMP9();
}
else
{
return new AudioPlayerVMR7();
}
}
// Use WMP Player as Default
return new AudioPlayerWMP9();
}
}
finally
{
Log.Debug("PlayerFactory: Successfully created player instance for file - {0}", aFileName);
}
}
private void OnPlayBackStopped(g_Player.MediaType type, int timeMovieStopped, string filename)
{
DoOnPlayBackStoppedOrChanged(type, timeMovieStopped, filename, "OnPlayBackStopped");
}
private void OnPlayBackStopped(g_Player.MediaType type, int stoptime, string filename)
{
if (type != g_Player.MediaType.TV && type != g_Player.MediaType.Radio)
{
return;
}
StopPlayback();
UpdateGUIonPlaybackStateChange(false);
}
private void OnPlayBackEnded(g_Player.MediaType type, string filename)
{
if (type != g_Player.MediaType.Video)
{
return;
}
// BD-DVD image stop time (change to index.bdmv if mpls file is played)
ISelectBDHandler selectBDHandler = GetSelectBDHandler();
selectBDHandler.IsBDPlayList(ref filename);
// Handle all movie files from idMovie
ArrayList movies = new ArrayList();
HashSet<string> watchedMovies = new HashSet<string>();
int idMovie = VideoDatabase.GetMovieId(filename);
if (idMovie >= 0)
{
VideoDatabase.GetFilesForMovie(idMovie, ref movies);
for (int i = 0; i < movies.Count; i++)
{
string strFilePath = (string)movies[i];
byte[] resumeData = null;
int idFile = VideoDatabase.GetFileId(strFilePath);
if (idFile < 0)
{
break;
}
// Set resumedata to zero
VideoDatabase.GetMovieStopTimeAndResumeData(idFile, out resumeData, g_Player.SetResumeBDTitleState);
VideoDatabase.SetMovieStopTimeAndResumeData(idFile, 0, resumeData, g_Player.SetResumeBDTitleState);
watchedMovies.Add(strFilePath);
}
int playTimePercentage = 0;
if (IsStacked && TotalMovieDuration != 0)
{
int duration = 0;
for (int i = 0; i < StackedMovieFiles.Count; i++)
{
int fileID = VideoDatabase.GetFileId((string)StackedMovieFiles[i]);
if (filename != (string)StackedMovieFiles[i])
{
duration += VideoDatabase.GetVideoDuration(fileID);
continue;
}
playTimePercentage = (int)(100 * (duration + g_Player.Player.CurrentPosition) / TotalMovieDuration);
break;
}
}
else
{
playTimePercentage = 100;
}
IMDBMovie details = new IMDBMovie();
VideoDatabase.GetMovieInfoById(idMovie, ref details);
if (playTimePercentage >= _watchedPercentage)
{
details.Watched = 1;
VideoDatabase.SetWatched(details);
VideoDatabase.SetMovieWatchedStatus(idMovie, true, playTimePercentage);
VideoDatabase.MovieWatchedCountIncrease(idMovie);
// Set date watched
VideoDatabase.SetDateWatched(details);
}
else
{
int percent = 0;
int timesWatched = 0;
bool wStatus = VideoDatabase.GetmovieWatchedStatus(idMovie, out percent, out timesWatched);
VideoDatabase.SetMovieWatchedStatus(idMovie, wStatus, playTimePercentage);
}
}
}
