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);
}
/// <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();
}
public static int BASS_Encode_StartUser(int handle, string filename, BASSEncode flags, ENCODERPROC proc, IntPtr user)
{
flags |= BASSEncode.BASS_UNICODE;
return(BassEnc.BASS_Encode_StartUserUnicode(handle, filename, flags, proc, user));
}
private static extern int BASS_Encode_StartUserUnicode(int chan, [MarshalAs(UnmanagedType.LPWStr)][In] string filename, BASSEncode flags, ENCODERPROC proc, IntPtr user);
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 int BASS_Encode_StartACMFile(int handle, ACMFORMAT form, BASSEncode flags, string filename)
{
flags |= BASSEncode.BASS_UNICODE;
return(BassEnc.BASS_Encode_StartACMFileUnicode(handle, form, flags, filename));
}
/// <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");
}
public static extern int BASS_Encode_StartACM(int handle, IntPtr form, BASSEncode flags, ENCODEPROC proc, IntPtr user);
public static int BASS_Encode_OGG_StartFile(int handle, string options, BASSEncode flags, string filename)
{
flags |= BASSEncode.BASS_UNICODE;
return(BassEnc_Ogg.BASS_Encode_OGG_StartFileUnicode(handle, options, flags, filename));
}
private static extern int BASS_Encode_OGG_StartFileUnicode(int chan, [MarshalAs(UnmanagedType.LPWStr)][In] string options, BASSEncode flags, [MarshalAs(UnmanagedType.LPWStr)][In] string filename);
public static int BASS_Encode_OGG_Start(int handle, string options, BASSEncode flags, ENCODERPROC proc, IntPtr user)
{
flags |= BASSEncode.BASS_UNICODE;
return(BassEnc_Ogg.BASS_Encode_OGG_StartUnicode(handle, options, flags, proc, user));
}
/// <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);
}
private static extern int BASS_Encode_StartACMFileUnicode(int handle, [In] ACMFORMAT form, BASSEncode flags, [MarshalAs(UnmanagedType.LPWStr)][In] string file);
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);
}
