Feat/#51

Epub/KoeBook.Epub/Services/AnalyzerService.cs

@@ -45,6 +45,7 @@ public async ValueTask<BookScripts> AnalyzeAsync(BookProperties bookProperties,
             }
 
             _createCoverFileService.Create(document.Title, document.Author, coverFilePath);
+            document.CoverFilePath = coverFilePath;
         }
         catch (EbookException) { throw; }
         catch (Exception ex)

Epub/KoeBook.Epub/Services/EpubGenerateService.cs

@@ -3,6 +3,7 @@
 using KoeBook.Core.Models;
 using KoeBook.Epub.Contracts.Services;
 using KoeBook.Epub.Models;
+using NAudio.Wave;
 
 namespace KoeBook.Epub.Services;
 
@@ -18,9 +19,17 @@ public async ValueTask<string> GenerateEpubAsync(BookScripts bookScripts, string
 
         var document = _documentStoreService.Documents.Single(d => d.Id == bookScripts.BookProperties.Id);
 
-        foreach (var scriptLine in bookScripts.ScriptLines)
+        for (var i = 0; i < bookScripts.ScriptLines.Length; i++)
         {
-            scriptLine.Audio = new Audio(await _soundGenerationService.GenerateLineSoundAsync(scriptLine, bookScripts.Options, cancellationToken).ConfigureAwait(false));
+            var scriptLine = bookScripts.ScriptLines[i];
+            var wavData = await _soundGenerationService.GenerateLineSoundAsync(scriptLine, bookScripts.Options, cancellationToken).ConfigureAwait(false);
+            var ms = new MemoryStream();
+            ms.Write(wavData);
+            ms.Position = 0;
+            using var reader = new WaveFileReader(ms);
+            var tmpMp3Path = Path.Combine(tempDirectory, $"{document.Title}{i}.mp3");
+            MediaFoundationEncoder.EncodeToMp3(reader, tmpMp3Path);
+            scriptLine.Audio = new Audio(reader.TotalTime, tmpMp3Path);
         }
 
         if (await _createService.TryCreateEpubAsync(document, tempDirectory, cancellationToken).ConfigureAwait(false))

KoeBook.Core/Models/Audio.cs

@@ -2,24 +2,13 @@
 
 namespace KoeBook.Epub.Models;
 
-public sealed class Audio
+public sealed class Audio(TimeSpan totalTIme, string tempFilePath)
 {
-    public TimeSpan TotalTime { get; }
-    private readonly byte[] _mp3Data;
+    public TimeSpan TotalTime { get; } = totalTIme;
+    public string TempFilePath { get; } = tempFilePath;
 
-    public Audio(byte[] mp3Data)
+    public FileStream GetStream()
     {
-        _mp3Data = mp3Data;
-        using var ms = new MemoryStream();
-        ms.Write(_mp3Data.AsSpan());
-        ms.Flush();
-        ms.Position = 0;
-        using var reader = new Mp3FileReader(ms);
-        TotalTime = reader.TotalTime;
-    }
-
-    public MemoryStream GetStream()
-    {
-        return new MemoryStream(_mp3Data);
+        return File.OpenRead(TempFilePath);
     }
 }

KoeBook.Core/Services/SoundGenerationService.cs

@@ -1,6 +1,10 @@
-using System.Web;
+using System.Buffers;
+using System.Runtime.CompilerServices;
+using System.Threading;
+using System.Web;
 using KoeBook.Core.Contracts.Services;
 using KoeBook.Core.Models;
+using NAudio.Wave;
 
 namespace KoeBook.Core.Services;
 
@@ -17,11 +21,87 @@ public async ValueTask<byte[]> GenerateLineSoundAsync(ScriptLine scriptLine, Boo
         var soundModel = _soundGenerationSelectorService.Models.FirstOrDefault(m => m.Name == model)
             ?? throw new EbookException(ExceptionType.SoundGenerationFailed);
         var style = soundModel.Styles.Contains(scriptLine.Style) ? scriptLine.Style : soundModel.Styles[0];
-        var queryCollection = HttpUtility.ParseQueryString(string.Empty);
-        queryCollection.Add("text", scriptLine.Text);
-        queryCollection.Add("model_id", soundModel.Id);
-        queryCollection.Add("style", style);
-        return await _styleBertVitsClientService
-            .GetAsByteArrayAsync($"/voice?{queryCollection}", ExceptionType.SoundGenerationFailed, cancellationToken).ConfigureAwait(false);
+        using var msWriter = new MemoryStream();
+        WaveFileWriter? writer = null;
+        byte[] dataBuffer = ArrayPool<byte>.Shared.Rent(1024);
+        try
+        {
+            await foreach (var voice in GenerateSoundAsync(scriptLine.Text, style, soundModel.Id, cancellationToken))
+            {
+                if (voice.Length > dataBuffer.Length)
+                {
+                    ArrayPool<byte>.Shared.Return(dataBuffer);
+                    dataBuffer = ArrayPool<byte>.Shared.Rent(voice.Length);
+                }
+                using var msReader = new MemoryStream();
+                await msReader.WriteAsync(voice, cancellationToken);
+                msReader.Position = 0;
+                using var reader = new WaveFileReader(msReader);
+                var read = await reader.ReadAsync(dataBuffer, cancellationToken);
+                if (writer is null)
+                {
+                    writer = new WaveFileWriter(msWriter, reader.WaveFormat);
+                }
+                await writer.WriteAsync(dataBuffer.AsMemory()[..read], cancellationToken);
+            }
+            if (writer is null)
+            {
+                throw new EbookException(ExceptionType.SoundGenerationFailed);
+            }
+            await writer.FlushAsync(cancellationToken);
+            return msWriter.ToArray();
+        }
+        catch { throw; }
+        finally
+        {
+            ArrayPool<byte>.Shared?.Return(dataBuffer);
+            writer?.Dispose();
+        }
+    }
+
+    private async IAsyncEnumerable<byte[]> GenerateSoundAsync(string text, string style, string modelId, [EnumeratorCancellation] CancellationToken cancellationToken)
+    {
+        foreach (var l in SplitPeriod(text, 300))
+        {
+            var queryCollection = HttpUtility.ParseQueryString(string.Empty);
+            queryCollection.Add("text", l);
+            queryCollection.Add("model_id", modelId);
+            queryCollection.Add("style", style);
+            yield return await _styleBertVitsClientService
+                .GetAsByteArrayAsync($"/voice?{queryCollection}", ExceptionType.SoundGenerationFailed, cancellationToken).ConfigureAwait(false);
+        }
+    }
+
+    private IEnumerable<string> SplitPeriod(string text, int limit)
+    {
+        if (text.Length < limit)
+        {
+            yield return text;
+        }
+        else
+        {
+            List<int> periodList = [0];
+            var textSpan = text.AsSpan();
+            var chunk = textSpan[..limit];
+            while (true)
+            {
+                var periodIndex = periodList[^1] + chunk.LastIndexOf('。') + 1;
+                periodList.Add(periodIndex);
+                var nextEnd = periodIndex + limit;
+                if (nextEnd < textSpan.Length)
+                {
+                    chunk = textSpan[periodIndex..nextEnd];
+                }
+                else
+                {
+                    periodList.Add(textSpan.Length);
+                    break;
+                }
+            }
+            for (var i = 1; i < periodList.Count; i++)
+            {
+                yield return text[periodList[i - 1]..periodList[i]];
+            }
+        }
     }
 }