public NowPlayingMusic(Song song)
        {
            ItemId = song.Id;
            Album = song.Album;
            AlbumArtist = song.AlbumArtist;
            Artist = song.Artist;
            BitRate = song.BitRate;
            BitRateMode = song.BitRateMode;
            BPM = song.BPM;
            Channels = song.Channels;
            Codec = song.Codec;
            Comment = song.Comment;
            Composer = song.Composer;
            Conductor = song.Conductor;
            DateTimeModified = song.DateTimeModified;
            DateTimePlayed = song.DateTimePlayed;
            DiscId = song.DiscId;
            DiscTotal = song.DiscTotal;
            Duration = song.Duration;
            Genre = song.Genre;
            Lyrics = song.Lyrics;
            Rating = song.Rating;
            SampleRate = song.SampleRate;
            TimesPlayed = song.TimesPlayed;
            Title = song.Title;
            Track = song.Track;
            TrackTotal = song.TrackTotal;
            URL = song.URL;
            WebImage = song.WebImage;
            Year = song.Year;

            ImageName = MediaPortal.Util.Utils.GetAlbumThumbName(song.Artist, song.Album);
            ImageName = MediaPortal.Util.Utils.ConvertToLargeCoverArt(ImageName);
        }

 public QueuedTrack(Song track)
 {
   this.artist = track.Artist;
   this.title = track.Title;
   this.start_time = track.getQueueTime(true);
   this.source = track.getSourceParam();
   this.rating = track.getRateActionParam();
   this.duration = (int)track.Duration;
   this.album = track.Album;
   this.tracknr = track.Track;
   this.auth = track.AuthToken;
 }

        /// <summary>
        /// Add MpExtended information to playlist item
        /// </summary>
        /// <param name="item">MediaPortal playlist item</param>
        /// <param name="message">Playlist message item that is sent to client</param>
        internal static void AddMpExtendedInfo(MediaPortal.Playlists.PlayListItem item, PlaylistEntry message)
        {
            MusicDatabase mpMusicDb = MusicDatabase.Instance;
            Song song = new Song();
            bool inDb = mpMusicDb.GetSongByFileName(item.FileName, ref song);

            if (inDb)
            {
                message.Name2 = song.Album;
                message.AlbumArtist = song.AlbumArtist;
                message.Title = song.Title;
                message.MpExtId = song.Id.ToString();
                message.MpExtMediaType = (int)MpExtended.MpExtendedMediaTypes.MusicTrack;
                message.MpExtProviderId = (int)MpExtended.MpExtendedProviders.MPMusic;
            }
        }

    public bool AssignAllSongFieldsFromResultSet(ref Song aSong, SQLiteResultSet aResult, int aRow)
    {
      if (aSong == null || aResult == null || aResult.Rows.Count < 1)
      {
        return false;
      }

      aSong.Id = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.idTrack");
      aSong.FileName = DatabaseUtility.Get(aResult, aRow, "tracks.strPath");
      aSong.Artist = DatabaseUtility.Get(aResult, aRow, "tracks.strArtist").Trim(trimChars);
      aSong.AlbumArtist = DatabaseUtility.Get(aResult, aRow, "tracks.strAlbumArtist").Trim(trimChars);
      aSong.Album = DatabaseUtility.Get(aResult, aRow, "tracks.strAlbum");
      aSong.Genre = DatabaseUtility.Get(aResult, aRow, "tracks.strGenre").Trim(trimChars);
      aSong.Title = DatabaseUtility.Get(aResult, aRow, "tracks.strTitle");
      aSong.Track = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iTrack");
      aSong.TrackTotal = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iNumTracks");
      aSong.Duration = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iDuration");
      aSong.Year = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iYear");
      aSong.TimesPlayed = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iTimesPlayed");
      aSong.Rating = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iRating");
      aSong.Favorite = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iFavorite") != 0;
      aSong.ResumeAt = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iResumeAt");
      aSong.DiscId = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iDisc");
      aSong.DiscTotal = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iNumDisc");
      aSong.Lyrics = DatabaseUtility.Get(aResult, aRow, "tracks.strLyrics");
      aSong.Composer = DatabaseUtility.Get(aResult, aRow, "tracks.strComposer").Trim(trimChars);
      aSong.Conductor = DatabaseUtility.Get(aResult, aRow, "tracks.strConductor").Trim(trimChars);
      aSong.Comment = DatabaseUtility.Get(aResult, aRow, "tracks.strComment").Trim(trimChars);
      aSong.FileType = DatabaseUtility.Get(aResult, aRow, "tracks.strFileType").Trim(trimChars);
      aSong.Codec = DatabaseUtility.Get(aResult, aRow, "tracks.strFullCodec").Trim(trimChars);
      aSong.BitRateMode = DatabaseUtility.Get(aResult, aRow, "tracks.strBitRateMode").Trim(trimChars);
      aSong.BPM = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iBPM");
      aSong.BitRate = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iBitRate");
      aSong.Channels = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iChannels");
      aSong.SampleRate = DatabaseUtility.GetAsInt(aResult, aRow, "tracks.iSampleRate");
      try
      {
        aSong.DateTimePlayed = DatabaseUtility.GetAsDateTime(aResult, aRow, "dateLastPlayed");
        aSong.DateTimeModified = DatabaseUtility.GetAsDateTime(aResult, aRow, "dateAdded");
      }
      catch (Exception ex)
      {
        Log.Warn("MusicDatabase Lookup: Exception parsing date fields: {0} stack: {1}", ex.Message, ex.StackTrace);
      }
      return true;
    }

        /// <summary>
        /// Adds a song to a playlist
        /// </summary>
        /// <param name="type">Type of the playlist</param>
        /// <param name="entry">Item that gets added</param>
        /// <param name="index">Index where the item should be added</param>
        /// <param name="refresh">Should the playlist be refreshed after the item is added</param>
        public static void AddItemToPlaylist(String type, PlaylistEntry entry, int index, bool refresh)
        {
            PlayListType plType = GetTypeFromString(type);
            PlayListPlayer playListPlayer = PlayListPlayer.SingletonPlayer;
            PlayList playList = playListPlayer.GetPlaylist(plType);
            PlayListItem item = null;

            //If it's a music item, try to find it in the db
            if (plType == PlayListType.PLAYLIST_MUSIC)
            {
                MusicDatabase mpMusicDb = MusicDatabase.Instance;
                Song song = new Song();
                bool inDb = mpMusicDb.GetSongByFileName(entry.FileName, ref song);

                if (inDb)
                {
                    item = ToPlayListItem(song);
                }
            }
            else if (plType == PlayListType.PLAYLIST_VIDEO)
            {
                IMDBMovie movie = new IMDBMovie();
                int id = VideoDatabase.GetMovieInfo(entry.FileName, ref movie);

                if (id > 0)
                {
                    item = ToPlayListItem(movie);
                }
            }

            if (item == null)
            {
                item = new PlayListItem(entry.Name, entry.FileName, entry.Duration);
            }

            playList.Insert(item, index);

            if (refresh)
            {
                RefreshPlaylistIfVisible();
            }
        }

    private void ShowSong()
    {
      GUIDialogNotify dlg = (GUIDialogNotify)GUIWindowManager.GetWindow((int)Window.WINDOW_DIALOG_NOTIFY);
      if (dlg == null)
      {
        return;
      }

      //get albumart
      string albumart = g_Player.CurrentFile;
      int e = albumart.LastIndexOf(@"\") + 1;
      albumart = albumart.Remove(e);
      if (_slideList[_currentSlideIndex].Contains(albumart))
      {
        albumart = string.Empty;
      }
      else
      {
        albumart = Util.Utils.GetFolderThumbForDir(albumart);
        if (!Util.Utils.FileExistsInCache(albumart))
        {
          albumart = string.Empty;
        }
      }
      // get Song-info

      // hwahrmann 2006-11-22 Using the Tagreader caused a COM exception in Win Media SDK, when reading WMA files
      // Accessing the Music Database instead of using the Tagreader.
      //MediaPortal.TagReader.MusicTag tag = MediaPortal.TagReader.TagReader.ReadTag(g_Player.CurrentFile);
      Song song = new Song();

      // If we don't have a tag in the db, we use the filename without the extension as song.title
      song.Title = Path.GetFileNameWithoutExtension(g_Player.CurrentFile);
      mDB.GetSongByFileName(g_Player.CurrentFile, ref song);

      // Show Dialog
      dlg.Reset();
      dlg.Dispose();
      dlg.SetImage(albumart);
      dlg.SetHeading(4540);
      //dlg.SetText(tag.Title + "\n" + tag.Artist + "\n" + tag.Album);
      dlg.SetText(song.Title + "\n" + song.Artist + "\n" + song.Album);
      dlg.TimeOut = 5;
      dlg.DoModal(GUIWindowManager.ActiveWindow);
    }

    public Song Clone()
    {
      var newsong = new Song
                      {
                        Id = Id,
                        Album = Album,
                        Artist = Artist,
                        AlbumArtist = AlbumArtist,
                        Duration = Duration,
                        FileName = FileName,
                        Genre = Genre,
                        Composer = Composer,
                        Conductor = Conductor,
                        TimesPlayed = TimesPlayed,
                        Title = Title,
                        Track = Track,
                        TrackTotal = TrackTotal,
                        Year = Year,
                        Rating = Rating,
                        Favorite = Favorite,
                        DateTimeModified = DateTimeModified,
                        DateTimePlayed = DateTimePlayed,
                        URL = URL,
                        ResumeAt = ResumeAt,
                        DiscId = DiscId,
                        DiscTotal = DiscTotal,
                        Lyrics = Lyrics,
                        AuthToken = AuthToken,
                        Comment = Comment,
                        FileType = FileType,
                        Codec = Codec,
                        BitRateMode = BitRateMode,
                        BPM = BPM,
                        Channels = Channels,
                        SampleRate = SampleRate
                      };

      return newsong;
    }

    /// <summary>
    /// Add or enque a song to the current playlist - call OnSongInserted() after this!!!
    /// </summary>
    /// <param name="song">the song to add</param>
    /// <returns>if the action was successful</returns>
    private bool AddSongToPlaylist(ref Song song)
    {
      PlayList playlist;
      if (PlaylistPlayer.CurrentPlaylistType == PlayListType.PLAYLIST_MUSIC_TEMP)
      {
        playlist = PlaylistPlayer.GetPlaylist(PlayListType.PLAYLIST_MUSIC_TEMP);
      }
      else
      {
        playlist = PlaylistPlayer.GetPlaylist(PlayListType.PLAYLIST_MUSIC);
      }
      
      if (playlist == null)
      {
        return false;
      }

      //add to playlist
      PlayListItem playlistItem = new PlayListItem();
      playlistItem.Type = PlayListItem.PlayListItemType.Audio;
      StringBuilder sb = new StringBuilder();

      playlistItem.FileName = song.FileName;
      sb.Append(song.Track);
      sb.Append(". ");
      sb.Append(song.Artist);
      sb.Append(" - ");
      sb.Append(song.Title);
      playlistItem.Description = sb.ToString();
      playlistItem.Duration = song.Duration;

      playlistItem.MusicTag = song.ToMusicTag();
      playlist.Add(playlistItem);

      OnSongInserted();
      return true;
    }

    private bool AddRandomSongToPlaylist(ref Song song)
    {
      //check duplication
      PlayList playlist = playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MUSIC);
      for (int i = 0; i < playlist.Count; i++)
      {
        PlayListItem item = playlist[i];
        if (item.FileName == song.FileName)
        {
          return false;
        }
      }

      //add to playlist
      PlayListItem playlistItem = new PlayListItem();
      playlistItem.Type = PlayListItem.PlayListItemType.Audio;
      StringBuilder sb = new StringBuilder();

      playlistItem.FileName = song.FileName;
      sb.Append(song.Track);
      sb.Append(". ");
      sb.Append(song.Artist);
      sb.Append(" - ");
      sb.Append(song.Title);
      playlistItem.Description = sb.ToString();
      playlistItem.Duration = song.Duration;

      MusicTag tag = new MusicTag();
      tag = song.ToMusicTag();

      playlistItem.MusicTag = tag;

      playlistPlayer.GetPlaylist(PlayListType.PLAYLIST_MUSIC).Add(playlistItem);
      return true;
    }

    public bool IncrTop100CounterByFileName(string aFileName)
    {
      try
      {
        Song song = new Song();
        string strFileName = aFileName;
        DatabaseUtility.RemoveInvalidChars(ref strFileName);

        strSQL = String.Format("SELECT * from tracks WHERE strPath = '{0}'", strFileName);

        SQLiteResultSet results = MusicDbClient.Execute(strSQL);
        if (results.Rows.Count == 0)
        {
          return false;
        }

        int idSong = DatabaseUtility.GetAsInt(results, 0, "idTrack");
        int iTimesPlayed = DatabaseUtility.GetAsInt(results, 0, "iTimesPlayed");

        strSQL = String.Format("UPDATE tracks SET iTimesPlayed={0}, dateLastPlayed='{1}' where idTrack='{2}'", 
          ++iTimesPlayed, DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"), idSong);
        if (DirectExecute(strSQL).Rows.Count > 0)
        {
          Log.Debug("MusicDatabase: increased playcount for song {1} to {0}", Convert.ToString(iTimesPlayed), aFileName);
          return true;
        }
      }
      catch (Exception ex)
      {
        Log.Error("musicdatabase exception err:{0} stack:{1}", ex.Message, ex.StackTrace);
        Open();
      }

      return false;
    }

    private void DoUpdateArtistInfo(ArtistInfoRequest request, Song song)
    {
      // artist tag can contain multiple artists and 
      // will be separated by " | " so split by | then trim
      // so we will add one thumb for artist
      String[] strArtists = CurrentTrackTag.Artist.Split('|');
      foreach (String strArtist in strArtists)
      {
        CurrentThumbFileName = Util.Utils.GetCoverArtName(Thumbs.MusicArtists,
                                                          Util.Utils.MakeFileName(strArtist.Trim()));
        if (CurrentThumbFileName.Length > 0)
        {
          // 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();
        }
      }
    }

 public void OnUpdateArtistInfoCompleted(ArtistInfoRequest request, Song song)
 {
   if (request.Equals(_lastArtistRequest))
   {
     GUIGraphicsContext.form.Invoke(new ArtistInfoCompletedDelegate(DoUpdateArtistInfo), new object[] {request, song});
   }
   else
   {
     Log.Warn("NowPlaying.OnUpdateArtistInfoCompleted: unexpected response for request: {0}", request.Type);
   }
 }

    private void AddInfoTrackToPlaylist(GUIListItem chosenTrack_)
    {
      try
      {
        MusicDatabase mdb = MusicDatabase.Instance;
        Song addSong = new Song();
        MusicTag tempTag = new MusicTag();
        tempTag = (MusicTag)chosenTrack_.MusicTag;

        if (mdb.GetSongByMusicTagInfo(tempTag.Artist, tempTag.Album, tempTag.Title, true, ref addSong))
        {
          if (AddSongToPlaylist(ref addSong))
          {
            Log.Info("GUIMusicPlayingNow: Song inserted: {0} - {1}", addSong.Artist, addSong.Title);
          }
        }
        else
        {
          Log.Info("GUIMusicPlayingNow: DB lookup for Artist: {0} Title: {1} unsuccessful", tempTag.Artist,
                   tempTag.Title);
        }
      }
      catch (Exception ex)
      {
        Log.Error("GUIMusicPlayingNow: DB lookup for Song failed - {0}", ex.Message);
      }
    }

        private void SetLevelForPlayback(string mediaType, string Level)
        {
            if ((previousLevel == "Play" || previousLevel == "Pause") && (Level == "Play") && (previousMediaType != mediaType))
            {
                previousLevel = "Stop";
            }
            string part2String;
            string part3String;
            string lengthString = "";
            string Genre = "";
            string CurrentFile = "";
            string SearchFile = "";
            if (!mediaType.Equals("Plugin"))
            {
                if ((mediaType == g_Player.MediaType.Video.ToString()) || mediaType == g_Player.MediaType.Recording.ToString())
                {
                    if (g_Player.Duration < (setLevelForMediaDuration * 60))
                    {
                        if (DebugMode) Logger.Debug("Length is Short");
                        lengthString = "Short.";
                    }
                    else
                    {
                        if (DebugMode) Logger.Debug("Length is Long");
                        lengthString = "Long.";
                    }
                }
                if (g_Player.IsDVD)
                {
                    if (DebugMode) Logger.Debug("Length is Long (Media is DVD)");
                    lengthString = "Long.";
                }

                if (Level == "Play")
                {
                    CurrentFile = g_Player.Player.CurrentFile;
                    SearchFile = CurrentFile;
                    if (g_Player.IsMusic)
                    {
                        Song song = new Song();
                        MusicDatabase musicDatabase = MusicDatabase.Instance;
                        musicDatabase.GetSongByFileName(SearchFile, ref song);
                        if (song != null)
                        {
                            Genre = song.Genre.ToString();
                        }
                    }
                    if (g_Player.IsVideo)
                    {
                        if (!SearchFile.StartsWith("http://localhost/")) // Online Video is not in DB so skip DB Search
                        {
                            try
                            {
                                if (DebugMode) Logger.Debug("Check to see if the video is a mounted disc.");
                                SearchFile = MountHelper.CheckMount(ref SearchFile);
                            }
                            catch
                            {
                                Logger.Warning("Daemontools not installed/configured");
                            }
                            if (DebugMode) Logger.Debug("Check to see if video is in MyVideos database.");
                            IMDBMovie movie = new IMDBMovie();
                            int movieID = VideoDatabase.GetMovieId(SearchFile);
                            VideoDatabase.GetMovieInfoById(movieID, ref movie);
                            if (movie.ID > 0)
                            {
                                if (DebugMode) Logger.Debug("Video is in MyVideos database.");
                                Genre = movie.Genre.ToString();
                            }
                            else // Movie not in MyVideo's DB
                            {
                                if (DebugMode) Logger.Debug("Video is not in MyVideos database.");
                                if (DebugMode) Logger.Debug("Check to see if video is in MovingPictures database.");
                                try
                                {
                                    if (Genre.Equals("")) Genre = MovingPicturesHelper.CheckDB(ref SearchFile);
                                }
                                catch
                                {
                                    Logger.Warning("Error while searching MovingPictures Database, probaly not installed");
                                }
                                if (DebugMode) Logger.Debug("Check to see if video is in TVSeries database.");
                                try
                                {
                                    if (Genre.Equals("")) Genre = TVSeriesHelper.CheckDB(SearchFile);
                                }
                                catch
                                {
                                    Logger.Warning("Error while searching TVSeries Database, probaly not installed");
                                }
                            }
                        }
                        else
                        {
                            if (DebugMode) Logger.Debug("Media is OnlineVideo");
                        }
                    }
                }
            }
            part2String = (egPart2.Equals("Type")) ? mediaType : Level;
//.........这里部分代码省略.........

 public static string GetFieldValue(Song song, string where)
 {
   if (where == "album")
   {
     return song.Album;
   }
   if (where == "artist")
   {
     return song.Artist;
   }
   if (where == "albumartist")
   {
     return song.AlbumArtist;
   }
   if (where == "title")
   {
     return song.Title;
   }
   if (where == "genre")
   {
     return song.Genre;
   }
   if (where == "composer")
   {
     return song.Composer;
   }
   if (where == "conductor")
   {
     return song.Conductor;
   }
   if (where == "year")
   {
     return song.Year.ToString();
   }
   if (where == "track")
   {
     return song.Track.ToString();
   }
   if (where == "timesplayed")
   {
     return song.TimesPlayed.ToString();
   }
   if (where == "rating")
   {
     return song.Rating.ToString();
   }
   if (where == "favorites")
   {
     if (song.Favorite)
     {
       return "1";
     }
     return "0";
   }
   if (where == "recently added")
   {
     return song.DateTimeModified.ToShortDateString();
   }
   if (where == "disc#")
   {
     return song.DiscId.ToString();
   }
   return "";
 }

    public bool Execute(out List<Song> songs)
    {
      if (currentLevel < 0)
      {
        previousLevel = -1;
        songs = new List<Song>();
        return false;
      }

      string whereClause = string.Empty;
      string orderClause = string.Empty;
      FilterDefinition definition = (FilterDefinition)currentView.Filters[CurrentLevel];

      restrictionLength = 0;
      for (int i = 0; i < CurrentLevel; ++i)
      {
        BuildSelect((FilterDefinition)currentView.Filters[i], ref whereClause, i);
      }
      BuildWhere((FilterDefinition)currentView.Filters[CurrentLevel], ref whereClause);
      BuildRestriction((FilterDefinition)currentView.Filters[CurrentLevel], ref whereClause);
      BuildOrder((FilterDefinition)currentView.Filters[CurrentLevel], ref orderClause);

      if (CurrentLevel > 0)
      {
        // When grouping is active, we need to omit the "where ";
        if (!whereClause.Trim().StartsWith("group ") && whereClause.Trim() != "")
        {
          whereClause = "where " + whereClause;
        }
      }

      //execute the query
      string sql = "";
      if (CurrentLevel == 0)
      {
        FilterDefinition defRoot = (FilterDefinition)currentView.Filters[0];
        string table = GetTable(defRoot.Where);
        string searchField = GetField(defRoot.Where);

        // Handle the grouping of songs
        if (definition.SqlOperator == "group")
        {
          string searchTable = table;
          string countField = searchField; // when grouping on Albums, we need to count the artists
          // We don't have an album table anymore, so change the table to search for to tracks here.
          if (table == "album")
          {
            searchTable = "tracks";
            countField = "strAlbumArtist";
          }

          sql = String.Format("Select UPPER(SUBSTR({0},1,{1})) as IX, Count(distinct {2}) from {3} GROUP BY IX",
                              searchField, definition.Restriction, countField, searchTable);
          // only group special characters into a "#" entry is field is text based
          if (defRoot.Where == "rating" || defRoot.Where == "year" || defRoot.Where == "track" || defRoot.Where == "disc#" ||
              defRoot.Where == "timesplayed" || defRoot.Where == "favourites" || defRoot.Where == "date")
          {
            database.GetSongsByFilter(sql, out songs, table);
          }
          else
          {
            database.GetSongsByIndex(sql, out songs, CurrentLevel, table);
          }

          previousLevel = currentLevel;
          
          return true;  

        }

        switch (table)
        {
          case "artist":
          case "albumartist":
          case "genre":
          case "composer":
            sql = String.Format("select * from {0} ", table);
            if (whereClause != string.Empty)
            {
              sql += "where " + whereClause;
            }
            if (orderClause != string.Empty)
            {
              sql += orderClause;
            }
            break;

          case "album":
            sql = String.Format("select * from tracks ");
            if (whereClause != string.Empty)
            {
              sql += "where " + whereClause;
            }
            sql += " group by strAlbum, strAlbumArtist ";
            // We need to group on AlbumArtist, to show Albums with same name for different artists
            if (orderClause != string.Empty)
            {
              sql += orderClause;
            }
            break;
//.........这里部分代码省略.........

 public void Select(Song song)
 {
   FilterDefinition definition = (FilterDefinition)currentView.Filters[CurrentLevel];
   definition.SelectedValue = GetFieldValue(song, definition.Where).ToString();
   if (currentLevel < currentView.Filters.Count)
   {
     currentLevel++;
   }
   currentSong = song;
 }

    public void SetFavorite(Song aSong)
    {
      try
      {
        if (aSong.Id == -1)
        {
          return;
        }

        int iFavorite = 0;
        if (aSong.Favorite)
        {
          iFavorite = 1;
        }
        string strSQL = String.Format("UPDATE tracks SET iFavorite={0} WHERE idTrack={1}", iFavorite, aSong.Id);
        DirectExecute(strSQL);
        return;
      }
      catch (Exception ex)
      {
        Log.Error("musicdatabase exception err:{0} stack:{1}", ex.Message, ex.StackTrace);
        Open();
      }
    }

    public void SetRating(string aFilename, int aRating)
    {
      if (string.IsNullOrEmpty(aFilename))
      {
        return;
      }

      try
      {
        Song song = new Song();
        string strFileName = aFilename;
        DatabaseUtility.RemoveInvalidChars(ref strFileName);

        strSQL = String.Format("UPDATE tracks SET iRating={0} WHERE strPath='{1}'", aRating, strFileName);

        DirectExecute(strSQL);

        // Let's fire the Ratings change event
        if (MusicRatingChanged != null)
        {
          MusicRatingChanged(this, strFileName, aRating);
        }
        return;
      }
      catch (Exception ex)
      {
        Log.Error("musicdatabase exception err:{0} stack:{1}", ex.Message, ex.StackTrace);
        Open();
      }

      return;
    }

    /// <summary>
    /// Push the given song on the queue.
    /// </summary>
    /// <param name="song_">The song to be enqueued.</param>
    public static void pushQueue(Song song_)
    {
      string logmessage = "Adding to queue: " + song_.ToShortString();
      if (_useDebugLog)
      {
        Log.Debug("AudioscrobblerBase: {0}", logmessage);
      }

      // Enqueue the song
      lock (queueLock)
      {
        queue.Add(song_);
      }

      if (submitThread != null)
      {
        if (submitThread.IsAlive)
        {
          try
          {
            Log.Debug("AudioscrobblerBase: trying to kill submit thread (no longer needed)");
            StopSubmitQueueThread();
          }
          catch (Exception ex)
          {
            Log.Warn("AudioscrobblerBase: Result of pre-submit thread abort - {0}", ex.Message);
          }
        }
      }

      // Try to submit immediately.
      StartSubmitQueueThread();
    }