public override IBassStream CreateInteractiveStream(PlaylistItem playlistItem, IEnumerable <IBassStreamAdvice> advice, BassFlags flags)
{
var drive = default(int);
var id = default(string);
var track = default(int);
var fileName = this.GetFileName(playlistItem, advice);
if (!CdUtils.ParseUrl(fileName, out drive, out id, out track))
{
//This shouldn't happen as CanCreateStream would have returned false.
return(BassStream.Empty);
}
this.AssertDiscId(drive, id);
var channelHandle = default(int);
lock (SyncRoot)
{
if (this.GetCurrentStream(drive, track, out channelHandle))
{
return(this.CreateInteractiveStream(channelHandle, advice, flags));
}
if (this.Output != null && this.Output.PlayFromMemory)
{
Logger.Write(this, LogLevel.Warn, "This provider cannot play from memory.");
}
if (BassCd.FreeOld)
{
Logger.Write(this, LogLevel.Debug, "Updating config: BASS_CONFIG_CD_FREEOLD = FALSE");
BassCd.FreeOld = false;
}
channelHandle = BassCd.CreateStream(drive, track, flags);
}
return(this.CreateInteractiveStream(channelHandle, advice, flags));
}
public override bool InitializeComponent()
{
Logger.Write(this, LogLevel.Debug, "Querying CDDB for drive: {0}", this.Drive);
try
{
//The CDDB and Read must be executed together so synchronize.
lock (SyncRoot)
{
var id = BassCd.GetID(this.Drive, CDID.CDDB);
var sequence = BassCd.GetID(this.Drive, CDID.Read);
this.Parser = new CddbTextParser(id, sequence);
}
if (this.Parser.Count == 0)
{
Logger.Write(this, LogLevel.Debug, "CDDB did not return any information for drive: {0}", this.Drive);
return(false);
}
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Warn, "Failed to query CDDB for drive {0}: {1}", this.Drive, e.Message);
return(false);
}
return(base.InitializeComponent());
}
protected virtual bool GetCurrentStream(int drive, int track, out int channelHandle)
{
if (this.Output != null && this.Output.IsStarted)
{
var enqueuedChannelHandle = default(int);
this.PipelineManager.WithPipeline(pipeline =>
{
if (pipeline != null)
{
using (var sequence = pipeline.Input.Queue.GetEnumerator())
{
while (sequence.MoveNext())
{
if (BassCd.StreamGetTrack(sequence.Current) == track)
{
enqueuedChannelHandle = sequence.Current;
break;
}
}
}
}
});
if (enqueuedChannelHandle != 0)
{
channelHandle = enqueuedChannelHandle;
return(true);
}
}
channelHandle = 0;
return(false);
}
protected virtual void Dispose(bool disposing)
{
if (_source != 0)
{
if (_mixer != 0)
{
Stop();
}
RemoveEq(ref _mixer);
Bass.StreamFree(_source);
Bass.MusicFree(_source);
Bass.StreamFree(_mixer);
_mixer = 0;
_source = 0;
}
if (_handle.IsAllocated)
{
_handle.Free();
}
if (_initialized)
{
Bass.Free();
}
BassCd.Unload();
BassFx.Unload();
BassMix.Unload();
Bass.PluginFree(0);
GC.SuppressFinalize(this);
}
/// <summary>
/// Free used resources
/// </summary>
public void Dispose()
{
if (_source != 0)
{
if (_mixer != 0)
{
Stop();
}
RemoveEq(ref _mixer);
Bass.StreamFree(_source);
Bass.MusicFree(_source);
Bass.StreamFree(_mixer);
_mixer = 0;
_source = 0;
}
if (_handle.IsAllocated)
{
_handle.Free();
}
if (_initialized)
{
Bass.Free();
}
BassCd.Unload();
BassFx.Unload();
BassMix.Unload();
Bass.PluginFree(0);
}
protected override async Task OnRun()
{
this.Name = "Opening CD";
try
{
if (!BassCd.IsReady(this.Drive))
{
throw new InvalidOperationException("Drive is not ready.");
}
var playlist = this.PlaylistManager.SelectedPlaylist;
var playlistItems = await this.Factory.Create().ConfigureAwait(false);
using (var task = new SingletonReentrantTask(this, ComponentSlots.Database, SingletonReentrantTask.PRIORITY_HIGH, async cancellationToken =>
{
//Always append for now.
this.Sequence = this.PlaylistBrowser.GetInsertIndex(this.PlaylistManager.SelectedPlaylist);
await this.AddPlaylistItems(playlist, playlistItems).ConfigureAwait(false);
await this.ShiftItems(QueryOperator.GreaterOrEqual, this.Sequence, this.Offset).ConfigureAwait(false);
await this.SetPlaylistItemsStatus(PlaylistItemStatus.None).ConfigureAwait(false);
}))
{
await task.Run().ConfigureAwait(false);
}
}
finally
{
//Ignoring result on purpose.
BassCd.Release(this.Drive);
}
await this.SignalEmitter.Send(new Signal(this, CommonSignals.PlaylistUpdated, new[] { this.Playlist })).ConfigureAwait(false);
}
private async Task AddOrUpdateMetaData()
{
Logger.Write(this, LogLevel.Debug, "Fetching meta data for new playlist items.");
using (var transaction = this.Database.BeginTransaction(this.Database.PreferredIsolationLevel))
{
var query = this.Database
.AsQueryable <PlaylistItem>(this.Database.Source(new DatabaseQueryComposer <PlaylistItem>(this.Database), transaction))
.Where(playlistItem => playlistItem.Status == PlaylistItemStatus.Import);
var info = default(CDInfo);
BassUtils.OK(BassCd.GetInfo(this.Drive, out info));
using (var writer = new MetaDataWriter(this.Database, this.Database.Queries.AddPlaylistMetaDataItem, transaction))
{
foreach (var playlistItem in query)
{
var metaData = await this.MetaDataSource.GetMetaData(playlistItem.FileName).ConfigureAwait(false);
foreach (var metaDataItem in metaData)
{
await writer.Write(playlistItem.Id, metaDataItem).ConfigureAwait(false);
}
}
}
transaction.Commit();
}
}
private Player()
{
var enginedir = AppDomain.CurrentDomain.BaseDirectory;
if (Is64Bit)
{
enginedir = Path.Combine(enginedir, @"Engine\x64");
}
else
{
enginedir = Path.Combine(enginedir, @"Engine\x86");
}
Bass.Load(enginedir);
BassMix.Load(enginedir);
BassCd.Load(enginedir);
BassFx.Load(enginedir);
Bass.PluginLoad(enginedir + "\\bass_aac.dll");
Bass.PluginLoad(enginedir + "\\bass_ac3.dll");
Bass.PluginLoad(enginedir + "\\bass_ape.dll");
Bass.PluginLoad(enginedir + "\\bass_mpc.dll");
Bass.PluginLoad(enginedir + "\\bass_spx.dll");
Bass.PluginLoad(enginedir + "\\bass_tta.dll");
Bass.PluginLoad(enginedir + "\\bassalac.dll");
Bass.PluginLoad(enginedir + "\\bassdsd.dll");
Bass.PluginLoad(enginedir + "\\bassflac.dll");
Bass.PluginLoad(enginedir + "\\bassopus.dll");
Bass.PluginLoad(enginedir + "\\basswma.dll");
Bass.PluginLoad(enginedir + "\\basswv.dll");
Bass.PluginLoad(enginedir + "\\bassmidi.dll");
_callback = MyDownloadProc;
_maxfft = (int)(DataFlags.Available | DataFlags.FFT2048);
}
public virtual IEnumerable <MetaDataItem> GetProperties(int track)
{
yield return(new MetaDataItem(CommonProperties.Duration, MetaDataItemType.Property)
{
//What the f**k is this? Something to do with 44.1kHz/16bit?
Value = ((BassCd.GetTrackLength(this.Drive, track) / 176400) * 1000).ToString()
});
}
public static IEnumerable <string> GetDrives()
{
for (int a = 0, b = BassCd.DriveCount; a < b; a++)
{
var cdInfo = default(CDInfo);
BassUtils.OK(BassCd.GetInfo(a, out cdInfo));
yield return(GetDriveName(cdInfo));
}
}
public static void ReleaseCDDrives()
{
int driveCount = BassCd.BASS_CD_GetDriveCount();
for (int i = 0; i < driveCount; i++)
{
BassCd.BASS_CD_Release(i);
}
}
private static IEnumerable <SelectionConfigurationOption> GetDrives()
{
for (int a = 0, b = BassCd.DriveCount; a < b; a++)
{
var cdInfo = default(CDInfo);
BassUtils.OK(BassCd.GetInfo(a, out cdInfo));
LogManager.Logger.Write(typeof(BassCdStreamProviderBehaviourConfiguration), LogLevel.Debug, "CD Drive: {0} => {1} => {2}", a, cdInfo.Name, cdInfo.Manufacturer);
yield return(new SelectionConfigurationOption(cdInfo.Name, string.Format("{0} ({1}:\\)", cdInfo.Name, cdInfo.DriveLetter), cdInfo.Name));
}
}
protected virtual void AssertDiscId(int drive, string expected)
{
var actual = BassCd.GetID(drive, CDID.CDPlayer);
if (string.Equals(expected, actual, StringComparison.OrdinalIgnoreCase))
{
return;
}
throw new InvalidOperationException(string.Format("Found disc with identifier \"{0}\" when \"{1}\" was required.", actual, expected));
}
private BassCDTrackInputSource(char drive, uint trackNo)
{
_drive = drive;
_trackNo = trackNo;
int bassDrive = BassUtils.Drive2BassID(_drive);
// Note: CD audio is always 44100hz stereo 16-bit. That's 176400 bytes per second. So dividing the track length by 176400 gives the length in seconds.
int cdLength = BassCd.BASS_CD_GetTrackLength(bassDrive, BassTrackNo);
_length = TimeSpan.FromSeconds((double)cdLength / 176400);
}
public static bool GetDiscMatchAndUpdate(string fileName, TrackInfo trackInfo)
{
int trackNo = 1; //TODO: Detect track from filename?
if (trackInfo.TrackNum > 0)
{
trackNo = trackInfo.TrackNum;
}
string root = Path.GetPathRoot(fileName);
if (string.IsNullOrEmpty(root))
{
return(false);
}
char rootLetter = root[0];
if (PHYSICAL_DISK_ROOTS.Contains(rootLetter) == false)
{
int drive = BassUtils.Drive2BassID(rootLetter);
if (drive > -1)
{
string cdDbId = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_CDDB);
string musicBrainzId = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_MUSICBRAINZ);
string upc = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_UPC);
string irsc = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_ISRC + (trackNo - 1));
BassCd.BASS_CD_Release(drive);
if (!string.IsNullOrEmpty(cdDbId))
{
trackInfo.AlbumCdDdId = cdDbId;
}
if (!string.IsNullOrEmpty(musicBrainzId))
{
trackInfo.AlbumMusicBrainzDiscId = musicBrainzId;
}
if (!string.IsNullOrEmpty(upc))
{
trackInfo.AlbumUpcEanId = upc;
}
if (!string.IsNullOrEmpty(irsc))
{
trackInfo.IsrcId = irsc;
}
return(true);
}
else
{
PHYSICAL_DISK_ROOTS.Add(rootLetter);
}
}
return(false);
}
void Refresh()
{
AvailableDrives.Clear();
CDInfo devInfo;
for (var i = 0; BassCd.GetInfo(i, out devInfo); ++i)
{
AvailableDrives.Add(devInfo);
}
}
public override bool InitializeComponent()
{
Logger.Write(this, LogLevel.Debug, "Querying CDDB for drive: {0}", this.Drive);
this.Parser = new CddbTextParser(BassCd.GetID(this.Drive, CDID.CDDB), BassCd.GetID(this.Drive, CDID.Read));
if (this.Parser.Count == 0)
{
Logger.Write(this, LogLevel.Debug, "CDDB did not return any information for drive: {0}", this.Drive);
return(false);
}
return(base.InitializeComponent());
}
private int Drive2BassID(char driveLetter)
{
for (int i = 0; i < 25; i++)
{
if (BassCd.BASS_CD_GetInfo(i).DriveLetter == driveLetter)
{
return(i);
}
}
return(-1);
}
public IEnumerable <string> JobFunction(string inputdata, IProgress <float> progress, CancellationToken ct)
{
var list = new List <string>();
int drivecount = BassCd.DriveCount;
int driveindex = 0;
for (int i = 0; i < drivecount; i++)
{
ct.ThrowIfCancellationRequested();
var info = BassCd.GetInfo(i);
if (info.DriveLetter == inputdata[0])
{
driveindex = i;
break;
}
}
if (BassCd.IsReady(driveindex))
{
ct.ThrowIfCancellationRequested();
var numtracks = BassCd.GetTracks(driveindex);
if (numtracks < 2)
{
return(list);
}
var discid = BassCd.GetID(0, CDID.CDDB); //cddb connect
if (App.DiscID != discid)
{
ct.ThrowIfCancellationRequested();
var datas = BassCd.GetIDText(driveindex);
App.DiscID = discid;
App.CdData.Clear();
foreach (var data in datas)
{
ct.ThrowIfCancellationRequested();
var item = data.Split('=');
App.CdData.Add(item[0], item[1]);
}
}
for (int i = 0; i < numtracks; i++)
{
ct.ThrowIfCancellationRequested();
var entry = string.Format("cd://{0}/{1}", driveindex, i);
list.Add(entry);
progress.Report((float)i / numtracks);
}
}
BassCd.Release(driveindex);
return(list);
}
protected virtual void OnFree(object sender, EventArgs e)
{
if (!this.IsInitialized)
{
return;
}
BassGaplessCd.Disable();
BassGaplessCd.Free();
//Ignoring result on purpose.
BassCd.Release(this.Drive);
this.IsInitialized = false;
}
/// <inheritdoc />
private void LoadLibs()
{
Log.Info("Loading bass.dll...");
Bass.Load(NativeLibPath);
Log.Info("Loading bassmix.dll...");
BassMix.Load(NativeLibPath);
Log.Info("Loading basscd.dll...");
BassCd.Load(NativeLibPath);
LoadPlugins("bass_aac.dll", "bass_ac3.dll",
"bassalac.dll", "bassflac.dll",
"basswma.dll", "basswv.dll");
}
public CdMetadata GetMetadataForCd(char driveLetter)
{
driveLetter = Char.ToLower(driveLetter);
// Not a valid drive letter.
if (driveLetter < 'a' || driveLetter > 'z')
{
throw new ArgumentException(string.Format("'{0}' is not a valid drive letter! Drive letter should be a letter between a-z.", driveLetter));
}
CheckForCddbServerConnection();
// Find drive details.
int driveIndex = _audioCdService.GetCdDriveIndex(driveLetter);
string cddbResponse = BassCd.BASS_CD_GetID(driveIndex, BASSCDId.BASS_CDID_CDDB_QUERY);
string entries = BassCd.BASS_CD_GetID(driveIndex, BASSCDId.BASS_CDID_CDDB_QUERY + 1);
// Get album name from server response.
string album = string.Empty;
Match albumInfoMatch = Regex.Match(entries, "DTITLE=");
if (albumInfoMatch != null)
{
int ablumIdx = albumInfoMatch.Index;
album = entries.Substring(ablumIdx, entries.Substring(ablumIdx).IndexOf("\r")).Split('=').LastOrDefault().Split('/').LastOrDefault();
album = album.Substring(1);
}
// Get artist name from server response.
string artist = string.Empty;
if (albumInfoMatch != null)
{
int artistIdx = albumInfoMatch.Index;
artist = entries.Substring(artistIdx, entries.Substring(artistIdx).IndexOf("\r")).Split('=').LastOrDefault().Split('/').FirstOrDefault();
artist = artist.Substring(0, artist.Length - 1);
}
// Get track names from server response.
var matches = Regex.Matches(entries, "TTITLE");
List <string> trackNames = new List <string>();
foreach (Match m in matches)
{
trackNames.Add(entries.Substring(m.Index, entries.Substring(m.Index).IndexOf('\r')).Split('=')[1]);
}
return(new CdMetadata {
Artist = artist, Album = album, Tracks = trackNames
});
}
public static int GetDrive(string name)
{
for (int a = 0, b = BassCd.DriveCount; a < b; a++)
{
var cdInfo = default(CDInfo);
BassUtils.OK(BassCd.GetInfo(a, out cdInfo));
if (string.Equals(GetDriveName(cdInfo), name, StringComparison.OrdinalIgnoreCase))
{
return(a);
}
}
return(NO_DRIVE);
}
public string GetCDDBDiscIDInfo(char driveLetter, char separator)
{
string retval = null;
int drive = BassUtils.Drive2BassID(driveLetter);
if (drive > -1)
{
string id = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_CDDB);
retval = id.Replace(' ', separator);
BassCd.BASS_CD_Release(drive);
}
return(retval);
}
public static int GetDrive(SelectionConfigurationOption option)
{
for (int a = 0, b = BassCd.DriveCount; a < b; a++)
{
var cdInfo = default(CDInfo);
BassUtils.OK(BassCd.GetInfo(a, out cdInfo));
if (string.Equals(cdInfo.Name, option.Id, StringComparison.OrdinalIgnoreCase))
{
return(a);
}
}
return(CD_NO_DRIVE);
}
public GridViewRip(Main main)
{
_main = main;
// Setup message queue for receiving Messages
IMessageQueue queueMessage = ServiceScope.Get <IMessageBroker>().GetOrCreate("message");
queueMessage.OnMessageReceive += OnMessageReceive;
InitializeComponent();
dataGridViewRip.CurrentCellDirtyStateChanged += dataGridViewRip_CurrentCellDirtyStateChanged;
// Listen to Messages
IMessageQueue queueMessageEncoding = ServiceScope.Get <IMessageBroker>().GetOrCreate("encoding");
queueMessageEncoding.OnMessageReceive += OnMessageReceiveEncoding;
audioEncoder = ServiceScope.Get <IAudioEncoder>();
mediaChangeMonitor = ServiceScope.Get <IMediaChangeMonitor>();
mediaChangeMonitor.MediaInserted += mediaChangeMonitor_MediaInserted;
mediaChangeMonitor.MediaRemoved += mediaChangeMonitor_MediaRemoved;
// Get number of CD Drives found and initialise a Bindinglist for every drove
int driveCount = BassCd.BASS_CD_GetDriveCount();
if (driveCount == 0)
{
bindingList.Add(new SortableBindingList <CDTrackDetail>()); // In case of no CD, we want a Dummy List
}
_main.RipButtonsEnabled = false;
for (int i = 0; i < driveCount; i++)
{
bindingList.Add(new SortableBindingList <CDTrackDetail>());
if (BassCd.BASS_CD_IsReady(i))
{
_main.RipButtonsEnabled = true;
}
}
// Prepare the Gridview
gridColumns = new GridViewColumnsRip();
dataGridViewRip.AutoGenerateColumns = false;
dataGridViewRip.DataSource = bindingList[0];
// Now Setup the columns, we want to display
CreateColumns();
SetStatusLabel("");
}
public string GetCDDBDiscID(char driveLetter)
{
string retval = null;
int drive = BassUtils.Drive2BassID(driveLetter);
if (drive > -1)
{
string id = BassCd.BASS_CD_GetID(drive, BASSCDId.BASS_CDID_CDDB);
retval = id.Substring(0, 8);
BassCd.BASS_CD_Release(drive);
}
return(retval);
}
public override bool InitializeComponent()
{
Logger.Write(this, LogLevel.Debug, "Querying CD-TEXT for drive: {0}", this.Drive);
lock (SyncRoot)
{
this.Parser = new CdTextParser(BassCd.GetIDText(this.Drive));
}
if (this.Parser.Count == 0)
{
Logger.Write(this, LogLevel.Debug, "CD-TEXT did not return any information for drive: {0}", this.Drive);
return(false);
}
return(base.InitializeComponent());
}
public void WriteCdaFileToWavFile(string inCdaFile, string outWavFile, BaseEncoder.ENCODEFILEPROC progressCallback)
{
var measuringStream = BassCd.BASS_CD_StreamCreateFile(inCdaFile, BASSFlag.BASS_DEFAULT);
if (measuringStream == 0)
{
return;
}
var totalLength = Bass.BASS_ChannelGetLength(measuringStream, BASSMode.BASS_POS_BYTES);
Bass.BASS_StreamFree(measuringStream);
var stream = BassCd.BASS_CD_StreamCreateFile(inCdaFile, BASSFlag.BASS_STREAM_DECODE);
if (stream == 0)
{
return;
}
try
{
var ww = new WaveWriter(outWavFile, stream, true);
var data = new short[32768];
var bytesSoFar = 0;
while (Bass.BASS_ChannelIsActive(stream) == BASSActive.BASS_ACTIVE_PLAYING)
{
var length = Bass.BASS_ChannelGetData(stream, data, 32768);
if (length > 0)
{
ww.Write(data, length);
bytesSoFar += length;
progressCallback.Invoke(totalLength, bytesSoFar);
}
}
// finilize the wave file!
ww.Close();
Bass.BASS_StreamFree(stream);
}
catch (Exception ex)
{
throw new Exception(string.Format("Error copying cda file '{0}' to wav file '{1}'", inCdaFile, outWavFile), ex);
}
}
private static void GetCDDrives()
{
// Get the number of CD/DVD drives
int driveCount = BassCd.BASS_CD_GetDriveCount();
StringBuilder builderDriveLetter = new StringBuilder();
// Get Drive letters assigned
for (int i = 0; i < driveCount; i++)
{
builderDriveLetter.Append(BassCd.BASS_CD_GetInfo(i).DriveLetter);
BassCd.BASS_CD_Release(i);
}
_cdDriveLetters = builderDriveLetter.ToString();
}
