public ReplayGainEffect(int channelHandle, float replayGain, ReplayGainMode mode) : base(channelHandle)
{
this.ReplayGain = replayGain;
this.Mode = mode;
this.Channel = 0; //Master channel.
this.Volume = GetVolume(replayGain);
}
public Task ScanLibrary(ReplayGainMode mode)
{
if (this.LibraryManager == null || this.LibraryManager.SelectedItem == null)
{
#if NET40
return(TaskEx.FromResult(false));
#else
return(Task.CompletedTask);
#endif
}
//TODO: Warning: Buffering a potentially large sequence. It might be better to run the query multiple times.
var libraryItems = this.LibraryHierarchyBrowser.GetItems(
this.LibraryManager.SelectedItem,
true
).ToArray();
if (!libraryItems.Any())
{
#if NET40
return(TaskEx.FromResult(false));
#else
return(Task.CompletedTask);
#endif
}
return(this.Scan(libraryItems, mode));
}
public static ScannerItem FromFileData(IFileData fileData, ReplayGainMode mode)
{
var scannerItem = new ScannerItem()
{
FileName = fileData.FileName,
Mode = mode
};
if (mode == ReplayGainMode.Album)
{
var parts = new List <string>();
lock (fileData.MetaDatas)
{
var metaDatas = fileData.MetaDatas.ToDictionary(
element => element.Name,
StringComparer.OrdinalIgnoreCase
);
var metaDataItem = default(MetaDataItem);
if (metaDatas.TryGetValue(CommonMetaData.Year, out metaDataItem))
{
parts.Add(metaDataItem.Value);
}
if (metaDatas.TryGetValue(CommonMetaData.Album, out metaDataItem))
{
parts.Add(metaDataItem.Value);
}
}
scannerItem.GroupName = string.Join(" - ", parts);
}
return(scannerItem);
}
public async Task Scan(PlaylistItem[] playlistItems, ReplayGainMode mode)
{
using (var task = new ScanPlaylistItemsTask(this, playlistItems, mode))
{
task.InitializeComponent(this.Core);
this.OnBackgroundTask(task);
await task.Run().ConfigureAwait(false);
this.OnReport(playlistItems, task.ScannerItems);
}
}
public AudioStreamBass(Track Track,
float GainDB,
float[] Equalizer,
int NumEqBands,
bool EqualizerOn,
ReplayGainMode ReplayGain)
{
this.track = Track;
this.streamRef = 0;
setupArrays();
this.ReplayGain = ReplayGain;
this.DecoderGainDB = GainDB;
this.EqualizerOn = EqualizerOn;
this.numEqBands = NumEqBands;
this.equalizer = Equalizer;
}
public static float GetReplayGain(Track Track, ReplayGainMode Type, bool FallBack)
{
if (Type == ReplayGainMode.Off)
{
return(0.0f);
}
switch (Type)
{
case ReplayGainMode.Album:
if (!Track.HasReplayGainInfoAlbum)
{
if (Track.HasReplayGainInfoTrack)
{
return(Track.ReplayGainTrack);
}
else
{
TrackWriter.LoadReplayGain(Track, BassTags.BASS_TAG_GetFromFile(Track.FilePath, true, false));
}
}
return(Track.ReplayGainAlbum);
case ReplayGainMode.Track:
if (!Track.HasReplayGainInfoTrack)
{
if (Track.HasReplayGainInfoAlbum)
{
return(Track.ReplayGainAlbum);
}
else
{
TrackWriter.LoadReplayGain(Track, BassTags.BASS_TAG_GetFromFile(Track.FilePath, true, false));
}
}
return(Track.ReplayGainTrack);
default: // off
return(0.0f);
}
}
public Task ScanPlaylist(ReplayGainMode mode)
{
if (this.PlaylistManager.SelectedItems == null)
{
#if NET40
return(TaskEx.FromResult(false));
#else
return(Task.CompletedTask);
#endif
}
var playlistItems = this.PlaylistManager.SelectedItems.ToArray();
if (!playlistItems.Any())
{
#if NET40
return(TaskEx.FromResult(false));
#else
return(Task.CompletedTask);
#endif
}
return(this.Scan(playlistItems, mode));
}
public AudioStreamRadio(RadioStation Station,
int PresumedFrequency,
Callback FrequencyMismatch,
float GainDB,
float[] Equalizer,
int NumEqBands,
bool EqualizerOn,
ReplayGainMode ReplayGain) : base(null, GainDB, Equalizer, NumEqBands, EqualizerOn, ReplayGain)
{
this.replayGainDB = -6.0f; // Radio is loud, clips a bunch
controller = Controller.GetInstance();
Controller.ShowMessageUntilReplaced(Localization.Get(UI_Key.Radio_Connecting));
this.station = Station;
presumedFreq = PresumedFrequency;
frequencyMismatchDelegate = FrequencyMismatch;
Clock.DoOnNewThread(setup);
}
public AudioStreamFile(Track Track,
float GainDB,
float[] Equalizer,
int NumEqBands,
bool EqualizerOn,
ReplayGainMode ReplayGain)
: base(Track, GainDB, Equalizer, NumEqBands, EqualizerOn, ReplayGain)
{
this.filePath = track.FilePath;
if (filePath != String.Empty)
{
Bass.BASS_Init(0, 0, BASSInit.BASS_DEVICE_DEFAULT, IntPtr.Zero);
streamRef = Bass.BASS_StreamCreateFile(filePath, 0, 0, BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SAMPLE_FLOAT);
}
setupChannelFromStream();
TrackWriter.UpdateTrackInfo(track, info);
}
public async Task CanScanPlaylistItems(ReplayGainMode mode)
{
var behaviour = ComponentRegistry.Instance.GetComponent <BassReplayGainScannerBehaviour>();
await behaviour.Scan(PlaylistItems, mode).ConfigureAwait(false);
}
protected virtual async Task UpdateMetaData(BassOutputStream stream, float gain, float peak, ReplayGainMode mode)
{
var names = new HashSet <string>();
lock (stream.PlaylistItem.MetaDatas)
{
var metaDatas = stream.PlaylistItem.MetaDatas.ToDictionary(
element => element.Name,
StringComparer.OrdinalIgnoreCase
);
var metaDataItem = default(MetaDataItem);
if (gain != 0)
{
var name = default(string);
switch (mode)
{
case ReplayGainMode.Album:
name = CommonMetaData.ReplayGainAlbumGain;
break;
case ReplayGainMode.Track:
name = CommonMetaData.ReplayGainTrackGain;
break;
}
if (!metaDatas.TryGetValue(name, out metaDataItem))
{
metaDataItem = new MetaDataItem(name, MetaDataItemType.Tag);
stream.PlaylistItem.MetaDatas.Add(metaDataItem);
}
metaDataItem.Value = Convert.ToString(gain);
names.Add(name);
}
if (peak != 0)
{
var name = default(string);
switch (mode)
{
case ReplayGainMode.Album:
name = CommonMetaData.ReplayGainAlbumPeak;
break;
case ReplayGainMode.Track:
name = CommonMetaData.ReplayGainTrackPeak;
break;
}
if (!metaDatas.TryGetValue(name, out metaDataItem))
{
metaDataItem = new MetaDataItem(name, MetaDataItemType.Tag);
stream.PlaylistItem.MetaDatas.Add(metaDataItem);
}
metaDataItem.Value = Convert.ToString(peak);
names.Add(name);
}
}
await this.MetaDataManager.Save(
new[] { stream.PlaylistItem },
this.WriteTags,
false,
names.ToArray()
).ConfigureAwait(false);
}
protected virtual bool TryCalculateReplayGain(BassOutputStream stream, out float gain, out float peak, out ReplayGainMode mode)
{
Logger.Write(this, LogLevel.Debug, "Attempting to calculate track replay gain for file \"{0}\".", stream.FileName);
try
{
var info = default(ReplayGainInfo);
if (BassReplayGain.Process(stream.ChannelHandle, out info))
{
Logger.Write(this, LogLevel.Debug, "Calculated track replay gain for file \"{0}\": {1}dB", stream.FileName, ReplayGainEffect.GetVolume(info.gain));
gain = info.gain;
peak = info.peak;
mode = ReplayGainMode.Track;
return(true);
}
else
{
Logger.Write(this, LogLevel.Warn, "Failed to calculate track replay gain for file \"{0}\".", stream.FileName);
}
}
catch (Exception e)
{
Logger.Write(this, LogLevel.Warn, "Failed to calculate track replay gain for file \"{0}\": {1}", stream.FileName, e.Message);
}
gain = 0;
peak = 0;
mode = ReplayGainMode.None;
return(false);
}
protected virtual bool TryGetReplayGain(BassOutputStream stream, out float replayGain, out ReplayGainMode mode)
{
var albumGain = default(float);
var trackGain = default(float);
lock (stream.PlaylistItem.MetaDatas)
{
foreach (var metaDataItem in stream.PlaylistItem.MetaDatas)
{
if (string.Equals(metaDataItem.Name, CommonMetaData.ReplayGainAlbumGain, StringComparison.OrdinalIgnoreCase))
{
if (float.TryParse(metaDataItem.Value, out albumGain))
{
if (!this.IsValidReplayGain(albumGain))
{
albumGain = default(float);
continue;
}
if (this.Mode == ReplayGainMode.Album)
{
Logger.Write(this, LogLevel.Debug, "Found preferred replay gain data for album: \"{0}\" => {1}", stream.FileName, albumGain);
mode = ReplayGainMode.Album;
replayGain = albumGain;
return(true);
}
}
}
else if (string.Equals(metaDataItem.Name, CommonMetaData.ReplayGainTrackGain, StringComparison.OrdinalIgnoreCase))
{
if (float.TryParse(metaDataItem.Value, out trackGain))
{
if (!this.IsValidReplayGain(trackGain))
{
trackGain = default(float);
continue;
}
if (this.Mode == ReplayGainMode.Track)
{
Logger.Write(this, LogLevel.Debug, "Found preferred replay gain data for track: \"{0}\" => {1}", stream.FileName, trackGain);
mode = ReplayGainMode.Track;
replayGain = trackGain;
return(true);
}
}
}
}
}
if (this.IsValidReplayGain(albumGain))
{
Logger.Write(this, LogLevel.Debug, "Using album replay gain data: \"{0}\" => {1}", stream.FileName, albumGain);
mode = ReplayGainMode.Album;
replayGain = albumGain;
return(true);
}
if (this.IsValidReplayGain(trackGain))
{
Logger.Write(this, LogLevel.Debug, "Using track replay gain data: \"{0}\" => {1}", stream.FileName, trackGain);
mode = ReplayGainMode.Track;
replayGain = trackGain;
return(true);
}
Logger.Write(this, LogLevel.Debug, "No replay gain data: \"{0}\".", stream.FileName);
mode = ReplayGainMode.None;
replayGain = 0;
return(false);
}
public ScanPlaylistItemsTask(BassReplayGainScannerBehaviour behaviour, PlaylistItem[] playlistItems, ReplayGainMode mode) : base(behaviour, playlistItems, mode)
{
}
public ScanLibraryItemsTask(BassReplayGainScannerBehaviour behaviour, LibraryItem[] libraryItems, ReplayGainMode mode) : base(behaviour, libraryItems, mode)
{
}
public ScanTaskBase(BassReplayGainScannerBehaviour behaviour, IFileData[] fileDatas, ReplayGainMode mode) : this()
{
this.Behaviour = behaviour;
this.FileDatas = fileDatas;
this.ScannerItems = fileDatas
.OrderBy(fileData => fileData.FileName)
.Select(fileData => ScannerItem.FromFileData(fileData, mode))
.ToArray();
}
