エンコーダーの設定画面を改善

src/Beutl.Engine/Media/Encoding/AudioEncoderSettings.cs

@@ -1,7 +1,48 @@
-namespace Beutl.Media.Encoding;
+using Beutl.Language;
+using System.ComponentModel.DataAnnotations;
+
+namespace Beutl.Media.Encoding;
+
+public class AudioEncoderSettings : MediaEncoderSettings
+{
+    public static readonly CoreProperty<int> SampleRateProperty;
+    public static readonly CoreProperty<int> ChannelsProperty;
+    public static readonly CoreProperty<int> BitrateProperty;
+
+    static AudioEncoderSettings()
+    {
+        SampleRateProperty = ConfigureProperty<int, AudioEncoderSettings>(nameof(SampleRate))
+            .DefaultValue(44100)
+            .Register();
+
+        ChannelsProperty = ConfigureProperty<int, AudioEncoderSettings>(nameof(Channels))
+            .DefaultValue(2)
+            .Register();
+
+        BitrateProperty = ConfigureProperty<int, AudioEncoderSettings>(nameof(Bitrate))
+            .DefaultValue(128_000)
+            .Register();
+    }
+
+    [Display(Name = nameof(Strings.SampleRate), Description = nameof(Strings.SampleRate_Tip), ResourceType = typeof(Strings), Order = int.MinValue)]
+    public int SampleRate
+    {
+        get => GetValue(SampleRateProperty);
+        set => SetValue(SampleRateProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.Channels), Description = nameof(Strings.Channels_Tip), ResourceType = typeof(Strings), Order = int.MinValue + 1)]
+    public int Channels
+    {
+        get => GetValue(ChannelsProperty);
+        set => SetValue(ChannelsProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.Bitrate), Description = nameof(Strings.Bitrate_Tip), ResourceType = typeof(Strings), Order = int.MinValue + 2)]
+    public int Bitrate
+    {
+        get => GetValue(BitrateProperty);
+        set => SetValue(BitrateProperty, value);
+    }
+}
 
-public sealed record AudioEncoderSettings(
-    int SampleRate = 44_100,
-    int Channels = 2,
-    int Bitrate = 128_000)
-    : MediaEncoderSettings;

src/Beutl.Engine/Media/Encoding/MediaEncoderSettings.cs

@@ -2,7 +2,22 @@
 
 namespace Beutl.Media.Encoding;
 
-public abstract record MediaEncoderSettings
+public abstract class MediaEncoderSettings : CoreObject
 {
-    public JsonNode? CodecOptions { get; init; }
+    [Obsolete]
+    public static readonly CoreProperty<JsonNode?> CodecOptionsProperty;
+
+    [Obsolete]
+    static MediaEncoderSettings()
+    {
+        CodecOptionsProperty = ConfigureProperty<JsonNode?, MediaEncoderSettings>(nameof(CodecOptions))
+            .Register();
+    }
+
+    [Obsolete()]
+    public JsonNode? CodecOptions
+    {
+        get => GetValue(CodecOptionsProperty);
+        set => SetValue(CodecOptionsProperty, value);
+    }
 }

src/Beutl.Engine/Media/Encoding/VideoEncoderSettings.cs

@@ -1,9 +1,71 @@
-namespace Beutl.Media.Encoding;
-
-public sealed record VideoEncoderSettings(
-    PixelSize SourceSize,
-    PixelSize DestinationSize,
-    Rational FrameRate,
-    int Bitrate = 5_000_000,
-    int KeyframeRate = 12)
-    : MediaEncoderSettings;
+using System.ComponentModel;
+using System.ComponentModel.DataAnnotations;
+using Beutl.Language;
+
+namespace Beutl.Media.Encoding;
+
+public class VideoEncoderSettings : MediaEncoderSettings
+{
+    public static readonly CoreProperty<PixelSize> SourceSizeProperty;
+    public static readonly CoreProperty<PixelSize> DestinationSizeProperty;
+    public static readonly CoreProperty<Rational> FrameRateProperty;
+    public static readonly CoreProperty<int> BitrateProperty;
+    public static readonly CoreProperty<int> KeyframeRateProperty;
+
+    static VideoEncoderSettings()
+    {
+        SourceSizeProperty = ConfigureProperty<PixelSize, VideoEncoderSettings>(nameof(SourceSize))
+            .Register();
+
+        DestinationSizeProperty = ConfigureProperty<PixelSize, VideoEncoderSettings>(nameof(DestinationSize))
+            .Register();
+
+        FrameRateProperty = ConfigureProperty<Rational, VideoEncoderSettings>(nameof(FrameRate))
+            .DefaultValue(new(30, 1))
+            .Register();
+
+        BitrateProperty = ConfigureProperty<int, VideoEncoderSettings>(nameof(Bitrate))
+            .DefaultValue(5_000_000)
+            .Register();
+
+        KeyframeRateProperty = ConfigureProperty<int, VideoEncoderSettings>(nameof(KeyframeRate))
+            .DefaultValue(12)
+            .Register();
+    }
+
+    [Browsable(false)]
+    public PixelSize SourceSize
+    {
+        get => GetValue(SourceSizeProperty);
+        set => SetValue(SourceSizeProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.FrameSize), Description = nameof(Strings.FrameSize_Tip), ResourceType = typeof(Strings), Order = int.MinValue)]
+    public PixelSize DestinationSize
+    {
+        get => GetValue(DestinationSizeProperty);
+        set => SetValue(DestinationSizeProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.FrameRate), Description = nameof(Strings.FrameRate_Tip), ResourceType = typeof(Strings), Order = int.MinValue + 1)]
+    public Rational FrameRate
+    {
+        get => GetValue(FrameRateProperty);
+        set => SetValue(FrameRateProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.Bitrate), Description = nameof(Strings.Bitrate_Tip), ResourceType = typeof(Strings), Order = int.MinValue + 2)]
+    public int Bitrate
+    {
+        get => GetValue(BitrateProperty);
+        set => SetValue(BitrateProperty, value);
+    }
+
+    [Display(Name = nameof(Strings.KeyframeRate), Description = nameof(Strings.KeyframeRate_Tip), ResourceType = typeof(Strings), Order = int.MinValue + 3)]
+    public int KeyframeRate
+    {
+        get => GetValue(KeyframeRateProperty);
+        set => SetValue(KeyframeRateProperty, value);
+    }
+}
+

src/Beutl.Extensions.FFmpeg/Encoding/FFmpegAudioEncoderSettings.cs

@@ -0,0 +1,49 @@
+using Beutl.Media.Encoding;
+
+using FFmpeg.AutoGen;
+
+#if FFMPEG_BUILD_IN
+namespace Beutl.Embedding.FFmpeg.Encoding;
+#else
+namespace Beutl.Extensions.FFmpeg.Encoding;
+#endif
+
+public sealed class FFmpegAudioEncoderSettings : AudioEncoderSettings
+{
+    public static readonly CoreProperty<AudioCodec> CodecProperty;
+    public static readonly CoreProperty<string> ArgumentsProperty;
+
+    static FFmpegAudioEncoderSettings()
+    {
+        CodecProperty = ConfigureProperty<AudioCodec, FFmpegAudioEncoderSettings>(nameof(Codec))
+            .DefaultValue(AudioCodec.Default)
+            .Register();
+
+        ArgumentsProperty = ConfigureProperty<string, FFmpegAudioEncoderSettings>(nameof(Arguments))
+            .DefaultValue("")
+            .Register();
+    }
+
+    public AudioCodec Codec
+    {
+        get => GetValue(CodecProperty);
+        set => SetValue(CodecProperty, value);
+    }
+
+    public string Arguments
+    {
+        get => GetValue(ArgumentsProperty);
+        set => SetValue(ArgumentsProperty, value);
+    }
+
+    public enum AudioCodec
+    {
+        Explicit = int.MinValue,
+        Default = AVCodecID.AV_CODEC_ID_NONE,
+        AAC = AVCodecID.AV_CODEC_ID_AAC,
+        AC3 = AVCodecID.AV_CODEC_ID_AC3,
+        MP3 = AVCodecID.AV_CODEC_ID_MP3,
+        WMA = AVCodecID.AV_CODEC_ID_WMAV2,
+        Vorbis = AVCodecID.AV_CODEC_ID_VORBIS,
+    }
+}

src/Beutl.Extensions.FFmpeg/Encoding/FFmpegEncoderInfo.cs

@@ -1,9 +1,4 @@
-using System.Text.Json.Nodes;
-
-using Beutl.Media;
-using Beutl.Media.Encoding;
-
-using FFmpeg.AutoGen;
+using Beutl.Media.Encoding;
 
 #if FFMPEG_BUILD_IN
 namespace Beutl.Embedding.FFmpeg.Encoding;
@@ -22,30 +17,12 @@ public sealed class FFmpegEncoderInfo(FFmpegEncodingSettings settings) : IEncode
 
     public AudioEncoderSettings DefaultAudioConfig()
     {
-        return new()
-        {
-            CodecOptions = new JsonObject()
-            {
-                ["Codec"] = ffmpeg.avcodec_get_name(AVCodecID.AV_CODEC_ID_NONE),
-                ["Arguments"] = "",
-            }
-        };
+        return new FFmpegAudioEncoderSettings();
     }
 
     public VideoEncoderSettings DefaultVideoConfig()
     {
-        return new(new PixelSize(1920, 1080), new PixelSize(1920, 1080), new(30))
-        {
-            CodecOptions = new JsonObject()
-            {
-                ["Format"] = ffmpeg.av_get_pix_fmt_name(AVPixelFormat.AV_PIX_FMT_NONE),
-                ["Codec"] = ffmpeg.avcodec_get_name(AVCodecID.AV_CODEC_ID_NONE),
-                ["Preset"] = "medium",
-                ["Crf"] = "22",
-                ["Profile"] = "high",
-                ["Arguments"] = "",
-            }
-        };
+        return new FFmpegVideoEncoderSettings();
     }
 
     public IEnumerable<string> SupportExtensions()

src/Beutl.Extensions.FFmpeg/Encoding/FFmpegInprocessVideoWriter.cs

@@ -24,7 +24,7 @@ public sealed unsafe class FFmpegInprocessVideoWriter : IFFmpegVideoWriter
     private SwsContext* _swsContext;
     private AVDictionary* _dictionary;
 
-    public FFmpegInprocessVideoWriter(string file, VideoEncoderSettings videoConfig)
+    public FFmpegInprocessVideoWriter(string file, FFmpegVideoEncoderSettings videoConfig)
     {
         try
         {
@@ -55,7 +55,7 @@ public FFmpegInprocessVideoWriter(string file, VideoEncoderSettings videoConfig)
 
     public long NumberOfFrames { get; private set; }
 
-    public VideoEncoderSettings VideoConfig { get; }
+    public FFmpegVideoEncoderSettings VideoConfig { get; }
 
     public bool AddVideo(IBitmap image)
     {
@@ -171,18 +171,14 @@ private void FlushEncoder(AVCodecContext* codecContext, AVStream* stream, AVPack
 
     private void CreateVideoStream(AVOutputFormat* format)
     {
-        var codecOptions = VideoConfig.CodecOptions as JsonObject;
         AVCodecID codecId = format->video_codec;
 
-        if (JsonHelper.TryGetString(codecOptions, "Codec", out string? codecStr))
+        AVCodecDescriptor* desc = ffmpeg.avcodec_descriptor_get((AVCodecID)VideoConfig.Codec);
+        if (desc != null
+            && desc->type == AVMediaType.AVMEDIA_TYPE_VIDEO
+            && desc->id != AVCodecID.AV_CODEC_ID_NONE)
         {
-            AVCodecDescriptor* desc = ffmpeg.avcodec_descriptor_get_by_name(codecStr);
-            if (desc != null
-                && desc->type == AVMediaType.AVMEDIA_TYPE_VIDEO
-                && desc->id != AVCodecID.AV_CODEC_ID_NONE)
-            {
-                codecId = desc->id;
-            }
+            codecId = desc->id;
         }
 
         _videoCodec = ffmpeg.avcodec_find_encoder(codecId);
@@ -208,13 +204,9 @@ private void CreateVideoStream(AVOutputFormat* format)
             throw new Exception("avcodec_alloc_context3 failed");
 
         AVPixelFormat videoPixFmt = AVPixelFormat.AV_PIX_FMT_YUV420P;
-        if (JsonHelper.TryGetString(codecOptions, "Format", out string? fmtStr))
+        if (VideoConfig.Format != AVPixelFormat.AV_PIX_FMT_NONE)
         {
-            AVPixelFormat pixFmt = ffmpeg.av_get_pix_fmt(fmtStr);
-            if (pixFmt != AVPixelFormat.AV_PIX_FMT_NONE)
-            {
-                videoPixFmt = pixFmt;
-            }
+            videoPixFmt = VideoConfig.Format;
         }
 
         _videoStream->codecpar->codec_id = codecId;
@@ -233,10 +225,11 @@ private void CreateVideoStream(AVOutputFormat* format)
         _videoCodecContext->thread_count = Math.Min(Environment.ProcessorCount, 16);
 
         AVDictionary* dictionary = null;
-        string preset = JsonHelper.TryGetString(codecOptions, "Preset", out string? presetStr) ? presetStr : "medium";
-        string crf = JsonHelper.TryGetString(codecOptions, "Crf", out string? crfStr) ? crfStr : "22";
-        string profile = JsonHelper.TryGetString(codecOptions, "Profile", out string? profileStr) ? profileStr : "high";
-        string level = JsonHelper.TryGetString(codecOptions, "Level", out string? levelStr) ? levelStr : "4.0";
+        string preset = VideoConfig.Preset;
+        string crf = VideoConfig.Crf.ToString();
+        string profile = VideoConfig.Profile;
+        string level = "4.0";
+        // string level = JsonHelper.TryGetString(codecOptions, "Level", out string? levelStr) ? levelStr : "4.0";
         ffmpeg.av_dict_set(&dictionary, "preset", preset, 0);
         ffmpeg.av_dict_set(&dictionary, "crf", crf, 0);
         ffmpeg.av_dict_set(&dictionary, "profile", profile, 0);

src/Beutl.Extensions.FFmpeg/Encoding/FFmpegOutprocessAudioWriter.cs

@@ -33,7 +33,7 @@ public sealed unsafe class FFmpegOutprocessAudioWriter : IFFmpegAudioWriter
     private readonly AVOutputFormat* _outputFormat;
     private readonly string _outputFile;
 
-    public FFmpegOutprocessAudioWriter(string file, AudioEncoderSettings audioConfig, FFmpegEncodingSettings settings)
+    public FFmpegOutprocessAudioWriter(string file, FFmpegAudioEncoderSettings audioConfig, FFmpegEncodingSettings settings)
     {
         try
         {
@@ -60,7 +60,7 @@ public FFmpegOutprocessAudioWriter(string file, AudioEncoderSettings audioConfig
 
     public long NumberOfSamples { get; private set; }
 
-    public AudioEncoderSettings AudioConfig { get; }
+    public FFmpegAudioEncoderSettings AudioConfig { get; }
 
     private void ConfigureInputArguments(FFMpegArgumentOptions options)
     {
@@ -98,20 +98,16 @@ private void ConfigureAudioOutputArguments(FFMpegArgumentOptions options)
     {
         var audioConfig = AudioConfig;
         var audioCodec = _outputFormat->audio_codec;
-        var audioOptions = audioConfig.CodecOptions as JsonObject;
 
-        if (JsonHelper.TryGetString(audioOptions, "Codec", out string? codecStr))
+        AVCodec* codec = ffmpeg.avcodec_find_encoder((AVCodecID)AudioConfig.Codec);
+        if (codec != null
+            && codec->type == AVMediaType.AVMEDIA_TYPE_AUDIO
+            && codec->id != AVCodecID.AV_CODEC_ID_NONE)
         {
-            AVCodec* codec = ffmpeg.avcodec_find_encoder_by_name(codecStr);
-            if (codec != null
-                && codec->type == AVMediaType.AVMEDIA_TYPE_AUDIO
-                && codec->id != AVCodecID.AV_CODEC_ID_NONE)
-            {
-                audioCodec = codec->id;
-            }
+            audioCodec = codec->id;
         }
 
-        JsonHelper.TryGetString(audioOptions, "Arguments", out string? args);
+        var args = AudioConfig.Arguments;
 
         var audioCodecName = ffmpeg.avcodec_get_name(audioCodec);