public virtual bool Stop()
{
if (this.EncoderHandle == 0)
{
return(true);
}
if (this._useAsyncQueue)
{
if (BassEnc.BASS_Encode_StopEx(this.EncoderHandle, false))
{
this.EncoderHandle = 0;
return(true);
}
if (BassEnc.BASS_Encode_Stop(this.EncoderHandle))
{
this.EncoderHandle = 0;
return(true);
}
}
else if (BassEnc.BASS_Encode_Stop(this.EncoderHandle))
{
this.EncoderHandle = 0;
return(true);
}
return(false);
}
public override string GetStats(string password)
{
string result = null;
try
{
if (password == null)
{
password = this.AdminUsername + ":" + this.AdminPassword;
}
else if (password.IndexOf(':') < 0)
{
password = this.AdminUsername + ":" + password;
}
if (base.UseBASS && this.IsConnected)
{
result = BassEnc.BASS_Encode_CastGetStats(base.Encoder.EncoderHandle, BASSEncodeStats.BASS_ENCODE_STATS_ICESERV, password);
}
else
{
result = this.ICEcastGetStats(password, BASSEncodeStats.BASS_ENCODE_STATS_ICESERV);
}
}
catch
{
result = null;
}
return(result);
}
public override bool UpdateTitle(string song, string url)
{
base.SongTitle = song.Trim(new char[1]).Replace('\0', ' ');
if (!string.IsNullOrEmpty(url))
{
url = url.Trim(new char[1]).Replace('\0', ' ');
}
if (string.IsNullOrEmpty(base.SongTitle))
{
return(false);
}
if (base.UseBASS && this.IsConnected)
{
Encoding encoding;
if (base.ForceUTF8TitleUpdates || base.Encoder.EncoderType == BASSChannelType.BASS_CTYPE_STREAM_OGG || base.Encoder.EncoderType == BASSChannelType.BASS_CTYPE_STREAM_FLAC_OGG || base.Encoder.EncoderType == BASSChannelType.BASS_CTYPE_STREAM_OPUS)
{
encoding = Encoding.UTF8;
}
else
{
encoding = Encoding.GetEncoding("latin1");
}
return(BassEnc.BASS_Encode_CastSetTitle(base.Encoder.EncoderHandle, encoding.GetBytes(base.SongTitle + "\0"), null));
}
return(this.ICEcastUpdateTitle(base.SongTitle));
}
private static void LoadLibraries()
{
BassEnc.BASS_Encode_GetVersion();
BassMix.BASS_Mixer_GetVersion();
BassFx.BASS_FX_GetVersion();
Bass.BASS_GetVersion();
}
private void PrepareChannelsToSplit(int index, IList <int> ArrangedChannels, int channels, float vol, string file, MoggSplitFormat format, string quality, bool slave = true)
{
var channel_map = new int[channels == 2 ? 3 : 2];
channel_map[0] = ArrangedChannels[index];
channel_map[1] = channels == 2 ? ArrangedChannels[index + 1] : -1;
if (channels == 2)
{
channel_map[2] = -1;
}
var flags = slave ? BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_SPLIT_SLAVE : BASSFlag.BASS_STREAM_DECODE;
var out_stream = BassMix.BASS_Split_StreamCreate(SourceStream, flags, channel_map);
var volumeFX = Bass.BASS_ChannelSetFX(out_stream, BASSFXType.BASS_FX_BFX_VOLUME, 0);
var volume = new BASS_BFX_VOLUME {
lChannel = 0, fVolume = vol
};
Bass.BASS_FXSetParameters(volumeFX, volume);
Splits.Add(out_stream);
if (format == MoggSplitFormat.OGG)
{
var cmd = "bin\\oggenc2.exe -q" + quality + " - -o\"" + file + "\"";
BassEnc.BASS_Encode_Start(out_stream, cmd, BASSEncode.BASS_ENCODE_FP_24BIT | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
else
{
BassEnc.BASS_Encode_Start(out_stream, file, BASSEncode.BASS_ENCODE_PCM | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
}
public override bool Start(ENCODEPROC proc, IntPtr user, bool paused)
{
if (base.EncoderHandle != 0 || (proc != null && !this.SupportsSTDOUT))
{
return(false);
}
BASSEncode bassencode = BASSEncode.BASS_ENCODE_DEFAULT;
if (base.Force16Bit)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_16BIT;
}
else
{
bassencode |= BASSEncode.BASS_ENCODE_FP_32BIT;
}
if (paused)
{
bassencode |= BASSEncode.BASS_ENCODE_PAUSE;
}
if (base.NoLimit)
{
bassencode |= BASSEncode.BASS_ENCODE_CAST_NOLIMIT;
}
if (base.UseAsyncQueue)
{
bassencode |= BASSEncode.BASS_ENCODE_QUEUE;
}
base.EncoderHandle = BassEnc.BASS_Encode_Start(base.ChannelHandle, this.EncoderCommandLine, bassencode, proc, user);
return(base.EncoderHandle != 0);
}
public override bool Start(ENCODEPROC proc, IntPtr user, bool paused)
{
if (base.EncoderHandle != 0 || (proc != null && !this.SupportsSTDOUT))
{
return(false);
}
if (base.OutputFile == null)
{
return(false);
}
int num = base.ChannelHandle;
if (base.InputFile != null)
{
num = Bass.BASS_StreamCreateFile(base.InputFile, 0L, 0L, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE);
if (num == 0)
{
return(false);
}
}
BASSEncode bassencode = BASSEncode.BASS_ENCODE_AIFF;
if (this._aiffBitsPerSample == 16)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_16BIT;
}
else if (this._aiffBitsPerSample == 24)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_24BIT;
}
else if (this._aiffBitsPerSample == 8)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_8BIT;
}
else if (this.AIFF_Use32BitInteger)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_32BIT;
}
if (paused)
{
bassencode |= BASSEncode.BASS_ENCODE_PAUSE;
}
if (base.NoLimit)
{
bassencode |= BASSEncode.BASS_ENCODE_CAST_NOLIMIT;
}
if (base.UseAsyncQueue)
{
bassencode |= BASSEncode.BASS_ENCODE_QUEUE;
}
base.EncoderHandle = BassEnc.BASS_Encode_Start(num, base.OutputFile, bassencode, null, IntPtr.Zero);
if (base.InputFile != null)
{
Utils.DecodeAllData(num, true);
}
return(base.EncoderHandle != 0);
}
public unsafe override bool Start(ENCODEPROC proc, IntPtr user, bool paused)
{
if (base.EncoderHandle != 0 || (proc != null && !this.SupportsSTDOUT))
{
return(false);
}
if (this.ACM_Codec == null)
{
this.ACM_Codec = new ACMFORMAT();
}
int num = base.ChannelHandle;
if (base.InputFile != null)
{
num = Bass.BASS_StreamCreateFile(base.InputFile, 0L, 0L, BASSFlag.BASS_STREAM_DECODE);
if (num == 0)
{
return(false);
}
}
BASSEncode bassencode = BASSEncode.BASS_ENCODE_DEFAULT;
if (paused && base.InputFile == null)
{
bassencode |= BASSEncode.BASS_ENCODE_PAUSE;
}
if (base.NoLimit)
{
bassencode |= BASSEncode.BASS_ENCODE_CAST_NOLIMIT;
}
if (base.UseAsyncQueue)
{
bassencode |= BASSEncode.BASS_ENCODE_QUEUE;
}
fixed(byte *ptr = this.acmCodecToByteArray())
{
if (base.OutputFile == null)
{
base.EncoderHandle = BassEnc.BASS_Encode_StartACM(num, (IntPtr)((void *)ptr), bassencode, proc, user);
}
else
{
if (base.OutputFile == null || this.ACM_EncoderType != BASSChannelType.BASS_CTYPE_STREAM_WAV || !this.ACM_WriteWaveHeader)
{
bassencode |= BASSEncode.BASS_ENCODE_NOHEAD;
}
base.EncoderHandle = BassEnc.BASS_Encode_StartACMFile(num, (IntPtr)((void *)ptr), bassencode, base.OutputFile);
}
}
if (base.InputFile != null)
{
Utils.DecodeAllData(num, true);
}
return(base.EncoderHandle != 0);
}
private bool DoConnect(bool startTimer)
{
this.Server.LastError = StreamingServer.STREAMINGERROR.Ok;
this.Server.LastErrorMessage = string.Empty;
this._automaticMode = false;
bool flag = false;
object @lock = this._lock;
lock (@lock)
{
flag = (!this.IsConnected || this.Disconnect());
if (flag)
{
flag = this.InternalConnect(startTimer);
if (!flag)
{
this.StopEncoder();
this._status = BroadCast.BROADCASTSTATUS.NotConnected;
}
}
else
{
this._status = BroadCast.BROADCASTSTATUS.NotConnected;
}
if (this.AutoReconnect)
{
if (this._retryTimer != null)
{
this._retryTimer.Change(-1, -1);
this._retryTimer.Dispose();
this._retryTimer = null;
}
if (flag && this.Server.UseBASS)
{
if (this.Server is WMAcast)
{
((EncoderWMA)this.Server.Encoder).WMA_Notify = this._myNotifyProc;
}
else
{
Bass.BASS_SetConfig(BASSConfig.BASS_CONFIG_ENCODE_CAST_TIMEOUT, (int)this._reconnectTimeout.TotalMilliseconds);
BassEnc.BASS_Encode_SetNotify(this.Server.Encoder.EncoderHandle, this._myNotifyProc, IntPtr.Zero);
}
}
else if (startTimer)
{
this._retryTimer = new Timer(this._retryTimerDelegate, null, this._reconnectTimeout, this._reconnectTimeout);
}
}
}
this._isStarted = flag;
return(flag);
}
/// <summary>
/// Stops the playback and copies the audio stream from CD to a <see cref="Stream"/> in MP3
/// format asynchronously. If the song was playing before copying, playback will be restored.
/// </summary>
/// <param name="TargetStream">The <see cref="Stream"/> where the media is written to.</param>
/// <param param name="Progress">An <see cref="IProgress{T}"/> instance that will be used to report the save progress. Can be null.</param>
/// <returns>A <see cref="Task"/> that represents the asynchronous process.</returns>
public async Task <bool> SaveToAsync(Stream TargetStream, IProgress <LongOperationProgress> Progress)
{
bool RequiresRestore = this.IsPlaying;
double Position = this.Position;
if (this.IsPlaying)
{
this.Stop();
}
ENCODEPROC proc = new ENCODEPROC(
(handle, channel, buffer, length, user) => {
byte[] ManagedBuffer = new byte[length];
Marshal.Copy(buffer, ManagedBuffer, 0, length);
TargetStream.Write(ManagedBuffer, 0, length);
}
);
int DecodingChannel = Bass.BASS_StreamCreateFile(this.Filename, 0, 0, BASSFlag.BASS_STREAM_DECODE);
long DecodingChannelLength = Bass.BASS_ChannelGetLength(DecodingChannel);
int Handle = BassEnc.BASS_Encode_Start(DecodingChannel, (new Lame()).GetCommandLine(), BASSEncode.BASS_ENCODE_AUTOFREE, proc, IntPtr.Zero);
LongOperationProgress Status = new LongOperationProgress {
IsIndetermine = false,
Maximum = DecodingChannelLength,
Position = 0
};
Progress?.Report(Status);
await Task.Run(() => {
int BufferLength = 10240;
byte[] Buffer = new byte[BufferLength];
while (Bass.BASS_ChannelGetPosition(DecodingChannel) < DecodingChannelLength)
{
Status.Position += Bass.BASS_ChannelGetData(DecodingChannel, Buffer, BufferLength);
Progress?.Report(Status);
}
BassEnc.BASS_Encode_Stop(Handle);
});
this.ChannelID = Bass.BASS_StreamCreateFile(this.Filename, 0, 0, BASSFlag.BASS_DEFAULT);
if (RequiresRestore)
{
this.Position = Position;
this.Play();
}
return(true);
}
private bool Disconnect(bool calledFromReconnectTry)
{
if (!calledFromReconnectTry)
{
this.Server.LastError = StreamingServer.STREAMINGERROR.Ok;
this.Server.LastErrorMessage = string.Empty;
}
this._isStarted = calledFromReconnectTry;
bool flag = false;
object @lock = this._lock;
lock (@lock)
{
flag = this.InternalDisconnect();
if (flag)
{
if (!calledFromReconnectTry)
{
this._killAutoReconnectTry = true;
if (this._autoReconnectTryRunning)
{
while (this._autoReconnectTryRunning)
{
Thread.Sleep(3);
}
}
}
if (this._retryTimer != null)
{
this._retryTimer.Change(-1, -1);
this._retryTimer.Dispose();
this._retryTimer = null;
}
if (this.Server.UseBASS)
{
if (this.Server is WMAcast)
{
((EncoderWMA)this.Server.Encoder).WMA_Notify = null;
}
else
{
BassEnc.BASS_Encode_SetNotify(this.Server.Encoder.EncoderHandle, null, IntPtr.Zero);
}
}
}
}
return(flag);
}
/// <summary>
/// Saves as wave.
/// </summary>
/// <param name="audioData">The audio data.</param>
/// <param name="outFilename">The out filename.</param>
public static void SaveAsWave(byte[] audioData, string outFilename)
{
var audioDataHandle = GCHandle.Alloc(audioData, GCHandleType.Pinned);
var audioDataPointer = audioDataHandle.AddrOfPinnedObject();
var channel = Bass.BASS_StreamCreateFile(audioDataPointer, 0, audioData.Length,
BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_STREAM_PRESCAN);
if (channel == 0)
{
throw new Exception("Cannot load audio data");
}
const BASSEncode flags = BASSEncode.BASS_ENCODE_PCM;
BassEnc.BASS_Encode_Start(channel, outFilename, flags, null, IntPtr.Zero);
const int startByte = 0;
var endByte = Bass.BASS_ChannelBytes2Seconds(channel, Bass.BASS_ChannelGetLength(channel));
var totalTransferLength = endByte - startByte;
Bass.BASS_ChannelSetPosition(channel, startByte, BASSMode.BASS_POS_BYTES);
while (totalTransferLength > 0)
{
var buffer = new byte[65536];
var transferLength = totalTransferLength;
if (transferLength > buffer.Length)
{
transferLength = buffer.Length;
}
// get the decoded sample data
var transferred = Bass.BASS_ChannelGetData(channel, buffer, (int)transferLength);
if (transferred <= 1)
{
break; // error or the end
}
totalTransferLength -= transferred;
}
BassEnc.BASS_Encode_Stop(channel);
Bass.BASS_StreamFree(channel);
audioDataHandle.Free();
}
private void Encode(string filename)
{
// Отключаем кнопки
playButton.Enabled = false;
saveButton.Enabled = false;
selectButton.Enabled = false;
encodeProgress.Visible = true;
// Энкодим в мп3
ThreadPool.QueueUserWorkItem(w =>
{
int encoder = BassEnc.BASS_Encode_Start(fxStream, "lame -b192 - \"" + filename + "\"", 0, null, IntPtr.Zero /*this.Handle*/);
long i = 0;
long chanLenght = Bass.BASS_ChannelGetLength(fxStream);
while (i < chanLenght - 1)
{
// Так как буфер в 1сек, то и записываем по одной секунде данных в проход
Bass.BASS_ChannelSetPosition(fxStream, i, BASSMode.BASS_POS_BYTES);
long len = Bass.BASS_ChannelSeconds2Bytes(fxStream, 1);
Bass.BASS_ChannelUpdate(fxStream, 1000);
i += len;
this.Invoke((MethodInvoker) delegate
{
encodeProgress.Value = (int)(i * 100 / chanLenght);
debugInfo.Text = Bass.BASS_ErrorGetCode().ToString() + "\n" + len + "\n" + i + "\n" + Bass.BASS_ChannelGetLength(fxStream);
});
}
// ехал инвок через инвок
this.Invoke((MethodInvoker) delegate
{
encodeProgress.Visible = false;
playButton.Enabled = true;
saveButton.Enabled = true;
selectButton.Enabled = true;
});
BassEnc.BASS_Encode_Stop(encoder);
});
}
public override int GetListeners(string password)
{
int result = -1;
try
{
if (password == null)
{
password = this.AdminUsername + ":" + this.AdminPassword;
}
else if (password.IndexOf(':') < 0)
{
password = this.AdminUsername + ":" + password;
}
string text;
if (base.UseBASS && this.IsConnected)
{
text = BassEnc.BASS_Encode_CastGetStats(base.Encoder.EncoderHandle, BASSEncodeStats.BASS_ENCODE_STATS_ICE, password);
}
else
{
text = this.ICEcastGetStats(password, BASSEncodeStats.BASS_ENCODE_STATS_ICE);
}
if (text != null)
{
int num = text.ToUpper().IndexOf("<LISTENERS>");
int num2 = text.ToUpper().IndexOf("</LISTENERS>");
if (num > 0 && num2 > 0)
{
num += 11;
result = int.Parse(text.Substring(num, num2 - num));
}
}
}
catch
{
result = -1;
}
return(result);
}
private async void EncodingStart(object o, DialogOpenedEventArgs args)
{
StopPlayback();
using (cancelEncoding = new CancellationTokenSource())
{
await Task.Run(() =>
{
Bass.ChannelSetPosition(fxStream, 0);
int encoder = BassEnc_Mp3.Start(fxStream, "-b 192", EncodeFlags.Default, saveFilename);
long i = 0;
while (i < audioLength - 1)
{
if (cancelEncoding.Token.IsCancellationRequested)
{
return;
}
Bass.ChannelSetPosition(fxStream, i);
Bass.ChannelUpdate(fxStream, buffer_length);
encodingDialog.Dispatcher?.Invoke(() =>
{
encodingDialog.UpdateProgress((double)i / audioLength * 100.0);
});
long len = Bass.ChannelSeconds2Bytes(fxStream, buffer_length / 1000.0);
i += len;
}
BassEnc.EncodeStop(encoder);
}, cancelEncoding.Token);
}
dialogHost.IsOpen = false;
}
public bool AddChunk(string ID, IntPtr buffer, int length)
{
return(BassEnc.EncodeAddChunk(Handle, ID, buffer, length));
}
public bool DownmixMogg(string CON_file, string output, MoggSplitFormat format, string quality, bool doWii = false, double start = 0.0, double length = 0.0, double fadeIn = 0.0, double fadeOut = 0.0, double volume = 0.0, string stems = "allstems")
{
if (!ExtractDecryptMogg(CON_file, true))
{
return(false);
}
try
{
if (!InitBass())
{
return(false);
}
var BassStream = Bass.BASS_StreamCreateFile(Tools.GetOggStreamIntPtr(), 0, Tools.PlayingSongOggData.Length, BASSFlag.BASS_STREAM_DECODE);
var channel_info = Bass.BASS_ChannelGetInfo(BassStream);
var BassMixer = BassMix.BASS_Mixer_StreamCreate(doWii ? 22050 : channel_info.freq, 2, BASSFlag.BASS_MIXER_END | BASSFlag.BASS_STREAM_DECODE);
if (doWii)
{
BassMix.BASS_Mixer_StreamAddChannelEx(BassMixer, BassStream, BASSFlag.BASS_MIXER_MATRIX, 0, Bass.BASS_ChannelSeconds2Bytes(BassMixer, length));
var track_vol = (float)Utils.DBToLevel(Convert.ToDouble(volume), 1.0);
Bass.BASS_ChannelSetPosition(BassStream, Bass.BASS_ChannelSeconds2Bytes(BassStream, start));
BASS_MIXER_NODE[] nodes =
{
new BASS_MIXER_NODE(0, 0),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(BassMixer, fadeIn), track_vol),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(BassMixer, length - fadeOut),track_vol),
new BASS_MIXER_NODE(Bass.BASS_ChannelSeconds2Bytes(BassMixer, length), 0)
};
BassMix.BASS_Mixer_ChannelSetEnvelope(BassStream, BASSMIXEnvelope.BASS_MIXER_ENV_VOL, nodes, nodes.Count());
}
else
{
BassMix.BASS_Mixer_StreamAddChannel(BassMixer, BassStream, BASSFlag.BASS_MIXER_MATRIX);
}
var matrix = GetChannelMatrix(Parser.Songs[0], channel_info.chans, stems);
BassMix.BASS_Mixer_ChannelSetMatrix(BassStream, matrix);
var output_file = output;
if (string.IsNullOrWhiteSpace(output))
{
output_file = Path.GetDirectoryName(CON_file) + "\\" + Parser.Songs[0].InternalName + (format == MoggSplitFormat.WAV ? ".wav" : ".ogg");
}
if (format == MoggSplitFormat.OGG)
{
var cmd = "bin\\oggenc2.exe -q" + quality + " - -o\"" + output_file + "\"";
BassEnc.BASS_Encode_Start(BassMixer, cmd, BASSEncode.BASS_ENCODE_FP_24BIT | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
else
{
BassEnc.BASS_Encode_Start(BassMixer, output_file, BASSEncode.BASS_ENCODE_PCM | BASSEncode.BASS_ENCODE_AUTOFREE, null, IntPtr.Zero);
}
while (true)
{
var buffer = new byte[20000];
var c = Bass.BASS_ChannelGetData(BassMixer, buffer, buffer.Length);
if (c < 0)
{
break;
}
}
UnloadLibraries();
Tools.ReleaseStreamHandle();
return(File.Exists(output_file));
}
catch (Exception ex)
{
ErrorLog.Add("Error downmixing mogg file:");
ErrorLog.Add(ex.Message);
UnloadLibraries();
Tools.ReleaseStreamHandle();
return(false);
}
}
private void BurningThread()
{
log.Trace(">>>");
List <string> outFiles = new List <string>();
bool bError = false;
foreach (DataGridViewRow row in dataGridViewBurn.Rows)
{
TrackData track = bindingList[row.Index];
string outFile = String.Format(@"{0}\{1}.wav", tmpBurnDirectory,
Path.GetFileNameWithoutExtension(track.FullFileName));
int stream = Bass.BASS_StreamCreateFile(track.FullFileName, 0, 0, BASSFlag.BASS_STREAM_DECODE);
if (stream == 0)
{
bError = true;
log.Error("Error creating stream for {0}.", track.FullFileName);
continue;
}
// In order to burn a file to CD, it must be stereo and 44kz
// To make sure that we have that, we create a mixer channel and add our stream to it
// The mixer will do the resampling
int mixer = BassMix.BASS_Mixer_StreamCreate(44100, 2, BASSFlag.BASS_STREAM_DECODE);
if (mixer == 0)
{
bError = true;
log.Error("Error creating mixer for {0}.", track.FullFileName);
continue;
}
// Now add the stream to the mixer
BassMix.BASS_Mixer_StreamAddChannel(mixer, stream, 0);
log.Info("Decoding to WAV: {0}", track.FullFileName);
BassEnc.BASS_Encode_Start(mixer, outFile, BASSEncode.BASS_ENCODE_PCM, null, IntPtr.Zero);
long pos = 0;
long chanLength = Bass.BASS_ChannelGetLength(stream);
byte[] encBuffer = new byte[20000]; // our encoding buffer
while (Bass.BASS_ChannelIsActive(stream) == BASSActive.BASS_ACTIVE_PLAYING)
{
// getting sample data will automatically feed the encoder
int len = Bass.BASS_ChannelGetData(mixer, encBuffer, encBuffer.Length);
pos = Bass.BASS_ChannelGetPosition(mixer);
double percentComplete = pos / (double)chanLength * 100.0;
dataGridViewBurn.Rows[row.Index].Cells[0].Value = (int)percentComplete;
}
outFiles.Add(outFile);
dataGridViewBurn.Rows[row.Index].Cells[0].Value = 100;
BassEnc.BASS_Encode_Stop(mixer);
Bass.BASS_StreamFree(stream);
Bass.BASS_StreamFree(mixer);
}
burnManager.BurningFailed += burnManager_BurningFailed;
burnManager.BurnProgressUpdate += burnManager_BurnProgressUpdate;
if (!bError && MediaAllowsBurning())
{
foreach (DataGridViewRow row in dataGridViewBurn.Rows)
{
dataGridViewBurn.Rows[row.Index].Cells[0].Value = 0;
}
BurnResult result = burnManager.BurnAudioCd(outFiles);
if (result == BurnResult.Successful)
{
log.Info("Burning of Audio CD was successful");
}
else
{
log.Error("Burning of Audio CD failed");
}
}
log.Trace("<<<");
}
public override bool Connect()
{
if (!base.Encoder.IsActive)
{
base.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError;
base.LastErrorMessage = "Encoder not active!";
return(false);
}
if (!base.UseBASS)
{
if (this._socket != null && this._socket.Connected)
{
this._socket.Close();
this._socket = null;
}
this._socket = this.CreateSocket(this.ServerAddress, this.ServerPort);
return(this._socket != null && this._socket.Connected);
}
if (this._isConnected)
{
return(true);
}
string content = BassEnc.BASS_ENCODE_TYPE_OGG;
if (base.Encoder.EncoderType == BASSChannelType.BASS_CTYPE_STREAM_MP3)
{
content = BassEnc.BASS_ENCODE_TYPE_MP3;
}
else if (base.Encoder.EncoderType == BASSChannelType.BASS_CTYPE_STREAM_AAC)
{
content = BassEnc.BASS_ENCODE_TYPE_AAC;
}
string pass = this.Password;
if (!string.IsNullOrEmpty(this.Username) && this.Username.ToLower() != "source")
{
pass = this.Username + ":" + this.Password;
}
if (BassEnc.BASS_Encode_CastInit(base.Encoder.EncoderHandle, string.Format("{0}:{1}{2}", this.ServerAddress, this.ServerPort, this.MountPoint), pass, content, this.StreamName, this.StreamUrl, this.StreamGenre, this.StreamDescription, (this.Quality == null) ? null : string.Format("ice-bitrate: {0}\r\n", this.Quality), (this.Quality == null) ? base.Encoder.EffectiveBitrate : 0, this.PublicFlag))
{
this._myNotifyProc = new ENCODENOTIFYPROC(this.EncoderNotifyProc);
this._isConnected = BassEnc.BASS_Encode_SetNotify(base.Encoder.EncoderHandle, this._myNotifyProc, IntPtr.Zero);
}
else
{
base.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError;
base.LastErrorMessage = "Encoder not active or a connction to the server could not be established!";
BASSError basserror = Bass.BASS_ErrorGetCode();
if (basserror <= BASSError.BASS_ERROR_HANDLE)
{
if (basserror != BASSError.BASS_ERROR_UNKNOWN)
{
if (basserror != BASSError.BASS_ERROR_FILEOPEN)
{
if (basserror == BASSError.BASS_ERROR_HANDLE)
{
base.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError;
base.LastErrorMessage = "Encoder not active or invalif Encoder used!";
}
}
else
{
base.LastError = StreamingServer.STREAMINGERROR.Error_CreatingConnection;
base.LastErrorMessage = "Couldn't connect to the server!";
}
}
else
{
base.LastError = StreamingServer.STREAMINGERROR.Error_CreatingConnection;
base.LastErrorMessage = "An unknown error occurred!";
}
}
else if (basserror != BASSError.BASS_ERROR_ALREADY)
{
if (basserror != BASSError.BASS_ERROR_ILLPARAM)
{
if (basserror == BASSError.BASS_ERROR_CAST_DENIED)
{
base.LastError = StreamingServer.STREAMINGERROR.Error_Login;
base.LastErrorMessage = "Username or Password incorrect!";
}
}
else
{
base.LastError = StreamingServer.STREAMINGERROR.Error_ResolvingServerAddress;
base.LastErrorMessage = "Couldn't connect to the server or server doesn't include a port number!";
}
}
else
{
base.LastError = StreamingServer.STREAMINGERROR.Error_NotConnected;
base.LastErrorMessage = "There is already a cast set on the encoder!";
}
this._isConnected = false;
}
return(this._isConnected);
}
private void SHOUTcastv2UpdateStationArtwork()
{
if (this.IsConnected && this.UseSHOUTcastv2 && this.v2SendArtwork && !string.IsNullOrEmpty(this.v2StationArtwork))
{
Task.Factory.StartNew(delegate()
{
try
{
BASSEncodeMetaDataType bassencodeMetaDataType = (BASSEncodeMetaDataType)0;
byte[] array = null;
TagPicture tagPicture = new TagPicture(this.v2StationArtwork, TagPicture.PICTURE_TYPE.Location, this.StationName);
if (tagPicture != null)
{
tagPicture = new TagPicture(tagPicture, 300);
if (tagPicture.PictureStorage == TagPicture.PICTURE_STORAGE.Internal)
{
if (tagPicture.Data.Length <= 523680)
{
array = tagPicture.Data;
}
}
else
{
try
{
using (Stream stream = new FileStream(Encoding.UTF8.GetString(tagPicture.Data), FileMode.Open, FileAccess.Read))
{
if (stream.Length <= 523680L)
{
byte[] array2 = new byte[stream.Length];
stream.Read(array2, 0, (int)stream.Length);
array = array2;
}
stream.Close();
}
}
catch
{
}
}
string mimetype = tagPicture.MIMEType;
if (!(mimetype == "image/jpeg"))
{
if (!(mimetype == "image/bmp"))
{
if (!(mimetype == "image/png"))
{
if (mimetype == "image/gif")
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_STATIONLOGO_GIF;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_STATIONLOGO_PNG;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_STATIONLOGO_BMP;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_STATIONLOGO_JPG;
}
}
if (bassencodeMetaDataType > (BASSEncodeMetaDataType)0 && array != null)
{
BassEnc.BASS_Encode_CastSendMeta(base.Encoder.EncoderHandle, bassencodeMetaDataType, array);
}
}
catch
{
}
});
}
}
public override bool UpdateTitle(string song, string url)
{
if (song == null)
{
base.SongTitle = string.Empty;
}
else
{
base.SongTitle = song.Trim(new char[1]).Replace('\0', ' ');
}
if (!string.IsNullOrEmpty(url))
{
url = url.Trim(new char[1]).Replace('\0', ' ');
}
if (string.IsNullOrEmpty(base.SongTitle))
{
this.v2SongTitleNext = string.Empty;
}
if (!base.UseBASS || !this.IsConnected)
{
return(this.SHOUTcastUpdateTitle(base.SongTitle, url));
}
if (this.UseSHOUTcastv2)
{
try
{
StringWriterWithEncoding stringWriterWithEncoding = new StringWriterWithEncoding(Encoding.UTF8);
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriterWithEncoding, new XmlWriterSettings
{
Encoding = stringWriterWithEncoding.Encoding,
IndentChars = string.Empty,
Indent = false,
NewLineHandling = NewLineHandling.None,
NewLineChars = string.Empty,
CheckCharacters = false
}))
{
xmlWriter.WriteStartElement("metadata");
xmlWriter.WriteElementString("TIT2", base.SongTitle);
if (!string.IsNullOrEmpty(this.StationName))
{
xmlWriter.WriteElementString("TRSN", this.StationName);
}
xmlWriter.WriteElementString("TENC", BassNet.InternalName + " (Broadcast Framework)");
if (!string.IsNullOrEmpty(url))
{
xmlWriter.WriteElementString("WOAF", url);
}
if (!string.IsNullOrEmpty(this.Url))
{
xmlWriter.WriteElementString("WORS", this.Url);
}
if (this.v2SongTitleNext != null)
{
xmlWriter.WriteStartElement("extension");
xmlWriter.WriteStartElement("title");
xmlWriter.WriteAttributeString("seq", "1");
xmlWriter.WriteString(base.SongTitle);
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("title");
xmlWriter.WriteAttributeString("seq", "2");
xmlWriter.WriteString(this.v2SongTitleNext);
xmlWriter.WriteEndElement();
xmlWriter.WriteElementString("soon", this.v2SongTitleNext);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
this.v2SongTitleNext = string.Empty;
return(BassEnc.BASS_Encode_CastSendMeta(base.Encoder.EncoderHandle, BASSEncodeMetaDataType.BASS_METADATA_XML_SHOUTCAST, stringWriterWithEncoding.ToString()));
}
catch
{
return(false);
}
}
if (base.ForceUTF8TitleUpdates)
{
this.v2SongTitleNext = string.Empty;
bool flag = BassEnc.BASS_Encode_CastSetTitle(base.Encoder.EncoderHandle, Encoding.UTF8.GetBytes(base.SongTitle + "\0"), string.IsNullOrEmpty(url) ? null : Encoding.UTF8.GetBytes(url + "\0"));
if (!flag)
{
flag = this.SHOUTcastUpdateTitle(base.SongTitle, url);
}
return(flag);
}
this.v2SongTitleNext = string.Empty;
bool flag2 = BassEnc.BASS_Encode_CastSetTitle(base.Encoder.EncoderHandle, this._encoding.GetBytes(base.SongTitle + "\0"), string.IsNullOrEmpty(url) ? null : this._encoding.GetBytes(url + "\0"));
if (!flag2)
{
flag2 = this.SHOUTcastUpdateTitle(base.SongTitle, url);
}
return(flag2);
}
public virtual bool Pause(bool paused)
{
return(this.EncoderHandle != 0 && BassEnc.BASS_Encode_SetPaused(this.EncoderHandle, paused));
}
public override bool UpdateTitle(TAG_INFO tag, string url)
{
if (tag == null)
{
this.v2SongTitleNext = string.Empty;
return(false);
}
if (!string.IsNullOrEmpty(url))
{
url = url.Trim(new char[1]).Replace('\0', ' ');
}
if (!base.UseBASS || !this.IsConnected)
{
string text = base.SongTitle;
if (string.IsNullOrEmpty(text))
{
text = tag.ToString();
}
return(this.SHOUTcastUpdateTitle(text, url));
}
if (this.UseSHOUTcastv2)
{
try
{
StringWriterWithEncoding stringWriterWithEncoding = new StringWriterWithEncoding(Encoding.UTF8);
using (XmlWriter xmlWriter = XmlWriter.Create(stringWriterWithEncoding, new XmlWriterSettings
{
Encoding = stringWriterWithEncoding.Encoding,
IndentChars = string.Empty,
Indent = false,
NewLineHandling = NewLineHandling.None,
NewLineChars = string.Empty,
CheckCharacters = false
}))
{
xmlWriter.WriteStartElement("metadata");
if (this.v2SendSongTitleOnly)
{
if (string.IsNullOrEmpty(base.SongTitle))
{
xmlWriter.WriteElementString("TIT2", tag.ToString());
}
else
{
xmlWriter.WriteElementString("TIT2", base.SongTitle);
}
}
else
{
if (!string.IsNullOrEmpty(tag.artist))
{
xmlWriter.WriteElementString("TIT2", tag.title);
xmlWriter.WriteElementString("TPE1", tag.artist);
}
else
{
xmlWriter.WriteElementString("TIT2", tag.ToString());
}
if (!string.IsNullOrEmpty(tag.album))
{
xmlWriter.WriteElementString("TALB", tag.album);
}
if (!string.IsNullOrEmpty(tag.albumartist))
{
xmlWriter.WriteElementString("TPE2", tag.albumartist);
}
if (!string.IsNullOrEmpty(tag.genre))
{
xmlWriter.WriteElementString("TCON", tag.genre);
}
if (!string.IsNullOrEmpty(tag.year))
{
xmlWriter.WriteElementString("TYER", tag.year);
}
if (!string.IsNullOrEmpty(tag.copyright))
{
xmlWriter.WriteElementString("TCOP", tag.copyright);
}
if (!string.IsNullOrEmpty(tag.publisher))
{
xmlWriter.WriteElementString("TPUB", tag.publisher);
}
if (!string.IsNullOrEmpty(tag.composer))
{
xmlWriter.WriteElementString("TCOM", tag.composer);
}
if (!string.IsNullOrEmpty(tag.conductor))
{
xmlWriter.WriteElementString("TPE3", tag.conductor);
}
if (!string.IsNullOrEmpty(tag.remixer))
{
xmlWriter.WriteElementString("TPE4", tag.remixer);
}
if (!string.IsNullOrEmpty(tag.lyricist))
{
xmlWriter.WriteElementString("TEXT", tag.lyricist);
}
if (!string.IsNullOrEmpty(tag.isrc))
{
xmlWriter.WriteElementString("TSRC", tag.isrc);
}
if (!string.IsNullOrEmpty(tag.producer))
{
xmlWriter.WriteStartElement("IPLS");
xmlWriter.WriteAttributeString("role", "producer");
xmlWriter.WriteString(tag.producer);
xmlWriter.WriteEndElement();
}
if (!string.IsNullOrEmpty(tag.grouping))
{
xmlWriter.WriteElementString("TIT1", tag.grouping);
}
if (!string.IsNullOrEmpty(this.StationName))
{
xmlWriter.WriteElementString("TRSN", this.StationName);
}
xmlWriter.WriteElementString("TENC", BassNet.InternalName + " (Broadcast Framework)");
if (!string.IsNullOrEmpty(url))
{
xmlWriter.WriteElementString("WOAF", url);
}
if (!string.IsNullOrEmpty(this.Url))
{
xmlWriter.WriteElementString("WORS", this.Url);
}
}
if (this.v2SongTitleNext != null)
{
xmlWriter.WriteStartElement("extension");
xmlWriter.WriteStartElement("title");
xmlWriter.WriteAttributeString("seq", "1");
if (string.IsNullOrEmpty(base.SongTitle))
{
xmlWriter.WriteString(tag.ToString());
}
else
{
xmlWriter.WriteString(base.SongTitle);
}
xmlWriter.WriteEndElement();
xmlWriter.WriteStartElement("title");
xmlWriter.WriteAttributeString("seq", "2");
xmlWriter.WriteString(this.v2SongTitleNext);
xmlWriter.WriteEndElement();
xmlWriter.WriteElementString("soon", this.v2SongTitleNext);
xmlWriter.WriteEndElement();
}
xmlWriter.WriteEndElement();
xmlWriter.Flush();
}
bool result = BassEnc.BASS_Encode_CastSendMeta(base.Encoder.EncoderHandle, BASSEncodeMetaDataType.BASS_METADATA_XML_SHOUTCAST, stringWriterWithEncoding.ToString());
if (this.v2SendArtwork)
{
Task.Factory.StartNew(delegate()
{
try
{
BASSEncodeMetaDataType bassencodeMetaDataType = (BASSEncodeMetaDataType)0;
TagPicture tagPicture = null;
byte[] array = null;
if (tag.PictureCount > 0)
{
tagPicture = tag.PictureGet(0);
}
if (tagPicture == null && !string.IsNullOrEmpty(this.v2StreamArtwork))
{
tagPicture = new TagPicture(this.v2StreamArtwork, TagPicture.PICTURE_TYPE.Location, this.StationName);
}
if (tagPicture != null)
{
tagPicture = new TagPicture(tagPicture, 300);
if (tagPicture.PictureStorage == TagPicture.PICTURE_STORAGE.Internal)
{
if (tagPicture.Data.Length <= 523680)
{
array = tagPicture.Data;
}
}
else
{
try
{
using (Stream stream = new FileStream(Encoding.UTF8.GetString(tagPicture.Data), FileMode.Open, FileAccess.Read))
{
if (stream.Length <= 523680L)
{
byte[] array2 = new byte[stream.Length];
stream.Read(array2, 0, (int)stream.Length);
array = array2;
}
stream.Close();
}
}
catch
{
}
}
string mimetype = tagPicture.MIMEType;
if (!(mimetype == "image/jpeg"))
{
if (!(mimetype == "image/bmp"))
{
if (!(mimetype == "image/png"))
{
if (mimetype == "image/gif")
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_ALBUMART_GIF;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_ALBUMART_PNG;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_ALBUMART_BMP;
}
}
else
{
bassencodeMetaDataType = BASSEncodeMetaDataType.BASS_METADATA_BIN_ALBUMART_JPG;
}
}
if (bassencodeMetaDataType > (BASSEncodeMetaDataType)0 && array != null)
{
BassEnc.BASS_Encode_CastSendMeta(this.Encoder.EncoderHandle, bassencodeMetaDataType, array);
}
}
catch
{
}
});
}
this.v2SongTitleNext = string.Empty;
return(result);
}
catch
{
return(false);
}
}
if (base.ForceUTF8TitleUpdates)
{
string text2 = base.SongTitle;
if (string.IsNullOrEmpty(text2))
{
text2 = tag.ToString();
}
this.v2SongTitleNext = string.Empty;
bool flag = BassEnc.BASS_Encode_CastSetTitle(base.Encoder.EncoderHandle, Encoding.UTF8.GetBytes(text2 + "\0"), string.IsNullOrEmpty(url) ? null : Encoding.UTF8.GetBytes(url + "\0"));
if (!flag)
{
flag = this.SHOUTcastUpdateTitle(text2, url);
}
return(flag);
}
string text3 = base.SongTitle;
if (string.IsNullOrEmpty(text3))
{
text3 = tag.ToString();
}
this.v2SongTitleNext = string.Empty;
bool flag2 = BassEnc.BASS_Encode_CastSetTitle(base.Encoder.EncoderHandle, this._encoding.GetBytes(text3 + "\0"), string.IsNullOrEmpty(url) ? null : this._encoding.GetBytes(url + "\0"));
if (!flag2)
{
flag2 = this.SHOUTcastUpdateTitle(text3, url);
}
return(flag2);
}
/// <summary>
/// 切鸡鸡
/// </summary>
/// <param name="dir_path"></param>
/// <param name="specific_bms_file_name">可选,钦定文件夹下某个bms谱面文件，如果不钦定就随机选取一个</param>
/// <param name="start_time">起始时间，单位毫秒或者百分比，默认最初</param>
/// <param name="end_time">终止时间，单位毫秒或者百分比，默认谱面末尾</param>
/// <param name="encoder_command_line">编码命令</param>
/// <param name="save_file_name">保存的文件名</param>
public static bool GeneratePreviewAudio(
string dir_path,
string specific_bms_file_name = null,
string start_time = null,
string end_time = null,
string encoder_command_line = "",
string save_file_name = "preview_auto_generator.ogg",
int fade_out = 0,
int fade_in = 0,
bool check_vaild = false,
bool fast_clip = false,
bool no_skip = false)
{
var created_audio_handles = new HashSet <int>();
var sync_record = new HashSet <int>();
int mixer = 0;
try
{
save_file_name = string.IsNullOrWhiteSpace(save_file_name) ? "preview_auto_generator.ogg" : save_file_name;
if (!Directory.Exists(dir_path))
{
throw new Exception($"Directory {dir_path} not found.");
}
var bms_file_path = string.IsNullOrWhiteSpace(specific_bms_file_name) ? Directory.EnumerateFiles(dir_path, "*.bm*", SearchOption.TopDirectoryOnly).Where(x => support_bms_format.Any(y => x.EndsWith(y, StringComparison.InvariantCultureIgnoreCase))).FirstOrDefault() : Path.Combine(dir_path, specific_bms_file_name);
if (!File.Exists(bms_file_path))
{
throw new Exception($"BMS file {bms_file_path} not found.");
}
Console.WriteLine($"BMS file path:{bms_file_path}");
var content = File.ReadAllText(bms_file_path);
if (((check_vaild && CheckBeforeFileVaild(dir_path, save_file_name)) || CheckSkipable(dir_path, content)) && !no_skip)
{
Console.WriteLine("This bms contains preview audio file, skiped.");
return(true);
}
var chart = bms_file_path.EndsWith(".bmson", StringComparison.InvariantCultureIgnoreCase) ? new BmsonChart(content) as Chart : new BMSChart(content);
chart.Parse(ParseType.Header);
chart.Parse(ParseType.Resources);
chart.Parse(ParseType.Content);
var audio_map = chart.IterateResourceData(ResourceType.wav)
.Select(x => (x.resourceId, Directory.EnumerateFiles(dir_path, $"{Path.GetFileNameWithoutExtension(x.dataPath)}.*").FirstOrDefault()))
.Select(x => (x.resourceId, LoadAudio(x.Item2)))
.ToDictionary(x => x.resourceId, x => x.Item2);
var bms_evemts = chart.Events
.Where(e => e.type ==
BMSEventType.WAV ||
e.type == BMSEventType.Note ||
e.type == BMSEventType.LongNoteEnd ||
e.type == BMSEventType.LongNoteStart)
.OrderBy(x => x.time)
.Where(x => audio_map.ContainsKey(x.data2))//filter
.ToArray();
//init mixer
mixer = BassMix.CreateMixerStream(44100, 2, BassFlags.Decode | BassFlags.MixerNonStop);
//build triggers
var mixer_events = new List <MixEventBase>(bms_evemts.Select(x => new AudioMixEvent()
{
Time = x.time,
Duration = TimeSpan.FromSeconds(Bass.ChannelBytes2Seconds(audio_map[x.data2], Bass.ChannelGetLength(audio_map[x.data2]))),
PlayOffset = TimeSpan.Zero,
AudioHandle = audio_map[x.data2]
}));
#region Calculate and Adjust StartTime/EndTime
var full_audio_duration = mixer_events.OfType <AudioMixEvent>().Max(x => x.Duration + x.Time).Add(TimeSpan.FromSeconds(1));
var actual_end_time = string.IsNullOrWhiteSpace(end_time) ? full_audio_duration : (end_time.EndsWith("%") ? TimeSpan.FromMilliseconds(float.Parse(end_time.TrimEnd('%')) / 100.0f * full_audio_duration.TotalMilliseconds) : TimeSpan.FromMilliseconds(int.Parse(end_time)));
var actual_start_time = string.IsNullOrWhiteSpace(start_time) ? TimeSpan.Zero : (start_time.EndsWith("%") ? TimeSpan.FromMilliseconds(float.Parse(start_time.TrimEnd('%')) / 100.0f * full_audio_duration.TotalMilliseconds) : TimeSpan.FromMilliseconds(int.Parse(start_time)));
actual_start_time = actual_start_time < TimeSpan.Zero ? TimeSpan.Zero : actual_start_time;
actual_start_time = actual_start_time > full_audio_duration ? full_audio_duration : actual_start_time;
actual_end_time = actual_end_time < TimeSpan.Zero ? TimeSpan.Zero : actual_end_time;
actual_end_time = actual_end_time > full_audio_duration ? full_audio_duration : actual_end_time;
if (actual_end_time < actual_start_time)
{
var t = actual_end_time;
actual_end_time = actual_start_time;
actual_start_time = t;
}
Console.WriteLine($"Actual clip({(int)full_audio_duration.TotalMilliseconds}ms):{(int)actual_start_time.TotalMilliseconds}ms ~ {(int)actual_end_time.TotalMilliseconds}ms");
#endregion
if (fast_clip)
{
FastClipEvent(mixer_events, ref actual_start_time, ref actual_end_time);
}
//add special events to control encorder and mixer
mixer_events.Add(new StopMixEvent {
Time = actual_end_time
});
mixer_events.Add(new StartMixEvent()
{
Time = actual_start_time
});
//save encoder handle
int encoder = 0;
#region apply fade in/out
var effect = new VolumeParameters();
var fx = Bass.ChannelSetFX(mixer, effect.FXType, 0);
if (fade_in != 0)
{
var fade_in_evt = new FadeMixEvent(false, fade_in)
{
Time = actual_start_time
};
mixer_events.Add(fade_in_evt);
}
if (fade_out != 0)
{
var fade_out_evt = new FadeMixEvent(true, fade_out)
{
Time = actual_end_time.Subtract(TimeSpan.FromMilliseconds(fade_out))
};
mixer_events.Add(fade_out_evt);
}
#endregion
foreach (var evt in mixer_events)
{
var trigger_position = Bass.ChannelSeconds2Bytes(mixer, evt.Time.TotalSeconds);
sync_record.Add(Bass.ChannelSetSync(mixer, SyncFlags.Position | SyncFlags.Mixtime, trigger_position, (nn, mm, ss, ll) =>
{
if (evt is StopMixEvent && encoder != 0)
{
Bass.ChannelStop(mixer);
BassEnc.EncodeStop(encoder);
encoder = 0;
}
else if (evt is StartMixEvent && encoder == 0)
{
var output_path = Path.Combine(dir_path, save_file_name);
Console.WriteLine($"Encoding output file path:{output_path}");
encoder = BassEnc_Ogg.Start(mixer, encoder_command_line, EncodeFlags.AutoFree, output_path);
}
else if (evt is AudioMixEvent audio)
{
var handle = audio.AudioHandle;
BassMix.MixerRemoveChannel(handle);
Bass.ChannelSetPosition(handle, Bass.ChannelSeconds2Bytes(handle, audio.PlayOffset.TotalSeconds));
BassMix.MixerAddChannel(mixer, handle, BassFlags.Default);
}
else if (evt is FadeMixEvent fade)
{
effect.fTime = fade.Duration / 1000.0f;
if (fade.FadeOut)
{
effect.fCurrent = 1;
effect.fTarget = 0;
}
else
{
effect.fCurrent = 0;
effect.fTarget = 1;
}
Bass.FXSetParameters(fx, effect);
}
}));
}
WaitChannelDataProcessed(mixer);
Console.WriteLine("Success!");
return(true);
}
catch (Exception ex)
{
Console.WriteLine($"Failed.\n{ex.Message}\n{ex.StackTrace}");
return(false);
}
finally
{
#region Clean Resource
foreach (var record in sync_record)
{
Bass.ChannelRemoveSync(mixer, record);
}
foreach (var handle in created_audio_handles)
{
Bass.StreamFree(handle);
}
if (mixer != 0)
{
Bass.StreamFree(mixer);
}
#endregion
}
int LoadAudio(string item2)
{
var handle = Bass.CreateStream(item2, 0, 0, BassFlags.Decode | BassFlags.Float);
created_audio_handles.Add(handle);
return(handle);
}
}
/// <summary>
/// Saves audio data as a mono wave.
/// </summary>
/// <param name="audioData">The audio data.</param>
/// <param name="outFilename">The output filename.</param>
/// <param name="length">The maximum length in seconds, or 0 for no limit.</param>
/// <param name="gain">The gain.</param>
/// <exception cref="System.Exception">Cannot load audio data</exception>
public static void SaveAsMonoWave(byte[] audioData, string outFilename, double length, float gain)
{
// DebugHelper.WriteLine("SaveAsMonoWave");
var audioDataHandle = GCHandle.Alloc(audioData, GCHandleType.Pinned);
var audioDataPointer = audioDataHandle.AddrOfPinnedObject();
var channel = Bass.BASS_StreamCreateFile(audioDataPointer, 0, audioData.Length,
BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE | BASSFlag.BASS_STREAM_PRESCAN);
if (channel == 0)
{
throw new Exception("Cannot load audio data");
}
// create a mono 44100Hz mixer
var mixer = BassMix.BASS_Mixer_StreamCreate(44100, 1, BASSFlag.BASS_MIXER_END | BASSFlag.BASS_STREAM_DECODE);
// plug in the source
BassMix.BASS_Mixer_StreamAddChannel(mixer, channel,
BASSFlag.BASS_MIXER_DOWNMIX | BASSFlag.BASS_MIXER_NORAMPIN);
AudioStreamHelper.SetReplayGain(mixer, gain);
const BASSEncode flags = BASSEncode.BASS_ENCODE_PCM;
BassEnc.BASS_Encode_Start(mixer, outFilename, flags, null, IntPtr.Zero);
const int startByte = 0;
if (length == 0)
{
length = Bass.BASS_ChannelBytes2Seconds(channel, Bass.BASS_ChannelGetLength(channel));
}
var totalTransferLength = Bass.BASS_ChannelSeconds2Bytes(mixer, length);
Bass.BASS_ChannelSetPosition(channel, startByte, BASSMode.BASS_POS_BYTES);
while (totalTransferLength > 0)
{
var buffer = new byte[65536];
var transferLength = totalTransferLength;
if (transferLength > buffer.Length)
{
transferLength = buffer.Length;
}
// get the decoded sample data
var transferred = Bass.BASS_ChannelGetData(mixer, buffer, (int)transferLength);
if (transferred <= 1)
{
break; // error or the end
}
totalTransferLength -= transferred;
}
BassEnc.BASS_Encode_Stop(mixer);
BassMix.BASS_Mixer_ChannelRemove(channel);
Bass.BASS_StreamFree(channel);
Bass.BASS_StreamFree(mixer);
audioDataHandle.Free();
// DebugHelper.WriteLine("END SaveAsMonoWave");
}
/// <summary>
/// Saves the partial as wave.
/// </summary>
/// <param name="inFilename">The in filename.</param>
/// <param name="outFilename">The out filename.</param>
/// <param name="start">The start position in seconds.</param>
/// <param name="length">The length in seconds.</param>
/// <param name="offset">The offset position in seconds.</param>
/// <param name="gain">The gain.</param>
/// <param name="bpm">The BPM.</param>
/// <param name="targetBpm">The target BPM.</param>
public static void SavePartialAsWave(string inFilename,
string outFilename,
double start,
double length,
double offset = 0,
float gain = 0,
decimal bpm = 0,
decimal targetBpm = 0)
{
// DebugHelper.WriteLine("Saving portion of track as wave with offset - " + inFilename);
var audioStream = new Sample
{
Filename = inFilename,
Description = inFilename,
Gain = gain,
Bpm = bpm
};
AudioStreamHelper.LoadAudio(audioStream);
if (targetBpm != 0)
{
if (bpm == 0)
{
bpm = BpmHelper.GetBpmFromLoopLength(length);
}
var percentChange = BpmHelper.GetAdjustedBpmPercentChange(bpm, targetBpm) / 100;
AudioStreamHelper.SetTempoToMatchBpm(audioStream.ChannelId, bpm, targetBpm);
length = length * (double)(1 + percentChange);
}
const BASSEncode flags = BASSEncode.BASS_ENCODE_PCM;
BassEnc.BASS_Encode_Start(audioStream.ChannelId, outFilename, flags, null, IntPtr.Zero);
var startByte = Bass.BASS_ChannelSeconds2Bytes(audioStream.ChannelId, start);
var endByte = Bass.BASS_ChannelSeconds2Bytes(audioStream.ChannelId, start + length);
if (offset == 0 || offset == start)
{
TransferBytes(audioStream.ChannelId, startByte, endByte);
}
else
{
startByte = Bass.BASS_ChannelSeconds2Bytes(audioStream.ChannelId, offset);
TransferBytes(audioStream.ChannelId, startByte, endByte);
startByte = Bass.BASS_ChannelSeconds2Bytes(audioStream.ChannelId, start);
endByte = Bass.BASS_ChannelSeconds2Bytes(audioStream.ChannelId, offset);
TransferBytes(audioStream.ChannelId, startByte, endByte);
}
BassEnc.BASS_Encode_Stop(audioStream.ChannelId);
Bass.BASS_StreamFree(audioStream.ChannelId);
AudioStreamHelper.UnloadAudio(audioStream);
}
public override bool Start(ENCODEPROC proc, IntPtr user, bool paused)
{
if (base.EncoderHandle != 0 || (proc != null && !this.SupportsSTDOUT))
{
return(false);
}
if (base.OutputFile == null)
{
return(false);
}
int num = base.ChannelHandle;
if (base.InputFile != null)
{
num = Bass.BASS_StreamCreateFile(base.InputFile, 0L, 0L, BASSFlag.BASS_SAMPLE_FLOAT | BASSFlag.BASS_STREAM_DECODE);
if (num == 0)
{
return(false);
}
}
BASSEncode bassencode = BASSEncode.BASS_ENCODE_PCM;
if (this._wavUseAIFF)
{
bassencode = BASSEncode.BASS_ENCODE_AIFF;
}
if (this._wavBitsPerSample == 16)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_16BIT;
}
else if (this._wavBitsPerSample == 24)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_24BIT;
}
else if (this._wavBitsPerSample == 8)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_8BIT;
}
else if (this.WAV_Use32BitInteger)
{
bassencode |= BASSEncode.BASS_ENCODE_FP_32BIT;
}
if (this.BWF_UseRF64)
{
bassencode |= BASSEncode.BASS_ENCODE_RF64;
}
if (paused || (base.TAGs != null && !this._wavUseAIFF))
{
bassencode |= BASSEncode.BASS_ENCODE_PAUSE;
}
if (base.NoLimit)
{
bassencode |= BASSEncode.BASS_ENCODE_CAST_NOLIMIT;
}
if (base.UseAsyncQueue)
{
bassencode |= BASSEncode.BASS_ENCODE_QUEUE;
}
if (this._wavBitsPerSample > 16 || base.ChannelSampleRate > 48000 || base.ChannelNumChans > 2)
{
bassencode |= BASSEncode.BASS_ENCODE_WFEXT;
}
base.EncoderHandle = BassEnc.BASS_Encode_Start(num, base.OutputFile, bassencode, null, IntPtr.Zero);
if (base.TAGs != null && !this._wavUseAIFF)
{
if (this.BWF_AddBEXT)
{
byte[] array = base.TAGs.ConvertToRiffBEXT(true);
if (array != null && array.Length != 0)
{
BassEnc.BASS_Encode_AddChunk(base.EncoderHandle, "bext", array, array.Length);
}
}
if (this.BWF_AddCART)
{
byte[] array2 = base.TAGs.ConvertToRiffCART(true);
if (array2 != null && array2.Length != 0)
{
BassEnc.BASS_Encode_AddChunk(base.EncoderHandle, "cart", array2, array2.Length);
}
}
if (this.WAV_AddRiffInfo)
{
byte[] array3 = base.TAGs.ConvertToRiffINFO(false);
if (array3 != null && array3.Length != 0)
{
BassEnc.BASS_Encode_AddChunk(base.EncoderHandle, "LIST", array3, array3.Length);
}
}
}
if (base.TAGs != null && !this._wavUseAIFF)
{
BassEnc.BASS_Encode_SetPaused(base.EncoderHandle, paused);
}
if (base.InputFile != null)
{
Utils.DecodeAllData(num, true);
}
return(base.EncoderHandle != 0);
}
private static void LoadBassEnc(string Directory)
{
BassEnc.LoadMe(Directory);
}
public static void BASSEncoderInit(Int32 format, String str)
{
try
{
string pathwithoutext = String.Format("{0}\\{1}", Properties.Settings.Default.LastExportFolder, Path.GetFileNameWithoutExtension(str));
string ext;
string enc;
string args;
int copynum = 1;
if (format == 1)
{
foreach (Process proc in Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Program.OGGEnc)))
{
proc.Kill();
}
ext = "ogg";
enc = Program.OGGEnc;
args = String.Format(Properties.Settings.Default.EncoderOGG, Properties.Settings.Default.OverrideBitrate ? Properties.Settings.Default.Bitrate : 192);
}
else if (format == 2)
{
foreach (Process proc in Process.GetProcessesByName(Path.GetFileNameWithoutExtension(Program.MP3Enc)))
{
proc.Kill();
}
ext = "mp3";
enc = Program.MP3Enc;
args = String.Format(Properties.Settings.Default.EncoderMP3, Properties.Settings.Default.OverrideBitrate ? Properties.Settings.Default.Bitrate : 192);
}
else
{
ext = "wav";
enc = null;
args = "";
}
if (File.Exists(String.Format("{0}.{1}", pathwithoutext, ext)))
{
string temp;
do
{
temp = String.Format("{0} ({1} {2})", pathwithoutext, Languages.Parse("CopyText"), copynum);
++copynum;
} while (File.Exists(String.Format("{0}.{1}", temp, ext)));
BassEnc.BASS_Encode_Stop(MainWindow.VSTs._VSTiHandle);
BassEnc.BASS_Encode_Stop(MainWindow.KMCGlobals._recHandle);
MainWindow.KMCGlobals._Encoder = BassEnc.BASS_Encode_Start((MainWindow.VSTs.VSTInfo[0].isInstrument ? MainWindow.VSTs._VSTiHandle : MainWindow.KMCGlobals._recHandle), EncoderString(enc, temp, ext, args), (Properties.Settings.Default.LoudMaxEnabled ? BASSEncode.BASS_ENCODE_FP_16BIT : BASSEncode.BASS_ENCODE_DEFAULT) | BASSEncode.BASS_ENCODE_AUTOFREE | IsOgg(format) | IsWav(format), null, IntPtr.Zero);
BASSCheckError();
}
else
{
BassEnc.BASS_Encode_Stop(MainWindow.VSTs._VSTiHandle);
BassEnc.BASS_Encode_Stop(MainWindow.KMCGlobals._recHandle);
MainWindow.KMCGlobals._Encoder = BassEnc.BASS_Encode_Start((MainWindow.VSTs.VSTInfo[0].isInstrument ? MainWindow.VSTs._VSTiHandle : MainWindow.KMCGlobals._recHandle), EncoderString(enc, pathwithoutext, ext, args), (Properties.Settings.Default.LoudMaxEnabled ? BASSEncode.BASS_ENCODE_FP_16BIT : BASSEncode.BASS_ENCODE_DEFAULT) | BASSEncode.BASS_ENCODE_AUTOFREE | IsOgg(format) | IsWav(format), null, IntPtr.Zero);
BASSCheckError();
}
}
catch (Exception ex)
{
BASSCloseStreamException(ex);
}
}
