Example #1
0
 public CDInfoDetail(string discID, string artist, string title,
                     string genre, int year, int duration, CDTrackDetail[] tracks,
                     string extd, int[] playorder)
 {
   m_discId = discID;
   m_artist = artist;
   m_title = title;
   m_genre = genre;
   m_year = year;
   m_duration = duration;
   m_tracks = tracks;
   m_extd = extd;
   m_playorder = playorder;
 }
 public CDInfoDetail(string discID, string artist, string title,
                 string genre, int year, int duration, CDTrackDetail[] tracks,
                 string extd, int[] playorder)
 {
     DiscID = discID;
       Artist = artist;
       Title = title;
       Genre = genre;
       Year = year;
       Duration = duration;
       m_tracks = tracks;
       EXTD = extd;
       PlayOrder = playorder;
 }
Example #3
0
        private MusicTag GetTrackTag(CDTrackDetail cdTrack)
        {
            if (GUIMusicFiles.MusicCD == null)
            {
                return(null);
            }
            var tag = new MusicTag();

            tag.Artist   = GUIMusicFiles.MusicCD.Artist;
            tag.Album    = GUIMusicFiles.MusicCD.Title;
            tag.Genre    = GUIMusicFiles.MusicCD.Genre;
            tag.Year     = GUIMusicFiles.MusicCD.Year;
            tag.Duration = cdTrack.Duration;
            tag.Title    = cdTrack.Title;
            return(tag);
        }
Example #4
0
        /// <summary>
        ///   Queries FreeDB for the Audio CD inserted
        /// </summary>
        /// <param name = "drive"></param>
        private void QueryFreeDB(char drive)
        {
            log.Trace(">>>");
            SetStatusLabel(localisation.ToString("Conversion", "FreeDBAccess"));
            string       discId  = string.Empty;
            CDInfoDetail MusicCD = new CDInfoDetail();
            int          driveID = Util.Drive2BassID(drive);

            if (driveID < 0)
            {
                SetStatusLabel("");
                return;
            }
            log.Info("Starting FreeDB Lookup");
            _main.Cursor = Cursors.WaitCursor;
            bindingList[driveID].Clear();
            try
            {
                FreeDBQuery freedb = new FreeDBQuery();
                freedb.Connect();
                CDInfo[] cds = freedb.GetDiscInfo(drive);
                if (cds != null)
                {
                    log.Debug("FreeDB: Found {0} matching discs.", cds.Length);
                    if (cds.Length == 1)
                    {
                        MusicCD = freedb.GetDiscDetails(cds[0].Category, cds[0].DiscId);
                    }
                    else
                    {
                        FreeDBMultiCDSelect multiCDSelect = new FreeDBMultiCDSelect();
                        multiCDSelect.CDList.ValueMember   = "DiscId";
                        multiCDSelect.CDList.DisplayMember = "Title";
                        multiCDSelect.CDList.DataSource    = cds;

                        if (multiCDSelect.ShowDialog() == DialogResult.OK)
                        {
                            MusicCD = freedb.GetDiscDetails(cds[0].Category, multiCDSelect.DiscID);
                        }
                        else
                        {
                            MusicCD = null;
                        }
                    }
                }
                else
                {
                    log.Debug("FreeDB: Disc could not be located in FreeDB.");
                    MusicCD = null;
                }

                freedb.Disconnect();
            }
            catch (System.Net.WebException webEx)
            {
                if (webEx.Status == WebExceptionStatus.Timeout)
                {
                    log.Info("FreeDB: Timeout querying FreeDB. No Data returned for CD");
                    MusicCD = null;
                }
                else
                {
                    log.Error("FreeDB: Exception querying Disc. {0} {1}", webEx.Message, webEx.StackTrace);
                    MusicCD = null;
                }
            }
            catch (Exception ex)
            {
                log.Error("FreeDB: Exception querying Disc. {0} {1}", ex.Message, ex.StackTrace);
                MusicCD = null;
            }
            log.Info("Finished FreeDB Lookup");
            _main.Cursor = Cursors.Default;

            if (MusicCD != null)
            {
                tbAlbumArtist.Text = MusicCD.Artist;
                tbAlbum.Text       = MusicCD.Title;
                tbGenre.Text       = MusicCD.Genre;
                tbYear.Text        = MusicCD.Year.ToString();

                foreach (CDTrackDetail trackDetail in MusicCD.Tracks)
                {
                    if (trackDetail.Artist == null)
                    {
                        trackDetail.Artist = MusicCD.Artist;
                    }

                    bindingList[driveID].Add(trackDetail);
                }
            }
            else
            {
                int numTracks = BassCd.BASS_CD_GetTracks(driveID);
                for (int i = 0; i < numTracks; i++)
                {
                    CDTrackDetail trackDetail = new CDTrackDetail();
                    trackDetail.Track = i + 1;
                    trackDetail.Title = string.Format("Track{0}", (i + 1).ToString().PadLeft(2, '0'));
                    bindingList[driveID].Add(trackDetail);
                }
            }
            CheckRows(true);
            (dataGridViewRip.Columns[0].HeaderCell as DatagridViewCheckBoxHeaderCell).Checked = true;
            SetStatusLabel("");

            log.Trace("<<<");
        }
Example #5
0
        private void RippingThread()
        {
            if (_main.TreeView.InvokeRequired)
            {
                ThreadSafeGridDelegate d = RippingThread;
                _main.TreeView.Invoke(d, new object[] { });
                return;
            }

            if (_selectedCDRomDrive == "")
            {
                log.Info("No CD drive selected. Rip not started.");
                return;
            }

            log.Trace(">>>");
            string targetDir = "";
            string encoder   = null;

            try
            {
                _musicDir = _main.RipOutputDirectory;

                if (_main.RipEncoderCombo.SelectedItem != null)
                {
                    encoder = (string)(_main.RipEncoderCombo.SelectedItem as Item).Value;
                    Options.MainSettings.RipEncoder = encoder;
                }
                else
                {
                    encoder = Options.MainSettings.RipEncoder;
                }

                if (encoder == null)
                {
                    return;
                }

                log.Debug("Rip: Using Encoder: {0}", encoder);

                try
                {
                    if (!Directory.Exists(_musicDir) && !string.IsNullOrEmpty(_musicDir))
                    {
                        Directory.CreateDirectory(_musicDir);
                    }
                }
                catch (Exception ex)
                {
                    SetStatusLabel(localisation.ToString("Conversion", "ErrorDirectory"));
                    log.Error("Error creating Ripping directory: {0}. {1}", _musicDir, ex.Message);
                    return;
                }

                // Build the Target Directory
                string artistDir = tbAlbumArtist.Text == string.Empty ? "Artist" : tbAlbumArtist.Text;
                string albumDir  = tbAlbum.Text == string.Empty ? "Album" : tbAlbum.Text;

                string outFileFormat = Options.MainSettings.RipFileNameFormat;
                int    index         = outFileFormat.LastIndexOf('\\');
                if (index > -1)
                {
                    targetDir     = outFileFormat.Substring(0, index);
                    targetDir     = targetDir.Replace("<A>", artistDir);
                    targetDir     = targetDir.Replace("<O>", artistDir);
                    targetDir     = targetDir.Replace("<B>", albumDir);
                    targetDir     = targetDir.Replace("<G>", tbGenre.Text);
                    targetDir     = targetDir.Replace("<Y>", tbYear.Text);
                    outFileFormat = outFileFormat.Substring(index + 1);
                }
                else
                {
                    targetDir = string.Format(@"{0}\{1}", artistDir, albumDir);
                }

                targetDir = Util.MakeValidFolderName(targetDir);

                targetDir = string.Format(@"{0}\{1}", _musicDir, targetDir);

                log.Debug("Rip: Using Target Folder: {0}", targetDir);

                try
                {
                    if (!Directory.Exists(targetDir))
                    {
                        Directory.CreateDirectory(targetDir);
                    }
                }
                catch (Exception ex)
                {
                    SetStatusLabel(localisation.ToString("Conversion", "ErrorDirectory"));
                    log.Error("Error creating Ripping directory: {0}. {1}", targetDir, ex.Message);
                    return;
                }

                log.Debug("Rip: Selected CD Drive: {0}", _selectedCDRomDrive);

                int selectedDriveID = 0;
                try
                {
                    // User may change to a different drive while ripping
                    selectedDriveID = CurrentDriveID;
                    log.Debug("Rip: Selected drive id: {0}", selectedDriveID);
                }
                catch (Exception)
                {
                    log.Debug("Rip: Error setting the drive id. Fallback to drive #0");
                    selectedDriveID = 0;
                }

                // Lock the Door
                BassCd.BASS_CD_Door(CurrentDriveID, BASSCDDoor.BASS_CD_DOOR_LOCK);

                foreach (DataGridViewRow row in dataGridViewRip.Rows)
                {
                    // Reset the Status field to 0
                    row.Cells[1].Value = 0;
                }

                _currentRow = -1;
                foreach (DataGridViewRow row in dataGridViewRip.Rows)
                {
                    // when checking and unchecking a row, we have the DBNull value
                    if (row.Cells[0].Value == null || row.Cells[0].Value == DBNull.Value)
                    {
                        continue;
                    }

                    if ((int)row.Cells[0].Value == 0)
                    {
                        continue;
                    }

                    SetStatusLabel(localisation.ToString("Conversion", "Ripping"));

                    _currentRow = row.Index;

                    CDTrackDetail track = bindingList[selectedDriveID][_currentRow];

                    int stream = BassCd.BASS_CD_StreamCreate(selectedDriveID, row.Index, BASSFlag.BASS_STREAM_DECODE);
                    if (stream == 0)
                    {
                        log.Error("Error creating stream for Audio Track {0}. Error: {1}", _currentRow,
                                  Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                        continue;
                    }

                    log.Info("Ripping Audio CD Track{0} - {1}", row.Index + 1, track.Title);
                    _outFile = outFileFormat;
                    _outFile = _outFile.Replace("<O>", artistDir);
                    _outFile = _outFile.Replace("<B>", albumDir);
                    _outFile = _outFile.Replace("<G>", tbGenre.Text);
                    _outFile = _outFile.Replace("<Y>", tbYear.Text);
                    _outFile = _outFile.Replace("<A>", track.Artist);
                    _outFile = _outFile.Replace("<K>", track.Track.ToString().PadLeft(Options.MainSettings.NumberTrackDigits, '0'));
                    _outFile = _outFile.Replace("<T>", track.Title);
                    _outFile = Util.MakeValidFileName(_outFile);

                    _outFile = string.Format(@"{0}\{1}", targetDir, _outFile);

                    _outFile = audioEncoder.SetEncoder(encoder, _outFile);

                    if (audioEncoder.StartEncoding(stream) != BASSError.BASS_OK)
                    {
                        log.Error("Error starting Encoder for Audio Track {0}. Error: {1}", _currentRow,
                                  Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()));
                    }

                    dataGridViewRip.Rows[_currentRow].Cells[1].Value = 100;

                    Bass.BASS_StreamFree(stream);
                    log.Info("Finished Ripping Audio CD Track{0}", _currentRow + 1);

                    try
                    {
                        // Now Tag the encoded File
                        File file = File.Create(_outFile);
                        file.Tag.AlbumArtists = new[] { tbAlbumArtist.Text };
                        file.Tag.Album        = tbAlbum.Text;
                        file.Tag.Genres       = new[] { tbGenre.Text };
                        file.Tag.Year         = tbYear.Text == string.Empty ? 0 : Convert.ToUInt32(tbYear.Text);
                        file.Tag.Performers   = new[] { track.Artist };
                        file.Tag.Track        = (uint)track.Track;
                        file.Tag.Title        = track.Title;
                        file = Util.FormatID3Tag(file);
                        file.Save();
                    }
                    catch (Exception ex)
                    {
                        log.Error("Error tagging encoded file {0}. Error: {1}", _outFile, ex.Message);
                    }
                }
            }
            catch (Exception ex)
            {
                log.Error("Rip: Exception: {0} {1}", ex.Message, ex.StackTrace);
            }

            _currentRow = -1;
            SetStatusLabel(localisation.ToString("Conversion", "RippingFinished"));
            Options.MainSettings.RipTargetFolder = _musicDir;
            Options.MainSettings.RipEncoder      = encoder;

            // Unlock the Drive and open the door, if selected
            BassCd.BASS_CD_Door(CurrentDriveID, BASSCDDoor.BASS_CD_DOOR_UNLOCK);
            if (Options.MainSettings.RipEjectCD)
            {
                BassCd.BASS_CD_Door(CurrentDriveID, BASSCDDoor.BASS_CD_DOOR_OPEN);
            }

            // Activate the target Folder, if selected
            if (Options.MainSettings.RipActivateTargetFolder)
            {
                _main.CurrentDirectory = targetDir;
                _main.TreeView.RefreshFolders();
                _main.Ribbon.CurrentTabPage = _main.TabTag;
                _main.TracksGridView.Show();
                if (_main.SplitterRight.IsCollapsed && !Options.MainSettings.RightPanelCollapsed)
                {
                    _main.SplitterRight.ToggleState();
                }
                _main.RefreshTrackList();
            }

            log.Trace("<<<");
        }