piper/src/cpp/config.hpp at master · sce-tts/piper · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
#ifndef CONFIG_H_
#define CONFIG_H_

#include <filesystem>
#include <map>
#include <optional>
#include <set>
#include <stdexcept>
#include <string>
#include <vector>

#include "json.hpp"
#include "utf8.h"

using namespace std;
using json = nlohmann::json;

namespace piper {

typedef char32_t Phoneme;
typedef int64_t PhonemeId;
typedef int64_t SpeakerId;

const string DefaultVoice = "en-gb-x-rp";

enum eSpeakMode { Text, TextWithPhonemes, SSML };

struct eSpeakConfig {
  string voice = DefaultVoice;
  eSpeakMode mode = Text;
  set<Phoneme> clauseBreakers{U'.', U'?', U'!', U',', U';', U':'};
};

struct PhonemizeConfig {
  string text;
  optional<vector<Phoneme>> phonemes;
  optional<map<Phoneme, vector<Phoneme>>> phonemeMap;
  map<Phoneme, vector<PhonemeId>> phonemeIdMap;

  PhonemeId idPad = 0; // padding (optionally interspersed)
  PhonemeId idBos = 1; // beginning of sentence
  PhonemeId idEos = 2; // end of sentence
  bool interspersePad = true;

  optional<eSpeakConfig> eSpeak;
};

struct SynthesisConfig {
  vector<PhonemeId> phonemeIds;
  float noiseScale = 0.667f;
  float lengthScale = 1.0f;
  float noiseW = 0.8f;
  int sampleRate = 22050;
  int sampleWidth = 2; // 16-bit
  int channels = 1;    // mono
  optional<SpeakerId> speakerId;
};

struct ModelConfig {
  int numSpeakers;
};

bool isSingleCodepoint(string s) {
  return utf8::distance(s.begin(), s.end()) == 1;
}

Phoneme getCodepoint(string s) {
  utf8::iterator character_iter(s.begin(), s.begin(), s.end());
  return *character_iter;
}

void parsePhonemizeConfig(json &configRoot, PhonemizeConfig &phonemizeConfig) {

  if (configRoot.contains("espeak")) {
    if (!phonemizeConfig.eSpeak) {
      phonemizeConfig.eSpeak.emplace();
    }

    auto espeakValue = configRoot["espeak"];
    if (espeakValue.contains("voice")) {
      phonemizeConfig.eSpeak->voice = espeakValue["voice"].get<string>();
    }
  }

  // phoneme to [phoneme] map
  if (configRoot.contains("phoneme_map")) {
    if (!phonemizeConfig.phonemeMap) {
      phonemizeConfig.phonemeMap.emplace();
    }

    auto phonemeMapValue = configRoot["phoneme_map"];
    for (auto &fromPhonemeItem : phonemeMapValue.items()) {
      string fromPhoneme = fromPhonemeItem.key();
      if (!isSingleCodepoint(fromPhoneme)) {
        throw runtime_error("Phonemes must be one codepoint (phoneme map)");
      }

      auto fromCodepoint = getCodepoint(fromPhoneme);
      for (auto &toPhonemeValue : fromPhonemeItem.value()) {
        string toPhoneme = toPhonemeValue.get<string>();
        if (!isSingleCodepoint(toPhoneme)) {
          throw runtime_error("Phonemes must be one codepoint (phoneme map)");
        }

        auto toCodepoint = getCodepoint(toPhoneme);
        (*phonemizeConfig.phonemeMap)[fromCodepoint].push_back(toCodepoint);
      }
    }
  }

  // phoneme to [id] map
  if (configRoot.contains("phoneme_id_map")) {
    auto phonemeIdMapValue = configRoot["phoneme_id_map"];
    for (auto &fromPhonemeItem : phonemeIdMapValue.items()) {
      string fromPhoneme = fromPhonemeItem.key();
      if (!isSingleCodepoint(fromPhoneme)) {
        throw runtime_error("Phonemes must be one codepoint (phoneme id map)");
      }

      auto fromCodepoint = getCodepoint(fromPhoneme);
      for (auto &toIdValue : fromPhonemeItem.value()) {
        PhonemeId toId = toIdValue.get<PhonemeId>();
        phonemizeConfig.phonemeIdMap[fromCodepoint].push_back(toId);
      }
    }
  }

} /* parsePhonemizeConfig */

void parseSynthesisConfig(json &configRoot, SynthesisConfig &synthesisConfig) {

  if (configRoot.contains("audio")) {
    auto audioValue = configRoot["audio"];
    if (audioValue.contains("sample_rate")) {
      // Default sample rate is 22050 Hz
      synthesisConfig.sampleRate = audioValue.value("sample_rate", 22050);
    }
  }

} /* parseSynthesisConfig */

void parseModelConfig(json &configRoot, ModelConfig &modelConfig) {

  modelConfig.numSpeakers = configRoot["num_speakers"].get<SpeakerId>();

} /* parseModelConfig */

} // namespace piper

#endif // CONFIG_H_