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="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)); }*/ }