Merge pull request #1075 from rokujyushi/AddVoicevox

VOICEVOX support

Author: stakira

OpenUtau.Core/Classic/ClassicSingerLoader.cs

@@ -11,6 +11,8 @@ static USinger AdjustSingerType(Voicebank v) {
                     return new Core.Enunu.EnunuSinger(v) as USinger;
                 case USingerType.DiffSinger:
                     return new Core.DiffSinger.DiffSingerSinger(v) as USinger;
+                case USingerType.Voicevox:
+                    return new Core.Voicevox.VoicevoxSinger(v) as USinger;
                 default:
                     return new ClassicSinger(v) as USinger;
             }

OpenUtau.Core/Render/RenderPhrase.cs

@@ -67,6 +67,9 @@ public class RenderPhone {
         public readonly bool direct;
         public readonly Vector2[] envelope;
 
+        // voicevox args
+        public readonly int toneShift;
+
         public readonly UOto oto;
         public readonly ulong hash;
 
@@ -118,6 +121,7 @@ internal RenderPhone(UProject project, UTrack track, UVoicePart part, UNote note
             leadingMs = phoneme.preutter;
             envelope = phoneme.envelope.data.ToArray();
             direct = phoneme.GetExpression(project, track, Format.Ustx.DIR).Item1 == 1;
+            toneShift = (int)phoneme.GetExpression(project, track, Format.Ustx.SHFT).Item1;
 
             oto = phoneme.oto;
             hash = Hash();

OpenUtau.Core/Render/Renderers.cs

@@ -13,11 +13,13 @@ public static class Renderers {
         public const string ENUNU = "ENUNU";
         public const string VOGEN = "VOGEN";
         public const string DIFFSINGER = "DIFFSINGER";
+        public const string VOICEVOX = "VOICEVOX";
 
         static readonly string[] classicRenderers = new[] { WORLDLINER, CLASSIC };
         static readonly string[] enunuRenderers = new[] { ENUNU };
         static readonly string[] vogenRenderers = new[] { VOGEN };
         static readonly string[] diffSingerRenderers = new[] { DIFFSINGER };
+        static readonly string[] voicevoxRenderers = new[] { VOICEVOX };
         static readonly string[] noRenderers = new string[0];
 
         public static string[] GetSupportedRenderers(USingerType singerType) {
@@ -30,6 +32,8 @@ public static string[] GetSupportedRenderers(USingerType singerType) {
                     return vogenRenderers;
                 case USingerType.DiffSinger:
                     return diffSingerRenderers;
+                case USingerType.Voicevox:
+                    return voicevoxRenderers;
                 default:
                     return noRenderers;
             }
@@ -61,6 +65,8 @@ public static IRenderer CreateRenderer(string renderer) {
                 return new Vogen.VogenRenderer();
             } else if (renderer == DIFFSINGER) {
                 return new DiffSinger.DiffSingerRenderer();
+            } else if (renderer == VOICEVOX) {
+                return new Voicevox.VoicevoxRenderer();
             }
             return null;
         }

OpenUtau.Core/Ustx/USinger.cs

@@ -185,19 +185,21 @@ private static void AddToneRange(string range, SortedSet<int> set) {
         }
     }
 
-    [Flags] public enum USingerType { Classic = 0x1, Enunu = 0x2, Vogen = 0x4, DiffSinger=0x5 }
+    [Flags] public enum USingerType { Classic = 0x1, Enunu = 0x2, Vogen = 0x4, DiffSinger=0x5, Voicevox=0x6 }
 
     public static class SingerTypeUtils{
         public static Dictionary<USingerType?, string> SingerTypeNames = new Dictionary<USingerType?, string>(){
             {USingerType.Classic, "utau"},
             {USingerType.Enunu, "enunu"},
             {USingerType.DiffSinger, "diffsinger"},
+            {USingerType.Voicevox, "voicevox"},
         };
 
         public static Dictionary<string, USingerType> SingerTypeFromName = new Dictionary<string, USingerType>(){
             {"utau", USingerType.Classic},
             {"enunu", USingerType.Enunu},
             {"diffsinger", USingerType.DiffSinger},
+            {"voicevox", USingerType.Voicevox},
         };
 
     }

OpenUtau.Core/Util/Base64.cs

@@ -1,8 +1,10 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
+using System.IO;
 using System.Text;
+using Serilog;
 
-namespace OpenUtau.Core.Util
-{
+namespace OpenUtau.Core.Util {
     public static class Base64
     {
         public static string Base64EncodeInt12(int[] data)
@@ -59,5 +61,17 @@ private static string Base64EncodeInt12(int data)
             base64[1] = intToBase64[data & 0x003F];
             return new string(base64);
         }
+
+        public static void Base64ToFile(string base64str,string filePath) {
+            try {
+                byte[] bytes = Convert.FromBase64String(base64str);
+
+                // Write to file
+                File.WriteAllBytes(filePath, bytes);
+
+            } catch (Exception ex) {
+                Log.Error(@"{ex}");
+            }
+        }
     }
 }

OpenUtau.Core/Voicevox/SimpleVoicevoxPhonemizer.cs

@@ -0,0 +1,68 @@
+using System.Linq;
+using OpenUtau.Api;
+using OpenUtau.Core.Ustx;
+using OpenUtau.Core.Voicevox;
+
+namespace Voicevox {
+    [Phonemizer("Simple Voicevox Japanese Phonemizer", "S-VOICEVOX JA", language: "JA")]
+    public class SimpleVoicevoxPhonemizer : Phonemizer {
+
+        protected VoicevoxSinger singer;
+
+        public override void SetSinger(USinger singer) {
+            this.singer = singer as VoicevoxSinger;
+            if (this.singer != null) {
+                this.singer.voicevoxConfig.Tag = this.Tag;
+            }
+        }
+
+        public override Result Process(Note[] notes, Note? prev, Note? next, Note? prevNeighbour, Note? nextNeighbour, Note[] prevNeighbours) {
+            var note = notes[0];
+            var currentLyric = note.lyric.Normalize(); //measures for Unicode
+
+            Dictionary_list dic = new Dictionary_list();
+            dic.Loaddic(singer.Location);
+            int toneShift = 0;
+            int? alt = null;
+            if (note.phonemeAttributes != null) {
+                var attr = note.phonemeAttributes.FirstOrDefault(attr => attr.index == 0);
+                toneShift = attr.toneShift;
+                alt = attr.alternate;
+            }
+
+            //currentLyric = note.phoneticHint.Normalize();
+            Note[][] simplenotes = new Note[1][];
+            var lyricList = notes[0].lyric.Split(" ");
+            if (lyricList.Length > 1) {
+                notes[0].lyric = lyricList[1];
+            }
+            if (VoicevoxUtils.IsHiraKana(notes[0].lyric)) {
+                return new Result {
+                    phonemes = new Phoneme[] {
+                        new Phoneme {
+                            phoneme = notes[0].lyric,
+                        }
+                    },
+                };
+            } else if (VoicevoxUtils.IsPau(notes[0].lyric)) {
+                return new Result {
+                    phonemes = new Phoneme[] {
+                        new Phoneme {
+                            phoneme = "R",
+                        }
+                    },
+                };
+            }
+            else
+            {
+                return new Result {
+                    phonemes = new Phoneme[] {
+                        new Phoneme {
+                            phoneme = "error",
+                        }
+                    },
+                };
+            }
+        }
+    }
+}

OpenUtau.Core/Voicevox/VoicevoxClient.cs

@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Text;
+using Serilog;
+
+namespace OpenUtau.Core.Voicevox {
+    class VoicevoxClient : Util.SingletonBase<VoicevoxClient> {
+        internal Tuple<string, byte[]> SendRequest(VoicevoxURL voicevoxURL) {
+            try {
+                using (var client = new HttpClient()) {
+                    using (var request = new HttpRequestMessage(new HttpMethod(voicevoxURL.method.ToUpper()), this.RequestURL(voicevoxURL))) {
+                        request.Headers.TryAddWithoutValidation("accept", voicevoxURL.accept);
+
+                        request.Content = new StringContent(voicevoxURL.body);
+                        request.Content.Headers.ContentType = MediaTypeHeaderValue.Parse("application/json");
+
+                        Log.Information($"VoicevoxProcess sending {request}");
+                        var response = client.SendAsync(request);
+                        Log.Information($"VoicevoxProcess received");
+                        string str = response.Result.Content.ReadAsStringAsync().Result;
+                        //May not fit json format
+                        if (!str.StartsWith("{") || !str.EndsWith("}")) {
+                            str = "{ \"json\":" + str + "}";
+                        }
+                        return new Tuple<string, byte[]>(str, response.Result.Content.ReadAsByteArrayAsync().Result);
+                    }
+                }
+            } catch (Exception ex) {
+                Log.Error(@"{ex}");
+            }
+            return new Tuple<string, byte[]>("", new byte[0]);
+        }
+
+        public string RequestURL(VoicevoxURL voicevoxURL) {
+            StringBuilder queryStringBuilder = new StringBuilder();
+            foreach (var parameter in voicevoxURL.query) {
+                queryStringBuilder.Append($"{parameter.Key}={parameter.Value}&");
+            }
+
+            // Remove extra "&" at the end
+            string queryString = "?" + queryStringBuilder.ToString().TrimEnd('&');
+
+            string str = $"{voicevoxURL.protocol}{voicevoxURL.host}{voicevoxURL.path}{queryString}";
+            return str;
+        }
+    }
+    public class VoicevoxURL {
+        public string method = string.Empty;
+        public string protocol = "http://";
+        //Currently fixed port 50021 to connect to
+        public string host = "127.0.0.1:50021";
+        public string path = string.Empty;
+        public Dictionary<string, string> query = new Dictionary<string, string>();
+        public string body = string.Empty;
+        public string accept = "application/json";
+    }
+}