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 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); }
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); }
/// <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); }
/// <summary> /// Initialize MP3 encoding whith LAME /// </summary> /// <param name="_rechandle"></param> /// <returns></returns> private bool StartLameEncoding(int _rechandle) { /* Voir si en utilisant "lameEncoder.OutputFile = outFile" * on pourrait créer un fichier au lieu d'un buffer * */ _lameMemBuffer.Clear(); _LameEncProc = new ENCODEPROC(LameEncCallback); // Callback function lameEncoder = new EncoderLAME(_rechandle); if (lameEncoder.EncoderExists == false) { Console.Write("Encoder does not exists ?\r"); } lameEncoder.InputFile = null; //STDIN if (bSaveToDisk) { lameEncoder.OutputFile = strSaveFile; } else { lameEncoder.OutputFile = null; //STDOUT - adding file name will prevent the callback from working instead will saving to disk } lameEncoder.LAME_Bitrate = (int)EncoderLAME.BITRATE.kbps_64; lameEncoder.LAME_Mode = EncoderLAME.LAMEMode.Default; lameEncoder.LAME_Quality = EncoderLAME.LAMEQuality.Quality; bool bret = lameEncoder.Start(_LameEncProc, IntPtr.Zero, false); BASSError txt = Bass.BASS_ErrorGetCode(); Msg(txt.ToString()); return(bret); }
public override bool Start(ENCODEPROC proc, IntPtr user, bool paused) { if (base.EncoderHandle != 0 || (proc != null && !this.SupportsSTDOUT)) { return(false); } this._paused = paused; this._encoderProc = null; this._byteSend = 0L; BASSWMAEncode basswmaencode = BASSWMAEncode.BASS_WMA_ENCODE_DEFAULT; if (this.WMA_ForceStandard) { basswmaencode |= BASSWMAEncode.BASS_WMA_ENCODE_STANDARD; } else { if (this.WMA_UsePro) { basswmaencode |= BASSWMAEncode.BASS_WMA_ENCODE_PRO; } if (this.WMA_Use24Bit) { basswmaencode |= BASSWMAEncode.BASS_WMA_ENCODE_24BIT; basswmaencode |= BASSWMAEncode.BASS_WMA_ENCODE_PRO; } } this._channel = base.ChannelHandle; this.WMA_TargetNumChans = base.ChannelNumChans; this.WMA_TargetSampleRate = base.ChannelSampleRate; if (base.InputFile != null) { this._channel = Bass.BASS_StreamCreateFile(base.InputFile, 0L, 0L, BASSFlag.BASS_STREAM_DECODE | (this.WMA_Use24Bit ? BASSFlag.BASS_SAMPLE_FLOAT : BASSFlag.BASS_DEFAULT)); if (this._channel == 0) { return(false); } if (this.WMA_Use24Bit) { basswmaencode |= BASSWMAEncode.BASS_SAMPLE_FLOAT; } } else if (base.ChannelBitwidth == 32) { basswmaencode |= BASSWMAEncode.BASS_SAMPLE_FLOAT; } else if (base.ChannelBitwidth == 8) { basswmaencode |= BASSWMAEncode.BASS_SAMPLE_8BITS; } if (this.WMA_UseNetwork) { basswmaencode |= BASSWMAEncode.BASS_WMA_ENCODE_SCRIPT; } int bitrate = this.WMA_Bitrate * 1000; if (this.WMA_UseVBR && this.WMA_VBRQuality > 0 && this.WMA_VBRQuality <= 100) { bitrate = this.WMA_VBRQuality; } if (proc != null && !this.WMA_UseNetwork) { this._encoderProc = proc; this._wmEncoderProc = new WMENCODEPROC(this.EncodingWMAHandler); } if (base.OutputFile == null) { if (this.WMA_UseNetwork && !this.WMA_UsePublish) { if (this.WMA_MultiBitrate != null && this.WMA_MultiBitrate.Length != 0) { int[] array = new int[this.WMA_MultiBitrate.Length]; for (int i = 0; i < this.WMA_MultiBitrate.Length; i++) { array[i] = this.WMA_MultiBitrate[i] * 1000; } base.EncoderHandle = BassWma.BASS_WMA_EncodeOpenNetworkMulti(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, array, this.WMA_NetworkPort, this.WMA_NetworkClients); } else { if (this.WMA_MultiBitrate != null) { bitrate = this.WMA_MultiBitrate[0]; } base.EncoderHandle = BassWma.BASS_WMA_EncodeOpenNetwork(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, bitrate, this.WMA_NetworkPort, this.WMA_NetworkClients); } } else if (this.WMA_UseNetwork && this.WMA_UsePublish) { if (this.WMA_MultiBitrate != null && this.WMA_MultiBitrate.Length > 1) { int[] array2 = new int[this.WMA_MultiBitrate.Length]; for (int j = 0; j < this.WMA_MultiBitrate.Length; j++) { array2[j] = this.WMA_MultiBitrate[j] * 1000; } base.EncoderHandle = BassWma.BASS_WMA_EncodeOpenPublishMulti(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, array2, this.WMA_PublishUrl, this.WMA_PublishUsername, this.WMA_PublishPassword); } else { base.EncoderHandle = BassWma.BASS_WMA_EncodeOpenPublish(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, bitrate, this.WMA_PublishUrl, this.WMA_PublishUsername, this.WMA_PublishPassword); } } else if (proc != null) { base.EncoderHandle = BassWma.BASS_WMA_EncodeOpen(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, bitrate, this._wmEncoderProc, user); } } else { base.EncoderHandle = BassWma.BASS_WMA_EncodeOpenFile(this.WMA_TargetSampleRate, this.WMA_TargetNumChans, basswmaencode, bitrate, base.OutputFile); if (base.TAGs != null) { if (!string.IsNullOrEmpty(base.TAGs.title)) { this.SetTag("Title", base.TAGs.title); } if (!string.IsNullOrEmpty(base.TAGs.artist)) { this.SetTag("Author", base.TAGs.artist); } if (!string.IsNullOrEmpty(base.TAGs.album)) { this.SetTag("WM/AlbumTitle", base.TAGs.album); } if (!string.IsNullOrEmpty(base.TAGs.albumartist)) { this.SetTag("WM/AlbumArtist", base.TAGs.albumartist); } if (!string.IsNullOrEmpty(base.TAGs.year)) { this.SetTag("WM/Year", base.TAGs.year); } if (!string.IsNullOrEmpty(base.TAGs.track)) { this.SetTag("WM/TrackNumber", base.TAGs.track); } if (!string.IsNullOrEmpty(base.TAGs.disc)) { this.SetTag("WM/PartOfSet", base.TAGs.disc); } if (!string.IsNullOrEmpty(base.TAGs.genre)) { this.SetTag("WM/Genre", base.TAGs.genre); } if (!string.IsNullOrEmpty(base.TAGs.comment)) { this.SetTag("Description", base.TAGs.comment); } if (!string.IsNullOrEmpty(base.TAGs.composer)) { this.SetTag("WM/Composer", base.TAGs.composer); } if (!string.IsNullOrEmpty(base.TAGs.conductor)) { this.SetTag("WM/Conductor", base.TAGs.conductor); } if (!string.IsNullOrEmpty(base.TAGs.lyricist)) { this.SetTag("WM/Writer", base.TAGs.lyricist); } if (!string.IsNullOrEmpty(base.TAGs.remixer)) { this.SetTag("WM/ModifiedBy", base.TAGs.remixer); } if (!string.IsNullOrEmpty(base.TAGs.producer)) { this.SetTag("WM/Producer", base.TAGs.producer); } if (!string.IsNullOrEmpty(base.TAGs.encodedby)) { this.SetTag("WM/EncodedBy", base.TAGs.encodedby); } if (!string.IsNullOrEmpty(base.TAGs.copyright)) { this.SetTag("Copyright", base.TAGs.copyright); } if (!string.IsNullOrEmpty(base.TAGs.publisher)) { this.SetTag("WM/Publisher", base.TAGs.publisher); } if (!string.IsNullOrEmpty(base.TAGs.bpm)) { this.SetTag("WM/BeatsPerMinute", base.TAGs.bpm); } if (!string.IsNullOrEmpty(base.TAGs.grouping)) { this.SetTag("WM/ContentGroupDescription", base.TAGs.grouping); } if (!string.IsNullOrEmpty(base.TAGs.rating)) { this.SetTag("WM/Rating", base.TAGs.rating); } if (!string.IsNullOrEmpty(base.TAGs.mood)) { this.SetTag("WM/Mood", base.TAGs.mood); } if (!string.IsNullOrEmpty(base.TAGs.isrc)) { this.SetTag("WM/ISRC", base.TAGs.isrc); } if (base.TAGs.replaygain_track_peak >= 0f) { this.SetTag("replaygain_track_peak", base.TAGs.replaygain_track_peak.ToString("R", CultureInfo.InvariantCulture)); } if (base.TAGs.replaygain_track_gain >= -60f && base.TAGs.replaygain_track_gain <= 60f) { this.SetTag("replaygain_track_gain", base.TAGs.replaygain_track_gain.ToString("R", CultureInfo.InvariantCulture) + " dB"); } } } if (base.EncoderHandle == 0) { return(false); } this._dspCallback = new DSPPROC(this.EncodingDSPHandler); this._dspHandle = Bass.BASS_ChannelSetDSP(base.ChannelHandle, this._dspCallback, IntPtr.Zero, Bass.BASS_GetConfig(BASSConfig.BASS_CONFIG_ENCODE_PRIORITY)); if (this._dspHandle == 0) { this.Stop(); return(false); } if (base.InputFile != null) { Utils.DecodeAllData(this._channel, true); } this._channel = 0; return(base.EncoderHandle != 0); }
public abstract bool Start(ENCODEPROC proc, IntPtr user, bool paused);
public bool StartEncoder(ENCODEPROC proc, IntPtr user, bool paused) { bool result = true; if (this.Server.Encoder.Start(proc, user, paused)) { this.RaiseNotification(BroadCastEventType.EncoderStarted, this.Server.Encoder); } else { this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = Enum.GetName(typeof(BASSError), Bass.BASS_ErrorGetCode()); BASSError basserror = Bass.BASS_ErrorGetCode(); if (basserror <= BASSError.BASS_ERROR_ILLPARAM) { if (basserror != BASSError.BASS_ERROR_FILEOPEN) { if (basserror == BASSError.BASS_ERROR_ILLPARAM) { this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = "Illegal parameters used to start encoder!"; goto IL_18C; } } else { if (this.Server.Encoder is EncoderWMA) { this.Server.LastError = StreamingServer.STREAMINGERROR.Error_CreatingConnection; this.Server.LastErrorMessage = "Couldn't connect to the server. Check URL!"; goto IL_18C; } this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = "Couldn't start the encoder. Check that executable exists!"; goto IL_18C; } } else { if (basserror == BASSError.BASS_ERROR_NOTAVAIL) { this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = "Encoder codec missing!"; goto IL_18C; } switch (basserror) { case BASSError.BASS_ERROR_WMA_WM9: case BASSError.BASS_ERROR_WMA_CODEC: this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = "WMA codec missing or WMA9 required!"; goto IL_18C; case BASSError.BASS_ERROR_WMA_DENIED: this.Server.LastError = StreamingServer.STREAMINGERROR.Error_Login; this.Server.LastErrorMessage = "Access denied. Check username/password!"; goto IL_18C; } } this.Server.LastError = StreamingServer.STREAMINGERROR.Error_EncoderError; this.Server.LastErrorMessage = "Some mystery problem occurred when trying to start the encoder!"; IL_18C: result = false; this.RaiseNotification(BroadCastEventType.EncoderStartError, this.Server.Encoder); } return(result); }
public static int BASS_Encode_Start(int handle, string cmdline, BASSEncode flags, ENCODEPROC proc, IntPtr user, int limit) { flags |= BASSEncode.BASS_UNICODE; return(BassEnc.BASS_Encode_StartUnicode(handle, cmdline, flags, proc, user, limit)); }
private static extern int BASS_Encode_StartUnicode(int chan, [MarshalAs(UnmanagedType.LPWStr)][In] string cmdline, BASSEncode flags, ENCODEPROC proc, IntPtr user, int limit);
public static extern int BASS_Encode_StartACM(int handle, IntPtr form, BASSEncode flags, ENCODEPROC proc, IntPtr user);
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); }