mirror of
https://github.com/claunia/cuetools.net.git
synced 2025-12-16 18:14:25 +00:00
272 lines
11 KiB
C#
272 lines
11 KiB
C#
using Newtonsoft.Json;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel;
|
|
using System.Text;
|
|
|
|
namespace CUETools.Codecs.Flake
|
|
{
|
|
[JsonObject(MemberSerialization.OptIn)]
|
|
public class EncoderSettings : IAudioEncoderSettings
|
|
{
|
|
#region IAudioEncoderSettings implementation
|
|
[Browsable(false)]
|
|
public string Extension => "flac";
|
|
|
|
[Browsable(false)]
|
|
public string Name => "cuetools";
|
|
|
|
[Browsable(false)]
|
|
public Type EncoderType => typeof(AudioEncoder);
|
|
|
|
[Browsable(false)]
|
|
public bool Lossless => true;
|
|
|
|
[Browsable(false)]
|
|
public int Priority => 4;
|
|
|
|
[Browsable(false)]
|
|
public string SupportedModes => this.AllowNonSubset || (this.PCM != null && this.PCM.SampleRate > 48000) ? "0 1 2 3 4 5 6 7 8 9 10 11" : "0 1 2 3 4 5 6 7 8";
|
|
|
|
[Browsable(false)]
|
|
public string DefaultMode => "5";
|
|
|
|
[Browsable(false)]
|
|
[DefaultValue("")]
|
|
[JsonProperty]
|
|
public string EncoderMode { get; set; }
|
|
|
|
[Browsable(false)]
|
|
public AudioPCMConfig PCM { get; set; }
|
|
|
|
[Browsable(false)]
|
|
public int BlockSize { get; set; }
|
|
|
|
[Browsable(false)]
|
|
[DefaultValue(4096)]
|
|
public int Padding { get; set; }
|
|
|
|
public IAudioEncoderSettings Clone()
|
|
{
|
|
return MemberwiseClone() as IAudioEncoderSettings;
|
|
}
|
|
#endregion
|
|
|
|
public EncoderSettings()
|
|
{
|
|
this.Init();
|
|
}
|
|
|
|
public bool IsSubset()
|
|
{
|
|
return (BlockSize == 0 || (BlockSize <= 16384 && (PCM.SampleRate > 48000 || BlockSize <= 4608)))
|
|
&& (PCM.SampleRate > 48000 || MaxLPCOrder <= 12)
|
|
&& MaxPartitionOrder <= 8
|
|
;
|
|
//The blocksize bits in the frame header must be 0001-1110. The blocksize must be <=16384; if the sample rate is <= 48000Hz, the blocksize must be <=4608.
|
|
//The sample rate bits in the frame header must be 0001-1110.
|
|
//The bits-per-sample bits in the frame header must be 001-111.
|
|
//If the sample rate is <= 48000Hz, the filter order in LPC subframes must be less than or equal to 12, i.e. the subframe type bits in the subframe header may not be 101100-111111.
|
|
//The Rice partition order in a Rice-coded residual section must be less than or equal to 8.
|
|
}
|
|
|
|
public void Validate()
|
|
{
|
|
if (this.GetEncoderModeIndex() < 0)
|
|
throw new Exception("unsupported encoder mode");
|
|
this.SetDefaultValuesForMode();
|
|
if (Padding < 0)
|
|
throw new Exception("unsupported padding value " + Padding.ToString());
|
|
if (BlockSize != 0 && (BlockSize < 256 || BlockSize >= FlakeConstants.MAX_BLOCKSIZE))
|
|
throw new Exception("unsupported block size " + BlockSize.ToString());
|
|
if (MinLPCOrder > MaxLPCOrder || MaxLPCOrder > lpc.MAX_LPC_ORDER)
|
|
throw new Exception("invalid MaxLPCOrder " + MaxLPCOrder.ToString());
|
|
if (MinFixedOrder < 0 || MinFixedOrder > 4)
|
|
throw new Exception("invalid MinFixedOrder " + MinFixedOrder.ToString());
|
|
if (MaxFixedOrder < 0 || MaxFixedOrder > 4)
|
|
throw new Exception("invalid MaxFixedOrder " + MaxFixedOrder.ToString());
|
|
if (MinPartitionOrder < 0)
|
|
throw new Exception("invalid MinPartitionOrder " + MinPartitionOrder.ToString());
|
|
if (MinPartitionOrder > MaxPartitionOrder || MaxPartitionOrder > 8)
|
|
throw new Exception("invalid MaxPartitionOrder " + MaxPartitionOrder.ToString());
|
|
if (PredictionType == PredictionType.None)
|
|
throw new Exception("invalid PredictionType " + PredictionType.ToString());
|
|
if (PredictionType != PredictionType.Fixed)
|
|
{
|
|
if (WindowMethod == WindowMethod.Invalid)
|
|
throw new InvalidOperationException("invalid WindowMethod " + WindowMethod.ToString());
|
|
if (WindowFunctions == WindowFunction.None)
|
|
throw new InvalidOperationException("invalid WindowFunctions " + WindowFunctions.ToString());
|
|
if (EstimationDepth > 32 || EstimationDepth < 1)
|
|
throw new InvalidOperationException("invalid EstimationDepth " + EstimationDepth.ToString());
|
|
if (MinPrecisionSearch < 0 || MinPrecisionSearch >= lpc.MAX_LPC_PRECISIONS)
|
|
throw new Exception("unsupported MinPrecisionSearch value");
|
|
if (MaxPrecisionSearch < 0 || MaxPrecisionSearch >= lpc.MAX_LPC_PRECISIONS)
|
|
throw new Exception("unsupported MaxPrecisionSearch value");
|
|
if (MaxPrecisionSearch < MinPrecisionSearch)
|
|
throw new Exception("unsupported MaxPrecisionSearch value");
|
|
}
|
|
if (!AllowNonSubset && !IsSubset())
|
|
throw new Exception("the encoding parameters specified do not conform to the FLAC Subset");
|
|
}
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(2, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0)]
|
|
[Browsable(false)]
|
|
[DisplayName("MinFixedOrder")]
|
|
[SRDescription(typeof(Properties.Resources), "MinFixedOrderDescription")]
|
|
public int MinFixedOrder { get; set; }
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(2, 4, 4, 4, 2, 2, 4, 4, 4, 4, 4, 4)]
|
|
[Browsable(false)]
|
|
[DisplayName("MaxFixedOrder")]
|
|
[SRDescription(typeof(Properties.Resources), "MaxFixedOrderDescription")]
|
|
public int MaxFixedOrder { get; set; }
|
|
|
|
[DefaultValue(1)]
|
|
[Browsable(false)]
|
|
[DisplayName("MinLPCOrder")]
|
|
[SRDescription(typeof(Properties.Resources), "MinLPCOrderDescription")]
|
|
public int MinLPCOrder { get; set; }
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(8, 8, 8, 12, 12, 12, 12, 12, 12, 32, 32, 32)]
|
|
[Browsable(false)]
|
|
[DisplayName("MaxLPCOrder")]
|
|
[SRDescription(typeof(Properties.Resources), "MaxLPCOrderDescription")]
|
|
public int MaxLPCOrder { get; set; }
|
|
|
|
[DefaultValue(0)]
|
|
[DisplayName("MinPartitionOrder")]
|
|
[Browsable(false)]
|
|
[SRDescription(typeof(Properties.Resources), "MinPartitionOrderDescription")]
|
|
public int MinPartitionOrder { get; set; }
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(6, 6, 6, 6, 6, 6, 6, 6, 7, 6, 6, 8)]
|
|
[DisplayName("MaxPartitionOrder")]
|
|
[Browsable(false)]
|
|
[SRDescription(typeof(Properties.Resources), "MaxPartitionOrderDescription")]
|
|
public int MaxPartitionOrder { get; set; }
|
|
|
|
[DefaultValue(false)]
|
|
[DisplayName("Verify")]
|
|
[SRDescription(typeof(Properties.Resources), "DoVerifyDescription")]
|
|
[JsonProperty]
|
|
public bool DoVerify { get; set; }
|
|
|
|
[DefaultValue(true)]
|
|
[DisplayName("MD5")]
|
|
[SRDescription(typeof(Properties.Resources), "DoMD5Description")]
|
|
[JsonProperty]
|
|
public bool DoMD5 { get; set; }
|
|
|
|
[DefaultValue(false)]
|
|
[DisplayName("Allow Non-subset")]
|
|
[SRDescription(typeof(Properties.Resources), "AllowNonSubsetDescription")]
|
|
[JsonProperty]
|
|
public bool AllowNonSubset { get; set; }
|
|
|
|
[DefaultValue(StereoMethod.Invalid)]
|
|
[DefaultValueForMode(
|
|
/* 0 */ StereoMethod.Independent,
|
|
/* 1 */ StereoMethod.EstimateFixed,
|
|
/* 2 */ StereoMethod.Estimate,
|
|
/* 3 */ StereoMethod.Estimate,
|
|
/* 4 */ StereoMethod.Evaluate,
|
|
/* 5 */ StereoMethod.Evaluate,
|
|
/* 6 */ StereoMethod.Evaluate,
|
|
/* 7 */ StereoMethod.Evaluate,
|
|
/* 8 */ StereoMethod.Evaluate,
|
|
/* 9 */ StereoMethod.Evaluate,
|
|
/* 10 */ StereoMethod.Evaluate,
|
|
/* 11 */ StereoMethod.Evaluate)]
|
|
[Browsable(false)]
|
|
public StereoMethod StereoMethod { get; set; }
|
|
|
|
[DefaultValue(PredictionType.None)]
|
|
[DefaultValueForMode(
|
|
/* 0 */ PredictionType.Fixed,
|
|
/* 1 */ PredictionType.Fixed,
|
|
/* 2 */ PredictionType.Levinson,
|
|
/* 3 */ PredictionType.Levinson,
|
|
/* 4 */ PredictionType.Search,
|
|
/* 5 */ PredictionType.Search,
|
|
/* 6 */ PredictionType.Search,
|
|
/* 7 */ PredictionType.Search,
|
|
/* 8 */ PredictionType.Search,
|
|
/* 9 */ PredictionType.Levinson,
|
|
/* 10 */ PredictionType.Search,
|
|
/* 11 */ PredictionType.Search)]
|
|
[Browsable(false)]
|
|
public PredictionType PredictionType { get; set; }
|
|
|
|
[DefaultValue(WindowMethod.Invalid)]
|
|
[DefaultValueForMode(
|
|
/* 0 */ WindowMethod.Invalid,
|
|
/* 1 */ WindowMethod.Invalid,
|
|
/* 2 */ WindowMethod.Estimate,
|
|
/* 3 */ WindowMethod.Estimate,
|
|
/* 4 */ WindowMethod.Estimate,
|
|
/* 5 */ WindowMethod.EvaluateN,
|
|
/* 6 */ WindowMethod.EvaluateN,
|
|
/* 7 */ WindowMethod.EvaluateN,
|
|
/* 8 */ WindowMethod.EvaluateN,
|
|
/* 9 */ WindowMethod.EvaluateN,
|
|
/* 10 */ WindowMethod.EvaluateN,
|
|
/* 11 */ WindowMethod.EvaluateN)]
|
|
[Browsable(false)]
|
|
public WindowMethod WindowMethod { get; set; }
|
|
|
|
[DefaultValue(WindowFunction.None)]
|
|
[DefaultValueForMode(
|
|
/* 0 */ WindowFunction.None,
|
|
/* 1 */ WindowFunction.None,
|
|
/* 2 */ WindowFunction.Tukey3,
|
|
/* 3 */ WindowFunction.Tukey4,
|
|
/* 4 */ WindowFunction.Tukey4,
|
|
/* 5 */ WindowFunction.Tukey4 | WindowFunction.Tukey3,
|
|
/* 6 */ WindowFunction.Tukey4 | WindowFunction.Tukey3 | WindowFunction.Tukey,
|
|
/* 7 */ WindowFunction.Tukey4 | WindowFunction.Tukey3 | WindowFunction.Tukey2 | WindowFunction.Tukey,
|
|
/* 8 */ WindowFunction.Tukey4 | WindowFunction.Tukey3 | WindowFunction.Tukey2 | WindowFunction.Tukey,
|
|
/* 9 */ WindowFunction.Tukey3 | WindowFunction.Tukey2 | WindowFunction.Tukey,
|
|
/* 10 */ WindowFunction.Tukey3 | WindowFunction.Tukey2 | WindowFunction.Tukey,
|
|
/* 11 */ WindowFunction.Tukey3 | WindowFunction.Tukey2 | WindowFunction.Tukey)]
|
|
[Browsable(false)]
|
|
[DisplayName("WindowFunctions")]
|
|
[SRDescription(typeof(Properties.Resources), "WindowFunctionsDescription")]
|
|
public WindowFunction WindowFunctions { get; set; }
|
|
|
|
[DefaultValue(0)]
|
|
[DefaultValueForMode(0, 0, 1, 1, 1, 1, 1, 1, 3, 1, 1, 5)]
|
|
[Browsable(false)]
|
|
public int EstimationDepth { get; set; }
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1)]
|
|
[Browsable(false)]
|
|
public int MinPrecisionSearch { get; set; }
|
|
|
|
[DefaultValue(-1)]
|
|
[DefaultValueForMode(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1)]
|
|
[Browsable(false)]
|
|
public int MaxPrecisionSearch { get; set; }
|
|
|
|
[DefaultValue(0)]
|
|
[Browsable(false)]
|
|
public int TukeyParts { get; set; }
|
|
|
|
[DefaultValue(1.0)]
|
|
[Browsable(false)]
|
|
public double TukeyOverlap { get; set; }
|
|
|
|
[DefaultValue(1.0)]
|
|
[Browsable(false)]
|
|
public double TukeyP { get; set; }
|
|
|
|
[Browsable(false)]
|
|
public string[] Tags { get; set; }
|
|
}
|
|
}
|