public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values == null || values.Length != 2)
{
return(null);
}
IList <AudioEncoderRateType> fetchRateTypes = EnumHelper <AudioEncoderRateType> .GetEnumList().ToList();
List <string> types = new List <string>();
foreach (var item in fetchRateTypes)
{
types.Add(EnumHelper <AudioEncoderRateType> .GetDisplay(item));
}
AudioEncoder audioEncoder = values[0] is AudioEncoder ? (AudioEncoder)values[0] : AudioEncoder.None;
AudioEncoder fallbackEncoder = values[1] is AudioEncoder ? (AudioEncoder)values[1] : AudioEncoder.None;
HBAudioEncoder selectedEncoder = HandBrakeEncoderHelpers.GetAudioEncoder(EnumHelper <AudioEncoder> .GetShortName(audioEncoder));
HBAudioEncoder selectedFallbackEncoder = HandBrakeEncoderHelpers.GetAudioEncoder(EnumHelper <AudioEncoder> .GetShortName(fallbackEncoder));
if (selectedEncoder != null && selectedEncoder.IsPassthrough)
{
if (selectedFallbackEncoder != null && !selectedFallbackEncoder.SupportsQuality)
{
types.Remove(EnumHelper <AudioEncoderRateType> .GetDisplay(AudioEncoderRateType.Quality));
}
}
return(types);
}
/// <summary>
/// Gets the number of audio samples used per frame for the given audio encoder.
/// </summary>
/// <param name="encoder">The encoder to query.</param>
/// <returns>The number of audio samples used per frame for the given
/// audio encoder.</returns>
internal static int GetAudioSamplesPerFrame(AudioEncoder encoder)
{
switch (encoder)
{
case AudioEncoder.Faac:
case AudioEncoder.ffaac:
case AudioEncoder.AacPassthru:
case AudioEncoder.Vorbis:
return(1024);
case AudioEncoder.Lame:
case AudioEncoder.Mp3Passthru:
return(1152);
case AudioEncoder.Ac3:
case AudioEncoder.Passthrough:
case AudioEncoder.Ac3Passthrough:
case AudioEncoder.DtsPassthrough:
case AudioEncoder.DtsHDPassthrough:
return(1536);
}
System.Diagnostics.Debug.Assert(true, "Audio encoder unrecognized.");
return(0);
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values.Length == 3)
{
bool isVisibile = (bool)values[0];
bool isPassthru = (bool)values[1];
AudioEncoder fallbackEncoder = AudioEncoder.ffaac;
if (values[2] != null && values[2].GetType() == typeof(AudioEncoder))
{
fallbackEncoder = (AudioEncoder)values[2];
}
if (!isVisibile)
{
return(Visibility.Collapsed);
}
if (fallbackEncoder == AudioEncoder.None && isPassthru)
{
return(Visibility.Collapsed);
}
}
return(Visibility.Visible);
}
public AudioTrack(AudioTrack track, bool setScannedTrack)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
if (setScannedTrack)
{
this.scannedTrack = track.ScannedTrack ?? new Audio();
}
if (!string.IsNullOrEmpty(this.scannedTrack?.Name))
{
this.TrackName = this.scannedTrack.Name;
}
if (!string.IsNullOrEmpty(track.TrackName))
{
this.TrackName = track.TrackName;
}
this.Quality = track.Quality;
// Setup Backing Properties
this.encoderRateType = track.EncoderRateType;
this.SetupLimits();
}
public Stream EncodeAsOggOpus(Stream audioStream)
{
var oggStream = new MemoryStream();
logger.LogInformation("Transcoding audio stream to ogg");
logger.LogDebug($"Transcoding with {config.Music.EncodingSampleRate} samples and {config.Music.EncodingBitrate} bits per second");
try
{
using (var inputStream = new AVIOStream(audioStream, FileAccess.Read))
using (var inputCtx = new InputContext(inputStream))
using (var decoder = new AudioDecoder(inputCtx))
using (var outputStream = new AVIOStream(oggStream, FileAccess.Write))
using (var outputCtx = new OutputContext(outputStream))
{
outputCtx.GuessOutputFormat(null, ".ogg", null);
using (var encoder = new AudioEncoder(outputCtx, FFmpeg.AutoGen.AVCodecID.AV_CODEC_ID_OPUS, config.Music.EncodingSampleRate, 2, config.Music.EncodingBitrate))
using (var transcoder = new AudioTranscoder(encoder, decoder))
{
outputCtx.WriteFileHeader();
transcoder.Transcode(true);
outputCtx.WriteFileTrailer();
logger.LogDebug("Transcoding finished");
}
}
oggStream.Position = 0;
return(oggStream);
}
catch (Exception ex)
{
logger.LogError(ex, "Exception while transcoding audio stream");
oggStream.Dispose();
return(null);
}
}
public void AddAudioTrack(AudioEncoder encoder)
{
throw new NotImplementedException();
/*IStream stream = null;
* switch (encoder) {
* case AUDIO_AMRNB:
* Log.d(TAG,"Audio streaming: AMR");
* stream = new AMRNBStream();
* break;
* case AUDIO_ANDROID_AMR:
* Log.d(TAG,"Audio streaming: GENERIC");
* stream = new GenericAudioStream();
* break;
* case AUDIO_AAC:
* Log.d(TAG,"Audio streaming: AAC (experimental)");
* stream = new AACStream();
* break;
* }
*
* if (stream != null) {
* stream.setDestination(destination, 5004);
* tracks.add(new Track(stream,Track.AUDIO));
* }*/
}
public void ConstructorTest()
{
AudioBuffer buff = Codecs.WAV.AudioDecoder.ReadAllSamples(new Codecs.WAV.DecoderSettings(), "test.wav");
AudioEncoder target;
target = new AudioEncoder(new EncoderSettings()
{
PCM = buff.PCM, EncoderMode = "7"
}, "flakewriter0.flac");
target.Settings.Padding = 1;
target.DoSeekTable = false;
//target.Vendor = "CUETools";
//target.CreationTime = DateTime.Parse("15 Aug 1976");
target.FinalSampleCount = buff.Length;
target.Write(buff);
target.Close();
CollectionAssert.AreEqual(File.ReadAllBytes("flake.flac"), File.ReadAllBytes("flakewriter0.flac"), "flakewriter0.flac doesn't match.");
target = new AudioEncoder(new EncoderSettings()
{
PCM = buff.PCM, EncoderMode = "7"
}, "flakewriter1.flac");
target.Settings.Padding = 1;
target.DoSeekTable = false;
//target.Vendor = "CUETools";
//target.CreationTime = DateTime.Parse("15 Aug 1976");
target.Write(buff);
target.Close();
CollectionAssert.AreEqual(File.ReadAllBytes("flake.flac"), File.ReadAllBytes("flakewriter1.flac"), "flakewriter1.flac doesn't match.");
}
/// <summary>
/// Gets the native code for the given encoder.
/// </summary>
/// <param name="encoder">The audio encoder to convert.</param>
/// <returns>The native code for the encoder.</returns>
public static uint AudioEncoderToNative(AudioEncoder encoder)
{
switch (encoder)
{
case AudioEncoder.Passthrough:
return NativeConstants.HB_ACODEC_AUTO_PASS;
case AudioEncoder.Ac3Passthrough:
return NativeConstants.HB_ACODEC_AC3_PASS;
case AudioEncoder.Ac3:
return NativeConstants.HB_ACODEC_AC3;
case AudioEncoder.Faac:
return NativeConstants.HB_ACODEC_FAAC;
case AudioEncoder.ffaac:
return NativeConstants.HB_ACODEC_FFAAC;
case AudioEncoder.AacPassthru:
return NativeConstants.HB_ACODEC_AAC_PASS;
case AudioEncoder.Lame:
return NativeConstants.HB_ACODEC_LAME;
case AudioEncoder.Mp3Passthru:
return NativeConstants.HB_ACODEC_MP3_PASS;
case AudioEncoder.DtsPassthrough:
return NativeConstants.HB_ACODEC_DCA_PASS;
case AudioEncoder.DtsHDPassthrough:
return NativeConstants.HB_ACODEC_DCA_HD_PASS;
case AudioEncoder.Vorbis:
return NativeConstants.HB_ACODEC_VORBIS;
case AudioEncoder.ffflac:
return NativeConstants.HB_ACODEC_FFFLAC;
}
return 0;
}
/// <summary>
/// 初始化音视频通信组件
/// </summary>
/// <param name="Model">视频显示大小模式</param>
public void iniAV(VideoSizeModel Model)
{
if (!IsIni)
{
IsIni = true;//标识已经初始化
}
else
{
return; //如果已经初始化，则退出
}
if (VC == null)
{
VC = new VideoCapturer(this.cLocal);//创建新的视频捕捉组件
VC.VideoCapturerBefore += new VideoCapturer.VideoCaptureredEventHandler(VC_VideoCapturerBefore);
VC.VideoDataCapturered += new VideoCapturer.VideoCaptureredEventHandler(VC_VideoDataCapturered);
VC.StartVideoCapture(Model);//开始捕捉视频
}
if (AE == null)
{
AE = new AudioEncoder();//创建G711音频编解码器
}
if (AC == null)
{
AC = new AudioCapturer(this.trackBarOut, this.trackBarIn);//创建新的音频捕捉组件
AC.AudioDataCapturered += new AudioCapturer.AudioDataCaptureredEventHandler(AC_AudioDataCapturered);
}
if (AR == null)
{
AR = new AudioRender();//创建G711音频回放组件
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Create a track from a behaviour track.
/// </summary>
/// <param name="track">
/// The Behavior track
/// </param>
/// <param name="sourceTrack">
/// The source track we are dealing with.
/// </param>
/// <param name="fallback">
/// An encoder to fall back to.
/// </param>
public AudioTrack(AudioBehaviourTrack track, Audio sourceTrack, AudioEncoder fallback)
{
AudioEncoder chosenEncoder = track.Encoder;
HBAudioEncoder encoderInfo = HandBrakeEncoderHelpers.GetAudioEncoder(EnumHelper <AudioEncoder> .GetShortName(track.Encoder));
if (track.IsPassthru && (sourceTrack.Codec & encoderInfo.Id) == 0)
{
chosenEncoder = fallback;
encoderInfo = HandBrakeEncoderHelpers.GetAudioEncoder(EnumHelper <AudioEncoder> .GetShortName(track.Encoder));
}
this.scannedTrack = sourceTrack;
this.drc = track.DRC;
this.encoder = chosenEncoder;
this.gain = track.Gain;
this.mixDown = track.MixDown != null ? track.MixDown.ShortName : "dpl2";
// If the mixdown isn't supported, downgrade it.
if (track.IsPassthru && track.MixDown != null && encoderInfo != null && !HandBrakeEncoderHelpers.MixdownIsSupported(track.MixDown, encoderInfo, sourceTrack.ChannelLayout))
{
HBMixdown changedMixdown = HandBrakeEncoderHelpers.GetDefaultMixdown(encoderInfo, (ulong)sourceTrack.ChannelLayout);
if (changedMixdown != null)
{
this.mixDown = changedMixdown.ShortName;
}
}
this.sampleRate = track.SampleRate;
this.encoderRateType = track.EncoderRateType;
this.quality = track.Quality;
this.bitrate = track.Bitrate;
this.SetupLimits();
}
/// <summary>
/// Get the CLI Audio Encoder name
/// </summary>
/// <param name="selectedEncoder">
/// String The GUI Encode name
/// </param>
/// <returns>
/// String CLI encoder name
/// </returns>
public static string GetCliAudioEncoder(AudioEncoder selectedEncoder)
{
switch (selectedEncoder)
{
case AudioEncoder.Faac:
return("faac");
case AudioEncoder.Lame:
return("lame");
case AudioEncoder.Vorbis:
return("vorbis");
case AudioEncoder.Ac3Passthrough:
return("copy:ac3");
case AudioEncoder.DtsPassthrough:
return("copy:dts");
case AudioEncoder.Ac3:
return("ac3");
default:
return("faac");
}
}
public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
{
if (values.Length == 3)
{
bool isVisibile = (bool)values[0];
bool isPassthru = (bool)values[1];
AudioEncoder fallbackEncoder = (AudioEncoder)values[2];
if (!isVisibile)
{
return(Visibility.Collapsed);
}
// When the Fallback Encoder is "None" and we have a passthru encoder selected on the track, we don't have any encoder options to override so don't show them.
if (isPassthru && fallbackEncoder == AudioEncoder.None)
{
return(Visibility.Collapsed);
}
}
if (values.Length == 2)
{
bool isPassthru = (bool)values[0];
AudioEncoder fallbackEncoder = (AudioEncoder)values[1];
// When the Fallback Encoder is "None" and we have a passthru encoder selected on the track, we don't have any encoder options to override so don't show them.
if (isPassthru && fallbackEncoder == AudioEncoder.None)
{
return(Visibility.Collapsed);
}
}
return(Visibility.Visible);
}
private void EncodeAudio()
{
AudioEncoder audioEncoder = new AudioEncoder(production);
audioEncoder.SuccessEvent += OnAudioEncoderSuccess;
audioEncoder.FailureEvent += OnAudioEncoderFailure;
audioEncoder.Encode();
}
/// <summary>
/// Determines if the given audio encoder is a passthrough encoder choice.
/// </summary>
/// <param name="encoder">The audio encoder to examine.</param>
/// <returns>True if the encoder is passthrough.</returns>
public static bool IsPassthrough(AudioEncoder encoder)
{
return(encoder == AudioEncoder.Ac3Passthrough ||
encoder == AudioEncoder.DtsHDPassthrough ||
encoder == AudioEncoder.DtsPassthrough ||
encoder == AudioEncoder.Mp3Passthru ||
encoder == AudioEncoder.AacPassthru ||
encoder == AudioEncoder.Passthrough);
}
/// <summary>
/// Determines if the given audio encoder is a passthrough encoder choice.
/// </summary>
/// <param name="encoder">The audio encoder to examine.</param>
/// <returns>True if the encoder is passthrough.</returns>
public static bool IsPassthrough(AudioEncoder encoder)
{
return encoder == AudioEncoder.Ac3Passthrough ||
encoder == AudioEncoder.DtsHDPassthrough ||
encoder == AudioEncoder.DtsPassthrough ||
encoder == AudioEncoder.Mp3Passthru ||
encoder == AudioEncoder.AacPassthru ||
encoder == AudioEncoder.Passthrough;
}
public string Convert(string inputFile, AudioEncoder audioEncoder, Bitrate audioBitrate, string outputFile)
{
var arguments = "-i " + "\"" + inputFile + "\"" +
" -v quiet -stats " +
_arguments.GetValue(audioEncoder.ToString()) +
_arguments.GetValue(audioBitrate.ToString()) +
" -y " + outputFile;
return(arguments);
}
/// <summary>
/// The refresh task.
/// </summary>
public void RefreshTask()
{
this.NotifyOfPropertyChange(() => this.Task);
if (this.Task.OutputFormat == OutputFormat.Mp4 &&
(this.AudioEncoderFallback == AudioEncoder.ffflac || this.AudioEncoderFallback == AudioEncoder.ffflac24 || this.AudioEncoderFallback == AudioEncoder.Vorbis))
{
this.AudioEncoderFallback = AudioEncoder.ffaac;
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Copy Constructor
/// </summary>
/// <param name="track">
/// The track.
/// </param>
public AudioTrack(AudioTrack track)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
this.scannedTrack = track.ScannedTrack ?? new Audio();
}
private void OnAudioEncoderFailure(object sender, ResultEventArgs ea)
{
AudioEncoder audioEncoder = (sender as AudioEncoder);
audioEncoder.SuccessEvent -= OnAudioEncoderSuccess;
audioEncoder.FailureEvent -= OnAudioEncoderFailure;
audioEncoder = null;
production.ErrorStatus = (ProductionErrorStatus)ea.Result;
FireFailureEvent();
}
private void OnAudioEncoderSuccess(object sender, EventArgs ea)
{
AudioEncoder audioEncoder = (sender as AudioEncoder);
audioEncoder.SuccessEvent -= OnAudioEncoderSuccess;
audioEncoder.FailureEvent -= OnAudioEncoderFailure;
audioEncoder = null;
production.Status = ProductionStatus.PS_JOIN_CLIPS;
Work();
}
public string Capture(string inputFile, int durationInSeconds, AudioEncoder audioEncoder, Bitrate audioBitrate, string outputFile)
{
var arguments = "-i " + "\"" + inputFile + "\"" +
" -c copy" +
" -t " + durationInSeconds +
_arguments.GetValue(audioEncoder.ToString()) +
_arguments.GetValue(audioBitrate.ToString()) +
" -y " + "\"" + outputFile + "\"";
return(arguments);
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Copy Constructor
/// </summary>
/// <param name="track">
/// The track.
/// </param>
public AudioBehaviourTrack(AudioBehaviourTrack track)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
this.Quality = track.Quality;
this.encoderRateType = track.EncoderRateType;
this.SetupLimits();
}
/// <summary>
/// 初始化音视频通信组件
/// </summary>
/// <param name="Model">视频显示大小模式</param>
public void iniAV(VideoSizeModel Model, System.Net.IPEndPoint ServerEP)
{
if (!IsIni)
{
IsIni = true;//标识已经初始化
}
else
{
return; //如果已经初始化，则退出
}
VideoSize.SetModel(Model); //设置视频编码尺寸
if (cam == null)
{
iniVideoCapturer();
}
#region //创建新的视频捕捉组件
//if (VC == null)
//{
// VC = new VideoCapturer(this.cLocal);
// VC.VideoCapturerBefore += new VideoCapturer.VideoCaptureredEventHandler(VC_VideoCapturerBefore);
// VC.VideoDataCapturered += new VideoCapturer.VideoCaptureredEventHandler(VC_VideoDataCapturered);
// VC.StartVideoCapture(Model);//开始捕捉视频
//}
#endregion
if (AE == null)
{
AE = new AudioEncoder();//创建G711音频编解码器
}
if (AC == null)
{
AC = new AudioCapturer(this.trackBarOut, this.trackBarIn);//创建新的音频捕捉组件
AC.AudioDataCapturered += new AudioCapturer.AudioDataCaptureredEventHandler(AC_AudioDataCapturered);
}
if (AR == null)
{
AR = new AudioRender();//创建G711音频回放组件
}
if (frameTransmit == null)
{
frameTransmit = new FrameTransmit(ServerEP);
frameTransmit.GetIPEndPoint += new FrameTransmit.GetIPEndPointEventHandler(frameTransmit_GetIPEndPoint);
frameTransmit.RecAudioData += new FrameTransmit.RecDataEventHandler(frameTransmit_RecAudioData);
frameTransmit.RecVideoData += new FrameTransmit.RecDataEventHandler(frameTransmit_RecVideoData);
frameTransmit.TransmitConnected += new FrameTransmit.TransmitEventHandler(frameTransmit_TransmitConnected);
frameTransmit.Start();
}
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Copy Constructor
/// </summary>
/// <param name="track">
/// The track.
/// </param>
public AudioBehaviourTrack(AudioBehaviourTrack track)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
this.Quality = track.Quality;
this.encoderRateType = track.EncoderRateType;
this.SetupLimits();
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioBehaviourTrack"/> class.
/// </summary>
public AudioBehaviourTrack(AudioEncoder fallback)
{
// Default Values
this.Encoder = AudioEncoder.ffaac;
this.MixDown = HandBrakeEncoderHelpers.Mixdowns.FirstOrDefault(m => m.ShortName == "dpl2");
this.SampleRate = 48;
this.Bitrate = 160;
this.DRC = 0;
this.EncoderRateType = AudioEncoderRateType.Bitrate;
this.fallbackEncoder = fallback;
this.SetupLimits();
}
/// <summary>
/// Builds an argument string from the settings
/// </summary>
/// <returns>A string to be used as argument to Handbrake CLI</returns>
public string Build()
{
var sb = new StringBuilder();
sb.Append($"--format {Format} ");
if (MaxHeight > 0)
{
sb.Append($"--maxHeight {MaxHeight} ");
}
if (MaxWidth > 0)
{
sb.Append($"--maxWidth {MaxWidth} ");
}
if (WebOptimize)
{
sb.Append("--optimize ");
}
sb.Append($"--modulus {Modulus} ");
sb.Append($"--{Anamorphic.Formatted()} ");
sb.Append($"--encoder {Encoder} ");
sb.Append($"--quality {VideoQuality} ");
sb.Append($"--{FrameRateSetting} ");
sb.Append($"--rate {FrameRate} ");
sb.Append($"--aencoder {AudioEncoder.Formatted()} ");
if (AudioEncoder == AudioEncoder.copy)
{
sb.Append($"--audio-copy-mask {AudioCopyMask.Formatted()} ");
}
if (AudioEncoder.ToString().StartsWith("copy"))
{
sb.Append($"--audio-fallback {AudioEncoderFallback.Formatted()} ");
}
sb.Append($"--mixdown {Mixdown.Formatted()} ");
sb.Append($"--arate {AudioSampleRate.Formatted()} ");
sb.Append($"--ab {AudioBitrate} ");
sb.Append($"--{AudioTracks.Formatted()} ");
sb.Append($"--gain {AudioGain} ");
sb.Append($"--subtitle none ");
if (TwoPass)
{
sb.Append("--two-pass ");
if (TurboTwoPass && (Encoder == Encoder.x264 || Encoder == Encoder.x265))
{
sb.Append("--turbo ");
}
}
sb.Append($"--encoder-level {EncoderLevel.Formatted()} ");
sb.Append("--verbose 0 ");
return(sb.ToString());
}
/// <summary>
/// 关闭
/// </summary>
public void Close()
{
if (frameTransmit != null)
{
frameTransmit.Dispose();
frameTransmit = null;
}
if (VC != null)
{
VC.Close();
VC = null;
}
if (VE != null)
{
VE.Close();
VE = null;
}
if (VD != null)
{
VD.Close();
VD = null;
}
if (VR != null)
{
VR = null;
}
if (AC != null)
{
AC.Close();
AC = null;
}
if (AE != null)
{
AE.Close(); AE = null;
}
if (AR != null)
{
AR.Close(); AE = null;
}
if (cam != null)
{
cam.Stop(); cam.Dispose();
cam = null;
timer1.Stop();
}
//cLocal.Dispose(); cLocal = null;
//cRemote.Dispose(); cRemote = null;
//trackBarIn.Dispose(); trackBarIn = null;
//trackBarOut.Dispose(); trackBarOut = null;
}
/// <summary>
/// Gets the bitrate limits for the given audio codec, sample rate and mixdown.
/// </summary>
/// <param name="encoder">The audio encoder used.</param>
/// <param name="sampleRate">The sample rate used (Hz).</param>
/// <param name="mixdown">The mixdown used.</param>
/// <returns>Limits on the audio bitrate for the given settings.</returns>
public static Limits GetBitrateLimits(AudioEncoder encoder, int sampleRate, Mixdown mixdown)
{
if (mixdown == Mixdown.Auto)
{
throw new ArgumentException("Mixdown cannot be Auto.");
}
int low = 0;
int high = 0;
HBFunctions.hb_get_audio_bitrate_limits(Converters.AudioEncoderToNative(encoder), sampleRate, Converters.MixdownToNative(mixdown), ref low, ref high);
return(new Limits {
Low = low, High = high
});
}
/// <summary>
/// Get the CLI Audio Encoder name
/// </summary>
/// <param name="selectedEncoder">
/// String The GUI Encode name
/// </param>
/// <returns>
/// String CLI encoder name
/// </returns>
public static string GetCliAudioEncoder(AudioEncoder selectedEncoder)
{
switch (selectedEncoder)
{
case AudioEncoder.Faac:
return("faac");
case AudioEncoder.ffaac:
return("ffaac");
case AudioEncoder.Lame:
return("lame");
case AudioEncoder.Vorbis:
return("vorbis");
case AudioEncoder.Ac3Passthrough:
return("copy:ac3");
case AudioEncoder.DtsPassthrough:
return("copy:dts");
case AudioEncoder.DtsHDPassthrough:
return("copy:dtshd");
case AudioEncoder.Ac3:
return("ffac3");
case AudioEncoder.AacPassthru:
return("copy:aac");
case AudioEncoder.Mp3Passthru:
return("copy:mp3");
case AudioEncoder.Passthrough:
return("copy");
case AudioEncoder.ffflac:
return("ffflac");
case AudioEncoder.ffflac24:
return("ffflac24");
default:
return("faac");
}
}
/// <summary>
/// Gets the native code for the given encoder.
/// </summary>
/// <param name="encoder">The audio encoder to convert.</param>
/// <returns>The native code for the encoder.</returns>
public static uint AudioEncoderToNative(AudioEncoder encoder)
{
switch (encoder)
{
case AudioEncoder.Passthrough:
return(NativeConstants.HB_ACODEC_AUTO_PASS);
case AudioEncoder.Ac3Passthrough:
return(NativeConstants.HB_ACODEC_AC3_PASS);
case AudioEncoder.Ac3:
return(NativeConstants.HB_ACODEC_AC3);
case AudioEncoder.ffaac:
return(NativeConstants.HB_ACODEC_FFAAC);
case AudioEncoder.fdkaac:
return(NativeConstants.HB_ACODEC_FDK_AAC);
case AudioEncoder.fdkheaac:
return(NativeConstants.HB_ACODEC_FDK_HAAC);
case AudioEncoder.AacPassthru:
return(NativeConstants.HB_ACODEC_AAC_PASS);
case AudioEncoder.Lame:
return(NativeConstants.HB_ACODEC_LAME);
case AudioEncoder.Mp3Passthru:
return(NativeConstants.HB_ACODEC_MP3_PASS);
case AudioEncoder.DtsPassthrough:
return(NativeConstants.HB_ACODEC_DCA_PASS);
case AudioEncoder.DtsHDPassthrough:
return(NativeConstants.HB_ACODEC_DCA_HD_PASS);
case AudioEncoder.Vorbis:
return(NativeConstants.HB_ACODEC_VORBIS);
case AudioEncoder.ffflac:
return(NativeConstants.HB_ACODEC_FFFLAC);
}
return(0);
}
/// <summary>
/// Gets the native code for the given encoder.
/// </summary>
/// <param name="encoder">The audio encoder to convert. Cannot be AudioEncoder.Passthrough.</param>
/// <returns>The native code for the encoder.</returns>
public static uint AudioEncoderToNative(AudioEncoder encoder)
{
switch (encoder)
{
case AudioEncoder.Ac3Passthrough:
return NativeConstants.HB_ACODEC_AC3_PASS;
case AudioEncoder.Faac:
return NativeConstants.HB_ACODEC_FAAC;
case AudioEncoder.Lame:
return NativeConstants.HB_ACODEC_LAME;
case AudioEncoder.Ac3:
return NativeConstants.HB_ACODEC_AC3;
case AudioEncoder.Vorbis:
return NativeConstants.HB_ACODEC_VORBIS;
}
return 0;
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Copy Constructor
/// </summary>
/// <param name="track">
/// The track.
/// </param>
/// <param name="setScannedTrack">
/// The set Scanned Track.
/// </param>
public AudioTrack(AudioTrack track, bool setScannedTrack)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
if (setScannedTrack)
{
this.scannedTrack = track.ScannedTrack ?? new Audio();
}
this.TrackName = track.TrackName;
this.Quality = track.Quality;
// Setup Backing Properties
this.encoderRateType = track.EncoderRateType;
this.SetupLimits();
}
public override void OnStart(EncoderOption option)
{
this.option = option;
var audio_file = StoryboardInstanceManager.ActivityInstance?.Info?.audio_file_path;
audio_reader = new MediaReader(audio_file);
audio_decoder = audio_reader.Decoders.OfType <AudioDecoder>().FirstOrDefault();
#region Video Init
var video_format = new VideoFormat(option.Width, option.Height, AVPixelFormat.Bgr24);
var video_param = new VideoEncoderParameters()
{
FrameRate = new Fraction(option.FPS), BitRate = option.BitRate
};
video_encoder = new VideoEncoder(option.EncoderName, video_format, video_param);
#endregion Video Init
writer = new MediaWriter(option.OutputPath, false).AddEncoder(video_encoder);
if (audio_decoder != null)
{
audio_encoder = new AudioEncoder(audio_decoder.ID, audio_decoder.OutFormat, BitRate._192Kbps);
writer.AddEncoder(audio_encoder);
}
writer.Initialize();
Log.User($"Format :{video_format.ToString()}\nVideo Encoder :{video_encoder.ToString()}");
video_frame = new VideoFrame(video_format);
audio_frame = new AudioFrame(audio_decoder.OutFormat);
audio_encoding_thread = new Thread(AudioEncoding);
audio_encoding_thread.Name = "Audio Encoder Thread";
audio_encoding_thread.Start();
}
private async Task StopAudioStream()
{
if (AudioSource != null)
{
DoStopAudioStream();
await AudioSource.Stop();
AudioSource.Destroy();
AudioSource = null;
}
if (AudioDepacketizer != null)
{
AudioDepacketizer.Destroy();
AudioDepacketizer = null;
}
if (AudioDecoder != null)
{
AudioDecoder.Destroy();
AudioDecoder = null;
}
if (ResetAudioPipe != null)
{
ResetAudioPipe.Destroy();
ResetAudioPipe = null;
}
if (AudioConverter != null)
{
AudioConverter.Destroy();
AudioConverter = null;
}
if (AudioEncoder != null)
{
AudioEncoder.Destroy();
AudioEncoder = null;
}
if (AudioPacketizer != null)
{
AudioPacketizer.Destroy();
AudioPacketizer = null;
}
}
public Ts3Full(Ts3FullClientData tfcd) : base(ClientType.Full)
{
tsFullClient = (Ts3FullClient)tsBaseClient;
ts3FullClientData = tfcd;
tfcd.PropertyChanged += Tfcd_PropertyChanged;
sendTick = TickPool.RegisterTick(AudioSend, sendCheckInterval, false);
encoder = new AudioEncoder(SendCodec)
{
Bitrate = ts3FullClientData.AudioBitrate * 1000
};
audioTimer = new PreciseAudioTimer(encoder.SampleRate, encoder.BitsPerSample, encoder.Channels);
isStall = false;
stallCount = 0;
identity = null;
Util.Init(ref channelSubscriptionsSetup);
Util.Init(ref clientSubscriptionsSetup);
subscriptionSetupChanged = true;
}
/// <summary>
/// Initializes a new instance of the <see cref="AudioTrack"/> class.
/// Copy Constructor
/// </summary>
/// <param name="track">
/// The track.
/// </param>
public AudioTrack(AudioTrack track)
{
this.bitrate = track.Bitrate;
this.drc = track.DRC;
this.encoder = track.Encoder;
this.gain = track.Gain;
this.mixDown = track.MixDown;
this.sampleRate = track.SampleRate;
this.scannedTrack = new Audio();
this.trackName = track.TrackName;
}
/// <summary>
/// Gets the bitrate limits for the given audio codec, sample rate and mixdown.
/// </summary>
/// <param name="encoder">The audio encoder used.</param>
/// <param name="sampleRate">The sample rate used (Hz).</param>
/// <param name="mixdown">The mixdown used.</param>
/// <returns>Limits on the audio bitrate for the given settings.</returns>
public static Limits GetBitrateLimits(AudioEncoder encoder, int sampleRate, Mixdown mixdown)
{
if (mixdown == Mixdown.Auto)
{
throw new ArgumentException("Mixdown cannot be Auto.");
}
int low = 0;
int high = 0;
HBFunctions.hb_get_audio_bitrate_limits(Converters.AudioEncoderToNative(encoder), sampleRate, Converters.MixdownToNative(mixdown), ref low, ref high);
return new Limits { Low = low, High = high };
}
/// <summary>
/// Gets the number of audio samples used per frame for the given audio encoder.
/// </summary>
/// <param name="encoder">The encoder to query.</param>
/// <returns>The number of audio samples used per frame for the given
/// audio encoder.</returns>
internal static int GetAudioSamplesPerFrame(AudioEncoder encoder)
{
switch (encoder)
{
case AudioEncoder.Faac:
case AudioEncoder.Vorbis:
return 1024;
case AudioEncoder.Lame:
return 1152;
case AudioEncoder.Ac3:
case AudioEncoder.Passthrough:
case AudioEncoder.Ac3Passthrough:
return 1536;
}
System.Diagnostics.Debug.Assert(true, "Audio encoder unrecognized.");
return 0;
}
/// <summary>
/// Sanitizes a mixdown given the output codec and input channel layout.
/// </summary>
/// <param name="mixdown">The desired mixdown.</param>
/// <param name="encoder">The output encoder to be used.</param>
/// <param name="layout">The input channel layout.</param>
/// <returns>A sanitized mixdown value.</returns>
public static Mixdown SanitizeMixdown(Mixdown mixdown, AudioEncoder encoder, int layout)
{
int sanitizedMixdown = HBFunctions.hb_get_best_mixdown(Converters.AudioEncoderToNative(encoder), layout, Converters.MixdownToNative(mixdown));
return Converters.NativeToMixdown(sanitizedMixdown);
}
/// <summary>
/// Sanitizes an audio bitrate given the output codec, sample rate and mixdown.
/// </summary>
/// <param name="audioBitrate">The desired audio bitrate.</param>
/// <param name="encoder">The output encoder to be used.</param>
/// <param name="sampleRate">The output sample rate to be used.</param>
/// <param name="mixdown">The mixdown to be used.</param>
/// <returns>A sanitized audio bitrate.</returns>
public static int SanitizeAudioBitrate(int audioBitrate, AudioEncoder encoder, int sampleRate, Mixdown mixdown)
{
return HBFunctions.hb_get_best_audio_bitrate(Converters.AudioEncoderToNative(encoder), audioBitrate, sampleRate, Converters.MixdownToNative(mixdown));
}
public static string EncodeAudio(string localFile, string ext, string destinationFile)
{
const string audioBitRate = "128";
var encoder = new AudioEncoder { FFmpegPath = FfMpegPath };
// select the commands depending on the file extension requested
string command;
switch (ext)
{
case "mp3":
command = QuickAudioEncodingCommands.MP3128Kbps;
break;
case "aac":
command = QuickAudioEncodingCommands.AAC128Kbps;
break;
case "wav":
default:
command = QuickAudioEncodingCommands.WAV128Kbps;
break;
}
// set up the parameters that we will use for the encoding
var parameters = new AudioEncoderParameters
{
InputPath = localFile,
EncodingCommandPass = command,
OutPutFile = OutPutFilePath + Path.GetFileName(destinationFile),
Suffix = audioBitRate,
Extension = ext
};
// if the destination file exists, then delete it or FFmpeg will freeze
// first we must recreate the final file path as it is created in the transcoder
var destinationFilePath = Path.GetDirectoryName(parameters.OutPutFile);
var destinationFileName = Path.GetFileNameWithoutExtension(parameters.OutPutFile);
destinationFileName = Path.Combine(destinationFilePath, string.Format("{0}_128.{1}", destinationFileName, ext));
if (File.Exists(destinationFileName))
{
File.Delete(destinationFileName);
}
var json = JsonConvert.SerializeObject(parameters);
// encode the file
var encoded = JsonConvert.DeserializeObject<EncodedAudio>(encoder.EncodeAudio(json));
if (encoded.Success)
{
destinationFile = encoded.EncodedAudioPath;
File.Delete(localFile);
}
else
{
using (var fs = File.Create(LogFilePath))
{
var sb = new StringBuilder();
sb.AppendLine(encoded.EncodingLog);
var info = new UTF8Encoding(true).GetBytes(sb.ToString());
// Add some information to the file.
fs.Write(info, 0, info.Length);
}
destinationFile = "error";
}
return destinationFile;
}
/// <summary>
/// Get the CLI Audio Encoder name
/// </summary>
/// <param name="selectedEncoder">
/// String The GUI Encode name
/// </param>
/// <returns>
/// String CLI encoder name
/// </returns>
public static string GetCliAudioEncoder(AudioEncoder selectedEncoder)
{
return EnumHelper<AudioEncoder>.GetShortName(selectedEncoder);
}
/// <summary>
/// Get the CLI Audio Encoder name
/// </summary>
/// <param name="selectedEncoder">
/// String The GUI Encode name
/// </param>
/// <returns>
/// String CLI encoder name
/// </returns>
public static string GetCliAudioEncoder(AudioEncoder selectedEncoder)
{
switch (selectedEncoder)
{
case AudioEncoder.Faac:
return "faac";
case AudioEncoder.ffaac:
return "ffaac";
case AudioEncoder.Lame:
return "lame";
case AudioEncoder.Vorbis:
return "vorbis";
case AudioEncoder.Ac3Passthrough:
return "copy:ac3";
case AudioEncoder.DtsPassthrough:
return "copy:dts";
case AudioEncoder.DtsHDPassthrough:
return "copy:dtshd";
case AudioEncoder.Ac3:
return "ffac3";
case AudioEncoder.AacPassthru:
return "copy:aac";
case AudioEncoder.Mp3Passthru:
return "copy:mp3";
case AudioEncoder.Passthrough:
return "copy";
case AudioEncoder.ffflac:
return "ffflac";
default:
return "faac";
}
}
public static string DisplayAudioEncoder(AudioEncoder audioEncoder)
{
return audioConverter.Convert(audioEncoder);
}
/** Set the default audio encoder, it will be used by addAudioTrack */
public static void SetDefaultAudioEncoder(AudioEncoder encoder) {
defaultAudioEncoder = encoder;
}
/// <summary>
/// Get the CLI Audio Encoder name
/// </summary>
/// <param name="selectedEncoder">
/// String The GUI Encode name
/// </param>
/// <returns>
/// String CLI encoder name
/// </returns>
public static string GetCliAudioEncoder(AudioEncoder selectedEncoder)
{
switch (selectedEncoder)
{
case AudioEncoder.Faac:
return "faac";
case AudioEncoder.Lame:
return "lame";
case AudioEncoder.Vorbis:
return "vorbis";
case AudioEncoder.Ac3Passthrough:
return "copy:ac3";
case AudioEncoder.DtsPassthrough:
return "copy:dts";
case AudioEncoder.Ac3:
return "ac3";
default:
return "faac";
}
}
/// <summary>
/// Get Appropiate Bitrates for the selected encoder and mixdown.
/// </summary>
/// <param name="encoder">
/// The encoder.
/// </param>
/// <param name="mixdown">
/// The mixdown.
/// </param>
/// <returns>
/// A List of valid audio bitrates
/// </returns>
private IEnumerable<int> GetAppropiateBitrates(AudioEncoder encoder, Mixdown mixdown)
{
return new ObservableCollection<int> { 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 640, 768 };
}
/// <summary>
/// Gets the default mixdown for the given audio encoder and channel layout.
/// </summary>
/// <param name="encoder">The output codec to be used.</param>
/// <param name="layout">The input channel layout.</param>
/// <returns>The default mixdown for the given codec and channel layout.</returns>
public static Mixdown GetDefaultMixdown(AudioEncoder encoder, int layout)
{
int defaultMixdown = HBFunctions.hb_get_default_mixdown(Converters.AudioEncoderToNative(encoder), layout);
return Converters.NativeToMixdown(defaultMixdown);
}
/// <summary>
/// Determines if the given audio encoder is a passthrough encoder choice.
/// </summary>
/// <param name="encoder">The audio encoder to examine.</param>
/// <returns>True if the encoder is passthrough.</returns>
public static bool IsPassthrough(AudioEncoder encoder)
{
return encoder == AudioEncoder.Ac3Passthrough || encoder == AudioEncoder.Passthrough;
}
public void AddAudioTrack(AudioEncoder encoder) {
throw new NotImplementedException();
/*IStream stream = null;
switch (encoder) {
case AUDIO_AMRNB:
Log.d(TAG,"Audio streaming: AMR");
stream = new AMRNBStream();
break;
case AUDIO_ANDROID_AMR:
Log.d(TAG,"Audio streaming: GENERIC");
stream = new GenericAudioStream();
break;
case AUDIO_AAC:
Log.d(TAG,"Audio streaming: AAC (experimental)");
stream = new AACStream();
break;
}
if (stream != null) {
stream.setDestination(destination, 5004);
tracks.add(new Track(stream,Track.AUDIO));
}*/
}
