/// <summary>
/// Get the track details
/// </summary>
/// <param name="mvSignature"></param>
/// <returns></returns>
public List <DBTrackInfo> GetTrackDetail(MusicVideoSignature mvSignature)
{
List <DBTrackInfo> results = new List <DBTrackInfo>();
if (mvSignature == null)
{
return(results);
}
lock (lockList)
{
DBTrackInfo mv = getMusicVideoTrack(mvSignature.Artist, mvSignature.Album, mvSignature.Track);
if (mv != null)
{
if (mv.ArtistInfo.Count == 0)
{
DBArtistInfo d4 = new DBArtistInfo();
d4.Artist = mvSignature.Artist;
mv.ArtistInfo.Add(d4);
}
results.Add(mv);
}
}
return(results);
}
/// <summary>
/// Get Track Artwork from Track Artwork folder
/// </summary>
/// <param name="mvTrackObject"></param>
/// <returns></returns>
private bool getTrackArtFromTrackArtFolder(DBTrackInfo mvTrackObject)
{
bool found = false;
logger.Debug("In Method getTrackArtFromTrackArtFolder(DBTrackInfo mv)");
if (mvTrackObject == null)
{
return(false);
}
// grab a list of possible filenames for the artistart based on the user pattern
string pattern = mvCentralCore.Settings.TrackArtworkFilenamePattern;
List <string> filenames = getPossibleNamesFromPattern(pattern, mvTrackObject);
// check the artistart folder for the user patterned artistarts
string trackartFolderPath = mvCentralCore.Settings.TrackArtFolder;
FileInfo newTrackArt = getFirstFileFromFolder(trackartFolderPath, filenames);
if (newTrackArt != null && newTrackArt.Exists)
{
mvTrackObject.ArtFullPath = newTrackArt.FullName;
logger.Info("Loaded trackimage from " + newTrackArt.FullName);
return(true);
}
return(found);
}
/// <summary>
/// Get the Album Artwork from Mediaportal folder
/// </summary>
/// <param name="mvArtistObject"></param>
/// <returns></returns>
private bool getMPAlbumArt(DBAlbumInfo mvAlbumObject)
{
logger.Debug("In Method: getMPAlbumArt(DBAlbumInfo mvAlbumObject)");
bool found = false;
string artist = string.Empty;
string album = mvAlbumObject.Album;
List <DBTrackInfo> a1 = DBTrackInfo.GetEntriesByAlbum(mvAlbumObject);
if (a1.Count > 0)
{
artist = a1[0].ArtistInfo[0].Artist;
}
string thumbFolder = Thumbs.MusicAlbum;
string cleanTitle = string.Format("{0}-{1}", MediaPortal.Util.Utils.MakeFileName(artist), MediaPortal.Util.Utils.MakeFileName(album));
string filename = thumbFolder + @"\" + cleanTitle + "L.jpg";
if (File.Exists(filename))
{
found &= mvAlbumObject.AddArtFromFile(filename);
}
logger.Debug("In Method: getMPAlbumArt(DBAlbumInfo mvAlbumObject) filename: " + filename + " - " + found);
return(found);
}
/// <summary>
/// Generate Thumbnail
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
bool generateVideoThumbnail(DBTrackInfo mv)
{
lock (this)
{
string outputFilename = Path.Combine(Path.GetTempPath(), mv.Track + DateTime.Now.ToFileTimeUtc().ToString() + ".jpg");
if (mvCentral.Utils.VideoThumbCreator.CreateVideoThumb(mv.LocalMedia[0].File.FullName, outputFilename))
{
if (File.Exists(outputFilename))
{
mv.AddArtFromFile(outputFilename);
File.Delete(outputFilename);
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
}
private void VideoActions(MediaPortal.GUI.Library.Action.ActionType actionType)
{
if ((actionType == MediaPortal.GUI.Library.Action.ActionType.ACTION_PLAY) || (actionType == MediaPortal.GUI.Library.Action.ActionType.ACTION_MUSIC_PLAY) || actionType == MediaPortal.GUI.Library.Action.ActionType.ACTION_SELECT_ITEM)
{
//play this song, or return to previous level
if (facadeLayout.ListLayout.SelectedListItem.Label == "..")
{
_currentView = MvView.Artist;
addToStack(_currentView, false);
logger.Debug("Calling loadCurrent from VideoActions");
loadCurrent();
}
else
{
//Play currently selected and activate video window
string vidPath = facadeLayout.ListLayout.SelectedListItem.Path;
DBTrackInfo db1 = (DBTrackInfo)facadeLayout.ListLayout.SelectedListItem.MusicTag;
g_Player.Play(db1.LocalMedia[0].File.FullName);
if (db1.LocalMedia[0].IsDVD)
{
//PlayDVD(db1);
}
}
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
}
public UpdateResults UpdateTrack(DBTrackInfo mv)
{
if (mv == null)
{
return(UpdateResults.FAILED);
}
lock (LockList)
{
DBArtistInfo db1 = DBArtistInfo.Get(mv);
if (db1 != null)
{
mv.ArtistInfo[0] = db1;
}
if (mv.ArtistInfo.Count > 0)
{
mv.ArtistInfo[0].PrimarySource = mv.PrimarySource;
mv.ArtistInfo[0].Commit();
}
DBAlbumInfo db2 = DBAlbumInfo.Get(mv);
if (db2 != null)
{
mv.AlbumInfo[0] = db2;
}
if (mv.AlbumInfo.Count > 0)
{
foreach (DBAlbumInfo db3 in mv.AlbumInfo)
{
db3.PrimarySource = mv.PrimarySource;
db3.Commit();
}
}
}
return(UpdateResults.SUCCESS);
}
private void ArtistActions(Action.ActionType actionType)
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE))
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE && !g_Player.HasVideo))
{
DBArtistInfo currArtist = DBArtistInfo.Get(facadeLayout.SelectedListItem.Label);
List <DBTrackInfo> allTracksByArtist = DBTrackInfo.GetEntriesByArtist(currArtist);
AddToPlaylist(allTracksByArtist, true, mvCentralCore.Settings.ClearPlaylistOnAdd, mvCentralCore.Settings.GeneratedPlaylistAutoShuffle);
}
}
else if (actionType == Action.ActionType.REMOTE_0 ||
actionType == Action.ActionType.REMOTE_1 ||
actionType == Action.ActionType.REMOTE_2 ||
actionType == Action.ActionType.REMOTE_3 ||
actionType == Action.ActionType.REMOTE_4 ||
actionType == Action.ActionType.REMOTE_5 ||
actionType == Action.ActionType.REMOTE_6 ||
actionType == Action.ActionType.REMOTE_7 ||
actionType == Action.ActionType.REMOTE_8 ||
actionType == Action.ActionType.REMOTE_9)
{
DoSpell(actionType);
}
else
{
_currentView = MvView.Artist;
artistID = facadeLayout.SelectedListItem.ItemId;
logger.Debug("Calling loadCurrent from ArtistActions");
loadCurrent();
}
}
public static DBSourceMusicVideoInfo Get(DBTrackInfo mv, DBSourceInfo source)
{
foreach (DBSourceMusicVideoInfo currInfo in mv.SourceMusicVideoInfo)
if (currInfo.Source == source)
return currInfo;
return null;
}
public CreateAlbumForTrack(DBTrackInfo trackToAdd)
{
InitializeComponent();
DBArtistInfo theArtist = DBArtistInfo.Get(trackToAdd);
tbArtistName.Text = theArtist.Artist;
tbTrackName.Text = trackToAdd.Track;
}
/// <summary>
/// Play tracks by selected Genre
/// </summary>
private void playByGenre()
{
GUIDialogMenu dlgMenu = (GUIDialogMenu)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlgMenu != null)
{
dlgMenu.Reset();
dlgMenu.SetHeading(mvCentralUtils.PluginName() + " - " + Localization.SmartPlaylistOptions);
List <DBGenres> genreList = DBGenres.GetAll();
genreList.Sort(delegate(DBGenres p1, DBGenres p2) { return(p1.Genre.CompareTo(p2.Genre)); });
foreach (DBGenres genre in genreList)
{
if (genre.Enabled)
{
dlgMenu.Add(genre.Genre);
}
}
dlgMenu.DoModal(GetID);
if (dlgMenu.SelectedLabel == -1) // Nothing was selected
{
return;
}
//dlgMenu.SelectedLabelText
PlayList playlist = Player.playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MVCENTRAL);
playlist.Clear();
List <DBArtistInfo> allArtists = DBArtistInfo.GetAll();
foreach (DBArtistInfo artist in allArtists)
{
if (tagMatched(dlgMenu.SelectedLabelText, artist))
{
logger.Debug("Matched Artist {0} with Tag {1}", artist.Artist, dlgMenu.SelectedLabelText);
List <DBTrackInfo> theTracks = DBTrackInfo.GetEntriesByArtist(artist);
foreach (DBTrackInfo artistTrack in theTracks)
{
playlist.Add(new PlayListItem(artistTrack));
}
}
}
Player.playlistPlayer.CurrentPlaylistType = PlayListType.PLAYLIST_MVCENTRAL;
if (mvCentralCore.Settings.GeneratedPlaylistAutoShuffle)
{
playlist.Shuffle();
}
Player.playlistPlayer.Play(0);
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
}
public static void AddWatchedHistory(DBTrackInfo MusicVideo, DBUser user)
{
DBWatchedHistory history = new DBWatchedHistory();
history.DateWatched = DateTime.Now;
history.Movie = MusicVideo;
history.User = user;
history.Commit();
MusicVideo.Commit();
}
public DBTrackInfo GetAlbumDetail(DBTrackInfo mv)
{
logger.Debug("In Method: GetAlbumDetail(DBTrackInfo mv)");
var albumTitle = mv.AlbumInfo[0].Album;
var albumMbid = mv.AlbumInfo[0].MdID;
var artist = mv.ArtistInfo[0].Artist;
var albumData = mv.AlbumInfo[0];
setMusicVideoAlbum(ref albumData, artist, albumTitle, albumMbid);
return(mv);
}
public GrabberPopup(DBTrackInfo mv)
{
InitializeComponent();
try {
CloseDVDInterfaces();
mvs = mv;
BuildGraph();
btnPlay_Click(null, null);
UpdateSeekBar();
}
catch (Exception) { }
}
public MusicVideoSignature(DBTrackInfo mv)
{
Title = mv.Track;
// Year = mv.Year;
MdId = mv.MdID;
ArtistMdId = mv.ArtistInfo[0].MdID;
if (mv.AlbumInfo.Count > 0)
{
AlbumMdId = mv.AlbumInfo[0].MdID;
}
LocalMedia = mv.LocalMedia;
}
public MatchResult GetMatchResult(DBTrackInfo mv)
{
MdId = mv.MdID;
ArtistMdId = mv.ArtistInfo[0].MdID;
if (mv.AlbumInfo.Count > 0)
{
AlbumMdId = mv.AlbumInfo[0].MdID;
}
// Create a new score card
MatchResult result = new MatchResult();
// Get the default scores for this mv
result.TitleScore = matchTitle(mv.ArtistInfo[0].Artist + " " + mv.Track);
result.MdMatch = matchMd(mv.MdID);
result.ArtistMdMatch = matchArtistMd(ArtistMdId);
result.AlbumMdMatch = matchAlbumMd(AlbumMdId);
// check if this match came from our #1 details provider
ReadOnlyCollection <DBSourceInfo> detailSources = mvCentralCore.DataProviderManager.TrackDetailSources;
if (detailSources.Count > 0 && detailSources[0] == mv.PrimarySource)
{
result.FromTopSource = true;
}
else
{
result.FromTopSource = false;
}
// If we don't have a perfect score on the original title
// iterate through the available alternate titles and check
// them to lower the score if possible
if (result.TitleScore > 0)
{
// foreach (string alternateTitle in mv.AlternateTitles.ToArray()) {
// int score = matchTitle(alternateTitle);
// if this match is better than the previous one save the score
// if (score < result.TitleScore) {
// result.TitleScore = score;
// result.AlternateTitle = alternateTitle;
// }
// if the best score is 0 (the best possible score) then stop score checking
// if (result.TitleScore == 0) break;
// }
}
// return the result
logger.Debug("MATCHING: '{0}' WITH: '{1}' RESULT: {2}", this.baseTitle, mv.Track, result.ToString());
return(result);
}
/// <summary>
/// Update the track with the received data
/// </summary>
/// <param name="mvTrackInfo"></param>
public void Update(DBTrackInfo mvTrackInfo)
{
List <DBSourceInfo> sources;
lock (trackDetailSources) sources = new List <DBSourceInfo>(trackDetailSources);
// unlock the mv fields for the first iteration
mvTrackInfo.ProtectExistingValuesFromCopy(false);
// first update from the primary source of this data
int providerCount = 0;
if (mvTrackInfo.PrimarySource != null && mvTrackInfo.PrimarySource.Provider != null)
{
UpdateResults success = mvTrackInfo.PrimarySource.Provider.UpdateTrack(mvTrackInfo);
logger.Debug("*** UPDATE: Track='{0}', Provider='{1}', Version={2}, Result={3}", mvTrackInfo.Track, mvTrackInfo.PrimarySource.Provider.Name, mvTrackInfo.PrimarySource.Provider.Version, success.ToString());
providerCount++;
}
foreach (DBSourceInfo currSource in sources)
{
if (currSource.IsDisabled(DataType.TRACKDETAIL))
{
continue;
}
if (currSource == mvTrackInfo.PrimarySource)
{
continue;
}
providerCount++;
if (providerCount <= mvCentralCore.Settings.DataProviderRequestLimit || mvCentralCore.Settings.DataProviderRequestLimit == 0)
{
UpdateResults success = currSource.Provider.UpdateTrack(mvTrackInfo);
logger.Debug("*** UPDATE: Track='{0}', Provider='{1}', Version={2}, Result={3}", mvTrackInfo.Track, currSource.Provider.Name, currSource.Provider.Version, success.ToString());
}
else
{
// stop update
break;
}
if (mvCentralCore.Settings.UseTranslator)
{
mvTrackInfo.Translate();
}
}
}
/// <summary>
/// Get the album details
/// </summary>
/// <param name="basicInfo"></param>
/// <param name="albumTitle"></param>
/// <param name="albumMbid"></param>
/// <returns></returns>
public bool GetAlbumDetails(DBBasicInfo basicInfo, string albumTitle, string albumMbid)
{
List <DBTrackInfo> tracksOnAlbum = DBTrackInfo.GetEntriesByAlbum((DBAlbumInfo)basicInfo);
if (tracksOnAlbum.Count > 0)
{
string artist = tracksOnAlbum[0].ArtistInfo[0].Artist;
DBAlbumInfo mv1 = (DBAlbumInfo)basicInfo;
basicInfo.ArtUrls.Clear();
setMusicVideoAlbum(ref mv1, albumMbid);
GetAlbumArt((DBAlbumInfo)basicInfo);
}
return(true);
}
private void setMusicVideoTrack(ref DBTrackInfo mv, string id)
{
if (id == null || mv == null)
{
return;
}
XmlNodeList xml = null;
// get release info
xml = getXML(apiTrackGetInfo, id);
if (xml == null)
{
return;
}
XmlNode root = xml.Item(0).ParentNode;
if (root.Attributes != null && root.Attributes["stat"].Value != "ok")
{
return;
}
mv.MdID = xml.Item(0).Attributes["id"].Value;
; XmlNodeList mvNodes = xml.Item(0).ChildNodes;
foreach (XmlNode node in mvNodes)
{
string value = node.InnerText;
switch (node.Name)
{
case "title":
mv.Track = value;
break;
case "release":
mv.MdID = node.FirstChild.Attributes["id"].Value;
break;
case "images":
{
mv.ArtUrls.Clear();
foreach (XmlNode x1 in node.ChildNodes)
{
mv.ArtUrls.Add(x1.Attributes["uri"].Value);
}
}
break;
}
}
}
public bool GetAlbumDetails(DBBasicInfo basicInfo, string albumTitle, string albumMbid)
{
logger.Debug("In Method: GetAlbumDetails(DBBasicInfo basicInfo, Album: " + albumTitle + " MBID: " + albumMbid + ")");
List <DBTrackInfo> tracksOnAlbum = DBTrackInfo.GetEntriesByAlbum((DBAlbumInfo)basicInfo);
if (tracksOnAlbum.Count > 0)
{
string artist = tracksOnAlbum[0].ArtistInfo[0].Artist;
DBAlbumInfo mv1 = (DBAlbumInfo)basicInfo;
basicInfo.ArtUrls.Clear();
setMusicVideoAlbum(ref mv1, artist, albumTitle, albumMbid);
GetAlbumArt((DBAlbumInfo)basicInfo);
}
return(true);
}
private bool AddItem(string ID, string Title, string ChapterID, string File)
{
DBTrackInfo mv = DBTrackInfo.Get(Convert.ToInt16(ID));
if (mv == null)
{
return(false);
}
PlayListItem newItem = new PlayListItem(mv);
newItem.FileName = mv.LocalMedia[0].File.FullName;
playlist.Add(newItem);
return(true);
}
private void GenreActions(MediaPortal.GUI.Library.Action.ActionType actionType)
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE))
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE && !g_Player.HasVideo))
{
List <DBArtistInfo> artistList = new List <DBArtistInfo>();
List <DBArtistInfo> artistFullList = DBArtistInfo.GetAll();
logger.Debug("Checking for matches for Genre : " + facadeLayout.SelectedListItem.Label);
foreach (DBArtistInfo artistInfo in artistFullList)
{
if (tagMatched(facadeLayout.SelectedListItem.Label, artistInfo))
{
logger.Debug("Matched Artist {0} with Tag {1}", artistInfo.Artist, facadeLayout.SelectedListItem.Label);
if (!artistList.Contains(artistInfo))
{
artistList.Add(artistInfo);
}
}
}
if (mvCentralCore.Settings.ClearPlaylistOnAdd)
{
ClearPlaylist();
}
foreach (DBArtistInfo currArtist in artistList)
{
List <DBTrackInfo> artistTracks = DBTrackInfo.GetEntriesByArtist(currArtist);
AddToPlaylist(artistTracks, false, false, mvCentralCore.Settings.GeneratedPlaylistAutoShuffle);
}
Player.playlistPlayer.Play(0);
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
else
{
_currentView = MvView.Genres;
artistID = facadeLayout.SelectedListItem.ItemId;
logger.Debug("Calling loadCurrent from GenreActions");
loadCurrent();
}
}
}
public int Compare(GUIListItem x, GUIListItem y)
{
try
{
DBTrackInfo trackX = (DBTrackInfo)x.MusicTag;
DBTrackInfo trackY = (DBTrackInfo)y.MusicTag;
int rtn;
switch (_sortField)
{
case SortingFields.DateAdded:
rtn = trackX.DateAdded.CompareTo(trackY.DateAdded);
break;
// default to the title field
case SortingFields.Artist:
default:
rtn = trackX.SortBy.CompareTo(trackY.SortBy);
break;
}
// if both items are identical, fallback to using the Title
if (rtn == 0)
{
rtn = trackX.Track.CompareTo(trackY.Track);
}
// if both items are STILL identical, fallback to using the ID
if (rtn == 0)
{
rtn = trackX.ID.GetValueOrDefault(0).CompareTo(trackY.ID.GetValueOrDefault(0));
}
if (_sortDirection == SortingDirections.Descending)
{
rtn = -rtn;
}
return(rtn);
}
catch
{
return(0);
}
}
/// <summary>
/// Get the details of the track
/// </summary>
/// <param name="trackObject"></param>
private void GetDVDDetails(DBTrackInfo trackObject)
{
string strArtistHTML;
string strAlbumHTML;
string strArtistURL;
bool songFound = false;
List <DBTrackInfo> results = new List <DBTrackInfo>();
string artist = trackObject.ArtistInfo[0].Artist;
if (GetArtistHTML(artist, out strArtistHTML, out strArtistURL))
{
var artistInfo = new MusicArtistInfo();
if (artistInfo.Parse(strArtistHTML))
{
artistInfo.Artist = artist;
if (GetDVDURLList(strArtistURL))
{
// we have some albums - now check the tracks in each album
foreach (string albumURL in _albumUrlList)
{
if (GetPageHTMLOnly(albumURL, out strAlbumHTML))
{
var albumInfo = new MusicAlbumInfo();
if (albumInfo.Parse(strAlbumHTML))
{
string[] tracksOnAlbum = albumInfo.Tracks.Split('|');
foreach (string track in tracksOnAlbum)
{
if (!string.IsNullOrEmpty(track.Trim()))
{
string[] trackData = track.Split('@');
if (trackObject.Track == trackData[1])
{
songFound = getTrackComposers(trackObject, strAlbumHTML, trackData[3]);
break;
}
}
}
}
}
}
}
}
}
}
/// <summary>
/// Get the Rating for the track
/// </summary>
/// <param name="trackObject"></param>
/// <param name="albumHTML"></param>
/// <returns></returns>
bool getTrackComposers(DBTrackInfo trackObject, string albumHTML, string trackURL)
{
string strSongHTML = string.Empty;
string songComposers = string.Empty;;
var strAlbumRemoveBrackets = BracketRegEx.Replace(trackObject.Track, "$1").Trim();
var strRemovePunctuation = PunctuationRegex.Replace(trackObject.Track, "").Trim();
var strAndAlbum = trackObject.Track.Replace("&", "and").Replace("+", "and");
// Extract the composers first
string trackHTML = string.Empty;
GetPageHTMLOnly(trackURL, out trackHTML);
MatchCollection allMatchResults = null;
CaptureCollection captureCollection;
GroupCollection groupCollection;
try
{
Regex composerRegion = new Regex(@"Composed by(?<composers>.+?)<\/h3>", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Compiled);
Match match = composerRegion.Match(trackHTML);
if (match.Success)
{
string _composers = match.Groups[1].Value;
Regex trackRegex = new Regex(@"<a.href=[^>]+?>(?<composer>[^<]+)<\/a>", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Compiled);
allMatchResults = trackRegex.Matches(_composers);
foreach (Match cmatch in allMatchResults)
{
groupCollection = cmatch.Groups;
captureCollection = groupCollection[1].Captures;
for (int i = 0; i < captureCollection.Count; i++)
{
songComposers += (i == captureCollection.Count - 1) ? captureCollection[i].Value : captureCollection[i].Value + "|";
}
}
}
trackObject.Composers = songComposers;
return(true);
}
catch (Exception)
{ }
return(false);
}
/// <summary>
/// Create a Random Playlist of All Videos
/// </summary>
private void playRandomAll()
{
PlayList playlist = Player.playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MVCENTRAL);
playlist.Clear();
List <DBTrackInfo> videos = DBTrackInfo.GetAll();
foreach (DBTrackInfo video in videos)
{
playlist.Add(new PlayListItem(video));
}
Player.playlistPlayer.CurrentPlaylistType = PlayListType.PLAYLIST_MVCENTRAL;
playlist.Shuffle();
Player.playlistPlayer.Play(0);
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
private void AlbumActions(MediaPortal.GUI.Library.Action.ActionType actionType)
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE))
{
if ((actionType == Action.ActionType.ACTION_MUSIC_PLAY) || (actionType == Action.ActionType.ACTION_PLAY) || (actionType == Action.ActionType.ACTION_PAUSE && !g_Player.HasVideo))
{
DBArtistInfo currArtist = DBArtistInfo.Get(facadeLayout.SelectedListItem.Label);
List <DBTrackInfo> allTracksOnAlbum = DBTrackInfo.GetEntriesByAlbum((DBAlbumInfo)facadeLayout.SelectedListItem.MusicTag);
AddToPlaylist(allTracksOnAlbum, true, mvCentralCore.Settings.ClearPlaylistOnAdd, mvCentralCore.Settings.GeneratedPlaylistAutoShuffle);
}
else
{
_currentView = MvView.Artist;
artistID = facadeLayout.SelectedListItem.ItemId;
logger.Debug("Calling loadCurrent from AlbumActions");
loadCurrent();
}
}
}
/// <summary>
/// Play by Selected Tag
/// </summary>
private void playByTag()
{
GUIDialogMenu dlgMenu = (GUIDialogMenu)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_MENU);
if (dlgMenu != null)
{
dlgMenu.Reset();
dlgMenu.SetHeading(mvCentralUtils.PluginName() + " - " + Localization.SmartPlaylistOptions);
foreach (string artistTag in artistTags)
{
dlgMenu.Add(artistTag);
}
dlgMenu.DoModal(GetID);
if (dlgMenu.SelectedLabel == -1) // Nothing was selected
{
return;
}
//dlgMenu.SelectedLabelText
PlayList playlist = Player.playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MVCENTRAL);
playlist.Clear();
List <DBArtistInfo> allArtists = DBArtistInfo.GetAll();
foreach (DBArtistInfo artist in allArtists)
{
if (artist.Tag.Contains(dlgMenu.SelectedLabelText))
{
List <DBTrackInfo> theTracks = DBTrackInfo.GetEntriesByArtist(artist);
foreach (DBTrackInfo artistTrack in theTracks)
{
playlist.Add(new PlayListItem(artistTrack));
}
}
}
Player.playlistPlayer.CurrentPlaylistType = PlayListType.PLAYLIST_MVCENTRAL;
playlist.Shuffle();
Player.playlistPlayer.Play(0);
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
}
/// <summary>
/// get the album details
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public DBTrackInfo GetAlbumDetail(DBTrackInfo mv)
{
// ****************** Additional Album Info Processing ******************
// Check and update Album details from additional providers
DBAlbumInfo albumInfo = new DBAlbumInfo();
albumInfo = mv.AlbumInfo[0];
foreach (DBSourceInfo albumExtraInfo in albumDetailSources)
{
if (albumInfo.PrimarySource != albumExtraInfo.Provider)
{
albumInfo = albumExtraInfo.Provider.GetAlbumDetail(mv).AlbumInfo[0];
albumInfo.PrimarySource = albumExtraInfo;
}
}
mv.AlbumInfo[0] = albumInfo;
return(mv);
}
/// <summary>
/// Grab the track data and process
/// </summary>
/// <param name="mv"></param>
/// <param name="artist"></param>
/// <param name="track"></param>
/// <param name="mbid"></param>
private void setMusicVideoTrack(ref DBTrackInfo mv, string artist, string track, string mbid)
{
if (track == null && mbid == null)
{
return;
}
logger.Debug("In Method: setMusicVideoTrack(ref DBTrackInfo mv, Artist: " + artist + ", Track: " + track + ", MBID: " + mbid + ")");
MusicDatabase m_db = null;
try
{
m_db = MusicDatabase.Instance;
}
catch (Exception e)
{
logger.Error("setMusicVideoTrack: Music database init failed " + e.ToString());
return;
}
var trackInfo = new MediaPortal.Music.Database.Song();
if (!m_db.GetSongByMusicTagInfo(artist, string.Empty, track, false, ref trackInfo))
{
return;
}
mv.Track = trackInfo.Title;
//mv.MdID = value;
// Tag
char[] delimiters = new char[] { ',' };
string[] tags = trackInfo.Genre.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
foreach (string tag in tags)
{
mv.Tag.Add(tag.Trim());
}
// mv.ArtUrls.Add(trackInfo.Image);
// mv.bioSummary = mvCentralUtils.StripHTML(cdataSection.Value);
// mv.bioContent = mvCentralUtils.StripHTML(cdataSection.Value);
return;
}
/// <summary>
/// Get the Track Artwork using the old Method
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
private bool getOldTrackArt(DBTrackInfo mv)
{
logger.Debug("In Method getOldTrackArt(DBTrackInfo mv)");
bool found = false;
string trackartFolderPath = mvCentralCore.Settings.TrackArtFolder;
DirectoryInfo trackartFolder = new DirectoryInfo(trackartFolderPath);
string safeName = mv.Track.Replace(' ', '.').ToValidFilename();
Regex oldtrackRegex = new Regex("^{?" + Regex.Escape(safeName) + "}? \\[-?\\d+\\]\\.(jpg|png)");
foreach (FileInfo currFile in trackartFolder.GetFiles())
{
if (oldtrackRegex.IsMatch(currFile.Name))
{
found &= mv.AddArtFromFile(currFile.FullName);
}
}
return(found);
}
/// <summary>
/// get the artist details and update missing data from this source
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public DBTrackInfo GetAlbumDetail(DBTrackInfo mv)
{
string strAlbumHTML;
string album = mv.AlbumInfo[0].Album;
string artist = mv.ArtistInfo[0].Artist;
if (GetAlbumHTML(artist, album, out strAlbumHTML))
{
//var albumInfo = new MusicAlbumInfo();
//if (albumInfo.Parse(strAlbumHTML))
var albumInfo = AMGHTMLParser.ParseAlbumHTML(strAlbumHTML, album, artist);
if (albumInfo != null)
{
albumInfo.Artist = album;
DBAlbumInfo mv1 = (DBAlbumInfo)mv.AlbumInfo[0];
SetMusicVideoAlbum(ref mv1, albumInfo);
getTrackComposers(mv, strAlbumHTML, string.Empty);
}
}
return(mv);
}
/// <summary>
/// Playlist startingh with the least played videos
/// </summary>
private void playLeastPlayed()
{
PlayList playlist = Player.playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MVCENTRAL);
playlist.Clear();
List <DBTrackInfo> videos = DBTrackInfo.GetAll();
// Sort Most played first
videos.Sort(delegate(DBTrackInfo p1, DBTrackInfo p2) { return(p1.UserSettings[0].WatchedCount.CompareTo(p2.UserSettings[0].WatchedCount)); });
// Now add to the list
foreach (DBTrackInfo video in videos)
{
playlist.Add(new PlayListItem(video));
}
Player.playlistPlayer.CurrentPlaylistType = PlayListType.PLAYLIST_MVCENTRAL;
Player.playlistPlayer.Play(0);
if (mvCentralCore.Settings.AutoFullscreen)
{
GUIWindowManager.ActivateWindow((int)GUIWindow.Window.WINDOW_FULLSCREEN_VIDEO);
}
}
public bool GetArtwork(DBTrackInfo mv)
{
return false;
}
/// <summary>
/// Get the details of the track
/// </summary>
/// <param name="trackObject"></param>
private void GetDVDDetails(DBTrackInfo trackObject)
{
string strArtistHTML;
string strAlbumHTML;
string strArtistURL;
bool songFound = false;
List<DBTrackInfo> results = new List<DBTrackInfo>();
string artist = trackObject.ArtistInfo[0].Artist;
if (GetArtistHTML(artist, out strArtistHTML, out strArtistURL))
{
var artistInfo = new MusicArtistInfo();
if (artistInfo.Parse(strArtistHTML))
{
artistInfo.Artist = artist;
if (GetDVDURLList(strArtistURL))
{
// we have some albums - now check the tracks in each album
foreach (string albumURL in _albumUrlList)
{
if (GetPageHTMLOnly(albumURL, out strAlbumHTML))
{
var albumInfo = new MusicAlbumInfo();
if (albumInfo.Parse(strAlbumHTML))
{
string[] tracksOnAlbum = albumInfo.Tracks.Split('|');
foreach (string track in tracksOnAlbum)
{
if (!string.IsNullOrEmpty(track.Trim()))
{
string[] trackData = track.Split('@');
if (trackObject.Track == trackData[1])
{
songFound = getTrackComposers(trackObject, strAlbumHTML, trackData[3]);
break;
}
}
}
}
}
}
}
}
}
}
/// <summary>
/// Get Track/Video Artwork already on disk
/// </summary>
/// <param name="trackInfo"></param>
/// <returns></returns>
public bool GetTrackArt(DBTrackInfo trackInfo)
{
logger.Debug("In Method GetTrackArt(DBTrackInfo mv)");
if (trackInfo == null)
return false;
if (this.mvTrackObject == null) this.mvTrackObject = trackInfo;
// if we already have a trackimage move on for now
if (trackInfo.ArtFullPath.Trim().Length > 0)
return false;
bool found = false;
if (mvCentralCore.Settings.SearchCustomFolderForTrackArt)
{
found = getTrackArtFromCustomTrackArtFolder(trackInfo);
logger.Debug("Sucessfully added fanart from custom folder: {0}", trackInfo.ArtFullPath);
}
if (!found)
found = getTrackArtFromTrackArtFolder(trackInfo);
if (!found)
found = getOldTrackArt(trackInfo);
return found;
}
/// <summary>
/// Update the track with the received data
/// </summary>
/// <param name="mvTrackInfo"></param>
public void Update(DBTrackInfo mvTrackInfo)
{
List<DBSourceInfo> sources;
lock (trackDetailSources) sources = new List<DBSourceInfo>(trackDetailSources);
// unlock the mv fields for the first iteration
mvTrackInfo.ProtectExistingValuesFromCopy(false);
// first update from the primary source of this data
int providerCount = 0;
if (mvTrackInfo.PrimarySource != null && mvTrackInfo.PrimarySource.Provider != null)
{
UpdateResults success = mvTrackInfo.PrimarySource.Provider.UpdateTrack(mvTrackInfo);
logger.Debug("*** UPDATE: Track='{0}', Provider='{1}', Version={2}, Result={3}", mvTrackInfo.Track, mvTrackInfo.PrimarySource.Provider.Name, mvTrackInfo.PrimarySource.Provider.Version, success.ToString());
providerCount++;
}
foreach (DBSourceInfo currSource in sources)
{
if (currSource.IsDisabled(DataType.TRACKDETAIL))
continue;
if (currSource == mvTrackInfo.PrimarySource)
continue;
providerCount++;
if (providerCount <= mvCentralCore.Settings.DataProviderRequestLimit || mvCentralCore.Settings.DataProviderRequestLimit == 0)
{
UpdateResults success = currSource.Provider.UpdateTrack(mvTrackInfo);
logger.Debug("*** UPDATE: Track='{0}', Provider='{1}', Version={2}, Result={3}", mvTrackInfo.Track, currSource.Provider.Name, currSource.Provider.Version, success.ToString());
}
else
{
// stop update
break;
}
if (mvCentralCore.Settings.UseTranslator)
{
mvTrackInfo.Translate();
}
}
}
/// <summary>
/// Generate Thumbnail
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
bool generateVideoThumbnail(DBTrackInfo mv)
{
lock (this)
{
string outputFilename = Path.Combine(Path.GetTempPath(), mv.Track + DateTime.Now.ToFileTimeUtc().ToString() + ".jpg");
if (mvCentral.Utils.VideoThumbCreator.CreateVideoThumb(mv.LocalMedia[0].File.FullName, outputFilename))
{
if (File.Exists(outputFilename))
{
mv.AddArtFromFile(outputFilename);
File.Delete(outputFilename);
return true;
}
else
return false;
}
else
return false;
}
}
/// <summary>
/// DVD Code - Play DVD
/// </summary>
/// <param name="db1"></param>
public void PlayDVD(DBTrackInfo db1)
{
DBLocalMedia mediaToPlay = db1.LocalMedia[0];
if (mediaToPlay.State != MediaState.Online) mediaToPlay.Mount();
while (mediaToPlay.State != MediaState.Online) { Thread.Sleep(1000); };
string dvdNavigator = "";
string dslibdvdnavMonikerString = @"@device:sw:{083863F1-70DE-11D0-BD40-00A0C911CE86}\{1FFD2F97-0C57-4E21-9FC1-60DF6C6D20BF}";
Log.Info("finding dslibdvdnav filter");
IBaseFilter filter = Marshal.BindToMoniker(dslibdvdnavMonikerString) as IBaseFilter;
if (filter != null)
{
Log.Info("dslibdvdnav filter found!");
DirectShowUtil.ReleaseComObject(filter);
filter = null;
using (MediaPortal.Profile.Settings xmlreader = mvCentralCore.MediaPortalSettings)
{
xmlreader.SetValue("dvdplayer", "navigator", "dslibdvdnav");
dvdNavigator = xmlreader.GetValueAsString("dvdplayer", "navigator", "DVD Navigator");
}
}
else
Log.Info("dslibdvdnav filter not found using mp default one!");
MediaPortal.Player.g_Player.Play(mediaToPlay.GetVideoPath());
// reset setting back to original
if (dvdNavigator == "dslibdvdnav")
using (MediaPortal.Profile.Settings xmlreader = mvCentralCore.MediaPortalSettings)
{
xmlreader.SetValue("dvdplayer", "navigator", "DVD Navigator");
}
PurgeEntries();
l1 = ROTClass.GetFilterGraphsFromROT();
foreach (DSGrapheditROTEntry e1 in l1)
{
logger.Info(e1.ToString());
_graphBuilder = e1.ConnectToROTEntry() as IGraphBuilder;
_dvdbasefilter = DirectShowUtil.GetFilterByName(_graphBuilder, dvdNavigator);
_dvdCtrl = _dvdbasefilter as IDvdControl2;
_dvdCtrl.SetOption(DvdOptionFlag.HMSFTimeCodeEvents, true); // use new HMSF timecode format
_dvdCtrl.SetOption(DvdOptionFlag.ResetOnStop, false);
_dvdCtrl.SetDVDDirectory(mediaToPlay.GetVideoPath());
DirectShowUtil.RenderOutputPins(_graphBuilder, _dvdbasefilter);
_basicVideo = _graphBuilder as IBasicVideo2;
_mediaCtrl = _graphBuilder as IMediaControl;
//hr = _mediaCtrl.Run();
//hr = _mediaCtrl.Pause();
//_offsetseek = (ulong)seekbar.Value;
TimeSpan t1 = TimeSpan.FromMilliseconds(0);
TimeSpan t2 = TimeSpan.Parse(db1.OffsetTime);
t1 = t1.Add(t2);
// t1 = TimeSpan.Parse(db1.PlayTime);
t2 = t2.Add(TimeSpan.Parse(db1.PlayTime));
DvdHMSFTimeCode t3 = mvCentralUtils.ConvertToDvdHMSFTimeCode(t1);
DvdHMSFTimeCode t4 = mvCentralUtils.ConvertToDvdHMSFTimeCode(t2);
//if (state == FilterState.Stopped)
int hr = _mediaCtrl.Run();
hr = _dvdCtrl.PlayAtTimeInTitle(db1.TitleID, t3, DvdCmdFlags.Flush | DvdCmdFlags.Block, out _cmdOption);
// hr = _dvdCtrl.PlayPeriodInTitleAutoStop(6, t3, t4, DvdCmdFlags.Flush | DvdCmdFlags.Block, out _cmdOption);
DsError.ThrowExceptionForHR(hr);
//int hr = _dvdCtrl.PlayChaptersAutoStop(1, db1.ChapterID, 1, 0, out _cmdOption);
//DsError.ThrowExceptionForHR(hr);
}
}
public GrabberPopup(DBTrackInfo mv)
{
InitializeComponent();
try {
CloseDVDInterfaces();
mvs = mv;
BuildGraph();
btnPlay_Click(null, null);
UpdateSeekBar();
}
catch (Exception) { }
}
public static DBSourceMusicVideoInfo GetOrCreate(DBTrackInfo mv, DBSourceInfo source)
{
DBSourceMusicVideoInfo rtn = Get(mv, source);
if (rtn != null)
return rtn;
rtn = new DBSourceMusicVideoInfo();
rtn.musicvideo = mv;
rtn.Source = source;
// if this is the IMDb data source, populate the id with the imdb_id field
// if (rtn.ScriptID == 874902 && mv.ImdbID.Trim().Length == 9)
// rtn.Identifier = mv.ImdbID;
mv.SourceMusicVideoInfo.Add(rtn);
return rtn;
}
public UpdateResults UpdateTrack(DBTrackInfo mv)
{
throw new NotImplementedException();
}
private bool checkTrackForRemoval(DBTrackInfo mv)
{
if (mv == null) return false;
// Check if all files belonging to the music video are available.
bool continueReassign = false;
while (!continueReassign)
{
continueReassign = true;
foreach (DBLocalMedia localMedia in mv.LocalMedia)
{
// if the file is offline
if (!localMedia.IsAvailable)
{
// do not continue
continueReassign = false;
// Prompt the user to insert the media containing the files
string connect = string.Empty;
if (localMedia.DriveLetter != null)
{
if (localMedia.ImportPath.GetDriveType() == DriveType.CDRom)
connect = "Please insert the disc labeled '" + localMedia.MediaLabel + "'.";
else
connect = "Please reconnect the media labeled '" + localMedia.MediaLabel + "' to " + localMedia.DriveLetter;
}
else
{
connect = "Please make sure the network share '" + localMedia.FullPath + "' is available.";
}
// Show dialog
DialogResult resultInsert = MessageBox.Show(
"The file or files you want to reassign are currently not available.\n\n" + connect,
"File(s) not available.", MessageBoxButtons.RetryCancel);
// if cancel is pressed stop the reassign process.
if (resultInsert == DialogResult.Cancel)
return false;
// break foreach loop (and recheck condition)
break;
}
}
}
return true;
}
public bool GetDetails(DBTrackInfo mv)
{
throw new NotImplementedException();
}
/// <summary>
/// Get Track Artwork from Track Artwork folder
/// </summary>
/// <param name="mvTrackObject"></param>
/// <returns></returns>
private bool getTrackArtFromTrackArtFolder(DBTrackInfo mvTrackObject)
{
bool found = false;
logger.Debug("In Method getTrackArtFromTrackArtFolder(DBTrackInfo mv)");
if (mvTrackObject == null)
return false;
// grab a list of possible filenames for the artistart based on the user pattern
string pattern = mvCentralCore.Settings.TrackArtworkFilenamePattern;
List<string> filenames = getPossibleNamesFromPattern(pattern, mvTrackObject);
// check the artistart folder for the user patterned artistarts
string trackartFolderPath = mvCentralCore.Settings.TrackArtFolder;
FileInfo newTrackArt = getFirstFileFromFolder(trackartFolderPath, filenames);
if (newTrackArt != null && newTrackArt.Exists)
{
mvTrackObject.ArtFullPath = newTrackArt.FullName;
logger.Info("Loaded trackimage from " + newTrackArt.FullName);
return true;
}
return found;
}
/// <summary>
/// Adds the given musicvideo and it's related files to the tree view
/// </summary>
/// <param name="mv"></param>
private void AddMusicVideo(DBTrackInfo mv)
{
TreeNode artistItem = null;
TreeNode albumItem = null;
var artistNodeExist = true;
var albumNodeExist = true;
// Check if we already have the Artist
foreach (TreeNode mvLibraryNode in mvLibraryTreeView.Nodes)
{
if (mvLibraryNode.Level != 0) continue;
var trtag = (DBArtistInfo)mvLibraryNode.Tag;
if (mv.ArtistInfo.Count == 0 || mv.ArtistInfo[0] != trtag) continue;
artistItem = mvLibraryNode;
break;
}
// Add the Artist if we do not already have them
if (artistItem == null && mv.ArtistInfo.Count > 0)
{
artistItem = new TreeNode(mv.ArtistInfo[0].Artist, 1, 1) {Name = mv.ArtistInfo[0].Artist};
if (mv.ArtistInfo[0].ArtFullPath.Trim() == "")
artistItem.ForeColor = Color.Red;
mv.ArtistInfo[0].Changed -= new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
mv.ArtistInfo[0].Changed += new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
artistItem.Tag = mv.ArtistInfo[0];
artistNodeExist = false;
}
// Check if we have the Album
if (mv.AlbumInfo.Count > 0)
{
foreach (TreeNode libraryMainNode in mvLibraryTreeView.Nodes)
{
foreach (TreeNode libraryChildNode in libraryMainNode.Nodes)
{
if ((libraryChildNode.Level != 1) || (libraryChildNode.Tag.GetType() != typeof(DBAlbumInfo))) continue;
var trtag = (DBAlbumInfo)libraryChildNode.Tag;
if (mv.AlbumInfo[0] != trtag) continue;
albumItem = libraryChildNode;
break;
}
}
// Add Album if we do not already have it
if (albumItem == null)
{
albumNodeExist = false;
albumItem = new TreeNode(mv.AlbumInfo[0].Album, 2, 2) {Tag = mv.AlbumInfo[0], Name = mv.AlbumInfo[0].Album};
if (mv.AlbumInfo[0].ArtFullPath.Trim() == "")
{
albumItem.ForeColor = Color.Red;
if (artistItem != null) artistItem.ForeColor = Color.Red;
}
mv.AlbumInfo[0].Changed -= new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
mv.AlbumInfo[0].Changed += new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
}
}
else
albumNodeExist = false;
TreeNode trackItem = null;
trackItem = mv.LocalMedia[0].IsDVD ? new TreeNode(mv.Track, 4, 4) : new TreeNode(mv.Track, 3, 3);
trackItem.Name = mv.Track;
if (mv.ArtFullPath.Trim() == "")
{
trackItem.ForeColor = Color.Red;
if (albumItem != null) albumItem.ForeColor = Color.Red;
if (artistItem != null) artistItem.ForeColor = Color.Red;
}
mv.Changed -= new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
mv.Changed += new DBBasicInfo.ChangedEventHandler(basicInfoChanged);
trackItem.Tag = mv;
if (albumItem == null)
albumItem = trackItem;
else
albumItem.Nodes.Add(trackItem);
if (!albumNodeExist)
{
albumTotal++;
if (artistItem != null) artistItem.Nodes.Add(albumItem);
}
if (!artistNodeExist)
{
artistTotal++;
mvLibraryTreeView.Nodes.Add(artistItem);
}
// if the movie is offline color it red
if (mv.LocalMedia.Count <= 0 || mv.LocalMedia[0].IsAvailable) return;
trackItem.ForeColor = Color.Red;
trackItem.ToolTipText = "This musicvideo is currently offline.";
}
private void manualAssignButton_Click(object sender, EventArgs e)
{
unapprovedGrid.EndEdit();
foreach (DataGridViewRow currRow in unapprovedGrid.SelectedRows)
{
MusicVideoMatch selectedMatch = (MusicVideoMatch)currRow.DataBoundItem;
DBLocalMedia mediaToPlay = selectedMatch.LocalMedia[0];
if (mediaToPlay.State != MediaState.Online) mediaToPlay.Mount();
while (mediaToPlay.State != MediaState.Online) { Thread.Sleep(1000); };
ManualAssignPopup popup = new ManualAssignPopup(selectedMatch);
popup.ShowDialog(this);
if (popup.DialogResult == DialogResult.OK)
{
// create a musicvideo with the user supplied information
DBTrackInfo mv = new DBTrackInfo();
mv.Track = popup.Track;
if (popup.Album.Trim().Length > 0)
{
DBAlbumInfo db1 = DBAlbumInfo.Get(popup.Album);
if (db1 == null) db1 = new DBAlbumInfo();
db1.Album = popup.Album;
mv.AlbumInfo.Add(db1);
}
DBArtistInfo db2 = DBArtistInfo.Get(popup.Artist);
if (db2 == null)
{
db2 = new DBArtistInfo();
db2.Artist = popup.Artist;
}
mv.ArtistInfo.Add(db2);
foreach (DBSourceInfo r1 in mvCentralCore.DataProviderManager.AllSources)
{
if (r1.Provider is ManualProvider)
{
mv.PrimarySource = r1;
mv.ArtistInfo[0].PrimarySource = r1;
if (mv.AlbumInfo != null && mv.AlbumInfo.Count > 0) mv.AlbumInfo[0].PrimarySource = r1;
}
}
// We have DVD and set to split DVD into chapters
// This is a great idea that falls flat for two reasons..
// 1. There is not decent source of DVD/Track info
// 2. Even if the tracks were split out and named I have yet to find a method of playing a single track from a DVD
// For now will skip this
bool dothisCodeBlock = false;
// Split the DVD into chapters
if (selectedMatch.LocalMedia[0].IsDVD && cbSplitDVD.Checked && dothisCodeBlock)
{
string videoPath = mediaToPlay.GetVideoPath();
if (videoPath == null) videoPath = selectedMatch.LongLocalMediaString;
string pathlower = Path.GetDirectoryName(videoPath).ToLower();
pathlower = pathlower.Replace("\\video_ts", "");
pathlower = pathlower.Replace("\\adv_obj", "");
pathlower = pathlower.Replace("\\bdmv", "");
if (pathlower.Length < 3) pathlower = pathlower + "\\";
ChapterExtractor ex =
Directory.Exists(Path.Combine(pathlower, "VIDEO_TS")) ?
new DvdExtractor() as ChapterExtractor :
Directory.Exists(Path.Combine(pathlower, "ADV_OBJ")) ?
new HddvdExtractor() as ChapterExtractor :
Directory.Exists(Path.Combine(Path.Combine(pathlower, "BDMV"), "PLAYLIST")) ?
new BlurayExtractor() as ChapterExtractor :
null;
if (ex != null)
{
List<ChapterInfo> rp = ex.GetStreams(pathlower, 1);
if (mediaToPlay.IsMounted)
{
mediaToPlay.UnMount();
while (mediaToPlay.IsMounted) { Thread.Sleep(1000); };
}
foreach (ChapterInfo ci in rp)
{
foreach (ChapterEntry c1 in ci.Chapters)
{
//skip menus/small crap
// if (c1.Time.TotalSeconds < 20) continue;
DBTrackInfo db1 = new DBTrackInfo();
db1.Copy(mv);
db1.TitleID = ci.TitleID;
db1.Track = "Chapter " + ci.TitleID.ToString("##") + " - " + c1.chId.ToString("##");
db1.Chapter = "Chapter " + c1.chId.ToString("##");
db1.ChapterID = c1.chId;
db1.PlayTime = c1.Time.ToString();
db1.OffsetTime = c1.OffsetTime.ToString();
db1.ArtistInfo.Add(mv.ArtistInfo[0]);
if (mv.AlbumInfo != null && mv.AlbumInfo.Count > 0) db1.AlbumInfo.Add(mv.AlbumInfo[0]);
db1.LocalMedia.Add(selectedMatch.LocalMedia[0]);
db1.Commit();
}
}
selectedMatch.LocalMedia[0].UpdateMediaInfo();
selectedMatch.LocalMedia[0].Commit();
mvStatusChangedListener(selectedMatch, MusicVideoImporterAction.COMMITED);
// ReloadList();
return;
}
}
// update the match
PossibleMatch selectedMV = new PossibleMatch();
selectedMV.MusicVideo = mv;
MatchResult result = new MatchResult();
result.TitleScore = 0;
result.YearScore = 0;
result.MdMatch = true;
selectedMV.Result = result;
selectedMatch.PossibleMatches.Add(selectedMV);
selectedMatch.Selected = selectedMV;
ThreadStart actions = delegate
{
// Manually Assign Movie
mvCentralCore.Importer.ManualAssign(selectedMatch);
};
Thread thread = new Thread(actions);
thread.Name = "ManualUpdateThread";
thread.Start();
}
}
}
/// <summary>
/// parses and replaces variables from a filename based on the pattern supplied
/// returning a list of possible file matches
/// </summary>
/// <param name="pattern"></param>
/// <param name="mv"></param>
/// <returns></returns>
private List<string> getPossibleNamesFromPattern(string pattern, object mv)
{
Regex parser = new Regex("%(.*?)%", RegexOptions.IgnoreCase);
// Artist Artwork
if (mv.GetType() == typeof(DBArtistInfo))
{
mvArtistObject = (DBArtistInfo)mv;
lock (lockObj)
{
List<string> filenames = new List<string>();
foreach (string currPattern in pattern.Split('|'))
{
// replace db field patterns
string filename = parser.Replace(currPattern, new MatchEvaluator(dbArtistNameParser)).Trim().ToLower();
if (filename != null)
filenames.Add(filename);
}
return filenames;
}
}
// Album Artwork
if (mv.GetType() == typeof(DBAlbumInfo))
{
mvAlbumObject = (DBAlbumInfo)mv;
lock (lockObj)
{
List<string> filenames = new List<string>();
foreach (string currPattern in pattern.Split('|'))
{
// replace db field patterns
string filename = parser.Replace(currPattern, new MatchEvaluator(dbAlbumNameParser)).Trim().ToLower();
if (filename != null)
filenames.Add(filename);
}
return filenames;
}
}
// This is track data
if (mv.GetType() == typeof(DBTrackInfo))
{
// try to create our filename(s)
this.mvTrackObject = (DBTrackInfo)mv;
//this.mvTrackObject.LocalMedia[0].TrimmedFullPath;
lock (lockObj)
{
List<string> filenames = new List<string>();
foreach (string currPattern in pattern.Split('|'))
{
// replace db field patterns
string filename = parser.Replace(currPattern, new MatchEvaluator(dbTrackNameParser)).Trim().ToLower();
// replace %filename% pattern
if (mvTrackObject.LocalMedia.Count > 0)
{
string videoFileName = Path.GetFileNameWithoutExtension(mvTrackObject.LocalMedia[0].File.Name);
filename = filename.Replace("%filename%", videoFileName);
}
filenames.Add(filename);
}
return filenames;
}
}
//should never get here
return null;
}
/// <summary>
/// Get the Track Artwork using the old Method
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
private bool getOldTrackArt(DBTrackInfo mv)
{
logger.Debug("In Method getOldTrackArt(DBTrackInfo mv)");
bool found = false;
string trackartFolderPath = mvCentralCore.Settings.TrackArtFolder;
DirectoryInfo trackartFolder = new DirectoryInfo(trackartFolderPath);
string safeName = mv.Track.Replace(' ', '.').ToValidFilename();
Regex oldtrackRegex = new Regex("^{?" + Regex.Escape(safeName) + "}? \\[-?\\d+\\]\\.(jpg|png)");
foreach (FileInfo currFile in trackartFolder.GetFiles())
{
if (oldtrackRegex.IsMatch(currFile.Name))
{
found &= mv.AddArtFromFile(currFile.FullName);
}
}
return found;
}
public static DBArtistInfo GetOrCreate(DBTrackInfo mv)
{
DBArtistInfo rtn = mv.ArtistInfo[0];
if (rtn != null)
return rtn;
rtn = new DBArtistInfo();
mv.ArtistInfo.Add(rtn);
return rtn;
}
/// <summary>
/// Get the details of the track
/// </summary>
/// <param name="trackObject"></param>
private void GetTrackDetails(DBTrackInfo trackObject)
{
string strArtistHTML;
string strAlbumHTML;
string strArtistURL;
bool songFound = false;
const int trackName = 1;
const int trackURL = 3;
List<DBTrackInfo> results = new List<DBTrackInfo>();
string strAlbumArtist = trackObject.ArtistInfo[0].Artist;
if (GetArtistHTML(strAlbumArtist, out strArtistHTML, out strArtistURL))
{
var artistInfo = new MusicArtistInfo();
if (artistInfo.Parse(strArtistHTML))
{
artistInfo.Artist = strAlbumArtist;
if (GetAlbumURLList(strArtistURL))
{
// we have some albums - now check the tracks in each album
foreach (string albumURL in _albumUrlList)
{
// If we found the song then exit...
if (songFound)
break;
if (GetPageHTMLOnly(albumURL, out strAlbumHTML))
{
string strAlbum = Regex.Match(albumURL, "[^/]+-", RegexOptions.Singleline | RegexOptions.IgnoreCase).Value;
strAlbum = Regex.Replace(strAlbum, "[-?*]", " ", RegexOptions.Singleline | RegexOptions.IgnoreCase);
var albumInfo = AMGHTMLParser.ParseAlbumHTML(strAlbumHTML, strAlbum.Trim(), strAlbumArtist);
if (albumInfo != null)
{
string[] tracksOnAlbum = albumInfo.Tracks.Split('|');
foreach (string track in tracksOnAlbum)
{
if (!string.IsNullOrEmpty(track.Trim()))
{
string[] trackData = track.Split('@');
if (string.Equals(trackObject.Track, trackData[trackName], StringComparison.CurrentCultureIgnoreCase))
{
Logger.Debug("Get Composers for Track {0} by {1}", trackObject.Track, strAlbumArtist);
songFound = getTrackComposers(trackObject, strAlbumHTML, trackData[trackURL]);
Logger.Debug("Composers for Track {0} by {1} are {2}", trackObject.Track, strAlbumArtist, trackObject.Composers);
break;
}
}
}
}
}
}
}
}
}
}
public DBTrackInfo GetArtistDetail(DBTrackInfo mv)
{
throw new NotImplementedException();
}
private void setMusicVideoTrack(ref DBTrackInfo mv, string id)
{
}
public bool GetTrackArt(DBTrackInfo mv)
{
return false;
}
/// <summary>
/// get the artist details and update missing data from this source
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public DBTrackInfo GetAlbumDetail(DBTrackInfo mv)
{
string strAlbumHTML;
string album = mv.AlbumInfo[0].Album;
string artist = mv.ArtistInfo[0].Artist;
if (GetAlbumHTML(artist, album, out strAlbumHTML))
{
//var albumInfo = new MusicAlbumInfo();
//if (albumInfo.Parse(strAlbumHTML))
var albumInfo = AMGHTMLParser.ParseAlbumHTML(strAlbumHTML, album, artist);
if (albumInfo != null)
{
albumInfo.Artist = album;
DBAlbumInfo mv1 = (DBAlbumInfo)mv.AlbumInfo[0];
SetMusicVideoAlbum(ref mv1, albumInfo);
getTrackComposers(mv, strAlbumHTML, string.Empty);
}
}
return mv;
}
public static DBAlbumInfo Get(DBTrackInfo mv)
{
if (mv.AlbumInfo.Count == 0)
return null;
foreach (DBAlbumInfo db1 in GetAll())
{
if (db1.MdID != null && db1.MdID.Trim().Length > 0)
if (String.Equals(db1.MdID.Trim(), mv.AlbumInfo[0].MdID.Trim(), StringComparison.InvariantCultureIgnoreCase))
return db1;
if (db1.Album.Trim().Length > 0)
if (String.Equals(db1.Album.Trim(), mv.AlbumInfo[0].Album.Trim(), StringComparison.InvariantCultureIgnoreCase))
return db1;
}
return null;
}
/// <summary>
/// get the artist details and update missing data from this source
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public DBTrackInfo GetArtistDetail(DBTrackInfo mv)
{
string strArtistHtml;
string strArtistUrl;
// Get details of the artist
string artist = mv.ArtistInfo[0].Artist;
if (GetArtistHTML(artist, out strArtistHtml, out strArtistUrl))
{
var artistInfo = AMGHTMLParser.ParseArtistHTML(strArtistHtml, artist);
//var artistInfo = new MusicArtistInfo();
if (artistInfo != null)
{
artistInfo.Artist = artist;
DBArtistInfo mv1 = (DBArtistInfo)mv.ArtistInfo[0];
UpdateMusicVideoArtist(ref mv1, artistInfo, strArtistHtml);
}
}
return mv;
}
/// <summary>
/// Play the video
/// </summary>
/// <param name="iItem"></param>
/// <returns></returns>
public bool Play(int iItem)
{
// if play returns false PlayNext is called but this does not help against selecting an invalid file
bool skipmissing = false;
do
{
if (_currentPlayList == PlayListType.PLAYLIST_NONE)
{
logger.Debug("PlaylistPlayer.Play() no playlist selected");
return false;
}
PlayList playlist = GetPlaylist(_currentPlayList);
if (playlist.Count <= 0)
{
logger.Debug("PlaylistPlayer.Play() playlist is empty");
return false;
}
if (iItem < 0)
iItem = 0;
if (iItem >= playlist.Count)
{
if (skipmissing)
return false;
else
{
if (_entriesNotFound < playlist.Count)
iItem = playlist.Count - 1;
else
return false;
}
}
GUIMessage GUIMessageToSend = null;
_currentItem = iItem;
PlayListItem item = playlist[_currentItem];
GUIMessageToSend = new GUIMessage(GUIMessage.MessageType.GUI_MSG_ITEM_FOCUS, 0, 0, 0, _currentItem, 0, null);
GUIMessageToSend.Label = item.Track.LocalMedia[0].File.FullName;
logger.Debug("Sending GUI_MSG_ITEM_FOCUS message from PlayListPlayer");
GUIGraphicsContext.SendMessage(GUIMessageToSend);
GUIMessageToSend = new GUIMessage(GUIMessage.MessageType.GUI_MSG_PLAYLIST_CHANGED, 0, 0, 0, _currentItem, 0, null);
GUIMessageToSend.Label = item.Track.LocalMedia[0].File.FullName;
logger.Debug("Sending GUI_MSG_PLAYLIST_CHANGED message from PlayListPlayer");
GUIGraphicsContext.SendMessage(GUIMessageToSend);
if (playlist.AllPlayed())
{
//playlist.ResetStatus();
}
bool playResult = false;
// If the file is an image file, it should be mounted before playing
string filename = item.Track.LocalMedia[0].File.FullName;
CurrentTrack = item.Track;
DBLocalMedia mediaToPlay = item.Track.LocalMedia[0];
MediaState mediaState = mediaToPlay.State;
while (mediaState != MediaState.Online)
{
switch (mediaState)
{
case MediaState.Removed:
GUIUtils.ShowOKDialog("Error", Localization.MediaIsMissing);
// resetPlayer();
return false;
case MediaState.Offline:
string bodyString = String.Format(Localization.MediaNotAvailableBody, mediaToPlay.MediaLabel);
// Special debug line to troubleshoot availability issues
logger.Debug("Media not available: Path={0}, DriveType={1}, Serial={2}, ExpectedSerial={3}",
mediaToPlay.FullPath, mediaToPlay.ImportPath.GetDriveType().ToString(),
mediaToPlay.ImportPath.GetVolumeSerial(), mediaToPlay.VolumeSerial);
// Prompt user to enter media
if (!GUIUtils.ShowCustomYesNoDialog(Localization.MediaNotAvailableHeader, bodyString, Localization.Retry, Localization.Cancel, true))
{
// user cancelled so exit
// resetPlayer();
return false;
}
break;
case MediaState.NotMounted:
// Mount this media
MountResult result = mediaToPlay.Mount();
while (result == MountResult.Pending)
{
if (GUIUtils.ShowCustomYesNoDialog(Localization.VirtualDriveHeader, Localization.VirtualDriveMessage, Localization.Retry, Localization.Cancel, true))
{
// User has chosen to retry
// We stay in the mount loop
result = mediaToPlay.Mount();
}
else
{
// Exit Player
return false;
}
}
// If the mounting failed (can not be solved within the loop) show error and return
if (result == MountResult.Failed)
{
GUIUtils.ShowOKDialog(Localization.Error, Localization.FailedMountingImage);
// Exit the player
return false;
}
// Mounting was succesfull, break the mount loop
break;
}
// Check mediaState again
mediaState = mediaToPlay.State;
}
// Start Listening to any External Player Events
logger.Debug("Start Listening to any External Player Events");
listenToExternalPlayerEvents = true;
// Play File
MvGuiMain.CurrentArtistId = (int)CurrentTrack.ArtistInfo[0].ID;
MvGuiMain.CurrentArtistInfo = CurrentTrack.ArtistInfo[0];
logger.Debug(string.Format("Start playing : Artist: {0} with and ID: {1} Filename :{2}", MvGuiMain.CurrentArtistInfo.Artist, MvGuiMain.CurrentArtistId, filename));
// Check if the playing is playling and stop playback if it is.
if (mvPlayer.Playing)
mvPlayer.Stop();
//if (CurrentTrack.LocalMedia[0].IsDVD)
// mvPlayer.PlayDVD(CurrentTrack);
//else
playResult = mvPlayer.Play(filename);
// Stop Listening to any External Player Events
logger.Debug("Stop Listening to any External Player Events");
listenToExternalPlayerEvents = false;
if (!playResult)
{
// Count entries in current playlist that couldn't be played
_entriesNotFound++;
logger.Info(string.Format("PlaylistPlayer: *** unable to play - {0} - skipping file!", item.FileName));
// do not try to play the next file list
if (MediaPortal.Util.Utils.IsVideo(filename))
skipmissing = false;
else
skipmissing = true;
iItem++;
}
else
{
logger.Debug("Starting playing Ok!");
SetProperties(item, false);
if (mvCentralCore.Settings.ShowOnLastFM)
ScrobbleSend(item);
skipmissing = false;
if (MediaPortal.Util.Utils.IsVideo(filename))
{
if (mvPlayer.HasVideo)
{
// needed so everything goes in sequence otherwise stop gets handled after the play events
if (mvCentralCore.Settings.AutoFullscreen)
{
logger.Debug("Setting Fullscreen");
mvPlayer.ShowFullScreenWindow();
}
}
}
}
}
while (skipmissing);
return mvPlayer.Playing;
}
public UpdateResults UpdateTrack(DBTrackInfo mv)
{
return UpdateResults.SUCCESS;
}
/// <summary>
/// Get the Rating for the track
/// </summary>
/// <param name="trackObject"></param>
/// <param name="albumHTML"></param>
/// <returns></returns>
bool getTrackComposers(DBTrackInfo trackObject, string albumHTML, string trackURL)
{
string strSongHTML = string.Empty;
string songComposers = string.Empty; ;
var strAlbumRemoveBrackets = BracketRegEx.Replace(trackObject.Track, "$1").Trim();
var strRemovePunctuation = PunctuationRegex.Replace(trackObject.Track, "").Trim();
var strAndAlbum = trackObject.Track.Replace("&", "and").Replace("+", "and");
// Extract the composers first
string trackHTML = string.Empty;
GetPageHTMLOnly(trackURL, out trackHTML);
MatchCollection allMatchResults = null;
CaptureCollection captureCollection;
GroupCollection groupCollection;
try
{
Regex composerRegion = new Regex(@"Composed by(?<composers>.+?)<\/h3>", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Compiled);
Match match = composerRegion.Match(trackHTML);
if (match.Success)
{
string _composers = match.Groups[1].Value;
Regex trackRegex = new Regex(@"<a.href=[^>]+?>(?<composer>[^<]+)<\/a>", RegexOptions.IgnoreCase | RegexOptions.Multiline | RegexOptions.CultureInvariant | RegexOptions.Compiled);
allMatchResults = trackRegex.Matches(_composers);
foreach (Match cmatch in allMatchResults)
{
groupCollection = cmatch.Groups;
captureCollection = groupCollection[1].Captures;
for (int i = 0; i < captureCollection.Count; i++)
songComposers += (i == captureCollection.Count - 1) ? captureCollection[i].Value : captureCollection[i].Value + "|";
}
}
trackObject.Composers = songComposers;
return true;
}
catch (Exception)
{ }
return false;
}
/// <summary>
/// get the artist details
/// </summary>
/// <param name="mv"></param>
/// <returns></returns>
public DBTrackInfo GetArtistDetail(DBTrackInfo mv)
{
// ****************** Additional Artist Info Processing ******************
// Check and update Artist details from additional providers
DBArtistInfo artInfo = new DBArtistInfo();
artInfo = mv.ArtistInfo[0];
foreach (DBSourceInfo artistExtraInfo in artistDetailSources)
{
if (artInfo.PrimarySource != artistExtraInfo.Provider)
{
artInfo = artistExtraInfo.Provider.GetArtistDetail(mv).ArtistInfo[0];
artInfo.PrimarySource = artistExtraInfo;
}
}
mv.ArtistInfo[0] = artInfo;
return mv;
}
