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); } }