Add files using upload-large-folder tool

CosyVoice-ttsfrd/.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bin.* filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zstandard filter=lfs diff=lfs merge=lfs -text
+*.tfevents* filter=lfs diff=lfs merge=lfs -text
+*.db* filter=lfs diff=lfs merge=lfs -text
+*.ark* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*data* filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.meta filter=lfs diff=lfs merge=lfs -text
+**/*ckpt*.index filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.gguf* filter=lfs diff=lfs merge=lfs -text
+*.ggml filter=lfs diff=lfs merge=lfs -text
+*.llamafile* filter=lfs diff=lfs merge=lfs -text
+resource.zip filter=lfs diff=lfs merge=lfs -text
+resource.tar filter=lfs diff=lfs merge=lfs -text

CosyVoice-ttsfrd/README.md

@@ -0,0 +1,227 @@
+[![SVG Banners](https://svg-banners.vercel.app/api?type=origin&text1=CosyVoice🤠&text2=Text-to-Speech%20💖%20Large%20Language%20Model&width=800&height=210)](https://github.com/Akshay090/svg-banners)
+
+## 👉🏻 CosyVoice 👈🏻
+**CosyVoice 2.0**: [Demos](https://funaudiollm.github.io/cosyvoice2/); [Paper](https://arxiv.org/abs/2412.10117); [Modelscope](https://www.modelscope.cn/studios/iic/CosyVoice2-0.5B); [HuggingFace](https://huggingface.co/spaces/FunAudioLLM/CosyVoice2-0.5B)
+
+**CosyVoice 1.0**: [Demos](https://fun-audio-llm.github.io); [Paper](https://funaudiollm.github.io/pdf/CosyVoice_v1.pdf); [Modelscope](https://www.modelscope.cn/studios/iic/CosyVoice-300M)
+
+## Highlight🔥
+
+**CosyVoice 2.0** has been released! Compared to version 1.0, the new version offers more accurate, more stable, faster, and better speech generation capabilities.
+### Multilingual
+- **Supported Language**: Chinese, English, Japanese, Korean, Chinese dialects (Cantonese, Sichuanese, Shanghainese, Tianjinese, Wuhanese, etc.)
+- **Crosslingual & Mixlingual**：Support zero-shot voice cloning for cross-lingual and code-switching scenarios.
+### Ultra-Low Latency
+- **Bidirectional Streaming Support**: CosyVoice 2.0 integrates offline and streaming modeling technologies.
+- **Rapid First Packet Synthesis**: Achieves latency as low as 150ms while maintaining high-quality audio output.
+### High Accuracy
+- **Improved Pronunciation**: Reduces pronunciation errors by 30% to 50% compared to CosyVoice 1.0.
+- **Benchmark Achievements**: Attains the lowest character error rate on the hard test set of the Seed-TTS evaluation set.
+### Strong Stability
+- **Consistency in Timbre**: Ensures reliable voice consistency for zero-shot and cross-language speech synthesis.
+- **Cross-language Synthesis**: Marked improvements compared to version 1.0.
+### Natural Experience
+- **Enhanced Prosody and Sound Quality**: Improved alignment of synthesized audio, raising MOS evaluation scores from 5.4 to 5.53.
+- **Emotional and Dialectal Flexibility**: Now supports more granular emotional controls and accent adjustments.
+
+## Roadmap
+
+- [x] 2024/12
+
+    - [x] 25hz cosyvoice 2.0 released
+
+- [x] 2024/09
+
+    - [x] 25hz cosyvoice base model
+    - [x] 25hz cosyvoice voice conversion model
+
+- [x] 2024/08
+
+    - [x] Repetition Aware Sampling(RAS) inference for llm stability
+    - [x] Streaming inference mode support, including kv cache and sdpa for rtf optimization
+
+- [x] 2024/07
+
+    - [x] Flow matching training support
+    - [x] WeTextProcessing support when ttsfrd is not available
+    - [x] Fastapi server and client
+
+
+## Install
+
+**Clone and install**
+
+- Clone the repo
+``` sh
+git clone --recursive https://github.com/FunAudioLLM/CosyVoice.git
+# If you failed to clone submodule due to network failures, please run following command until success
+cd CosyVoice
+git submodule update --init --recursive
+```
+
+- Install Conda: please see https://docs.conda.io/en/latest/miniconda.html
+- Create Conda env:
+
+``` sh
+conda create -n cosyvoice python=3.10
+conda activate cosyvoice
+# pynini is required by WeTextProcessing, use conda to install it as it can be executed on all platform.
+conda install -y -c conda-forge pynini==2.1.5
+pip install -r requirements.txt -i https://mirrors.aliyun.com/pypi/simple/ --trusted-host=mirrors.aliyun.com
+
+# If you encounter sox compatibility issues
+# ubuntu
+sudo apt-get install sox libsox-dev
+# centos
+sudo yum install sox sox-devel
+```
+
+**Model download**
+
+We strongly recommend that you download our pretrained `CosyVoice2-0.5B` `CosyVoice-300M` `CosyVoice-300M-SFT` `CosyVoice-300M-Instruct` model and `CosyVoice-ttsfrd` resource.
+
+``` python
+# SDK模型下载
+from modelscope import snapshot_download
+snapshot_download('iic/CosyVoice2-0.5B', local_dir='pretrained_models/CosyVoice2-0.5B')
+snapshot_download('iic/CosyVoice-300M', local_dir='pretrained_models/CosyVoice-300M')
+snapshot_download('iic/CosyVoice-300M-25Hz', local_dir='pretrained_models/CosyVoice-300M-25Hz')
+snapshot_download('iic/CosyVoice-300M-SFT', local_dir='pretrained_models/CosyVoice-300M-SFT')
+snapshot_download('iic/CosyVoice-300M-Instruct', local_dir='pretrained_models/CosyVoice-300M-Instruct')
+snapshot_download('iic/CosyVoice-ttsfrd', local_dir='pretrained_models/CosyVoice-ttsfrd')
+```
+
+``` sh
+# git模型下载，请确保已安装git lfs
+mkdir -p pretrained_models
+git clone https://www.modelscope.cn/iic/CosyVoice2-0.5B.git pretrained_models/CosyVoice2-0.5B
+git clone https://www.modelscope.cn/iic/CosyVoice-300M.git pretrained_models/CosyVoice-300M
+git clone https://www.modelscope.cn/iic/CosyVoice-300M-25Hz.git pretrained_models/CosyVoice-300M-25Hz
+git clone https://www.modelscope.cn/iic/CosyVoice-300M-SFT.git pretrained_models/CosyVoice-300M-SFT
+git clone https://www.modelscope.cn/iic/CosyVoice-300M-Instruct.git pretrained_models/CosyVoice-300M-Instruct
+git clone https://www.modelscope.cn/iic/CosyVoice-ttsfrd.git pretrained_models/CosyVoice-ttsfrd
+```
+
+Optionally, you can unzip `ttsfrd` resouce and install `ttsfrd` package for better text normalization performance.
+
+Notice that this step is not necessary. If you do not install `ttsfrd` package, we will use WeTextProcessing by default.
+
+``` sh
+cd pretrained_models/CosyVoice-ttsfrd/
+unzip resource.zip -d .
+pip install ttsfrd_dependency-0.1-py3-none-any.whl
+pip install ttsfrd-0.4.2-cp310-cp310-linux_x86_64.whl
+```
+
+**Basic Usage**
+
+We strongly recommend using `CosyVoice2-0.5B` for better performance.
+Follow code below for detailed usage of each model.
+
+``` python
+import sys
+sys.path.append('third_party/Matcha-TTS')
+from cosyvoice.cli.cosyvoice import CosyVoice, CosyVoice2
+from cosyvoice.utils.file_utils import load_wav
+import torchaudio
+```
+
+**CosyVoice2 Usage**
+```python
+cosyvoice = CosyVoice2('pretrained_models/CosyVoice2-0.5B', load_jit=False, load_trt=False, fp16=False)
+
+# NOTE if you want to reproduce the results on https://funaudiollm.github.io/cosyvoice2, please add text_frontend=False during inference
+# zero_shot usage
+prompt_speech_16k = load_wav('zero_shot_prompt.wav', 16000)
+for i, j in enumerate(cosyvoice.inference_zero_shot('收到好友从远方寄来的生日礼物，那份意外的惊喜与深深的祝福让我心中充满了甜蜜的快乐，笑容如花儿般绽放。', '希望你以后能够做的比我还好呦。', prompt_speech_16k, stream=False)):
+    torchaudio.save('zero_shot_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+
+# fine grained control, for supported control, check cosyvoice/tokenizer/tokenizer.py#L248
+for i, j in enumerate(cosyvoice.inference_cross_lingual('在他讲述那个荒诞故事的过程中，他突然[laughter]停下来，因为他自己也被逗笑了[laughter]。', prompt_speech_16k, stream=False)):
+    torchaudio.save('fine_grained_control_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+
+# instruct usage
+for i, j in enumerate(cosyvoice.inference_instruct2('收到好友从远方寄来的生日礼物，那份意外的惊喜与深深的祝福让我心中充满了甜蜜的快乐，笑容如花儿般绽放。', '用四川话说这句话', prompt_speech_16k, stream=False)):
+    torchaudio.save('instruct_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+```
+
+**CosyVoice Usage**
+```python
+cosyvoice = CosyVoice('pretrained_models/CosyVoice-300M-SFT', load_jit=False, load_trt=False, fp16=False)
+# sft usage
+print(cosyvoice.list_available_spks())
+# change stream=True for chunk stream inference
+for i, j in enumerate(cosyvoice.inference_sft('你好，我是通义生成式语音大模型，请问有什么可以帮您的吗？', '中文女', stream=False)):
+    torchaudio.save('sft_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+
+cosyvoice = CosyVoice('pretrained_models/CosyVoice-300M') # or change to pretrained_models/CosyVoice-300M-25Hz for 25Hz inference
+# zero_shot usage, <|zh|><|en|><|jp|><|yue|><|ko|> for Chinese/English/Japanese/Cantonese/Korean
+prompt_speech_16k = load_wav('zero_shot_prompt.wav', 16000)
+for i, j in enumerate(cosyvoice.inference_zero_shot('收到好友从远方寄来的生日礼物，那份意外的惊喜与深深的祝福让我心中充满了甜蜜的快乐，笑容如花儿般绽放。', '希望你以后能够做的比我还好呦。', prompt_speech_16k, stream=False)):
+    torchaudio.save('zero_shot_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+# cross_lingual usage
+prompt_speech_16k = load_wav('cross_lingual_prompt.wav', 16000)
+for i, j in enumerate(cosyvoice.inference_cross_lingual('<|en|>And then later on, fully acquiring that company. So keeping management in line, interest in line with the asset that\'s coming into the family is a reason why sometimes we don\'t buy the whole thing.', prompt_speech_16k, stream=False)):
+    torchaudio.save('cross_lingual_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+# vc usage
+prompt_speech_16k = load_wav('zero_shot_prompt.wav', 16000)
+source_speech_16k = load_wav('cross_lingual_prompt.wav', 16000)
+for i, j in enumerate(cosyvoice.inference_vc(source_speech_16k, prompt_speech_16k, stream=False)):
+    torchaudio.save('vc_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+
+cosyvoice = CosyVoice('pretrained_models/CosyVoice-300M-Instruct')
+# instruct usage, support <laughter></laughter><strong></strong>[laughter][breath]
+for i, j in enumerate(cosyvoice.inference_instruct('在面对挑战时，他展现了非凡的<strong>勇气</strong>与<strong>智慧</strong>。', '中文男', 'Theo \'Crimson\', is a fiery, passionate rebel leader. Fights with fervor for justice, but struggles with impulsiveness.', stream=False)):
+    torchaudio.save('instruct_{}.wav'.format(i), j['tts_speech'], cosyvoice.sample_rate)
+```
+
+**Start web demo**
+
+You can use our web demo page to get familiar with CosyVoice quickly.
+
+Please see the demo website for details.
+
+``` python
+# change iic/CosyVoice-300M-SFT for sft inference, or iic/CosyVoice-300M-Instruct for instruct inference
+python3 webui.py --port 50000 --model_dir pretrained_models/CosyVoice-300M
+```
+
+**Advanced Usage**
+
+For advanced user, we have provided train and inference scripts in `examples/libritts/cosyvoice/run.sh`.
+
+**Build for deployment**
+
+Optionally, if you want service deployment,
+you can run following steps.
+
+``` sh
+cd runtime/python
+docker build -t cosyvoice:v1.0 .
+# change iic/CosyVoice-300M to iic/CosyVoice-300M-Instruct if you want to use instruct inference
+# for grpc usage
+docker run -d --runtime=nvidia -p 50000:50000 cosyvoice:v1.0 /bin/bash -c "cd /opt/CosyVoice/CosyVoice/runtime/python/grpc && python3 server.py --port 50000 --max_conc 4 --model_dir iic/CosyVoice-300M && sleep infinity"
+cd grpc && python3 client.py --port 50000 --mode <sft|zero_shot|cross_lingual|instruct>
+# for fastapi usage
+docker run -d --runtime=nvidia -p 50000:50000 cosyvoice:v1.0 /bin/bash -c "cd /opt/CosyVoice/CosyVoice/runtime/python/fastapi && python3 server.py --port 50000 --model_dir iic/CosyVoice-300M && sleep infinity"
+cd fastapi && python3 client.py --port 50000 --mode <sft|zero_shot|cross_lingual|instruct>
+```
+
+## Discussion & Communication
+
+You can directly discuss on [Github Issues](https://github.com/FunAudioLLM/CosyVoice/issues).
+
+You can also scan the QR code to join our official Dingding chat group.
+
+<img src="./asset/dingding.png" width="250px">
+
+## Acknowledge
+
+1. We borrowed a lot of code from [FunASR](https://github.com/modelscope/FunASR).
+2. We borrowed a lot of code from [FunCodec](https://github.com/modelscope/FunCodec).
+3. We borrowed a lot of code from [Matcha-TTS](https://github.com/shivammehta25/Matcha-TTS).
+4. We borrowed a lot of code from [AcademiCodec](https://github.com/yangdongchao/AcademiCodec).
+5. We borrowed a lot of code from [WeNet](https://github.com/wenet-e2e/wenet).
+
+## Disclaimer
+The content provided above is for academic purposes only and is intended to demonstrate technical capabilities. Some examples are sourced from the internet. If any content infringes on your rights, please contact us to request its removal.

CosyVoice-ttsfrd/configuration.json

@@ -0,0 +1 @@
+{"framework":"Pytorch","task":"text-to-speech"}

CosyVoice-ttsfrd/resource/festival/Sable.v0_2.dtd

@@ -0,0 +1,137 @@
+<!-- <!DOCTYPE sable SYSTEM "Sable.v0_2.dtd" [                           -->
+<!--;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-->
+<!--                                                                     -->
+<!--               Centre for Speech Technology Research                 -->
+<!--                    University of Edinburgh, UK                      -->
+<!--                        Copyright (c) 1998                           -->
+<!--                       All Rights Reserved.                          -->
+<!--                                                                     -->
+<!-- Permission is hereby granted, free of charge, to use and distribute -->
+<!-- this software and its documentation without restriction, including  -->
+<!-- without limitation the rights to use, copy, modify, merge, publish, -->
+<!-- distribute, sublicense, and/or sell copies of this work, and to     -->
+<!-- permit persons to whom this work is furnished to do so, subject to  -->
+<!-- the following conditions:                                           -->
+<!--  1. The code must retain the above copyright notice, this list of   -->
+<!--     conditions and the following disclaimer.                        -->
+<!--  2. Any modifications must be clearly marked as such.               -->
+<!--  3. Original authors' names are not deleted.                        -->
+<!--  4. The authors' names are not used to endorse or promote products  -->
+<!--     derived from this software without specific prior written       -->
+<!--     permission.                                                     -->
+<!--                                                                     -->
+<!-- THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK       -->
+<!-- DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING     -->
+<!-- ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT  -->
+<!-- SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE    -->
+<!-- FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   -->
+<!-- WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN  -->
+<!-- AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,         -->
+<!-- ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF      -->
+<!-- THIS SOFTWARE.                                                      -->
+<!--                                                                     -->
+<!--                                                                     -->
+<!-- An early draft of SABLE 0.1 (Jan 8th 1998)                          -->
+<!--       (Alan W Black [email protected])                              -->
+<!-- This not an official DTD just one that allows a mock up of the      -->
+<!-- system for Festival-1.2.1 and later                                 -->
+<!--                                                                     -->
+<!-- Modified to be XML compliant    April 2nd 1998                      -->
+<!--                                                                     -->
+<!-- Modified for SABLE 0.2 (August 15, 1998)                            --> 
+<!--       (Richard Sproat [email protected])                   -->
+<!--                                                                     -->
+<!-- Note that in order to use this as both an XML and SGML DTD, we need -->
+<!-- to declare OMITTAG NO in the accompanying sable.decl for SGML.      -->
+<!-- This means that end tags are REQUIRED for a sable document to be    -->
+<!-- conformant, even when viewed as an SGML document.                   -->
+
+<!ENTITY % baseelements "EMPH | 
+			 BREAK |
+			 PITCH |
+                         RATE |
+                         VOLUME |
+                         AUDIO |
+                         ENGINE |
+                         MARKER |
+                         PRON |
+                         SAYAS |
+                         LANGUAGE |
+                         SPEAKER |
+			 DIV">
+
+<!ELEMENT SABLE (#PCDATA| %baseelements; )*>
+
+<!-- The non-hierarchical ones -->
+<!ELEMENT BREAK EMPTY >
+<!ATTLIST BREAK 
+                LEVEL (large|medium|small|none|NUMBER) "medium"
+		TYPE (quest|excl|period|comma) #IMPLIED
+                MSEC CDATA #IMPLIED
+                MARK CDATA #IMPLIED>
+<!ELEMENT AUDIO EMPTY >
+<!ATTLIST AUDIO 
+                SRC CDATA #IMPLIED 
+                MODE (background|insertion) "insertion"
+		LEVEL CDATA #IMPLIED
+                MARK CDATA #IMPLIED>
+<!ELEMENT MARKER EMPTY >
+<!ATTLIST MARKER 
+                MARK CDATA #IMPLIED>
+
+<!-- The non-nestable ones -->
+
+<!ELEMENT PRON (#PCDATA) >
+<!ATTLIST PRON  IPA CDATA #IMPLIED
+                SUB CDATA #IMPLIED
+		ORIGIN CDATA #IMPLIED
+		MARK CDATA #IMPLIED>
+<!ELEMENT SAYAS (#PCDATA) >
+<!ATTLIST SAYAS MODE (literal|date|time|phone|net|postal|currency|math|fraction|measure|ordinal|cardinal|name) #REQUIRED
+                MODETYPE (DMY|MDY|YMD|YM|MY|MD|HM|HMS|EMAIL|URL) #IMPLIED
+		MARK CDATA #IMPLIED>
+
+<!-- The nestable ones -->
+
+<!ELEMENT EMPH ( #PCDATA | %baseelements; )*>
+<!ATTLIST EMPH  LEVEL (Strong|Moderate|None|Reduced|NUMBER) "moderate"
+                MARK CDATA #IMPLIED>
+<!ELEMENT PITCH ( #PCDATA | %baseelements; )*>
+<!ATTLIST PITCH BASE CDATA "0%"
+                MIDDLE  CDATA "0%"
+                RANGE CDATA "0%"
+                MARK CDATA #IMPLIED>
+<!ELEMENT RATE  ( #PCDATA | %baseelements; )*>
+<!ATTLIST RATE  SPEED CDATA "0%"
+                MARK CDATA #IMPLIED>
+<!ELEMENT VOLUME  ( #PCDATA | %baseelements; )*>
+<!ATTLIST VOLUME LEVEL CDATA "medium"
+                 MARK CDATA #IMPLIED>
+<!ELEMENT ENGINE  ( #PCDATA | %baseelements; )*>
+<!ATTLIST ENGINE ID CDATA #IMPLIED
+                 DATA CDATA #IMPLIED
+                 MARK CDATA #IMPLIED>
+
+<!ELEMENT LANGUAGE  ( #PCDATA | %baseelements; )*>
+<!ATTLIST LANGUAGE ID CDATA #IMPLIED
+		   CODE CDATA #IMPLIED
+                   MARK CDATA #IMPLIED>
+<!ELEMENT SPEAKER  ( #PCDATA | %baseelements; )*>
+<!ATTLIST SPEAKER  GENDER (male|female) #IMPLIED
+                   AGE    (older|middle|younger|teen|child) #IMPLIED
+                   NAME   CDATA #IMPLIED
+                   MARK   CDATA #IMPLIED>
+
+<!ELEMENT DIV  ( #PCDATA | %baseelements; )*>
+<!ATTLIST DIV TYPE (sentence|paragraph) #IMPLIED
+              MARK CDATA #IMPLIED>
+
+<!-- Character entities for latin 1 -->
+
+<!ENTITY % ISOlat1 PUBLIC
+  "-//SABLE//ENTITIES Added Latin 1 for SABLE//EN"
+  "sable-latin.ent" >
+%ISOlat1;
+
+
+

CosyVoice-ttsfrd/resource/festival/Singing.v0_1.dtd

@@ -0,0 +1,34 @@
+<!-- <!DOCTYPE singing SYSTEM "Singing.v0_1.dtd" [    -->
+
+<!ENTITY % baseelements "PITCH |
+                         DURATION
+						 ">
+
+<!ELEMENT SINGING (#PCDATA| %baseelements; )*>
+<!ATTLIST SINGING BPM CDATA "120"
+                MARK CDATA #IMPLIED>
+
+<!ELEMENT PITCH ( #PCDATA | %baseelements; )*>
+<!ATTLIST PITCH FREQ CDATA "X"
+                NOTE CDATA "X"
+                MARK CDATA #IMPLIED>
+
+<!ELEMENT DURATION  ( #PCDATA | %baseelements; )*>
+<!ATTLIST DURATION SECONDS CDATA "X"
+                   BEATS CDATA "X"
+                   MARK CDATA #IMPLIED>
+
+<!ELEMENT REST  ( #PCDATA | %baseelements; )*>
+<!ATTLIST REST SECONDS CDATA "X"
+               BEATS CDATA "X"
+               MARK CDATA #IMPLIED>
+
+<!-- Character entities for latin 1 -->
+
+<!ENTITY % ISOlat1 PUBLIC
+  "-//SINGING//ENTITIES Added Latin 1 for SINGING//EN"
+  "sable-latin.ent" >
+%ISOlat1;
+
+
+

CosyVoice-ttsfrd/resource/festival/VCLocalRules

@@ -0,0 +1,8 @@
+SIOD =  siod.scm web.scm cstr.scm fringe.scm
+
+.copy_from_est: $(SIOD)
+
+$(SIOD) :
+	@echo 'Copy $@ from EST/lib/siod'
+	-del $@
+	copy $(EST)\lib\siod\$@ $@

CosyVoice-ttsfrd/resource/festival/apml.scm

@@ -0,0 +1,551 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 2002                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Rob Clark
+;;;                         Date:   July 2002
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Sets up the current voice to synthesise from APML.
+;;
+;;
+
+(require 'apml_f2bf0lr)
+(require 'apml_kaldurtreeZ)
+
+;; Default pitch settings (if unspecified in current voice.)
+
+(defvar apml_default_pitch_mean 170 )
+(defvar apml_default_pitch_standard_deviation 34 )
+
+;; apml sythesis wrappers.
+
+(define (apml_client_synth apml)
+  "(apml_client_synth apml)
+Synthesise apml and return waveform(s) to client."
+  (utt.send.wave.client (apml_synth apml)))
+
+(define (apml_synth apml)
+"(apml_synth xml)
+Synthesis an apml string."
+(let ((tmpfile (make_tmp_filename))
+      utt)
+  (string_to_file tmpfile apml)
+  (set! utt (apml_file_synth tmpfile))
+  (delete-file tmpfile)
+  utt))
+
+(define (apml_file_synth filename)
+  "(apml_file_synth filename)
+Synthesis an apml file."
+  (let ((utt (Utterance Tokens nil)))
+    (utt.load utt filename)
+    (utt.synth utt)))
+
+(define (string_to_file file s)
+"(string_to_file file string)
+ Write string to file."
+(let ((fd))
+  (set! fd (fopen file "wb"))
+  (format fd "%s" s)
+  (fclose fd)))
+
+
+;;;
+;;; Phrasing.
+;;;
+
+;; phrasing CART.
+;
+; It has been decided that by default, only punctuation should affect
+; phrasing (and subsequently pauses)
+;
+(set! apml_phrase_tree
+      '
+      ((lisp_apml_punc in ("?" "." ":"))         ; big punctuation
+       ((BB))
+       ((lisp_apml_punc in ("'" "\"" "," ";"))   ; else little punctuation
+	((B))
+	((lisp_apml_last_word is 1)
+	 ((BB))                                  ; need a BB at the end!
+	 ((NB))))))                              ; else nothing
+
+;; feature functions for phrasing
+(define (apml_punc word)
+  (item.feat (item.relation.parent word 'Token) 'punc))
+
+(define (apml_last_word word)
+  (if (item.next word)
+      "0" "1"))
+
+
+;;;
+;;; Pauses
+;;;
+
+;; feature functions for pauses
+(define (apml_is_pause word)
+  (if (item.relation (item.relation.parent word 'Token) 'Pause)
+      t
+      nil))
+
+(define (apml_pause word)
+  (if (item.relation word 'Pause)
+	(item.feat (item.relation.parent (item.relation.parent word 'Token) 'Pause) "sec")
+      0))
+
+(define (Apml_Pauses utt)
+  "(Pauses UTT)
+Predict pause insertion for apml."
+  (let ((words (utt.relation.items utt 'Word)) lastword tpname)
+    (if words
+        (begin
+          (insert_initial_pause utt)   ;; always have a start pause
+          (set! lastword (car (last words)))
+          (mapcar
+           (lambda (w)
+             (let ((pbreak (item.feat w "pbreak"))
+                   (emph (item.feat w "R:Token.parent.EMPH")))
+               (cond
+		((apml_is_pause w)
+		 (insert_pause utt w))
+                ((or (string-equal "B" pbreak)
+                     (string-equal "BB" pbreak))
+                 (insert_pause utt w))
+                ((equal? w lastword)
+                 (insert_pause utt w)))))
+           words)
+          ;; The embarassing bit.  Remove any words labelled as punc or fpunc
+          (mapcar
+           (lambda (w)
+             (let ((pos (item.feat w "pos")))
+               (if (or (string-equal "punc" pos)
+                       (string-equal "fpunc" pos))
+                   (let ((pbreak (item.feat w "pbreak"))
+                         (wp (item.relation w 'Phrase)))
+                     (if (and (string-matches pbreak "BB?")
+                              (item.relation.prev w 'Word))
+                         (item.set_feat 
+                          (item.relation.prev w 'Word) "pbreak" pbreak))
+                     (item.relation.remove w 'Word)
+                     ;; can't refer to w as we've just deleted it
+                     (item.relation.remove wp 'Phrase)))))
+           words)))
+  utt))
+
+
+
+;;;
+;;; Intonation.
+;;;
+
+;; Accent prediction (well transfer really).
+;; 
+;; We treat L+H* L-H% on a single syllable as a special case.
+
+(set! apml_accent_cart
+      '
+      ((lisp_apml_accent is "Hstar")
+       ((H*))
+       ((lisp_apml_accent is "Lstar")
+	((L*))
+	((lisp_apml_LHLH is "LHLH")
+	 ((L+H*L-H%))
+	 ((lisp_apml_accent is "LplusHstar")
+	  ((L+H*))
+	  ((lisp_apml_accent is "LstarplusH")
+	   ((L*+H))
+	   ((NONE))))))))
+
+(set! apml_boundary_cart
+      '
+      ((lisp_apml_boundary is "LL")
+       ((L-L%))
+       ((lisp_apml_LHLH is "LHLH")
+	((NONE))                      ; this is dealt with by the accent feature
+	((lisp_apml_boundary is "LH")
+	 ((L-H%))
+	 ((lisp_apml_boundary is "HH")
+	  ((H-H%))
+	  ((lisp_apml_boundary is "HL")
+	   ((H-L%))
+	   ((NONE))))))))
+
+;; feature functions.
+(define (apml_accent syl)
+  (let ((token (item.relation.parent (item.relation.parent syl 'SylStructure) 'Token)))
+    (if (and (eq (item.feat syl 'stress) 1)
+	     (item.relation.parent token 'Emphasis))
+	(item.feat (item.relation.parent token 'Emphasis) 'x-pitchaccent)
+	0)))
+	     
+(define (apml_boundary syl)
+  (let ((token (item.relation.parent (item.relation.parent syl 'SylStructure) 'Token)))
+    (if (and (> (item.feat syl 'syl_break) 0)
+	     (item.relation.parent token 'Boundary))
+	(item.feat (item.relation.parent token 'Boundary) 'type)
+	0)))
+
+(define (apml_LHLH syl)
+  (let ((accent (apml_accent syl))
+	(boundary (apml_boundary syl)))
+    (if (and (string-equal accent "LplusHstar")
+	     (string-equal boundary "LH"))
+	"LHLH"
+	0)))
+
+
+(define (apml_seg_is_LHLH_vowel seg)
+  (if (and (string-equal (apml_LHLH (item.relation.parent seg 'SylStructure))
+			 "LHLH")
+	   (string-equal (item.feat seg 'ph_vc) "+"))
+      "LHLH"
+      0))
+
+
+;;;; feature functions:
+
+(define (apml_tgtype syl)
+  (let ((l (apml_boundl (item.relation.parent syl 'SylStructure)))
+	(r (apml_boundr (item.relation.parent syl 'SylStructure))))
+    (if (eq (item.feat syl 'accented) 0)
+	0   ; this is a quirk related to the way the models were trained
+	(cond
+	 ((eq l 0)
+	  1)
+	 ((eq r 1)
+	  3)
+	 (t 2)))))
+  
+
+(define (apml_iecount syl)
+  (if (eq (item.feat syl 'accented) 0)
+      0   ; this is a quirk related to the way the models were trained
+      (+ (item.feat syl 'asyl_in) 1)))
+
+;; suport functions.
+(define (apml_boundl word)
+"(apml_boundl word)
+Number of boundaries in this performative to the left of this word."
+  (let ((w (item.prev word))
+	(c 0))
+    (while (and w (apml_same_p w word))
+	   (if (item.relation.parent (item.relation.parent w 'Token) 'Boundary)
+	       (set! c (+ c 1)))
+	   (set! w (item.prev w)))
+    c))
+
+(define (apml_boundr word)
+"(apml_boundr word)
+Number of boundaries in this performative to the right of this word."
+  (let ((w word)
+	(c 0))
+    (while (and w (apml_same_p w word))
+	   (if (item.relation.parent (item.relation.parent w 'Token) 'Boundary)
+	       (set! c (+ c 1)))
+	   (set! w (item.next w)))
+    c))
+
+(define (apml_same_p w1 w2)
+"(apml_same_p w1 w2)
+ Are these two words in the same performative?"
+(let ((p1 (item.relation.parent (item.relation.parent w1 'Token) 'SemStructure))
+      (p2 (item.relation.parent (item.relation.parent w1 'Token) 'SemStructure)))
+  (if (and (item.parent p1) (item.parent p2))  ; not true if theme/rheme omitted.
+      (equal? (item.parent p1) (item.parent p2))
+      (equal? p1 p2))))
+
+;;;
+;;; segment timings
+;;;
+
+(define (apml_seg_times utt)
+  "(apml_seg_times utt)
+Output the segment timings for an apml utterance."
+  (let ((segs (utt.relation.items utt 'Segment)))
+    (mapcar
+     (lambda (x)
+       (format t "%s %s\n" (item.name x) (item.feat x 'end)))
+     segs)
+    t))
+
+;;;
+;;; Additional functions for f0model.
+;;;
+
+
+(define (find_hstar_left syl)
+"(find_hstar_left syl)
+If the closest accent or boundary to the left is H* return how many syllables away it is. Returns 0 if nearest accent is not H*"
+(let ((count 0))
+  ;; if this syllable has a pitch event
+  (if (or (not (string-equal (item.feat syl 'tobi_accent) "NONE"))
+	  (not (string-equal (item.feat syl 'tobi_endtone) "NONE")))
+      0)
+  (while (and syl
+	      (string-equal (item.feat syl 'tobi_accent) "NONE")
+	      (string-equal (item.feat syl 'tobi_endtone) "NONE"))
+	 (set! count (+ count 1))
+	 (set! syl (item.prev syl)))
+  (cond
+   ;; run out of syllables before finding accent
+   ((null syl)
+    0)
+   ((string-equal (item.feat syl 'tobi_accent) "H*")
+    count)
+   (t 0))))
+
+(define (find_ll_right syl)
+"(find_ll_right syl)
+If the closest accent or boundary to the right is L-L% return how many syllables away it is. Returns 0 if nearest is not L-L%."
+(let ((count 0))
+  ;; if this syllable has a pitch event
+  (if (or (not (string-equal (item.feat syl 'tobi_accent) "NONE"))
+	  (not (string-equal (item.feat syl 'tobi_endtone) "NONE")))
+      0)
+  (while (and syl
+	      (string-equal (item.feat syl 'tobi_accent) "NONE")
+	      (string-equal (item.feat syl 'tobi_endtone) "NONE"))
+	 (set! count (+ count 1))
+	 (set! syl (item.next syl)))
+  (cond
+   ;; run out of syllables before finding boundary
+   ((null syl)
+    0)
+   ((string-equal (item.feat syl 'tobi_endtone) "L-L%")
+    count)
+   (t 0))))
+
+(define (l_spread syl)
+"(l_spread syl)
+Proportion of pitch lowering required due to L- spreading backwards."
+(let ((l (find_hstar_left syl))
+      (r (find_ll_right syl)))
+  (cond
+   ((or (eq l 0)
+	(eq r 0))
+    0)
+   (t
+    (/ r (- (+ l r) 1))))))
+
+
+;;;
+;;; Debuging and other useful stuff.
+;;;
+
+
+
+(define (apml_print_semstruct utt)
+"(apml_print_semstruct utt)
+Pretty print APML semantic structure."
+  (let ((i (utt.relation.first utt 'SemStructure)))
+    (while (not (null i))
+	   (apml_pss_item 0 i)
+	   (apml_pss_daughters 1 (item.daughters i))
+	   (set! i (item.next i)))))
+			  
+(define (apml_pss_daughters depth list)
+  (mapcar
+   (lambda (x)
+     (apml_pss_item depth x)
+     (apml_pss_daughters (+ depth 1) (item.daughters x))
+     )
+   list))
+
+
+(define (apml_pss_item depth item)
+  (let ((c 0))
+    (while (< c depth)
+	   (format t " ")
+	   (set! c (+ c 1)))
+    (format t "%s\n" (item.name item))))
+
+
+(define (apml_print_words utt)
+"(apml_print_words utt)
+ Pretty print APML words with associated accents."
+  (mapcar
+   (lambda (x)
+     (format t "%s (" (item.name x))
+     (apml_pww_accent x)
+     (apml_pww_boundary x)
+     (apml_pww_pause x)
+     (format t ")\n"))
+   (utt.relation.items utt 'Word))
+  t)
+
+(define (apml_pww_accent item)
+  (let ((p (item.relation.parent (item.relation.parent item 'Token) 'Emphasis)))
+    (if p (apml_ppw_list (item.features p)))))
+
+(define (apml_pww_boundary item)
+  (let ((p (item.relation.parent (item.relation.parent item 'Token) 'Boundary)))
+    (if p (apml_ppw_list (item.features p)))))
+
+(define (apml_pww_pause item)
+  (let ((p (item.relation.parent (item.relation.parent item 'Token) 'Pause)))
+    (if p (apml_ppw_list (item.features p)))))
+
+(define (apml_ppw_list l)
+  (mapcar
+   (lambda (x)
+     (format t " %s" x))
+   (flatten l)))
+
+
+(define (apml_print_sylstructure utt filename)
+"(apml_print_sylstructure utt filename)
+Pretty print APML syllable structure. Filename t for stdout"
+  (let (fd)
+    (if (not (eq? filename t))
+      (set! fd (fopen filename "wb"))
+      (set! fd t))
+    (mapcar
+      (lambda (x)
+        (format fd "%s\n" (item.name x))
+      (apml_psyl fd x))
+    (utt.relation.items utt 'Word))
+    t))
+
+(define (apml_psyl fd word)
+  (mapcar
+   (lambda (x)
+     (apml_psegs fd x)
+     (if (eq (item.feat x 'stress) 1)
+	 (format fd " (1)"))
+     (if (item.relation.daughter1 x 'Intonation)
+	 (begin
+	   (let ((ie (item.relation.daughter1 x 'Intonation)))
+	     (format fd " [")
+	     (while ie
+		    (format fd "%s" (item.name ie))
+		    (set! ie (item.next ie))
+		    (if ie (format t " ")))
+	     (format fd "]"))))
+     (format fd "\n"))
+   (item.daughters (item.relation word 'SylStructure))))
+
+(define (apml_psegs fd syl)
+  (let ((segs (item.daughters syl)))
+    (format fd " ")
+    (while segs
+	   (format fd "%s" (item.name (car segs)))
+	   (if (cdr segs)
+	       (format fd "."))
+	   (set! segs (cdr segs)))))
+
+
+(define (apml_get_lr_params)
+  (let ((m 0)
+	(s 0))
+    (if (or (equal? (Parameter.get 'Int_Target_Method) Int_Targets_LR)
+	    (equal? (Parameter.get 'Int_Target_Method) Int_Targets_5_LR))
+	(begin
+	  (set! m (car (cdr (car int_lr_params))))
+	  (set! s (car (cdr (car (cdr int_lr_params))))))
+	(begin
+        (set! m apml_default_pitch_mean)
+        (set! s apml_default_pitch_standard_deviation)))
+    (list m s)))
+
+
+
+
+(define (apml_initialise)
+  "(apml_initialise)
+Set up the current voice for apml use."
+  (if (not (string-matches current-voice ".*multisyn.*")) ; nothing if multisyn
+      (cond
+       ((or (string-equal (Parameter.get 'Language) "americanenglish")
+	    (string-equal (Parameter.get 'Language) "britishenglish"))
+	(begin
+	  (format t "Initialising APML for English.\n")
+	  ;; Phrasing.
+	  (Parameter.set 'Phrase_Method 'cart_tree)
+	  (set! phrase_cart_tree apml_phrase_tree)
+	  ;; Pauses.
+	  ;;(set! duration_cart_tree apml_kal_duration_cart_tree)
+	  ;;(set! duration_ph_info apml_kal_durs)
+	  ;;(Parameter.set 'Pause_Method Apml_Pauses)
+	  ;; Lexicon.
+      ;;;; We now assume the lexicon you have already set is suitable,
+      ;;;; You probably want to ensure this is "apmlcmu" or "unilex"
+	  ;;(if (not (member_string "apmlcmu" (lex.list)))
+	  ;;  (load (path-append lexdir "apmlcmu/apmlcmulex.scm")))
+	  ;;(lex.select "apmlcmu")
+	  ;; Add other lex entries here:
+	  ;;(lex.add.entry '("minerals" nil (((m ih n) 1) ((er) 0) ((ax l z) 0))))
+	  ;;(lex.add.entry '("fibre" nil (((f ay b) 1) ((er) 0))))
+	  ;;(lex.add.entry '("dont" v (((d ow n t) 1))))
+	  ;;(lex.add.entry '("pectoris" nil (((p eh k) 2) ((t ao r) 1) ((ih s) 0))))
+	  ;;(lex.add.entry '("sideeffects" nil (((s ay d) 1) ((ax f) 0) ((eh k t s) 2))))
+	  
+	  ;; Intonation events.
+	  (set! int_accent_cart_tree apml_accent_cart)
+	  (set! int_tone_cart_tree   apml_boundary_cart)
+	  (Parameter.set 'Int_Method Intonation_Tree)
+	  ;; Intonation f0 contour.
+	  (set! f0_lr_start apml_f2b_f0_lr_start)
+	  (set! f0_lr_left apml_f2b_f0_lr_left)
+	  (set! f0_lr_mid apml_f2b_f0_lr_mid)
+	  (set! f0_lr_right apml_f2b_f0_lr_right)
+	  (set! f0_lr_end apml_f2b_f0_lr_end)
+	  (set! int_lr_params
+		(list (list 'target_f0_mean (car (apml_get_lr_params)))
+		      (list 'target_f0_std (car (cdr (apml_get_lr_params))))
+		      (list 'model_f0_mean 170)
+		      (list 'model_f0_std 40)))
+	  (Parameter.set 'Int_Target_Method Int_Targets_5_LR)
+	  nil))
+       ((string-equal (Parameter.get 'Language) "italian")
+	(begin
+	  (format t "Initialising APML for Italian.\n")
+	  ;; Phrasing.
+	  (Parameter.set 'Phrase_Method 'cart_tree)
+	  (set! phrase_cart_tree apml_phrase_tree)
+	  ;; Intonation events.
+	  (set! int_accent_cart_tree apml_accent_cart)
+	  (set! int_tone_cart_tree   apml_boundary_cart)
+	  (Parameter.set 'Int_Method Intonation_Tree)
+	  ;; Intonation f0 contour.
+	  (set! f0_lr_start apml_f2b_f0_lr_start)
+	  (set! f0_lr_mid apml_f2b_f0_lr_mid)
+	  (set! f0_lr_end apml_f2b_f0_lr_end)
+	  (set! int_lr_params
+		(list (list 'target_f0_mean (car (apml_get_lr_params)))
+		      (list 'target_f0_std (car (cdr (apml_get_lr_params))))
+		      (list 'model_f0_mean 170)
+		      (list 'model_f0_std 34)))
+	  (Parameter.set 'Int_Target_Method Int_Targets_LR)
+	  nil))
+   (t nil))))
+
+(provide 'apml)

CosyVoice-ttsfrd/resource/festival/apml_f2bf0lr.scm

@@ -0,0 +1,530 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 2002                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Rob Clark
+;;;                         Date:   July 2002
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; APML.f0 trees.
+;;
+;;
+
+(set! apml_f2b_f0_lr_start
+'(
+( Intercept                       163.9871			 )
+( pp.lisp_apml_tgtype             -3.1750		(1) )
+( p.lisp_apml_tgtype              5.0332		(1) )
+( lisp_apml_tgtype                0.0000		(1) )
+( n.lisp_apml_tgtype              17.7799		(1) )
+( nn.lisp_apml_tgtype             13.6845		(1) )
+( pp.lisp_apml_tgtype             0.0000		(2) )
+( p.lisp_apml_tgtype              0.0000		(2) )
+( lisp_apml_tgtype                0.0000		(2) )
+( n.lisp_apml_tgtype              0.0000		(2) )
+( nn.lisp_apml_tgtype             0.0000		(2) )
+( pp.lisp_apml_tgtype             0.0000		(3) )
+( p.lisp_apml_tgtype              0.0000		(3) )
+( lisp_apml_tgtype                -9.7245		(3) )
+( n.lisp_apml_tgtype              0.0000		(3) )
+( nn.lisp_apml_tgtype             -2.4009		(3) )
+( pp.lisp_apml_iecount            0.0000			 )
+( p.lisp_apml_iecount             -0.4484			 )
+( lisp_apml_iecount               0.0000			 )
+( n.lisp_apml_iecount             -2.0165			 )
+( nn.lisp_apml_iecount            0.0000			 )
+( pp.tobi_accent                  0.0000		(H*) )
+( p.tobi_accent                   11.1239		(H*) )
+( tobi_accent                     21.5164		(H*) )
+( n.tobi_accent                   -2.5990		(H*) )
+( nn.tobi_accent                  -6.5307		(H*) )
+( pp.tobi_accent                  0.0000		(L*) )
+( p.tobi_accent                   -10.0000		(L*) )
+( tobi_accent                     -5.0000		(L*) )
+( n.tobi_accent                   -10.6798		(L*) )
+( nn.tobi_accent                  -5.6561		(L*) )
+( pp.tobi_accent                  5.3577		(L*+H) )
+( p.tobi_accent                   60.0000		(L*+H) )
+( tobi_accent                     -5.0000		(L*+H) )
+( n.tobi_accent                   0.0000		(L*+H) )
+( nn.tobi_accent                  0.0000		(L*+H) )
+( pp.tobi_accent                  0.0000		(L+H*) )
+( p.tobi_accent                   11.1200		(L+H*) )
+( tobi_accent                     21.5200		(L+H*) )
+( n.tobi_accent                   -2.6000		(L+H*) )
+( nn.tobi_accent                  -6.5300		(L+H*) )
+( pp.tobi_endtone                 0.0000		(L-L%) )
+( p.tobi_endtone                  -0.6164		(L-L%) )
+( tobi_endtone                    -50		        (L-L%) )
+( n.tobi_endtone                  -10.8729		(L-L%) )
+( nn.tobi_endtone                 -7.6522		(L-L%) )
+( pp.tobi_endtone                 0.7583		(L-H%) )
+( p.tobi_endtone                  0.0000		(L-H%) )
+( tobi_endtone                    -20.0000		(L-H%) )
+( n.tobi_endtone                  -11.8935		(L-H%) )
+( nn.tobi_endtone                 -7.2012		(L-H%) )
+( pp.tobi_endtone                 0.0000		(H-L%) )
+( p.tobi_endtone                  0.0000		(H-L%) )
+( tobi_endtone                    4.0790		(H-L%) )
+( n.tobi_endtone                  -19.3463		(H-L%) )
+( nn.tobi_endtone                 -29.3615		(H-L%) )
+( pp.tobi_endtone                 0.0000		(H-H%) )
+( p.tobi_endtone                  0.0000		(H-H%) )
+( tobi_endtone                    0.0000		(H-H%) )
+( n.tobi_endtone                  0.0000		(H-H%) )
+( nn.tobi_endtone                 0.0000		(H-H%) )
+( pp.tobi_endtone                 0.0000		(L-) )
+( p.tobi_endtone                  -15.1702		(L-) )
+( tobi_endtone                    0.0000		(L-) )
+( n.tobi_endtone                  -14.5562		(L-) )
+( nn.tobi_endtone                 0.0000		(L-) )
+( pp.tobi_endtone                 -13.5046		(H-) )
+( p.tobi_endtone                  0.0000		(H-) )
+( tobi_endtone                    6.3377		(H-) )
+( n.tobi_endtone                  -6.8631		(H-) )
+( nn.tobi_endtone                 0.0000		(H-) )
+( p.tobi_accent                   60.0000		(L+H*L-H%) )
+( tobi_accent                     -60.0000		(L+H*L-H%) )
+( n.tobi_accent                   0.0000		(L+H*L-H%) )
+( pp.syl_break                    0.0000			 )
+( p.syl_break                     0.0000			 )
+( syl_break                       0.6417			 )
+( n.syl_break                     1.3532			 )
+( nn.syl_break                    1.0724			 )
+( pp.stress                       0.0000			 )
+( p.stress                        -0.6193			 )
+( stress                          2.4121			 )
+( n.stress                        0.0000			 )
+( nn.stress                       2.5478			 )
+( syl_in                          -1.4373			 )
+( syl_out                         0.4181			 )
+( ssyl_in                         0.0000			 )
+( ssyl_out                        0.6125			 )
+( asyl_in                         0.0000			 )
+( asyl_out                        0.9906			 )
+( last_accent                     0.0000			 )
+( next_accent                     -0.3700			 )
+( sub_phrases                     0.0000			 )
+( lisp_l_spread                   -60.0000			 )
+))
+
+(set! apml_f2b_f0_lr_left
+'(
+( Intercept                       162.1173			 )
+( pp.lisp_apml_tgtype             -1.5875		(1) )
+( p.lisp_apml_tgtype              4.8101		(1) )
+( lisp_apml_tgtype                12.8265		(1) )
+( n.lisp_apml_tgtype              16.3027		(1) )
+( nn.lisp_apml_tgtype             13.3225		(1) )
+( pp.lisp_apml_tgtype             0.0000		(2) )
+( p.lisp_apml_tgtype              1.7434		(2) )
+( lisp_apml_tgtype                6.7783		(2) )
+( n.lisp_apml_tgtype              0.6679		(2) )
+( nn.lisp_apml_tgtype             0.0000		(2) )
+( pp.lisp_apml_tgtype             1.6494		(3) )
+( p.lisp_apml_tgtype              1.2861		(3) )
+( lisp_apml_tgtype                -2.0724		(3) )
+( n.lisp_apml_tgtype              0.0000		(3) )
+( nn.lisp_apml_tgtype             -1.2004		(3) )
+( pp.lisp_apml_iecount            0.0000			 )
+( p.lisp_apml_iecount             -0.5857			 )
+( lisp_apml_iecount               0.0000			 )
+( n.lisp_apml_iecount             -2.3543			 )
+( nn.lisp_apml_iecount            0.0000			 )
+( pp.tobi_accent                  0.0000		(H*) )
+( p.tobi_accent                   8.5867		(H*) )
+( tobi_accent                     21.2169		(H*) )
+( n.tobi_accent                   -1.2995		(H*) )
+( nn.tobi_accent                  -6.5056		(H*) )
+( pp.tobi_accent                  0.0000		(L*) )
+( p.tobi_accent                   -7.5000		(L*) )
+( tobi_accent                     -25.0000		(L*) )
+( n.tobi_accent                   -8.3939		(L*) )
+( nn.tobi_accent                  -4.5688		(L*) )
+( pp.tobi_accent                  2.6789		(L*+H) )
+( p.tobi_accent                   45.0000		(L*+H) )
+( tobi_accent                     -17.5000		(L*+H) )
+( n.tobi_accent                   -1.3600		(L*+H) )
+( nn.tobi_accent                  0.0000		(L*+H) )
+( pp.tobi_accent                  0.0000		(L+H*) )
+( p.tobi_accent                   8.5850		(L+H*) )
+( tobi_accent                     21.2200		(L+H*) )
+( n.tobi_accent                   -1.3000		(L+H*) )
+( nn.tobi_accent                  -6.5050		(L+H*) )
+( pp.tobi_endtone                 1.8117		(L-L%) )
+( p.tobi_endtone                  -0.1681		(L-L%) )
+( tobi_endtone                    -70   		(L-L%) )
+( n.tobi_endtone                  -8.9334		(L-L%) )
+( nn.tobi_endtone                 -8.4034		(L-L%) )
+( pp.tobi_endtone                 1.2099		(L-H%) )
+( p.tobi_endtone                  1.1220		(L-H%) )
+( tobi_endtone                    -10.0000		(L-H%) )
+( n.tobi_endtone                  -5.9467		(L-H%) )
+( nn.tobi_endtone                 -6.9072		(L-H%) )
+( pp.tobi_endtone                 0.0000		(H-L%) )
+( p.tobi_endtone                  0.0000		(H-L%) )
+( tobi_endtone                    2.0395		(H-L%) )
+( n.tobi_endtone                  -12.3940		(H-L%) )
+( nn.tobi_endtone                 -24.2593		(H-L%) )
+( pp.tobi_endtone                 0.0000		(H-H%) )
+( p.tobi_endtone                  0.0000		(H-H%) )
+( tobi_endtone                    0.0000		(H-H%) )
+( n.tobi_endtone                  0.0000		(H-H%) )
+( nn.tobi_endtone                 16.1076		(H-H%) )
+( pp.tobi_endtone                 -1.8913		(L-) )
+( p.tobi_endtone                  -15.5650		(L-) )
+( tobi_endtone                    -18.3620		(L-) )
+( n.tobi_endtone                  -9.8322		(L-) )
+( nn.tobi_endtone                 -1.8182		(L-) )
+( pp.tobi_endtone                 -13.4429		(H-) )
+( p.tobi_endtone                  0.0000		(H-) )
+( tobi_endtone                    1.9053		(H-) )
+( n.tobi_endtone                  -3.4315		(H-) )
+( nn.tobi_endtone                 0.0000		(H-) )
+( p.tobi_accent                   0.0000		(L+H*L-H%) )
+( tobi_accent                     10.0000		(L+H*L-H%) )
+( n.tobi_accent                   0.0000		(L+H*L-H%) )
+( pp.syl_break                    0.3501			 )
+( p.syl_break                     -0.8121			 )
+( syl_break                       0.3209			 )
+( n.syl_break                     0.7486			 )
+( nn.syl_break                    0.8182			 )
+( pp.stress                       -0.9778			 )
+( p.stress                        -0.3096			 )
+( stress                          2.7752			 )
+( n.stress                        0.9976			 )
+( nn.stress                       2.7343			 )
+( syl_in                          -1.9845			 )
+( syl_out                         0.7142			 )
+( ssyl_in                         1.0376			 )
+( ssyl_out                        0.3062			 )
+( asyl_in                         0.0000			 )
+( asyl_out                        0.4953			 )
+( last_accent                     0.0000			 )
+( next_accent                     0.1084			 )
+( sub_phrases                     0.0000			 )
+( lisp_l_spread                   -60.0000			 )
+))
+
+(set! apml_f2b_f0_lr_mid
+'(
+( Intercept                       160.2474			 )
+( pp.lisp_apml_tgtype             0.0000		(1) )
+( p.lisp_apml_tgtype              4.5869		(1) )
+( lisp_apml_tgtype                25.6530		(1) )
+( n.lisp_apml_tgtype              14.8255		(1) )
+( nn.lisp_apml_tgtype             12.9605		(1) )
+( pp.lisp_apml_tgtype             0.0000		(2) )
+( p.lisp_apml_tgtype              3.4867		(2) )
+( lisp_apml_tgtype                13.5566		(2) )
+( n.lisp_apml_tgtype              1.3359		(2) )
+( nn.lisp_apml_tgtype             0.0000		(2) )
+( pp.lisp_apml_tgtype             3.2989		(3) )
+( p.lisp_apml_tgtype              2.5723		(3) )
+( lisp_apml_tgtype                5.5798		(3) )
+( n.lisp_apml_tgtype              0.0000		(3) )
+( nn.lisp_apml_tgtype             0.0000		(3) )
+( pp.lisp_apml_iecount            0.0000			 )
+( p.lisp_apml_iecount             -0.7231			 )
+( lisp_apml_iecount               0.0000			 )
+( n.lisp_apml_iecount             -2.6922			 )
+( nn.lisp_apml_iecount            0.0000			 )
+( pp.tobi_accent                  0.0000		(H*) )
+( p.tobi_accent                   6.0496		(H*) )
+( tobi_accent                     20.9174		(H*) )
+( n.tobi_accent                   0.0000		(H*) )
+( nn.tobi_accent                  -6.4804		(H*) )
+( pp.tobi_accent                  0.0000		(L*) )
+( p.tobi_accent                   -5.0000		(L*) )
+( tobi_accent                     -45.0000		(L*) )
+( n.tobi_accent                   -6.1079		(L*) )
+( nn.tobi_accent                  -3.4815		(L*) )
+( pp.tobi_accent                  0.0000		(L*+H) )
+( p.tobi_accent                   30.0000		(L*+H) )
+( tobi_accent                     -30.0000		(L*+H) )
+( n.tobi_accent                   -2.7200		(L*+H) )
+( nn.tobi_accent                  0.0000		(L*+H) )
+( pp.tobi_accent                  0.0000		(L+H*) )
+( p.tobi_accent                   6.0500		(L+H*) )
+( tobi_accent                     20.9200		(L+H*) )
+( n.tobi_accent                   0.0000		(L+H*) )
+( nn.tobi_accent                  -6.4800		(L+H*) )
+( pp.tobi_endtone                 3.6235		(L-L%) )
+( p.tobi_endtone                  0.2801		(L-L%) )
+( tobi_endtone                    -80   		(L-L%) )
+( n.tobi_endtone                  -6.9938		(L-L%) )
+( nn.tobi_endtone                 -9.1546		(L-L%) )
+( pp.tobi_endtone                 1.6616		(L-H%) )
+( p.tobi_endtone                  2.2441		(L-H%) )
+( tobi_endtone                    0.0000		(L-H%) )
+( n.tobi_endtone                  0.0000		(L-H%) )
+( nn.tobi_endtone                 -6.6132		(L-H%) )
+( pp.tobi_endtone                 0.0000		(H-L%) )
+( p.tobi_endtone                  0.0000		(H-L%) )
+( tobi_endtone                    0.0000		(H-L%) )
+( n.tobi_endtone                  -5.4416		(H-L%) )
+( nn.tobi_endtone                 -19.1570		(H-L%) )
+( pp.tobi_endtone                 0.0000		(H-H%) )
+( p.tobi_endtone                  0.0000		(H-H%) )
+( tobi_endtone                    0.0000		(H-H%) )
+( n.tobi_endtone                  0.0000		(H-H%) )
+( nn.tobi_endtone                 32.2151		(H-H%) )
+( pp.tobi_endtone                 -3.7825		(L-) )
+( p.tobi_endtone                  -15.9598		(L-) )
+( tobi_endtone                    -36.7241		(L-) )
+( n.tobi_endtone                  -5.1082		(L-) )
+( nn.tobi_endtone                 -3.6363		(L-) )
+( pp.tobi_endtone                 -13.3813		(H-) )
+( p.tobi_endtone                  0.0000		(H-) )
+( tobi_endtone                    -2.5270		(H-) )
+( n.tobi_endtone                  0.0000		(H-) )
+( nn.tobi_endtone                 0.0000		(H-) )
+( p.tobi_accent                   0.0000		(L+H*L-H%) )
+( tobi_accent                     40.0000		(L+H*L-H%) )
+( n.tobi_accent                   0.0000		(L+H*L-H%) )
+( pp.syl_break                    0.7003			 )
+( p.syl_break                     -1.6241			 )
+( syl_break                       0.0000			 )
+( n.syl_break                     0.1439			 )
+( nn.syl_break                    0.5640			 )
+( pp.stress                       -1.9556			 )
+( p.stress                        0.0000			 )
+( stress                          3.1383			 )
+( n.stress                        1.9952			 )
+( nn.stress                       2.9208			 )
+( syl_in                          -2.5317			 )
+( syl_out                         1.0103			 )
+( ssyl_in                         2.0751			 )
+( ssyl_out                        0.0000			 )
+( asyl_in                         0.0000			 )
+( asyl_out                        0.0000			 )
+( last_accent                     0.0000			 )
+( next_accent                     0.5869			 )
+( sub_phrases                     0.0000			 )
+( lisp_l_spread                   -60.0000			 )
+))
+
+(set! apml_f2b_f0_lr_right
+'(
+( Intercept                       162.6687			 )
+( pp.lisp_apml_tgtype             -4.0459		(1) )
+( p.lisp_apml_tgtype              3.0601		(1) )
+( lisp_apml_tgtype                27.8166		(1) )
+( n.lisp_apml_tgtype              7.4127		(1) )
+( nn.lisp_apml_tgtype             11.3458		(1) )
+( pp.lisp_apml_tgtype             -3.8091		(2) )
+( p.lisp_apml_tgtype              1.7434		(2) )
+( lisp_apml_tgtype                17.1672		(2) )
+( n.lisp_apml_tgtype              0.6679		(2) )
+( nn.lisp_apml_tgtype             0.0000		(2) )
+( pp.lisp_apml_tgtype             1.6494		(3) )
+( p.lisp_apml_tgtype              1.2861		(3) )
+( lisp_apml_tgtype                9.5674		(3) )
+( n.lisp_apml_tgtype              -3.1085		(3) )
+( nn.lisp_apml_tgtype             0.0000		(3) )
+( pp.lisp_apml_iecount            0.0000			 )
+( p.lisp_apml_iecount             -0.7829			 )
+( lisp_apml_iecount               -0.5447			 )
+( n.lisp_apml_iecount             -1.3461			 )
+( nn.lisp_apml_iecount            -0.7178			 )
+( pp.tobi_accent                  0.7904		(H*) )
+( p.tobi_accent                   3.0248		(H*) )
+( tobi_accent                     14.1116		(H*) )
+( n.tobi_accent                   0.0000		(H*) )
+( nn.tobi_accent                  -3.2402		(H*) )
+( pp.tobi_accent                  0.0000		(L*) )
+( p.tobi_accent                   -2.5000		(L*) )
+( tobi_accent                     -32.5000		(L*) )
+( n.tobi_accent                   -3.0539		(L*) )
+( nn.tobi_accent                  -1.7408		(L*) )
+( pp.tobi_accent                  0.0000		(L*+H) )
+( p.tobi_accent                   17.5000		(L*+H) )
+( tobi_accent                     -9.0000		(L*+H) )
+( n.tobi_accent                   -2.8025		(L*+H) )
+( nn.tobi_accent                  -0.5455		(L*+H) )
+( pp.tobi_accent                  0.7900		(L+H*) )
+( p.tobi_accent                   3.0250		(L+H*) )
+( tobi_accent                     14.1150		(L+H*) )
+( n.tobi_accent                   0.0000		(L+H*) )
+( nn.tobi_accent                  -3.2400		(L+H*) )
+( pp.tobi_endtone                 5.7534		(L-L%) )
+( p.tobi_endtone                  0.1401		(L-L%) )
+( tobi_endtone                    -65   		(L-L%) )
+( n.tobi_endtone                  -11.1795		(L-L%) )
+( nn.tobi_endtone                 -7.8158		(L-L%) )
+( pp.tobi_endtone                 4.4276		(L-H%) )
+( p.tobi_endtone                  1.1220		(L-H%) )
+( tobi_endtone                    20.0000		(L-H%) )
+( n.tobi_endtone                  -6.8995		(L-H%) )
+( nn.tobi_endtone                 -6.1219		(L-H%) )
+( pp.tobi_endtone                 2.4327		(H-L%) )
+( p.tobi_endtone                  0.0000		(H-L%) )
+( tobi_endtone                    -7.5781		(H-L%) )
+( n.tobi_endtone                  -2.7208		(H-L%) )
+( nn.tobi_endtone                 -14.4838		(H-L%) )
+( pp.tobi_endtone                 0.0000		(H-H%) )
+( p.tobi_endtone                  0.0000		(H-H%) )
+( tobi_endtone                    0.0000		(H-H%) )
+( n.tobi_endtone                  0.0000		(H-H%) )
+( nn.tobi_endtone                 16.1076		(H-H%) )
+( pp.tobi_endtone                 -1.8913		(L-) )
+( p.tobi_endtone                  -15.5651		(L-) )
+( tobi_endtone                    -40.2021		(L-) )
+( n.tobi_endtone                  -2.5541		(L-) )
+( nn.tobi_endtone                 -2.2224		(L-) )
+( pp.tobi_endtone                 -6.6906		(H-) )
+( p.tobi_endtone                  -3.5483		(H-) )
+( tobi_endtone                    -1.2635		(H-) )
+( n.tobi_endtone                  0.0000		(H-) )
+( nn.tobi_endtone                 0.0000		(H-) )
+( p.tobi_accent                   0.0000		(L+H*L-H%) )
+( tobi_accent                     -40.0000		(L+H*L-H%) )
+( n.tobi_accent                   0.0000		(L+H*L-H%) )
+( pp.syl_break                    0.3501			 )
+( p.syl_break                     -1.0003			 )
+( syl_break                       -1.5536			 )
+( n.syl_break                     0.0720			 )
+( nn.syl_break                    0.5989			 )
+( pp.stress                       -0.9778			 )
+( p.stress                        -0.8046			 )
+( stress                          1.2124			 )
+( n.stress                        3.9715			 )
+( nn.stress                       2.3914			 )
+( syl_in                          -2.3468			 )
+( syl_out                         0.9792			 )
+( ssyl_in                         2.0463			 )
+( ssyl_out                        0.0000			 )
+( asyl_in                         -0.1460			 )
+( asyl_out                        0.0000			 )
+( last_accent                     -1.0992			 )
+( next_accent                     0.2935			 )
+( sub_phrases                     0.0000			 )
+( lisp_l_spread                   -60.0000			 )
+))
+
+(set! apml_f2b_f0_lr_end
+'(
+( Intercept                       165.0901			 )
+( pp.lisp_apml_tgtype             -8.0918		(1) )
+( p.lisp_apml_tgtype              1.5332		(1) )
+( lisp_apml_tgtype                29.9802		(1) )
+( n.lisp_apml_tgtype              0.0000		(1) )
+( nn.lisp_apml_tgtype             9.7312		(1) )
+( pp.lisp_apml_tgtype             -7.6181		(2) )
+( p.lisp_apml_tgtype              0.0000		(2) )
+( lisp_apml_tgtype                20.7778		(2) )
+( n.lisp_apml_tgtype              0.0000		(2) )
+( nn.lisp_apml_tgtype             0.0000		(2) )
+( pp.lisp_apml_tgtype             0.0000		(3) )
+( p.lisp_apml_tgtype              0.0000		(3) )
+( lisp_apml_tgtype                13.5550		(3) )
+( n.lisp_apml_tgtype              -6.2170		(3) )
+( nn.lisp_apml_tgtype             0.0000		(3) )
+( pp.lisp_apml_iecount            0.0000			 )
+( p.lisp_apml_iecount             -0.8428			 )
+( lisp_apml_iecount               -1.0894			 )
+( n.lisp_apml_iecount             0.0000			 )
+( nn.lisp_apml_iecount            -1.4355			 )
+( pp.tobi_accent                  1.5807		(H*) )
+( p.tobi_accent                   0.0000		(H*) )
+( tobi_accent                     7.3057		(H*) )
+( n.tobi_accent                   0.0000		(H*) )
+( nn.tobi_accent                  0.0000		(H*) )
+( pp.tobi_accent                  0.0000		(L*) )
+( p.tobi_accent                   0.0000		(L*) )
+( tobi_accent                     -20.0000		(L*) )
+( n.tobi_accent                   0.0000		(L*) )
+( nn.tobi_accent                  0.0000		(L*) )
+( pp.tobi_accent                  0.0000		(L*+H) )
+( p.tobi_accent                   5.0000		(L*+H) )
+( tobi_accent                     12.0000		(L*+H) )
+( n.tobi_accent                   -2.8850		(L*+H) )
+( nn.tobi_accent                  -1.0910		(L*+H) )
+( pp.tobi_accent                  1.5800		(L+H*) )
+( p.tobi_accent                   0.0000		(L+H*) )
+( tobi_accent                     7.3100		(L+H*) )
+( n.tobi_accent                   0.0000		(L+H*) )
+( nn.tobi_accent                  0.0000		(L+H*) )
+( pp.tobi_endtone                 7.8833		(L-L%) )
+( p.tobi_endtone                  0.0000		(L-L%) )
+( tobi_endtone                    -80    		(L-L%) )
+( n.tobi_endtone                  -35   		(L-L%) )
+( nn.tobi_endtone                 -6.4769		(L-L%) )
+( pp.tobi_endtone                 7.1936		(L-H%) )
+( p.tobi_endtone                  0.0000		(L-H%) )
+( tobi_endtone                    40.0000		(L-H%) )
+( n.tobi_endtone                  -13.7990		(L-H%) )
+( nn.tobi_endtone                 -5.6305		(L-H%) )
+( pp.tobi_endtone                 4.8654		(H-L%) )
+( p.tobi_endtone                  0.0000		(H-L%) )
+( tobi_endtone                    -15.1561		(H-L%) )
+( n.tobi_endtone                  0.0000		(H-L%) )
+( nn.tobi_endtone                 -9.8107		(H-L%) )
+( pp.tobi_endtone                 0.0000		(H-H%) )
+( p.tobi_endtone                  0.0000		(H-H%) )
+( tobi_endtone                    0.0000		(H-H%) )
+( n.tobi_endtone                  0.0000		(H-H%) )
+( nn.tobi_endtone                 0.0000		(H-H%) )
+( pp.tobi_endtone                 0.0000		(L-) )
+( p.tobi_endtone                  -15.1705		(L-) )
+( tobi_endtone                    -43.6801		(L-) )
+( n.tobi_endtone                  0.0000		(L-) )
+( nn.tobi_endtone                 -0.8085		(L-) )
+( pp.tobi_endtone                 0.0000		(H-) )
+( p.tobi_endtone                  -7.0967		(H-) )
+( tobi_endtone                    0.0000		(H-) )
+( n.tobi_endtone                  0.0000		(H-) )
+( nn.tobi_endtone                 0.0000		(H-) )
+( p.tobi_accent                   0.0000		(L+H*L-H%) )
+( tobi_accent                     60.0000		(L+H*L-H%) )
+( n.tobi_accent                   -60.0000		(L+H*L-H%) )
+( pp.syl_break                    0.0000			 )
+( p.syl_break                     -0.3765			 )
+( syl_break                       -3.1072			 )
+( n.syl_break                     0.0000			 )
+( nn.syl_break                    0.6338			 )
+( pp.stress                       0.0000			 )
+( p.stress                        -1.6093			 )
+( stress                          -0.7136			 )
+( n.stress                        5.9479			 )
+( nn.stress                       1.8619			 )
+( syl_in                          -2.1619			 )
+( syl_out                         0.9481			 )
+( ssyl_in                         2.0175			 )
+( ssyl_out                        0.0000			 )
+( asyl_in                         -0.2919			 )
+( asyl_out                        0.0000			 )
+( last_accent                     -2.1984			 )
+( next_accent                     0.0000			 )
+( sub_phrases                     0.0000			 )
+( lisp_l_spread                   -60.0000			 )
+))
+

CosyVoice-ttsfrd/resource/festival/apml_kaldurtreeZ.scm

@@ -0,0 +1,996 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   A tree to predict zcore durations build from f2b
+;;;   doesn't use actual phonemes so it can have better generalizations
+;;;
+;;;   Basically copied from ked
+;;;
+
+(set! apml_kal_durs
+'(
+  (uh 0.067 0.025)
+  (hh 0.061 0.028)
+  (ao 0.138 0.046)
+  (hv 0.053 0.020)
+  (v 0.051 0.019)
+  (ih 0.058 0.023)
+  (el 0.111 0.043)
+  (ey 0.132 0.042)
+  (em 0.080 0.033)
+  (jh 0.094 0.024)
+  (w 0.054 0.023)
+  (uw 0.107 0.044)
+  (ae 0.120 0.036)
+  (en 0.117 0.056)
+  (k 0.089 0.034)
+  (y 0.048 0.025)
+  (axr 0.147 0.035)
+;  (l 0.056 0.026)
+  (l 0.066 0.026)
+  (ng 0.064 0.024)
+  (zh 0.071 0.030)
+  (z 0.079 0.034)
+  (brth 0.246 0.046)
+  (m 0.069 0.028)
+  (iy 0.097 0.041)
+  (n 0.059 0.025)
+  (ah 0.087 0.031)
+  (er 0.086 0.010)
+  (b 0.069 0.024)
+  (pau 0.200 0.1)
+  (aw 0.166 0.053)
+  (p 0.088 0.030)
+  (ch 0.115 0.025)
+  (ow 0.134 0.039)
+  (dh 0.031 0.016)
+  (nx 0.049 0.100)
+  (d 0.048 0.021)
+  (ax 0.046 0.024)
+  (h# 0.060 0.083)
+  (r 0.053 0.031)
+  (eh 0.095 0.036)
+  (ay 0.137 0.047)
+  (oy 0.183 0.050)
+  (f 0.095 0.033)
+  (sh 0.108 0.031)
+  (s 0.102 0.037)
+  (g 0.064 0.021)
+  (dx 0.031 0.016)
+  (th 0.093 0.050)
+  (aa 0.094 0.037)
+  (t 0.070 0.020)
+)
+)
+
+(set! apml_kal_duration_cart_tree
+'
+((name is pau)
+ ((emph_sil is +)
+  ((0.0 -0.5))
+  ((p.R:SylStructure.parent.parent.lisp_apml_pause = 0.2)
+   ((0.0 0.0))
+   ((p.R:SylStructure.parent.parent.lisp_apml_pause = 0.4)
+    ((0.0 2.0))
+    ((p.R:SylStructure.parent.parent.lisp_apml_pause = 0.6)
+     ((0.0 4.0))
+     ((p.R:SylStructure.parent.parent.lisp_apml_pause = 0.8)
+      ((0.0 6.0))
+      ((p.R:SylStructure.parent.parent.lisp_apml_pause = 1.0)
+       ((0.0 8.0))
+       ((p.R:SylStructure.parent.parent.lisp_apml_pause = 1.5)
+	((0.0 13.0))
+	((p.R:SylStructure.parent.parent.lisp_apml_pause = 2.0)
+	 ((0.0 18.0))
+	 ((p.R:SylStructure.parent.parent.lisp_apml_pause = 2.5)
+	  ((0.0 23.0))
+	  ((p.R:SylStructure.parent.parent.lisp_apml_pause = 3.0)
+	   ((0.0 28.0))
+	   ((p.R:SylStructure.parent.parent.pbreak is BB)
+	    ((0.0 2.0))  
+	    ((0.0 0.0)))))))))))))
+ ((R:SylStructure.parent.accented is 0)
+  ((n.ph_ctype is 0)
+   ((p.ph_vlng is 0)
+    ((R:SylStructure.parent.syl_codasize < 1.5)
+     ((p.ph_ctype is n)
+      ((ph_ctype is f)
+       ((0.559208 -0.783163))
+       ((1.05215 -0.222704)))
+      ((ph_ctype is s)
+       ((R:SylStructure.parent.syl_break is 2)
+	((0.589948 0.764459))
+	((R:SylStructure.parent.asyl_in < 0.7)
+	 ((1.06385 0.567944))
+	 ((0.691943 0.0530272))))
+       ((ph_vlng is l)
+	((pp.ph_vfront is 1)
+	 ((1.06991 0.766486))
+	 ((R:SylStructure.parent.syl_break is 1)
+	  ((0.69665 0.279248))
+	  ((0.670353 0.0567774))))
+	((p.ph_ctype is s)
+	 ((seg_onsetcoda is coda)
+	  ((0.828638 -0.038356))
+	  ((ph_ctype is f)
+	   ((0.7631 -0.545853))
+	   ((0.49329 -0.765994))))
+	 ((R:SylStructure.parent.parent.gpos is det)
+	  ((R:SylStructure.parent.last_accent < 0.3)
+	   ((R:SylStructure.parent.sub_phrases < 1)
+	    ((0.811686 0.160195))
+	    ((0.799015 0.713958)))
+	   ((0.731599 -0.215472)))
+	  ((ph_ctype is r)
+	   ((0.673487 0.092772))
+          ((R:SylStructure.parent.asyl_in < 1)
+           ((0.745273 0.00132813))
+           ((0.75457 -0.334898)))))))))
+    ((pos_in_syl < 0.5)
+     ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+      ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+       ((0.902446 -0.041618))
+       ((R:SylStructure.parent.sub_phrases < 2.3)
+        ((0.900629 0.262952))
+        ((1.18474 0.594794))))
+      ((seg_onset_stop is 0)
+       ((R:SylStructure.parent.position_type is mid)
+        ((0.512323 -0.760444))
+        ((R:SylStructure.parent.syl_out < 6.8)
+         ((pp.ph_vlng is a)
+          ((0.640575 -0.450449))
+          ((ph_ctype is f)
+           ((R:SylStructure.parent.sub_phrases < 1.3)
+            ((0.862876 -0.296956))
+            ((R:SylStructure.parent.syl_out < 2.4)
+             ((0.803215 0.0422868))
+             ((0.877856 -0.154465))))
+           ((R:SylStructure.parent.syl_out < 3.6)
+            ((R:SylStructure.parent.syl_out < 1.2)
+             ((0.567081 -0.264199))
+             ((0.598043 -0.541738)))
+            ((0.676843 -0.166623)))))
+         ((0.691678 -0.57173))))
+       ((R:SylStructure.parent.parent.gpos is cc)
+        ((1.15995 0.313289))
+        ((pp.ph_vfront is 1)
+         ((0.555993 0.0695819))
+         ((R:SylStructure.parent.asyl_in < 1.2)
+          ((R:SylStructure.parent.sub_phrases < 2.7)
+           ((0.721635 -0.367088))
+           ((0.71919 -0.194887)))
+          ((0.547052 -0.0637491)))))))
+     ((ph_ctype is s)
+      ((R:SylStructure.parent.syl_break is 0)
+       ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+        ((0.650007 -0.333421))
+        ((0.846301 -0.165383)))
+       ((0.527756 -0.516332)))
+      ((R:SylStructure.parent.syl_break is 0)
+       ((p.ph_ctype is s)
+        ((0.504414 -0.779112))
+        ((0.812498 -0.337611)))
+       ((pos_in_syl < 1.4)
+        ((0.513041 -0.745807))
+        ((p.ph_ctype is s)
+         ((0.350582 -1.04907))
+         ((0.362 -0.914974))))))))
+   ((R:SylStructure.parent.syl_break is 0)
+    ((ph_ctype is n)
+     ((R:SylStructure.parent.position_type is initial)
+      ((pos_in_syl < 1.2)
+       ((0.580485 0.172658))
+       ((0.630973 -0.101423)))
+      ((0.577937 -0.360092)))
+     ((R:SylStructure.parent.syl_out < 2.9)
+      ((R:SylStructure.parent.syl_out < 1.1)
+       ((R:SylStructure.parent.position_type is initial)
+        ((0.896092 0.764189))
+        ((R:SylStructure.parent.sub_phrases < 3.6)
+         ((ph_ctype is s)
+          ((0.877362 0.555132))
+          ((0.604511 0.369882)))
+         ((0.799982 0.666966))))
+       ((seg_onsetcoda is coda)
+        ((p.ph_vlng is a)
+         ((R:SylStructure.parent.last_accent < 0.4)
+          ((0.800736 0.240634))
+          ((0.720606 0.486176)))
+         ((1.18173 0.573811)))
+        ((0.607147 0.194468))))
+      ((ph_ctype is r)
+       ((0.88377 0.499383))
+       ((R:SylStructure.parent.last_accent < 0.5)
+        ((R:SylStructure.parent.position_type is initial)
+         ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+          ((0.62798 0.0737318))
+          ((0.787334 0.331014)))
+         ((ph_ctype is s)
+          ((0.808368 0.0929299))
+          ((0.527948 -0.0443271))))
+        ((seg_coda_fric is 0)
+         ((p.ph_vlng is a)
+          ((0.679745 0.517681))
+          ((R:SylStructure.parent.sub_phrases < 1.1)
+           ((0.759979 0.128316))
+           ((0.775233 0.361383))))
+         ((R:SylStructure.parent.last_accent < 1.3)
+          ((0.696255 0.054136))
+          ((0.632425 0.246742))))))))
+    ((pos_in_syl < 0.3)
+     ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+      ((0.847602 0.621547))
+      ((ph_ctype is s)
+       ((0.880645 0.501679))
+       ((R:SylStructure.parent.sub_phrases < 3.3)
+        ((R:SylStructure.parent.sub_phrases < 0.3)
+         ((0.901014 -0.042049))
+         ((0.657493 0.183226)))
+        ((0.680126 0.284799)))))
+     ((ph_ctype is s)
+      ((p.ph_vlng is s)
+       ((0.670033 -0.820934))
+       ((0.863306 -0.348735)))
+      ((ph_ctype is n)
+       ((R:SylStructure.parent.asyl_in < 1.2)
+        ((0.656966 -0.40092))
+        ((0.530966 -0.639366)))
+       ((seg_coda_fric is 0)
+        ((1.04153 0.364857))
+        ((pos_in_syl < 1.2)
+         ((R:SylStructure.parent.syl_out < 3.4)
+          ((0.81503 -0.00768613))
+          ((0.602665 -0.197753)))
+         ((0.601844 -0.394632)))))))))
+  ((n.ph_ctype is f)
+   ((pos_in_syl < 1.5)
+    ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+     ((pos_in_syl < 0.1)
+      ((1.63863 0.938841))
+      ((R:SylStructure.parent.position_type is initial)
+       ((0.897722 -0.0796637))
+       ((nn.ph_vheight is 0)
+        ((0.781081 0.480026))
+        ((0.779711 0.127175)))))
+     ((ph_ctype is r)
+      ((p.ph_ctype is s)
+       ((0.581329 -0.708767))
+       ((0.564366 -0.236212)))
+      ((ph_vlng is a)
+       ((p.ph_ctype is r)
+        ((0.70992 -0.273389))
+        ((R:SylStructure.parent.parent.gpos is in)
+         ((0.764696 0.0581338))
+         ((nn.ph_vheight is 0)
+          ((0.977737 0.721904))
+          ((R:SylStructure.parent.sub_phrases < 2.2)
+           ((pp.ph_vfront is 0)
+            ((0.586708 0.0161206))
+            ((0.619949 0.227372)))
+           ((0.707285 0.445569))))))
+       ((ph_ctype is n)
+        ((R:SylStructure.parent.syl_break is 1)
+         ((nn.ph_vfront is 2)
+          ((0.430295 -0.120097))
+          ((0.741371 0.219042)))
+         ((0.587492 0.321245)))
+        ((p.ph_ctype is n)
+         ((0.871586 0.134075))
+         ((p.ph_ctype is r)
+          ((0.490751 -0.466418))
+          ((R:SylStructure.parent.syl_codasize < 1.3)
+           ((R:SylStructure.parent.sub_phrases < 2.2)
+            ((p.ph_ctype is s)
+             ((0.407452 -0.425925))
+             ((0.644771 -0.542809)))
+            ((0.688772 -0.201899)))
+           ((ph_vheight is 1)
+            ((nn.ph_vheight is 0)
+             ((0.692018 0.209018))
+             ((0.751345 -0.178136)))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+             ((R:SylStructure.parent.asyl_in < 1.5)
+              ((0.599633 -0.235593))
+              ((0.60042 0.126118)))
+             ((p.ph_vlng is a)
+              ((0.7148 -0.174812))
+              ((R:SylStructure.parent.parent.gpos is content)
+               ((0.761296 -0.231509))
+               ((0.813081 -0.536405)))))))))))))
+    ((ph_ctype is n)
+     ((0.898844 0.163343))
+     ((p.ph_vlng is s)
+      ((seg_coda_fric is 0)
+       ((0.752921 -0.45528))
+       ((0.890079 -0.0998025)))
+      ((ph_ctype is f)
+       ((0.729376 -0.930547))
+       ((ph_ctype is s)
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+         ((0.745052 -0.634119))
+         ((0.521502 -0.760176)))
+        ((R:SylStructure.parent.syl_break is 1)
+         ((0.766575 -0.121355))
+         ((0.795616 -0.557509))))))))
+   ((p.ph_vlng is 0)
+    ((p.ph_ctype is r)
+     ((ph_vlng is 0)
+      ((0.733659 -0.402734))
+      ((R:SylStructure.parent.sub_phrases < 1.5)
+       ((ph_vlng is s)
+        ((0.326176 -0.988478))
+        ((n.ph_ctype is s)
+         ((0.276471 -0.802536))
+         ((0.438283 -0.900628))))
+       ((nn.ph_vheight is 0)
+        ((ph_vheight is 2)
+         ((0.521 -0.768992))
+         ((0.615436 -0.574918)))
+        ((ph_vheight is 1)
+         ((0.387376 -0.756359))
+         ((pos_in_syl < 0.3)
+          ((0.417235 -0.808937))
+          ((0.384043 -0.93315)))))))
+     ((ph_vlng is a)
+      ((ph_ctype is 0)
+       ((n.ph_ctype is s)
+        ((p.ph_ctype is f)
+         ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+          ((0.415908 -0.428493))
+          ((pos_in_syl < 0.1)
+           ((0.790441 0.0211071))
+           ((0.452465 -0.254485))))
+         ((p.ph_ctype is s)
+          ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+           ((0.582447 -0.389966))
+           ((0.757648 0.185781)))
+          ((R:SylStructure.parent.sub_phrases < 1.4)
+           ((0.628965 0.422551))
+           ((0.713613 0.145576)))))
+        ((seg_onset_stop is 0)
+         ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+          ((pp.ph_vfront is 1)
+           ((0.412363 -0.62319))
+           ((R:SylStructure.parent.syl_out < 3.6)
+            ((0.729259 -0.317324))
+            ((0.441633 -0.591051))))
+          ((R:SylStructure.parent.syl_break is 1)
+           ((R:SylStructure.parent.sub_phrases < 2.7)
+            ((0.457728 -0.405607))
+            ((0.532411 -0.313148)))
+           ((R:SylStructure.parent.last_accent < 0.3)
+            ((1.14175 0.159416))
+            ((0.616396 -0.254651)))))
+         ((R:SylStructure.parent.position_type is initial)
+          ((0.264181 -0.799896))
+          ((0.439801 -0.551309)))))
+       ((R:SylStructure.parent.position_type is final)
+        ((0.552027 -0.707084))
+        ((0.585661 -0.901874))))
+      ((ph_ctype is s)
+       ((pos_in_syl < 1.2)
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+         ((pp.ph_vfront is 1)
+          ((0.607449 0.196466))
+          ((0.599662 0.00382414)))
+         ((0.64109 -0.12859)))
+        ((pp.ph_vfront is 1)
+         ((0.720484 -0.219339))
+         ((0.688707 -0.516734))))
+       ((ph_vlng is s)
+        ((n.ph_ctype is s)
+         ((R:SylStructure.parent.parent.gpos is content)
+          ((R:SylStructure.parent.position_type is single)
+           ((0.659206 0.159445))
+           ((R:SylStructure.parent.parent.word_numsyls < 3.5)
+            ((R:SylStructure.parent.sub_phrases < 2)
+             ((0.447186 -0.419103))
+             ((0.631822 -0.0928561)))
+            ((0.451623 -0.576116))))
+          ((ph_vheight is 3)
+           ((0.578626 -0.64583))
+           ((0.56636 -0.4665))))
+         ((R:SylStructure.parent.parent.gpos is in)
+          ((0.771516 -0.217292))
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.688571 -0.304382))
+           ((R:SylStructure.parent.parent.gpos is content)
+            ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+             ((n.ph_ctype is n)
+              ((0.556085 -0.572203))
+              ((0.820173 -0.240338)))
+             ((R:SylStructure.parent.parent.word_numsyls < 2.2)
+              ((0.595398 -0.588171))
+              ((0.524737 -0.95797))))
+            ((R:SylStructure.parent.sub_phrases < 3.9)
+             ((0.371492 -0.959427))
+             ((0.440479 -0.845747)))))))
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+         ((p.ph_ctype is f)
+          ((0.524088 -0.482247))
+          ((nn.ph_vheight is 1)
+           ((0.587666 -0.632362))
+           ((ph_vlng is l)
+            ((R:SylStructure.parent.position_type is final)
+             ((0.513286 -0.713117))
+             ((0.604613 -0.924308)))
+            ((R:SylStructure.parent.syl_codasize < 2.2)
+             ((0.577997 -0.891342))
+             ((0.659804 -1.15252))))))
+         ((pp.ph_vlng is s)
+          ((ph_ctype is f)
+           ((0.813383 -0.599624))
+           ((0.984027 -0.0771909)))
+          ((p.ph_ctype is f)
+           ((R:SylStructure.parent.parent.gpos is in)
+            ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+             ((0.313572 -1.03242))
+             ((0.525854 -0.542799)))
+            ((R:SylStructure.parent.syl_out < 2.8)
+             ((0.613007 -0.423979))
+             ((0.570258 -0.766379))))
+           ((R:SylStructure.parent.syl_break is 1)
+            ((R:SylStructure.parent.parent.gpos is to)
+             ((0.364585 -0.792895))
+             ((ph_vlng is l)
+              ((0.69143 -0.276816))
+              ((0.65673 -0.523721))))
+            ((R:SylStructure.parent.syl_out < 3.6)
+             ((R:SylStructure.parent.position_type is initial)
+              ((0.682096 -0.488102))
+              ((0.406364 -0.731758)))
+             ((0.584694 -0.822229)))))))))))
+    ((n.ph_ctype is r)
+     ((R:SylStructure.parent.position_type is initial)
+      ((p.ph_vlng is a)
+       ((0.797058 1.02334))
+       ((ph_ctype is s)
+        ((1.0548 0.536277))
+        ((0.817253 0.138201))))
+      ((R:SylStructure.parent.sub_phrases < 1.1)
+       ((R:SylStructure.parent.syl_out < 3.3)
+        ((0.884574 -0.23471))
+        ((0.772063 -0.525292)))
+       ((nn.ph_vfront is 1)
+        ((1.25254 0.417485))
+        ((0.955557 -0.0781996)))))
+     ((pp.ph_vfront is 0)
+      ((ph_ctype is f)
+       ((n.ph_ctype is s)
+        ((R:SylStructure.parent.parent.gpos is content)
+         ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+          ((0.583506 -0.56941))
+          ((0.525949 -0.289362)))
+         ((0.749316 -0.0921038)))
+        ((p.ph_vlng is s)
+         ((0.734234 0.139463))
+         ((0.680119 -0.0708717))))
+       ((ph_vlng is s)
+        ((ph_vheight is 1)
+         ((0.908712 -0.618971))
+         ((0.55344 -0.840495)))
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 1.2)
+         ((pos_in_syl < 1.2)
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.838715 0.00913392))
+           ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+            ((ph_vheight is 2)
+             ((0.555513 -0.512523))
+             ((R:SylStructure.parent.position_type is initial)
+              ((0.758711 0.121704))
+              ((0.737555 -0.25637))))
+            ((R:SylStructure.parent.syl_out < 3.1)
+             ((n.ph_ctype is s)
+              ((0.611756 -0.474522))
+              ((1.05437 -0.247206)))
+             ((R:SylStructure.parent.syl_codasize < 2.2)
+              ((R:SylStructure.parent.position_type is final)
+               ((0.567761 -0.597866))
+               ((0.785599 -0.407765)))
+              ((0.575598 -0.741256))))))
+          ((ph_ctype is s)
+           ((n.ph_ctype is s)
+            ((0.661069 -1.08426))
+            ((0.783184 -0.39789)))
+           ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+            ((R:SylStructure.parent.sub_phrases < 2.6)
+             ((0.511323 -0.666011))
+             ((0.691878 -0.499492)))
+            ((ph_ctype is r)
+             ((0.482131 -0.253186))
+             ((0.852955 -0.372832))))))
+         ((0.854447 -0.0936489)))))
+      ((R:SylStructure.parent.position_type is final)
+       ((0.685939 -0.249982))
+       ((R:SylStructure.parent.syl_out < 3.2)
+        ((0.989843 0.18086))
+        ((0.686805 -0.0402908)))))))))
+ ((R:SylStructure.parent.syl_out < 2.4)
+  ((R:SylStructure.parent.syl_out < 0.2)
+   ((seg_onsetcoda is coda)
+    ((ph_ctype is s)
+     ((R:SylStructure.parent.syl_break is 4)
+      ((pp.ph_vlng is 0)
+       ((0.959737 1.63203))
+       ((1.20714 0.994933)))
+      ((n.ph_ctype is 0)
+       ((R:SylStructure.parent.syl_break is 2)
+        ((0.864809 0.214457))
+        ((0.874278 0.730381)))
+       ((pp.ph_vfront is 0)
+        ((seg_coda_fric is 0)
+         ((1.20844 -0.336221))
+         ((1.01357 0.468302)))
+        ((0.658106 -0.799121)))))
+     ((n.ph_ctype is f)
+      ((ph_ctype is f)
+       ((1.26332 0.0300613))
+       ((ph_vlng is d)
+        ((1.02719 1.1649))
+        ((ph_ctype is 0)
+         ((R:SylStructure.parent.asyl_in < 1.2)
+          ((1.14048 2.2668))
+          ((ph_vheight is 1)
+           ((1.15528 1.50375))
+           ((1.42406 2.07927))))
+         ((R:SylStructure.parent.sub_phrases < 1.1)
+          ((0.955892 1.10243))
+          ((R:SylStructure.parent.syl_break is 2)
+           ((1.32682 1.8432))
+           ((1.27582 1.59853)))))))
+      ((n.ph_ctype is 0)
+       ((ph_ctype is n)
+        ((R:SylStructure.parent.syl_break is 2)
+         ((1.45399 1.12927))
+         ((1.05543 0.442376)))
+        ((R:SylStructure.parent.syl_break is 4)
+         ((R:SylStructure.parent.position_type is final)
+          ((ph_ctype is f)
+           ((1.46434 1.76508))
+           ((0.978055 0.7486)))
+          ((1.2395 2.30826)))
+         ((ph_ctype is 0)
+          ((0.935325 1.69917))
+          ((nn.ph_vfront is 1)
+           ((1.20456 1.31128))
+           ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+            ((nn.ph_vheight is 0)
+             ((1.16907 0.212421))
+             ((0.952091 0.653094)))
+            ((p.ph_ctype is 0)
+             ((1.05502 1.25802))
+             ((0.818731 0.777568))))))))
+       ((ph_ctype is f)
+        ((p.ph_ctype is 0)
+         ((1.03918 0.163941))
+         ((0.737545 -0.167063)))
+        ((R:SylStructure.parent.position_type is final)
+         ((n.ph_ctype is n)
+          ((R:SylStructure.parent.last_accent < 0.5)
+           ((R:SylStructure.parent.sub_phrases < 2.8)
+            ((0.826207 -0.000859005))
+            ((0.871119 0.273433)))
+           ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+            ((1.17405 1.05694))
+            ((0.858394 0.244916))))
+          ((R:SylStructure.parent.syl_codasize < 2.2)
+           ((p.ph_ctype is 0)
+            ((1.14092 1.21187))
+            ((R:SylStructure.parent.syl_break is 2)
+             ((1.02653 0.59865))
+             ((0.94248 1.1634))))
+           ((seg_coda_fric is 0)
+            ((1.07441 0.292935))
+            ((1.15736 0.92574)))))
+         ((ph_vlng is s)
+          ((R:SylStructure.parent.syl_break is 2)
+           ((1.34638 1.23484))
+           ((0.951514 2.02008)))
+          ((ph_ctype is 0)
+           ((p.ph_ctype is r)
+            ((0.806106 0.697089))
+            ((R:SylStructure.parent.syl_break is 2)
+             ((1.10891 0.992197))
+             ((1.04657 1.51093))))
+           ((1.18165 0.520952)))))))))
+    ((p.ph_vlng is 0)
+     ((pos_in_syl < 0.7)
+      ((R:SylStructure.parent.position_type is final)
+       ((ph_ctype is r)
+        ((0.966357 0.185827))
+        ((ph_ctype is s)
+         ((0.647163 0.0332298))
+         ((0.692972 -0.534917))))
+       ((ph_ctype is s)
+        ((0.881521 0.575107))
+        ((p.ph_ctype is f)
+         ((0.8223 -0.111275))
+         ((R:SylStructure.parent.last_accent < 0.3)
+          ((0.969188 0.09447))
+          ((0.894438 0.381947))))))
+      ((p.ph_ctype is f)
+       ((0.479748 -0.490108))
+       ((0.813125 -0.201268))))
+     ((ph_ctype is s)
+      ((0.908566 1.20397))
+      ((R:SylStructure.parent.last_accent < 1.2)
+       ((0.88078 0.636568))
+       ((0.978087 1.07763))))))
+   ((pos_in_syl < 1.3)
+    ((R:SylStructure.parent.syl_break is 0)
+     ((pos_in_syl < 0.1)
+      ((R:SylStructure.parent.position_type is initial)
+       ((p.ph_ctype is n)
+        ((0.801651 -0.0163359))
+        ((ph_ctype is s)
+         ((n.ph_ctype is r)
+          ((0.893307 1.07253))
+          ((p.ph_vlng is 0)
+           ((0.92651 0.525806))
+           ((0.652444 0.952792))))
+         ((p.ph_vlng is 0)
+          ((seg_onsetcoda is coda)
+           ((0.820151 0.469117))
+           ((p.ph_ctype is f)
+            ((0.747972 -0.0716448))
+            ((ph_ctype is f)
+             ((0.770882 0.457137))
+             ((0.840905 0.102492)))))
+          ((R:SylStructure.parent.syl_out < 1.1)
+           ((0.667824 0.697337))
+           ((0.737967 0.375114))))))
+       ((ph_vheight is 1)
+        ((0.624353 0.410671))
+        ((R:SylStructure.parent.asyl_in < 0.8)
+         ((0.647905 -0.331055))
+         ((p.ph_ctype is s)
+          ((0.629039 -0.240616))
+          ((0.749277 -0.0191273))))))
+      ((ph_vheight is 3)
+       ((p.ph_ctype is s)
+        ((0.626922 0.556537))
+        ((0.789357 0.153892)))
+       ((seg_onsetcoda is coda)
+        ((n.ph_ctype is 0)
+         ((R:SylStructure.parent.parent.word_numsyls < 3.4)
+          ((0.744714 0.123242))
+          ((0.742039 0.295753)))
+         ((seg_coda_fric is 0)
+          ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+           ((ph_vheight is 1)
+            ((0.549715 -0.341018))
+            ((0.573641 -0.00893114)))
+           ((nn.ph_vfront is 2)
+            ((0.67099 -0.744625))
+            ((0.664438 -0.302803))))
+          ((p.ph_vlng is 0)
+           ((0.630028 0.113815))
+           ((0.632794 -0.128733)))))
+        ((ph_ctype is r)
+         ((0.367169 -0.854509))
+         ((0.94334 -0.216179))))))
+     ((n.ph_ctype is f)
+      ((ph_vlng is 0)
+       ((1.3089 0.46195))
+       ((R:SylStructure.parent.syl_codasize < 1.3)
+        ((1.07673 0.657169))
+        ((pp.ph_vlng is 0)
+         ((0.972319 1.08222))
+         ((1.00038 1.46257)))))
+      ((p.ph_vlng is l)
+       ((1.03617 0.785204))
+       ((p.ph_vlng is a)
+        ((R:SylStructure.parent.position_type is final)
+         ((1.00681 0.321168))
+         ((0.928115 0.950834)))
+        ((ph_vlng is 0)
+         ((pos_in_syl < 0.1)
+          ((R:SylStructure.parent.position_type is final)
+           ((0.863682 -0.167374))
+           ((nn.ph_vheight is 0)
+            ((p.ph_ctype is f)
+             ((0.773591 -0.00374425))
+             ((R:SylStructure.parent.syl_out < 1.1)
+              ((0.951802 0.228448))
+              ((1.02282 0.504252))))
+            ((1.09721 0.736476))))
+          ((R:SylStructure.parent.position_type is final)
+           ((1.04302 0.0590974))
+           ((0.589208 -0.431535))))
+         ((n.ph_ctype is 0)
+          ((1.27879 1.00642))
+          ((ph_vlng is s)
+           ((R:SylStructure.parent.asyl_in < 1.4)
+            ((0.935787 0.481652))
+            ((0.9887 0.749861)))
+           ((R:SylStructure.parent.syl_out < 1.1)
+            ((R:SylStructure.parent.position_type is final)
+             ((0.921307 0.0696307))
+             ((0.83675 0.552212)))
+            ((0.810076 -0.0479225))))))))))
+    ((ph_ctype is s)
+     ((n.ph_ctype is s)
+      ((0.706959 -1.0609))
+      ((p.ph_ctype is n)
+       ((0.850614 -0.59933))
+       ((n.ph_ctype is r)
+        ((0.665947 0.00698725))
+        ((n.ph_ctype is 0)
+         ((R:SylStructure.parent.position_type is initial)
+          ((0.762889 -0.0649044))
+          ((0.723956 -0.248899)))
+         ((R:SylStructure.parent.sub_phrases < 1.4)
+          ((0.632957 -0.601987))
+          ((0.889114 -0.302401)))))))
+     ((ph_ctype is f)
+      ((R:SylStructure.parent.syl_codasize < 2.2)
+       ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+        ((R:SylStructure.parent.syl_out < 1.1)
+         ((0.865267 0.164636))
+         ((0.581827 -0.0989051)))
+        ((nn.ph_vfront is 2)
+         ((0.684459 -0.316836))
+         ((0.778854 -0.0961191))))
+       ((R:SylStructure.parent.syl_out < 1.1)
+        ((p.ph_ctype is s)
+         ((0.837964 -0.429437))
+         ((0.875304 -0.0652743)))
+        ((0.611071 -0.635089))))
+      ((p.ph_ctype is r)
+       ((R:SylStructure.parent.syl_out < 1.1)
+        ((0.762012 0.0139361))
+        ((0.567983 -0.454845)))
+       ((R:SylStructure.parent.syl_codasize < 2.2)
+        ((ph_ctype is l)
+         ((1.18845 0.809091))
+         ((R:SylStructure.parent.position_type is initial)
+          ((ph_ctype is n)
+           ((0.773548 -0.277092))
+           ((1.01586 0.281001)))
+          ((p.ph_ctype is 0)
+           ((1.06831 0.699145))
+           ((0.924189 0.241873)))))
+        ((R:SylStructure.parent.syl_break is 0)
+         ((ph_ctype is n)
+          ((0.592321 -0.470784))
+          ((0.778688 -0.072112)))
+         ((n.ph_ctype is s)
+          ((1.08848 0.0733489))
+          ((1.25674 0.608371))))))))))
+  ((pos_in_syl < 0.7)
+   ((p.ph_vlng is 0)
+    ((R:SylStructure.parent.position_type is mid)
+     ((ph_ctype is 0)
+      ((ph_vheight is 2)
+       ((0.456225 -0.293282))
+       ((0.561529 -0.0816115)))
+      ((0.6537 -0.504024)))
+     ((ph_ctype is s)
+      ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+       ((1.31586 0.98395))
+       ((R:SylStructure.parent.position_type is single)
+        ((0.816869 0.634789))
+        ((R:SylStructure.parent.syl_out < 4.4)
+         ((1.05578 0.479029))
+         ((R:SylStructure.parent.asyl_in < 0.4)
+          ((1.11813 0.143214))
+          ((0.87178 0.406834))))))
+      ((n.ph_ctype is n)
+       ((R:SylStructure.parent.last_accent < 0.6)
+        ((0.838154 -0.415599))
+        ((0.924024 0.110288)))
+       ((seg_onsetcoda is coda)
+        ((nn.ph_vfront is 2)
+         ((0.670096 0.0314187))
+         ((n.ph_ctype is f)
+          ((1.00363 0.693893))
+          ((R:SylStructure.parent.syl_out < 6)
+           ((0.772363 0.215675))
+           ((0.920313 0.574068)))))
+        ((R:SylStructure.parent.position_type is final)
+         ((0.673837 -0.458142))
+         ((R:SylStructure.parent.sub_phrases < 2.8)
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.894817 0.304628))
+           ((ph_ctype is n)
+            ((0.787302 -0.23094))
+            ((R:SylStructure.parent.asyl_in < 1.2)
+             ((ph_ctype is f)
+              ((R:SylStructure.parent.last_accent < 0.5)
+               ((1.12278 0.326954))
+               ((0.802236 -0.100616)))
+              ((0.791255 -0.0919132)))
+             ((0.95233 0.219053)))))
+          ((R:SylStructure.parent.position_type is initial)
+           ((ph_ctype is f)
+            ((1.0616 0.216118))
+            ((0.703216 -0.00834086)))
+           ((ph_ctype is f)
+            ((1.22277 0.761763))
+            ((0.904811 0.332721))))))))))
+    ((ph_vheight is 0)
+     ((p.ph_vlng is s)
+      ((0.873379 0.217178))
+      ((n.ph_ctype is r)
+       ((0.723915 1.29451))
+       ((n.ph_ctype is 0)
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+         ((R:SylStructure.parent.sub_phrases < 4)
+          ((seg_coda_fric is 0)
+           ((p.ph_vlng is l)
+            ((0.849154 0.945261))
+            ((0.633261 0.687498)))
+           ((0.728546 0.403076)))
+          ((0.850962 1.00255)))
+         ((0.957999 1.09113)))
+        ((0.85771 0.209045)))))
+     ((ph_vheight is 2)
+      ((0.803401 -0.0544067))
+      ((0.681353 0.256045)))))
+   ((n.ph_ctype is f)
+    ((ph_ctype is s)
+     ((p.ph_vlng is 0)
+      ((0.479307 -0.9673))
+      ((0.700477 -0.351397)))
+     ((ph_ctype is f)
+      ((0.73467 -0.6233))
+      ((R:SylStructure.parent.syl_break is 0)
+       ((p.ph_ctype is s)
+        ((0.56282 0.266234))
+        ((p.ph_ctype is r)
+         ((0.446203 -0.302281))
+         ((R:SylStructure.parent.sub_phrases < 2.7)
+          ((ph_ctype is 0)
+           ((0.572016 -0.0102436))
+           ((0.497358 -0.274514)))
+          ((0.545477 0.0482177)))))
+       ((ph_vlng is s)
+        ((0.805269 0.888495))
+        ((ph_ctype is n)
+         ((0.869854 0.653018))
+         ((R:SylStructure.parent.sub_phrases < 2.2)
+          ((0.735031 0.0612886))
+          ((0.771859 0.346637))))))))
+    ((R:SylStructure.parent.syl_codasize < 1.4)
+     ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+      ((R:SylStructure.parent.position_type is initial)
+       ((0.743458 0.0411808))
+       ((1.13068 0.613305)))
+      ((pos_in_syl < 1.2)
+       ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+        ((1.11481 0.175467))
+        ((0.937893 -0.276407)))
+       ((0.74264 -0.550878))))
+     ((pos_in_syl < 3.4)
+      ((seg_onsetcoda is coda)
+       ((ph_ctype is r)
+        ((n.ph_ctype is s)
+         ((0.714319 -0.240328))
+         ((p.ph_ctype is 0)
+          ((0.976987 0.330352))
+          ((1.1781 -0.0816682))))
+        ((ph_ctype is l)
+         ((n.ph_ctype is 0)
+          ((1.39137 0.383533))
+          ((0.725585 -0.324515)))
+         ((ph_vheight is 3)
+          ((ph_vlng is d)
+           ((0.802626 -0.62487))
+           ((n.ph_ctype is r)
+            ((0.661091 -0.513869))
+            ((R:SylStructure.parent.position_type is initial)
+             ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+              ((0.482285 0.207874))
+              ((0.401601 -0.0204711)))
+             ((0.733755 0.397372)))))
+          ((n.ph_ctype is r)
+           ((p.ph_ctype is 0)
+            ((pos_in_syl < 1.2)
+             ((0.666325 0.271734))
+             ((nn.ph_vheight is 0)
+              ((0.642401 -0.261466))
+              ((0.783684 -0.00956571))))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+             ((0.692225 -0.381895))
+             ((0.741921 -0.0898767))))
+           ((nn.ph_vfront is 2)
+            ((ph_ctype is s)
+             ((0.697527 -1.12626))
+             ((n.ph_ctype is s)
+              ((ph_vlng is 0)
+               ((R:SylStructure.parent.sub_phrases < 2.4)
+                ((0.498719 -0.906926))
+                ((0.635342 -0.625651)))
+               ((0.45886 -0.385089)))
+              ((0.848596 -0.359702))))
+            ((p.ph_vlng is a)
+             ((p.ph_ctype is 0)
+              ((0.947278 0.216904))
+              ((0.637933 -0.394349)))
+             ((p.ph_ctype is r)
+              ((R:SylStructure.parent.syl_break is 0)
+               ((0.529903 -0.860573))
+               ((0.581378 -0.510488)))
+              ((ph_vlng is 0)
+               ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+                ((seg_onset_stop is 0)
+                 ((R:SylStructure.parent.syl_break is 0)
+                  ((p.ph_vlng is d)
+                   ((0.768363 0.0108428))
+                   ((ph_ctype is s)
+                    ((0.835756 -0.035054))
+                    ((ph_ctype is f)
+                     ((p.ph_vlng is s)
+                      ((0.602016 -0.179727))
+                      ((0.640126 -0.297341)))
+                     ((0.674628 -0.542602)))))
+                  ((ph_ctype is s)
+                   ((0.662261 -0.60496))
+                   ((0.662088 -0.432058))))
+                 ((R:SylStructure.parent.syl_out < 4.4)
+                  ((0.582448 -0.389079))
+                  ((ph_ctype is s)
+                   ((0.60413 -0.73564))
+                   ((0.567153 -0.605444)))))
+                ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+                 ((0.761115 -0.827377))
+                 ((ph_ctype is n)
+                  ((0.855183 -0.275338))
+                  ((R:SylStructure.parent.syl_break is 0)
+                   ((0.788288 -0.802801))
+                   ((R:SylStructure.parent.syl_codasize < 2.2)
+                    ((0.686134 -0.371234))
+                    ((0.840184 -0.772883)))))))
+               ((pos_in_syl < 1.2)
+                ((R:SylStructure.parent.syl_break is 0)
+                 ((n.ph_ctype is n)
+                  ((0.423592 -0.655006))
+                  ((R:SylStructure.parent.syl_out < 4.4)
+                   ((0.595269 -0.303751))
+                   ((0.478433 -0.456882))))
+                 ((0.688133 -0.133182)))
+                ((seg_onset_stop is 0)
+                 ((1.27464 0.114442))
+                 ((0.406837 -0.167545))))))))))))
+       ((ph_ctype is r)
+        ((0.462874 -0.87695))
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+         ((0.645442 -0.640572))
+         ((0.673717 -0.321322)))))
+      ((0.61008 -0.925472))))))))
+;; RMSE 0.8085 Correlation is 0.5899 Mean (abs) Error 0.6024 (0.5393)
+
+
+))
+
+(provide 'apml_kaldurtreeZ)

CosyVoice-ttsfrd/resource/festival/cart_aux.scm

@@ -0,0 +1,200 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996-2011                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Some functions for manipulating decision trees
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (cart_prune_tree_thresh tree threshold default)
+"(prune_cart_tree_thresh TREE THRESHOLD DEFAULT)
+Prune the classification tree TREE so that all tail nodes with
+a prediction probabality less than THRESHOLD and changed to return
+DEFAULT instead.  This may be used when different mistakes have actually
+different penalites hence some control of the defaults need to be
+controlled."
+  (cond
+   ((cdr tree) ;; a question
+    (list
+     (car tree)
+     (cart_prune_tree_thresh (car (cdr tree)) threshold default)
+     (cart_prune_tree_thresh (car (cdr (cdr tree))) threshold default)))
+   ((< (cart_class_probability (car tree)) threshold)
+    (list (list (list threshold default) default)))
+   (t   ;; leave asis
+    tree)))
+
+(define (cart_class_probability class)
+  "(cart_class_probability CLASS)
+Returns the probability of the best class in the cart leaf node CLASS.
+If CLASS simple has a value and now probabilities the probabilities
+it assume to be 1.0."
+  (let ((val 0.0))
+    (set! val (assoc (car (last class)) class))
+    (if val
+	(car (cdr val))
+	1.0)))
+
+(define (cart_class_prune_merge tree)
+  "(cart_class_prune_merge tree)
+Prune all sub trees which are pure.  That is they all predict the
+same class.  This can happen when some other pruning technique
+as modified a sub-tree now making it pure."
+  (let ((pure (cart_tree_pure tree)))
+    (cond
+     (pure pure)
+     ((cdr tree);; a question   
+      (list
+       (car tree)
+       (cart_class_prune_merge (car (cdr tree)))
+       (cart_class_prune_merge (car (cdr (cdr tree))))))
+     (t;; a leaf leave asis
+      tree))))
+
+(define (cart_tree_pure tree)
+  "(cart_tree_pure tree)
+Returns a probability density function if all nodes in this tree
+predict the same class and nil otherwise"
+  (cond
+   ((cdr tree) 
+    (let ((left (cart_tree_pure (car (cdr tree))))
+	  (right (cart_tree_pure (car (cdr (cdr tree))))))
+      (cond
+       ((not left) nil)
+       ((not right) nil)
+       ((equal? (car (last left)) (car (last right)))
+	left)
+       (t
+	nil))))
+   (t   ;; its a leaf, so of couse its pure
+    tree)))
+
+(define (cart_simplify_tree tree map)
+  "(cart_simplify_tree TREE)
+Simplify a CART tree by reducing probability density functions to
+simple single clasifications (no probabilities).  This removes valuable
+information from the tree but makes them smaller easier to read by humans
+and faster to read by machines.  Also the classes may be mapped by the assoc
+list in map.  The bright ones amongst you will note this could be
+better and merge 'is' operators into 'in' operators in some situations
+especially if you are ignoring actual probability distributions."
+  (cond
+   ((cdr tree)
+    (list
+     (car tree)
+     (cart_simplify_tree (car (cdr tree)) map)
+     (cart_simplify_tree (car (cdr (cdr tree))) map)))
+   (t
+    (let ((class (car (last (car tree)))))
+      (if (assoc class map)
+	  (list (cdr (assoc class map)))
+	  (list (last (car tree))))))))
+
+(define (cart_simplify_tree2 tree)
+  "(cart_simplify_tree2 TREE)
+Simplify a CART tree by reducing probability density functions to
+only non-zero probabilities."
+  (cond
+   ((cdr tree)
+    (list
+     (car tree)
+     (cart_simplify_tree2 (car (cdr tree)))
+     (cart_simplify_tree2 (car (cdr (cdr tree))))))
+   (t
+    (list
+     (cart_remove_zero_probs (car tree))))))
+
+(define (cart_remove_zero_probs pdf)
+  "(cart_remove_zero_probs pdf)
+Removes zero probability classes in pdf, last in list
+is best in class (as from cart leaf node)."
+  (cond
+   ((null (cdr pdf)) pdf)
+   ((equal? 0 (car (cdr (car pdf))))
+    (cart_remove_zero_probs (cdr pdf)))
+   (t
+    (cons 
+     (car pdf)
+     (cart_remove_zero_probs (cdr pdf))))))
+
+(define (cart_interpret_debug i tree)
+  "(cart_interpret_debug i tree)
+In comparing output between different implementations (flite vs festival)
+This prints out the details as it interprets the tree."
+  (cond
+   ((cdr tree) ;; question
+    (format t "%s %s %s\n" (car (car tree)) (upcase (cadr (car tree)))
+            (car (cddr (car tree))))
+    (set! a (item.feat i (car (car tree))))
+    (format t "%s\n" a)
+    (cond
+     ((string-equal "is" (cadr (car tree)))
+      (if (string-equal a (car (cddr (car tree))))
+          (begin
+            (format t "   YES\n")
+            (cart_interpret_debug i (car (cdr tree))))
+          (begin
+            (format t "   NO\n")
+            (cart_interpret_debug i (car (cddr tree))))))
+     ((string-equal "<" (cadr (car tree)))
+      (if (< (parse-number a) (parse-number (car (cddr (car tree)))))
+          (begin
+            (format t "   YES\n")
+            (cart_interpret_debug i (car (cdr tree))))
+          (begin
+            (format t "   NO\n")
+            (cart_interpret_debug i (car (cddr tree))))))
+     (t
+      (format t "unknown q type %l\n" (car tree)))))
+   (t ;; leaf
+    (car tree)
+    )))
+
+;;;
+;;;  Prediction tree for OLS trees
+;;;     applies OLS coefficients from appropriate leaf of tree
+;;;
+(define (ols_tree_predict i tree)
+  ;; Surprisingly simple function does the necessary work
+  (let ((p (wagon i tree)))
+    (apply
+     +
+     (cons
+      (cadr (car (car p))) ;; Intercept
+      (mapcar
+       (lambda (fp)
+         ;; get feature value and multiple by coefficent
+         (* (parse-number (item.feat i (car fp))) (cadr fp)))
+       (cdr (car p)))))))
+
+(provide 'cart_aux)
+	

CosyVoice-ttsfrd/resource/festival/clunits.scm

@@ -0,0 +1,287 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                   Carnegie Mellon University and                      ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1998-2001                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH, CARNEGIE MELLON UNIVERSITY AND THE      ;;
+;;;  CONTRIBUTORS TO THIS WORK DISCLAIM ALL WARRANTIES WITH REGARD TO     ;;
+;;;  THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY   ;;
+;;;  AND FITNESS, IN NO EVENT SHALL THE UNIVERSITY OF EDINBURGH, CARNEGIE ;;
+;;;  MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE FOR ANY SPECIAL,    ;;
+;;;  INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER          ;;
+;;;  RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN  AN ACTION   ;;
+;;;  OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF     ;;
+;;;  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Cluster Unit selection support (Black and Taylor Eurospeech '97)
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Run-time support, selection and synthesis and some debugging functions
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(require_module 'clunits)
+
+(defvar cluster_synth_pre_hooks nil)
+(defvar cluster_synth_post_hooks nil)
+
+(defvar clunits_time time)  ;; some old voices might use this
+
+(defSynthType Cluster
+    (apply_hooks cluster_synth_pre_hooks utt)
+    (Clunits_Select utt)
+    (Clunits_Get_Units utt)
+    (Clunits_Join_Units utt)
+    (apply_hooks cluster_synth_post_hooks utt)
+    utt
+)
+
+(define (Clunits_Join_Units utt)
+  "(Clunits_Join_Units utt)
+Join the preselected and gotten units into a waveform."
+  (let ((join_method (get_param 'join_method clunits_params 'simple)))
+    ;; Choice of function to put them together
+    (cond
+     ((string-equal join_method 'windowed)
+      (Clunits_Windowed_Wave utt)
+      (clunits::fix_segs_durs utt))
+     ((string-equal join_method 'smoothedjoin)
+      (Clunits_SmoothedJoin_Wave utt)
+      (clunits::fix_segs_durs utt))
+     ((string-equal join_method 'none)
+      t)
+     ((string-equal join_method 'modified_lpc)
+      (defvar UniSyn_module_hooks nil)
+      (Param.def "unisyn.window_name" "hanning")
+      (Param.def "unisyn.window_factor" 1.0)
+      (Parameter.def 'us_sigpr 'lpc)
+      (mapcar 
+       (lambda (u s)
+	 (item.set_feat s "source_end" (item.feat u "end")))
+       (utt.relation.items utt 'Unit)
+       (utt.relation.items utt 'Segment))
+      (us_unit_concat utt)
+      (if (not (member 'f0 (utt.relationnames utt)))
+	  (targets_to_f0 utt))
+      (if (utt.relation.last utt 'Segment)
+	  (set! pm_end (+ (item.feat (utt.relation.last utt 'Segment) "end")
+			  0.02))
+	  (set! pm_end 0.02))
+      (us_f0_to_pitchmarks  utt 'f0 'TargetCoef pm_end)
+      (us_mapping utt 'segment_single)
+      (us_generate_wave utt (Parameter.get 'us_sigpr)
+			'analysis_period))
+     ((string-equal join_method 'smoothed_lpc)
+;      (format t "smoothed_lpc\n")
+      (defvar UniSyn_module_hooks nil)
+      (Param.def "unisyn.window_name" "hanning")
+      (Param.def "unisyn.window_factor" 1.0)
+      (Parameter.def 'us_sigpr 'lpc)
+      (mapcar 
+       (lambda (u s)
+	 (item.set_feat s "source_end" (item.feat u "end"))
+	 (item.set_feat s "unit_duration" 
+			(- (item.feat u "seg_end") (item.feat u "seg_start")))
+	 )
+       (utt.relation.items utt 'Unit)
+       (utt.relation.items utt 'Segment))
+      (us_unit_concat utt)
+      (mapcar 
+       (lambda (u s)
+	 (item.set_feat s "num_frames" (item.feat u "num_frames")))
+       (utt.relation.items utt 'Unit)
+       (utt.relation.items utt 'Segment))
+      (if (not (member 'f0 (utt.relationnames utt)))
+	  (targets_to_f0 utt))
+      (if (utt.relation.last utt 'Segment)
+	  (set! pm_end (+ (item.feat (utt.relation.last utt 'Segment) "end")
+			  0.02))
+	  (set! pm_end 0.02))
+      (us_f0_to_pitchmarks  utt 'f0 'TargetCoef pm_end)
+      (cl_mapping utt clunits_params)
+      (us_generate_wave utt (Parameter.get 'us_sigpr)
+			'analysis_period))
+     (t
+      (Clunits_Simple_Wave utt)))
+    utt
+  )
+)
+
+(define (clunits::units_selected utt filename)
+  "(clunits::units_selected utt filename)
+Output selected unitsfile indexes for each unit in the given utterance.
+Results saved in given file name, or stdout if filename is \"-\"."
+  (let ((fd (if (string-equal filename "-")
+		t
+		(fopen filename "w")))
+	(end 0)
+	(sample_rate
+	 (cadr (assoc 'sample_rate (wave.info (utt.wave utt))))))
+    (format fd "#\n")
+    (mapcar
+     (lambda (s)
+       (let ((dur (/ (- (item.feat s "samp_end")
+		      (item.feat s "samp_start"))
+		   sample_rate))
+	     (start (/ (item.feat s "samp_start") sample_rate)))
+	 (set! end (+ end dur))
+	 (format fd "%f 125 %s ; %s %10s %f %f %f\n"
+		 end
+		 (string-before (item.name s) "_")
+		 (item.name s)
+		 (item.feat s "fileid")
+		 (item.feat s "unit_start")
+		 (item.feat s "unit_middle")
+		 (item.feat s "unit_end"))
+	 ))
+     (utt.relation.items utt 'Unit))
+    (if (not (string-equal filename "-"))
+	(fclose fd))
+    t))
+
+(define (clunits::units_segs utt filename)
+  "(clunits::units_segs utt filename)
+Svaes the unit selections (alone) for display."
+  (let ((fd (if (string-equal filename "-")
+		t
+		(fopen filename "w")))
+	(end 0)
+	(sample_rate
+	 (cadr (assoc 'sample_rate (wave.info (utt.wave utt))))))
+    (format fd "#\n")
+    (mapcar
+     (lambda (s)
+       (let ((dur (/ (- (item.feat s "samp_end")
+		      (item.feat s "samp_start"))
+		   sample_rate))
+	     (start (/ (item.feat s "samp_start") sample_rate)))
+	 (set! end (+ end dur))
+	 (format fd "%f 125 %s \n"
+		 end
+		 (string-before (item.name s) "_")
+;		 (item.name s)
+		 )
+	 ))
+     (utt.relation.items utt 'Unit))
+    (if (not (string-equal filename "-"))
+	(fclose fd))
+    t))
+
+(define (clunits::fix_segs_durs utt)
+  "(clunits::fix_segs_durs utt)
+Takes the actual unit times and places then back on the segs."
+  (let ((end 0)
+	(sample_rate
+	 (cadr (assoc 'sample_rate (wave.info (utt.wave utt))))))
+    (mapcar
+     (lambda (u s)
+       (let ((dur (/ (- (item.feat u "samp_end")
+		      (item.feat u "samp_start"))
+		   sample_rate))
+	     (seg_start (/ (- (item.feat u "samp_seg_start")
+			    (item.feat u "samp_start"))
+			 sample_rate)))
+	 (if (item.prev s)
+	     (item.set_feat (item.prev s) "end" 
+			    (+ (item.feat s "p.end") seg_start)))
+	 (set! end (+ end dur))
+	 (item.set_feat s "end" end)))
+     (utt.relation.items utt 'Unit)
+     (utt.relation.items utt 'Segment)
+     )
+    utt))
+
+(define (clunits::display utt)
+  "(clunits::display utt)
+Display utterance with emulabel.  Note this saves files in
+scratch/wav/ and scratch/lab/."
+  (let ((id "cl01"))
+    (utt.save.wave utt (format nil "scratch/wav/%s.wav" id))
+    (utt.save.segs utt (format nil "scratch/lab/%s.lab" id))
+    (system "cd scratch; emulabel ../etc/emu_lab cl01 &")
+    t))
+
+; (define (clunits::debug_resynth_units utt)
+;   "(clunits::debug_resynth_units utt)
+; Check each of the units in utt against the related label
+; files and re-synth with any given new boundaries.  Note this is 
+; will only work if the segment still overlaps with its original and
+; also note that with a rebuild of the clunits db a complete different
+; set of units may be selected for this utterance."
+;   (let ()
+;     (mapcar 
+;      (lambda (unit)
+;        (clunits::check_unit_boundaries unit))
+;      (utt.relation.items utt 'Unit))
+;     ;; This can't be done like this ... 
+;     (Clunits_Get_Units utt)  ;; get unit signal/track stuff
+;     (Clunits_Join_Units utt) ;; make a complete waveform
+;     (apply_hooks cluster_synth_post_hooks utt)
+;     utt)
+; )
+
+(define (clunits::join_parameters utt)
+  "(clunits::join_parameters utt)
+Join selected paremeters (rather than the signal), used in F0 and
+Articulatory selection."
+  (let ((params nil)
+	(num_channels 0)
+	(num_frames 0 ))
+
+    (mapcar
+     (lambda (unit)
+       (set! num_frames 
+	     (+ num_frames
+		(track.num_frames (item.feat unit "coefs"))))
+       (set! num_channels (track.num_channels (item.feat unit "coefs")))
+       (format t "coounting %d %d\n" num_frames num_channels)
+       )
+     (utt.relation.items utt 'Unit))
+    
+    (set! params (track.resize nil 0 num_channels))
+    
+    (mapcar
+     (lambda (unit)
+       (set! frames 0)
+       (format t "inserting \n")
+       (format t "%l %l %l %l %l\n"
+	       params (track.num_frames params)
+	       (item.feat unit "coefs") 0
+	       (track.num_frames (item.feat unit "coefs")))
+       (track.insert
+	params (track.num_frames params)
+	(item.feat unit "coefs") 0
+	(track.num_frames (item.feat unit "coefs")))
+       )
+     (utt.relation.items utt 'Unit))
+
+    (utt.relation.create utt "AllCoefs")
+    (set! coefs_item (utt.relation.append utt "AllCoefs"))
+    (item.set_feat coefs_item "name" "AllCoefs")
+    (item.set_feat coefs_item "AllCoefs" params)
+  
+    utt
+))
+
+
+(provide 'clunits)

CosyVoice-ttsfrd/resource/festival/cmusphinx2_phones.scm

@@ -0,0 +1,119 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                     ;;;
+;;;                     Carnegie Mellon University                      ;;;
+;;;                  and Alan W Black and Kevin Lenzo                   ;;;
+;;;                      Copyright (c) 1998-2000                        ;;;
+;;;                        All Rights Reserved.                         ;;;
+;;;                                                                     ;;;
+;;; Permission is hereby granted, free of charge, to use and distribute ;;;
+;;; this software and its documentation without restriction, including  ;;;
+;;; without limitation the rights to use, copy, modify, merge, publish, ;;;
+;;; distribute, sublicense, and/or sell copies of this work, and to     ;;;
+;;; permit persons to whom this work is furnished to do so, subject to  ;;;
+;;; the following conditions:                                           ;;;
+;;;  1. The code must retain the above copyright notice, this list of   ;;;
+;;;     conditions and the following disclaimer.                        ;;;
+;;;  2. Any modifications must be clearly marked as such.               ;;;
+;;;  3. Original authors' names are not deleted.                        ;;;
+;;;  4. The authors' names are not used to endorse or promote products  ;;;
+;;;     derived from this software without specific prior written       ;;;
+;;;     permission.                                                     ;;;
+;;;                                                                     ;;;
+;;; CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK        ;;;
+;;; DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING     ;;;
+;;; ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT  ;;;
+;;; SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE     ;;;
+;;; FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES   ;;;
+;;; WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN  ;;;
+;;; AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,         ;;;
+;;; ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF      ;;;
+;;; THIS SOFTWARE.                                                      ;;;
+;;;                                                                     ;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  A definition of the cmusphinx2 phone set used in the BU RADIO FM
+;;;  corpus, some people call this the darpa set.  This one
+;;;  has the closures removed
+;;;
+
+(defPhoneSet
+  cmusphinx2
+  ;;;  Phone Features
+  (;; vowel or consonant
+   (vc + -)  
+   ;; vowel length: short long dipthong schwa
+   (vlng s l d a 0)
+   ;; vowel height: high mid low
+   (vheight 1 2 3 0)
+   ;; vowel frontness: front mid back
+   (vfront 1 2 3 0)
+   ;; lip rounding
+   (vrnd + - 0)
+   ;; consonant type: stop fricative affricate nasal lateral approximant
+   (ctype s f a n l r 0)
+   ;; place of articulation: labial alveolar palatal labio-dental
+   ;;                         dental velar glottal
+   (cplace l a p b d v g 0)
+   ;; consonant voicing
+   (cvox + - 0)
+   )
+  ;; Phone set members
+  (
+
+   ;; Note these features were set by awb so they are wrong !!!
+
+; phone vc  vl  vh  vf  vr  ct  cp  cv
+   (AA  +   l   3   3   -   0   0   0) ;; father
+   (AE  +   s   3   1   -   0   0   0) ;; fat
+   (AH  +   s   2   2   -   0   0   0) ;; but
+   (AO  +   l   3   3   +   0   0   0) ;; lawn
+   (AW  +   d   3   2   -   0   0   0) ;; how
+   (AX  +   a   2   2   -   0   0   0) ;; about
+   (AXR +   a   2   2   -   r   a   +)
+   (AY  +   d   3   2   -   0   0   0) ;; hide
+   (B   -   0   0   0   0   s   l   +)
+   (CH  -   0   0   0   0   a   p   -)
+   (D   -   0   0   0   0   s   a   +)
+   (DH  -   0   0   0   0   f   d   +)
+   (DX  -   0   0   0   0   s   a   +)
+   (EH  +   s   2   1   -   0   0   0) ;; get
+   (ER  +   a   2   2   -   r   0   0) 
+   (EY  +   d   2   1   -   0   0   0) ;; gate
+   (F   -   0   0   0   0   f   b   -)
+   (G   -   0   0   0   0   s   v   +)
+   (HH  -   0   0   0   0   f   g   -)
+   (IH  +   s   1   1   -   0   0   0) ;; bit
+   (IY  +   l   1   1   -   0   0   0) ;; beet
+   (JH  -   0   0   0   0   a   p   +)
+   (K   -   0   0   0   0   s   v   -)
+   (L   -   0   0   0   0   l   a   +)
+   (M   -   0   0   0   0   n   l   +)
+   (N   -   0   0   0   0   n   a   +)
+   (NG  -   0   0   0   0   n   v   +)
+   (OW  +   d   2   3   +   0   0   0) ;; lone
+   (OY  +   d   2   3   +   0   0   0) ;; toy
+   (P   -   0   0   0   0   s   l   -)
+   (R   -   0   0   0   0   r   a   +)
+   (S   -   0   0   0   0   f   a   -)
+   (SH  -   0   0   0   0   f   p   -)
+   (T   -   0   0   0   0   s   a   -)
+   (TH  -   0   0   0   0   f   d   -)
+   (UH  +   s   1   3   +   0   0   0) ;; full
+   (UW  +   l   1   3   +   0   0   0) ;; fool
+   (V   -   0   0   0   0   f   b   +)
+   (W   -   0   0   0   0   r   l   +)
+   (Y   -   0   0   0   0   r   p   +)
+   (Z   -   0   0   0   0   f   a   +)
+   (ZH  -   0   0   0   0   f   p   +)
+   (SIL -   0   0   0   0   0   0   -) ; added
+  )
+)
+
+(PhoneSet.silences '(SIL))
+
+(provide 'cmusphinx2_phones)
+
+
+  
+

CosyVoice-ttsfrd/resource/festival/cslush.scm

@@ -0,0 +1,79 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Functions specific to using Festival in cslush part of the OGI toolkit
+;;;  The OGI toolkit is a complete dialog building system with speech
+;;;  recognition and synthesis (Festival) it is available for free for
+;;;  research purposes from
+;;;     http://www.cse.ogi.edu/CSLU/toolkit/toolkit.html
+;;;
+;;;  Note this cslush interface requires you to compile festival
+;;;  with tcl (7.6)
+;;;
+;;;  The functions replace the C++ level functions Jacques H. de Villiers
+;;;  <[email protected]> from CSLU wrote for the previous version
+;;;
+
+(if (not (member 'tcl *modules*))
+      (error "cslush: can't load cslush, TCL not supported in this installation of Festival."))
+
+(define (cslush.getwave utt)
+"(cslush.getwave UTT)
+Extract wave memory info, pass this to wave import in CSLUsh."
+ (format nil "%s %s %s"
+	 (utt.wave.info utt 'data_addr)
+	 (utt.wave.info utt 'num_samples)
+	 (utt.wave.info utt 'sample_rate)))
+
+(define (cslush.getphone utt)
+"(cslush.getphone UTT)
+Return segment names a single string of phones, for use to pass to
+TCL."
+  (let ((phones ""))
+    (mapcar
+     (lambda (s)
+       (if (string-equal phones "")
+	   (set! phones (format nil "%s" (utt.streamitem.feat utt s 'name)))
+	   (set! phones (format nil "%s %s" 
+				phones (utt.streamitem.feat utt s 'name)))))
+     (utt.stream utt 'Segment))
+    phones))
+
+(define (cslush TCLCOMMAND)
+"(cslush TCLCOMMAND)
+Pass TCLCOMMAND to TCL interpreter, returns what TCL returns as a
+string."
+  (tcl_eval TCLCOMMAND))
+
+
+(provide 'cslush)

CosyVoice-ttsfrd/resource/festival/cstr.scm

@@ -0,0 +1,121 @@
+
+
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;; DO NOT EDIT THIS FILE ON PAIN OF MORE PAIN.
+ ;;; 
+ ;;; The master copy of this file is in ../../speech_tools/lib/siod/cstr.scm
+ ;;; and is copied here at build time.
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+
+
+
+
+
+
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; CSTR siod extensions.
+
+;(defvar Parameter nil
+;  "Parameter
+;  An assoc-list of parameters and values for various parts of the speech
+;  synthesis system.  This is used by the functions Parameter.set 
+;  Parameter.def and Parameter.get as well as internal C++ functions.")
+
+(defvar Param (feats.make)
+  "Param
+  A feature set for arbitrary parameters for modules.")
+
+(define (Param.set name val)
+"(Param.set NAME VAL)
+  Set parameter NAME to VAL (deleting any previous setting)"
+  (feats.set Param name val))
+
+(define (Parameter.set name val)
+"(Parameter.set NAME VAL)
+  Set parameter NAME to VAL (deleting any previous setting).  This is
+  an old function and you should use Param.set instead."
+  (Param.set name val)
+  val
+  )
+
+(define (Parameter.def name val)
+"(Parameter.def NAME VAL)
+  Set parameter NAME to VAL if not already set.  This is an OLD function
+  you shold use Param.def instead."
+   (Param.def name val)
+  )
+
+(define (Param.def name val)
+"(Param.def NAME VAL)
+  Set parameter NAME to VAL if not already set"
+   (if (not (feats.present Param name))
+       (feats.set Param name val)))
+
+(define (Parameter.get name)
+"(Parameter.get NAME)
+  Get parameter NAME's value (nil if unset).  This is an OLD function
+  and may not exist in later versions (or change functionality).  This
+  function (unlike Param.get) may return sylbols (rather than strings
+  if the val doesn't contain whitespace (to allow older functions to 
+  still work."
+   (let ((val (Param.get name)))
+     (if (and (eq? 'string (typeof val))
+	      (not (string-matches val ".*[ \t\r\n].*")))
+	 (intern val)
+	 val))
+  )
+
+(define (Param.get name)
+"(Param.get NAME)
+  Get parameter NAME's value (nil if unset)"
+  (feats.get Param name))
+
+(define (get_param name params default)
+  "(get_param name params default)
+Get named parameters in params returning default if its not present."
+  (let ((pair (assoc name params)))
+    (if pair
+	(car (cdr pair))
+	default)))
+
+(provide 'cstr)

CosyVoice-ttsfrd/resource/festival/darpa_phones.scm

@@ -0,0 +1,115 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1999                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Alan W Black
+;;;                         Date:   April 1999
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  
+;;;  (yet another) darpa definition
+;;;
+
+(require 'phoneset)
+
+(set! darpa_fs (cadr
+(defPhoneSet
+  darpa
+  (Features
+   (vowel (syllabic + -)
+	  (length long short diphthong schwa)
+	  (height high mid low)
+	  (front front mid back)
+	  (round + -))
+   (consonant
+    (syllabic + -)
+    (manner stop affricate fricative approximant nasal)
+    (place alveolar dental labial palatal velar)
+    (voicing + -))
+   (silence
+    (syllabic -)))
+  (Phones
+   ;;  type syl length  height front round
+   (aa  vowel + long      low   back    -)
+   (ae  vowel + short     low   front   -)
+   (ah  vowel + short     mid   mid     -)
+   (ao  vowel + long      low   front   +)
+   (aw  vowel + diphthong low   mid     -)
+   (ax  vowel + schwa     mid   mid     -)
+   (axr vowel + schwa     mid   mid     -)
+   (ay  vowel + diphthong low   mid     -)
+   (eh  vowel + short     mid   front   -)
+   (ey  vowel + diphthong mid   front   -)
+   (ih  vowel + short     high  front   -)
+   (iy  vowel + long      high  front   -)
+   (ow  vowel + diphthong mid   back    +)
+   (oy  vowel + diphthong mid   back    +)
+   (uh  vowel + short     high  back    +)
+   (uw  vowel + long      high  back    +)
+   ;;   type     syl manner     place   voicing
+   (b   consonant -   stop      labial     +)
+   (ch  consonant - affricate   alveolar   -)
+   (d   consonant -   stop      alveolar   +)
+   (dh  consonant - fricative   dental     +)
+   (dx  consonant -   stop      alveolar   +)
+   (el  consonant + approximant alveolar   +)
+   (em  consonant +   nasal     labial     +)
+   (en  consonant +   stop      alveolar   +)
+   (er  consonant + approximant alveolar   +)
+   (f   consonant - fricative   labial     -)
+   (g   consonant -   stop      velar      +)
+   (hh  consonant - fricative   velar      -)
+   (jh  consonant - affricate   alveolar   +)
+   (k   consonant -   stop      velar      -)
+   (l   consonant - approximant alveolar   +)
+   (m   consonant -   nasal     labial     +)
+   (n   consonant -   nasal     alveolar   +)
+   (nx  consonant -   nasal     alveolar   +)
+   (ng  consonant -   nasal     velar      +)
+   (p   consonant -   stop      labial     -)
+   (r   consonant - approximant alveolar   +) 
+   (s   consonant - fricative   alveolar   -)
+   (sh  consonant - fricative   palatal    -)
+   (t   consonant -   stop      alveolar   -)
+   (th  consonant - fricative   dental     -) 
+   (v   consonant - fricative   labial     +)
+   (w   consonant - approximant velar      +)
+   (y   consonant - approximant palatal    +)
+   (z   consonant - fricative   alveolar   +)
+   (zh  consonant - fricative   palatal    +)
+   (pau silence   -)
+;   (sil silence   -)
+   ))))
+
+(provide 'darpa_phones)
+
+
+
+

CosyVoice-ttsfrd/resource/festival/dicts/cmu/COPYING

@@ -0,0 +1,35 @@
+
+This directory contains an American English Lexicon and letter to 
+sournd rules based on CMUDICT 0.4.  This distribution falls under
+the following copyright.  CMUDICT falls under a simialr free licence
+that has no commercial restrictions.
+
+                Centre for Speech Technology Research                  
+                     University of Edinburgh, UK                       
+                       Copyright (c) 1996,1997                         
+                        All Rights Reserved.                           
+                                                                       
+  Permission is hereby granted, free of charge, to use and distribute  
+  this software and its documentation without restriction, including   
+  without limitation the rights to use, copy, modify, merge, publish,  
+  distribute, sublicense, and/or sell copies of this work, and to      
+  permit persons to whom this work is furnished to do so, subject to   
+  the following conditions:                                            
+   1. The code must retain the above copyright notice, this list of    
+      conditions and the following disclaimer.                         
+   2. Any modifications must be clearly marked as such.                
+   3. Original authors' names are not deleted.                         
+   4. The authors' names are not used to endorse or promote products   
+      derived from this software without specific prior written        
+      permission.                                                      
+                                                                       
+  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        
+  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      
+  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   
+  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     
+  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   
+  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          
+  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       
+  THIS SOFTWARE.                                                       
+

CosyVoice-ttsfrd/resource/festival/dicts/cmu/allowables.scm

@@ -0,0 +1,102 @@
+(require 'lts_build)
+(set! allowables 
+      '((a _epsilon_ aa aa1 aa0
+           ax ax1 ax0
+	   eh eh1 eh0
+	   ah  ah1 ah0
+	   ae  ae1 ae0
+	   ey  ey1 ey0
+	   ay  ay1 ay0
+	   er  er1 er0
+	   y-ax0 y-ah1 y-ah0
+	   aw  aw1 aw0
+	   ao  ao1 ao0
+	   ih  ih1 ih0
+	   w-ax0 w-ah1 w-ah0
+	   ow  ow1 ow0
+	   w-ey  w-ey1 ey0
+	   iy  iy1 iy0)
+        (b _epsilon_ b p )
+        (c _epsilon_ k ch s sh t-s )
+        (d _epsilon_ d t jh)
+        (e _epsilon_ ih  ih1 ih0
+           ax ax1 ax0
+	   iy  iy1 iy0
+	   er  er1 er0
+	   ax ah1 ah0
+	   eh  eh1 eh0
+	   ey  ey1 ey0
+	   uw  uw1 uw0
+	   ay  ay1 ay0
+	   ow  ow1 ow0
+	   y-uw  y-uw1 y-uw0
+	   oy  oy1 oy0
+	   aa  aa1 aa0)
+        (f _epsilon_ f )
+        (g _epsilon_ g jh zh k f)
+        (h _epsilon_ hh )
+        (i _epsilon_ iy  iy1 iy0
+           ax ax1 ax0
+	   ih  ih1 ih0
+	   ah  ah1 ah0
+	   ax ah1 ah0
+	   ay  ay1 ay0
+	   y 
+	   aa  aa1 aa0
+	   ae  ae1 ae0
+	   w-ax0 w-ah1 w-ah0
+	   eh  eh1 eh0 
+           er er0 er1 )
+        (j _epsilon_ jh y hh zh)
+        (k _epsilon_ k )
+        (l _epsilon_ l ax-l y ax0-l)
+        (m _epsilon_ m ax-m m-ax0 ax0-m m-ax0
+	   m-ae  m-ae1 m-ae0 
+	   m-ih m-ih0 )
+        (n _epsilon_ n ng n-y)
+        (o _epsilon_ ax ax0 ah1 ah0
+	   ao  ao1 ao0
+	   ow  ow1 ow0
+	   uw  uw1 uw0
+	   er  er1 er0
+	   aa  aa1 aa0
+	   aw  aw1 aw0
+	   oy  oy1 oy0
+	   uh  uh1 uh0
+	   w 
+	   w-ax0 w-ah1 w-ah0
+	   aa  aa1 aa0
+	   ih  ih1 ih0
+	   ae  ae1 ae0)
+        (p _epsilon_ p f)
+        (q _epsilon_ k )
+        (r _epsilon_ r er1 er er0 )
+        (s _epsilon_ s sh z zh ch)
+        (t _epsilon_ t th sh ch dh d s zh)
+        (u _epsilon_ 
+	   ax ax0
+	   ah  ah1 ah0
+	   uw  uw1 uw0
+	   er  er1 er0
+	   uh  uh1 uh0
+	   y-uw  y-uw1 y-uw0
+	   ax-w ah1-w ah0-w
+	   y-er  y-er1 y-er0
+	   y-ax y-ax0 y-ah1 y-ah0
+	   w 
+	   ih  ih1 ih0
+	   ao  ao1 ao0
+	   eh  eh1 eh0
+	   y-uh  y-uh1 y-uh0 )
+        (v _epsilon_ v f)
+        (w _epsilon_ w v f)
+        (x _epsilon_ k-s g-z ng-z k-sh z g-zh zh)
+        (y _epsilon_ 
+	   iy  iy1 iy0
+	   ih  ih1 ih0
+	   ay  ay1 ay0
+	   y 
+	   ax ax0 ah1 ah0)
+        (z _epsilon_ z t-s zh s)
+        (# #)))
+

CosyVoice-ttsfrd/resource/festival/display.scm

@@ -0,0 +1,69 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Alan W Black
+;;;                         Date:   December 1996
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  An xwaves display function for utterances
+;;;
+;;;  Requires Xwaves to be running, saves labels etc and sends 
+;;;  messages to Xwaves to display the utterance.
+;;;
+;;;  This can be a model for other display functions.
+;;;
+
+(define (display utt)
+"(display utt)
+Display an utterance's waveform, F0 and segment labels in Xwaves.
+Xwaves must be running on the current machine, with a labeller for
+this to work."
+  (let ((tmpname (make_tmp_filename)))
+    (utt.save.wave utt (string-append tmpname ".wav"))
+    (utt.save.segs utt (string-append tmpname ".lab"))
+    (utt.save.f0 utt (string-append tmpname ".f0"))
+    (system (format nil "send_xwaves make file %s name %s height 150"
+		    (string-append tmpname ".f0") tmpname))
+    (system (format nil "send_xwaves make name %s file %s height 200"
+		    tmpname (string-append tmpname ".wav")))
+    (system (format nil "send_xwaves send make file %s name %s color 125"
+		    (string-append tmpname ".lab") tmpname))
+    (system (format nil "send_xwaves send activate name %s fields 1"
+		    tmpname))
+    (system (format nil "send_xwaves %s align file %s"
+		    tmpname (string-append tmpname ".wav"))))
+ )
+
+(provide 'display)
+
+
+
+

CosyVoice-ttsfrd/resource/festival/duration.scm

@@ -0,0 +1,196 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Basic Duration module which will call appropriate duration
+;;;  (C++) modules based on set parameter
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;  These modules should predict intonation events/labels
+;;;  based on information in the phrase and word streams
+
+(define (Duration utt)
+"(Duration utt)
+Predict segmental durations using Duration_Method defined in Parameters.
+Four methods are currently available: averages, Klatt rules, CART tree
+based, and fixed duration."
+  (let ((rval (apply_method 'Duration_Method utt)))
+    (cond
+     (rval rval) ;; new style
+     ;; 1.1.1 voices still use other names
+     ((eq 'Averages (Parameter.get 'Duration_Method))
+      (Duration_Averages utt))
+     ((eq 'Klatt (Parameter.get 'Duration_Method))
+      (Duration_Klatt utt))
+     ((eq 'Tree_ZScores (Parameter.get 'Duration_Method))
+      (Duration_Tree_ZScores utt))
+     ((eq 'Tree (Parameter.get 'Duration_Method))
+      (Duration_Tree utt))
+     (t
+      (Duration_Default utt)))))
+
+(define (Duration_LogZScores utt)
+"(Duration_LogZScores utt)
+Predicts duration to segments using the CART tree in duration_logzscore_tree
+and duration_logzscore_tree_silence which produces a zscore of the log
+duration.  The variable duration_logzscore_ph_info contains (log) means
+and std for each phone in the set."
+  (let ((silence (car (car (cdr (assoc 'silences (PhoneSet.description))))))
+	ldurinfo)
+    (mapcar
+     (lambda (s)
+       (if (string-equal silence (item.name s))
+	   (set! ldurinfo
+		 (wagon s duration_logzscore_tree_silence))
+	   (set! ldurinfo
+		 (wagon s duration_logzscore_tree)))
+       (set! dur (exp (duration_unzscore 
+		       (item.name s)
+		       (car (last ldurinfo))
+		       duration_logzscore_ph_info)))
+       (set! dur (* dur (duration_find_stretch s)))
+       (item.set_feat 
+	s "end" (+ dur (item.feat s "start_segment"))))
+     (utt.relation.items utt 'Segment))
+    utt))
+
+(define (duration_unzscore phname zscore table)
+"(duration_unzscore phname zscore table)
+Look up phname in table and convert xscore back to absolute domain."
+  (let ((phinfo (assoc phname table))
+	mean std)
+    (if phinfo
+	(begin
+	  (set! mean (car (cdr phinfo)))
+	  (set! std (car (cdr (cdr phinfo)))))
+	(begin
+	  (format t "Duration: unzscore no info for %s\n" phname)
+	  (set! mean 0.100)
+	  (set! std 0.25)))
+    (+ mean (* zscore std))))
+
+(define (duration_find_stretch seg)
+"(duration_find_stretch utt seg)
+Find any relavant duration stretch."
+  (let ((global (Parameter.get 'Duration_Stretch))
+	(local (item.feat
+		seg "R:SylStructure.parent.parent.R:Token.parent.dur_stretch")))
+    (if (or (not global)
+	    (equal? global 0.0))
+	(set! global 1.0))
+    (if (string-equal local 0.0)
+	(set! local 1.0))
+    (* global local)))
+
+;; These provide lisp level functions, some of which have
+;; been converted in C++ (in festival/src/modules/base/ff.cc)
+(define (onset_has_ctype seg type)
+  ;; "1" if onset contains ctype
+  (let ((syl (item.relation.parent seg 'SylStructure)))
+    (if (not syl)
+	"0" ;; a silence 
+	(let ((segs (item.relation.daughters syl 'SylStructure))
+	      (v "0"))
+	  (while (and segs 
+		      (not (string-equal 
+			    "+" 
+			    (item.feat (car segs) "ph_vc"))))
+		 (if (string-equal 
+		      type
+		      (item.feat (car segs) "ph_ctype"))
+		     (set! v "1"))
+		 (set! segs (cdr segs)))
+	  v))))
+
+(define (coda_has_ctype seg type)
+  ;; "1" if coda contains ctype
+  (let ((syl (item.relation.parent seg 'SylStructure)))
+    (if (not syl)
+	"0" ;; a silence 
+	(let ((segs (reverse (item.relation.daughters
+			      syl 'SylStructure)))
+	      (v "0"))
+	  (while (and segs 
+		      (not (string-equal 
+			    "+" 
+			    (item.feat (car segs) "ph_vc"))))
+		 (if (string-equal 
+		      type
+		      (item.feat (car segs) "ph_ctype"))
+		     (set! v "1"))
+		 (set! segs (cdr segs)))
+	  v))))
+
+(define (onset_stop seg)
+  (onset_has_ctype seg "s"))
+(define (onset_fric seg)
+  (onset_has_ctype seg "f"))
+(define (onset_nasal seg)
+  (onset_has_ctype seg "n"))
+(define (onset_glide seg)
+  (let ((l (onset_has_ctype seg "l")))
+    (if (string-equal l "0")
+	(onset_has_ctype seg "r")
+	"1")))
+(define (coda_stop seg)
+  (coda_has_ctype seg "s"))
+(define (coda_fric seg)
+  (coda_has_ctype seg "f"))
+(define (coda_nasal seg)
+  (coda_has_ctype seg "n"))
+(define (coda_glide seg)
+  (let ((l (coda_has_ctype seg "l")))
+    (if (string-equal l "0")
+	(coda_has_ctype seg "r")
+	"1")))
+
+(define (Unisyn_Duration utt)
+  "(UniSyn_Duration utt)
+predicts Segment durations is some speficied way but holds the
+result in a way necessary for other Unisyn code."
+  (let ((end 0))
+    (mapcar
+     (lambda (s)
+       (item.get_utt s)
+       (let ((dur (wagon_predict s duration_cart_tree)))
+	 (set! dur (* (Parameter.get 'Duration_Stretch) dur))
+	 (set! end (+ dur end))
+	 (item.set_feat s "target_dur" dur)
+	 (item.set_function s "start" "unisyn_start")
+	 (item.set_feat s "end" end)
+	 (item.set_feat s "dur" dur)
+	 ))
+     (utt.relation.items utt 'Segment))
+    utt))
+
+(provide 'duration)

CosyVoice-ttsfrd/resource/festival/email-mode.scm

@@ -0,0 +1,89 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  An example tts text mode for reading email messages, this includes
+;;;  support for extracting the interesting headers from the message
+;;;  and for dealing with quoted text.  Its all very primitive and
+;;;  will easily be confused but its here just as an example
+;;;
+
+(define (email_init_func)
+ "(email_init_func)
+Called on starting email text mode."
+ (voice_rab_diphone)
+ (set! email_previous_t2w_func token_to_words)
+ (set! english_token_to_words email_token_to_words)
+ (set! token_to_words english_token_to_words)
+ (set! email_in_quote nil))
+
+(define (email_exit_func)
+ "(email_exit_func)
+Called on exit email text mode."
+ (set! english_token_to_words email_previous_t2w_func)
+ (set! token_to_words english_token_to_words))
+
+(define (email_token_to_words token name)
+  "(email_token_to_words utt token name)
+Email spcific token to word rules."
+  (cond
+   ((string-matches name "<.*@.*>")
+     (append
+      (email_previous_t2w_func token
+       (string-after (string-before name "@") "<"))
+      (cons 
+       "at"
+       (email_previous_t2w_func token
+	(string-before (string-after name "@") ">")))))
+   ((and (string-matches name ">")
+         (string-matches (item.feat token "whitespace") 
+			 "[ \t\n]*\n *"))
+    (voice_cmu_us_awb_cg)
+    nil ;; return nothing to say
+   )
+   (t  ;; for all other cases
+     (if (string-matches (item.feat token "whitespace") 
+			 ".*\n[ \n]*")
+	 (voice_rab_diphone))
+     (email_previous_t2w_func token name))))
+
+(set! tts_text_modes
+   (cons
+    (list
+      'email   ;; mode name
+      (list         ;; email mode params
+       (list 'init_func email_init_func)
+       (list 'exit_func email_exit_func)
+       '(filter "email_filter")))
+    tts_text_modes))
+
+(provide 'email-mode)

CosyVoice-ttsfrd/resource/festival/engmorph.scm

@@ -0,0 +1,151 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1997                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Alan W Black
+;;;                         Date:   December 1997
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  
+;;;   THIS IS EXPERIMENTAL AND DOES *NOT* WORK
+;;;
+;;;  Koskenniemi-style context rewrite rules for English Morphographemics
+;;;  Basically splits words into their (potential) morphemes.
+;;;
+;;;  Based (roughly) on the rules in "Computational Morphology"
+;;;  Ritchie et al. MIT Press 1992.
+;;;
+;;;  This is not a Scheme file and can't be loaded and evaluated
+;;;  It is designed for use with the wfst tools in the speech tools
+;;;  e.g. wfst_build -type kk -o engmorph.wfst -detmin engmorph.scm
+;;;
+
+(KKrules
+ engmorph
+ (Alphabets
+  ;; Input Alphabet
+  (a b c d e f g h i j k l m n o p q r s t u v w x y z #) 
+  ;; Output Alphabet
+  (a b c d e f g h i j k l m n o p q r s t u v w x y z + #) 
+ )
+ (Sets
+  (LET a b c d e f g h i j k l m n o p q r s t u v w x y z)
+ )
+ (Rules
+ ;; The basic rules
+ ( a => nil --- nil) 
+ ( b => nil --- nil) 
+ ( c => nil --- nil) 
+ ( d => nil --- nil) 
+ ( e => nil --- nil) 
+ ( f => nil --- nil) 
+ ( g => nil --- nil) 
+ ( h => nil --- nil) 
+ ( i => nil --- nil) 
+ ( j => nil --- nil) 
+ ( k => nil --- nil) 
+ ( l => nil --- nil) 
+ ( m => nil --- nil) 
+ ( n => nil --- nil) 
+ ( o => nil --- nil) 
+ ( p => nil --- nil) 
+ ( q => nil --- nil) 
+ ( r => nil --- nil) 
+ ( s => nil --- nil) 
+ ( t => nil --- nil) 
+ ( u => nil --- nil) 
+ ( v => nil --- nil) 
+ ( w => nil --- nil) 
+ ( x => nil --- nil) 
+ ( y => nil --- nil) 
+ ( z => nil --- nil) 
+ ( # => nil --- nil)
+; ( _epsilon_/+ => (or LET _epsilon_/e ) --- (LET))
+ ( _epsilon_/+ => (or LET _epsilon_/e) --- nil)
+
+ ;; The rules that do interesting things
+ 
+ ;; Epenthesis
+ ;;   churches -> church+s
+ ;;   boxes -> box+s
+ (e/+ <=> (or (s h) (or s x z) (i/y) (c h))
+	    ---
+	    (s))
+ ;; Gemination
+ (b/+ <=> ( (or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) b )
+	   ---
+	   ((or a e i o u)))
+ (d/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) d )
+          ---
+	  ((or a e i o u)))
+ (f/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) f )
+          ---
+	  ((or a e i o u)))
+ (g/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) g )
+          ---
+	  ((or a e i o u)))
+ (m/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) m )
+          ---
+	  ((or a e i o u)))
+ (p/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) p )
+          ---
+	  ((or a e i o u)))
+ (s/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) s )
+          ---
+	  ((or a e i o u)))
+ (t/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) t )
+          ---
+	  ((or a e i o u)))
+ (z/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) z )
+          ---
+	  ((or a e i o u)))
+ (n/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) n )
+          ---
+	  ((or a e i o u)))
+ (l/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) l )
+          ---
+	  ((or a e i o u)))
+ (r/+ <=> ((or b c d f g h j k l m n p q r s t v w z) (or a e i o u y) r )
+          ---
+	  ((or a e i o u)))
+ ;; tries->try+s
+ ( i/y <=>  ((or b c d f g h j k l m n p q r s t v w x z))
+            ---
+	    ((or ( e/+ s )
+		 ( _epsilon_/+ (or a d e f h i l m n o p s w y)))))
+ ;; Elision
+ ;;   moved -> move+ed
+ (_epsilon_/e <=> 
+	      ((or a e i o u ) (or b c d f g j k l m n p q r s t v x z))
+	      ---
+	      ( _epsilon_/+ (or a e i o u )))
+
+ )
+)

CosyVoice-ttsfrd/resource/festival/engmorphsyn.scm

@@ -0,0 +1,170 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1997                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                         Author: Alan W Black
+;;;                         Date:   December 1997
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  
+;;;   THIS IS EXPERIMENTAL AND DOES *NOT* WORK
+;;;
+;;;  
+;;;  An English morpho-syntax finite-state grammar
+;;;  This is used for morphological decomposition of unknown words
+;;;  specifically (only) words that are not found in the lexicon.
+;;;  This idea is that when an unknown word is found an attempt is made
+;;;  to see if it contains any well known morphological inflections or
+;;;  derivations, if so a better use of LTS can be made on the root, of
+;;;  none are found this
+;;;
+;;;
+;;;  Based on "Analysis of Unknown Words through Morphological 
+;;;  Decomposition", Black, van de Plassche, Willians, European ACL 91.
+;;;  with the anyword matcher from a question by Lauri Karttunen after
+;;;  the talk.
+;;;
+;;;  The suffixes and finite-state morph-syntax grammar is based 
+;;;  (very roughly) on the rules in "Computational Morphology"
+;;;  Ritchie et al. MIT Press 1992.
+;;;
+;;;  Can be compiled with
+;;;   wfst_build -type rg -o engmorphsyn.wfst -detmin engmorphsyn.scm
+;;;
+;;;  The result can be combined with the morphographemic rules 
+;;;  with
+;;;   	wfst_build -type compose engmorph.wfst engmorphsyn.wfst -detmin -o engstemmer.wfst
+;;;
+;;;  echo "# b o x e/+ s #" | wfst_run -wfst engstemmer.wfst -recog
+;;;  state 0 #/# -> 1
+;;;  state 1 b/b -> 3
+;;;  state 3 o/o -> 17
+;;;  state 17 x/x -> 14
+;;;  state 14 e/+ -> 36
+;;;  state 36 s/s -> 34
+;;;  state 34 #/# -> 16
+;;;  OK.
+;;;  echo "# b o x e s #" | wfst_run -wfst engstemmer.wfst -recog
+;;;  state 0 #/# -> 1
+;;;  state 1 b/b -> 3
+;;;  state 3 o/o -> 17
+;;;  state 17 x/x -> 14
+;;;  state 14 e/e -> 22
+;;;  state 22 s/s -> -1
+
+(RegularGrammar
+ engsuffixmorphosyntax
+ ;; Sets 
+ (
+ (V a e i o u y)
+ (C b c d f g h j k l m n p q r s t v w x y z)
+ )
+ ;; Rules
+
+ (
+ ;; A word *must* have a suffix to be recognized
+ (Word -> # Syls Suffix )
+ (Word -> # Syls End )
+
+ ;; This matches any string of characters that contains at least one vowel
+ (Syls -> Syl Syls )
+ (Syls -> Syl )
+ (Syl -> Cs V Cs )
+ (Cs -> C Cs )
+ (Cs -> )
+
+ (Suffix -> VerbSuffix )
+ (Suffix -> NounSuffix )
+ (Suffix -> AdjSuffix )
+ (VerbSuffix -> VerbFinal End )
+ (VerbSuffix -> VerbtoNoun NounSuffix )
+ (VerbSuffix -> VerbtoNoun End )
+ (VerbSuffix -> VerbtoAdj  AdjSuffix )
+ (VerbSuffix -> VerbtoAdj End )
+ (NounSuffix -> NounFinal End )
+ (NounSuffix -> NountoNoun NounSuffix )
+ (NounSuffix -> NountoNoun End )
+ (NounSuffix -> NountoAdj AdjSuffix )
+ (NounSuffix -> NountoAdj End )
+ (NounSuffix -> NountoVerb VerbSuffix )
+ (NounSuffix -> NountoVerb End )
+ (AdjSuffix -> AdjFinal End )
+ (AdjSuffix -> AdjtoAdj AdjSuffix)
+ (AdjSuffix -> AdjtoAdj End)
+ (AdjSuffix -> AdjtoAdv End)  ;; isn't any Adv to anything
+
+ (End -> # )  ;; word boundary symbol *always* present
+
+ (VerbFinal -> + e d)
+ (VerbFinal -> + i n g)
+ (VerbFinal -> + s)
+
+ (VerbtoNoun -> + e r)
+ (VerbtoNoun -> + e s s)
+ (VerbtoNoun -> + a t i o n)
+ (VerbtoNoun -> + i n g)
+ (VerbtoNoun -> + m e n t)
+
+ (VerbtoAdj -> + a b l e)
+
+ (NounFinal -> + s)
+
+ (NountoNoun -> + i s m)
+ (NountoNoun -> + i s t)
+ (NountoNoun -> + s h i p)
+
+ (NountoAdj -> + l i k e)
+ (NountoAdj -> + l e s s)
+ (NountoAdj -> + i s h)
+ (NountoAdj -> + o u s)
+
+ (NountoVerb -> + i f y)
+ (NountoVerb -> + i s e)
+ (NountoVerb -> + i z e)
+
+ (AdjFinal -> + e r)
+ (AdjFinal -> + e s t)
+
+ (AdjtoAdj -> + i s h)
+ (AdjtoAdv -> + l y)
+ (AdjtoNoun -> + n e s s)
+ (AdjtoVerb -> + i s e)
+ (AdjtoVerb -> + i z e)
+
+)
+)
+
+
+
+
+
+
+
+

CosyVoice-ttsfrd/resource/festival/f2bdurtreeZ.scm

@@ -0,0 +1,869 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1996                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   First attempt at a tree to learn durations.  Although
+;;;   it was trained from F2B and the radio phone set should
+;;;   work for others that are decalred with the same phone
+;;;   features
+;;;
+
+;; in ancient items (not on independent data)
+;; RMSE 0.821086 Correlation is 0.573693 Mean (abs) Error 0.612327 (0.547034)
+
+;; on independent test data
+;; RMSE 0.8054 Correlation is 0.5327 Mean (abs) Error 0.6073 (0.5290)
+
+(set! f2b_duration_cart_tree
+'
+((name is #)
+ ((emph_sil is +)
+  ((0.0 -0.5))
+  ((R:Segment.p.R:SylStructure.parent.parent.pbreak is BB)
+   ((0.0 2.0))  
+   ((0.0 0.0))))
+((R:SylStructure.parent.accented is 0)
+ ((R:Segment.p.ph_ctype is 0)
+  ((R:Segment.n.ph_cplace is 0)
+   ((ph_ctype is n)
+    ((R:SylStructure.parent.position_type is initial)
+     ((ph_cplace is a)
+      ((0.675606 -0.068741))
+      ((0.674321 0.204279)))
+     ((ph_cplace is l)
+      ((0.688993 -0.124997))
+      ((R:SylStructure.parent.syl_out < 10)
+       ((0.610881 -0.394451))
+       ((0.664504 -0.603196)))))
+    ((ph_ctype is r)
+     ((lisp_onset_glide is 0)
+      ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+       ((0.949991 0.619256))
+       ((1.05066 0.979668)))
+      ((0.858728 0.457972)))
+     ((R:SylStructure.parent.position_type is single)
+      ((syl_initial is 0)
+       ((ph_ctype is s)
+        ((0.692981 -0.788933))
+        ((0.834878 -0.116988)))
+       ((R:SylStructure.parent.syl_out < 9.4)
+        ((0.777932 0.357818))
+        ((0.852909 0.115478))))
+      ((R:Segment.n.ph_vrnd is +)
+       ((ph_ctype is s)
+        ((0.81305 0.87399))
+        ((0.65978 0.418928)))
+       ((R:SylStructure.parent.position_type is final)
+        ((R:SylStructure.parent.parent.word_numsyls < 2.3)
+         ((0.71613 -0.2888))
+         ((0.642029 0.0624649)))
+        ((R:Segment.nn.ph_cplace is a)
+         ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+          ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+           ((R:SylStructure.parent.position_type is initial)
+            ((0.854092 0.384456))
+            ((0.769274 0.10705)))
+           ((lisp_coda_stop is 0)
+            ((0.571763 0.0755348))
+            ((0.632928 -0.11117))))
+          ((lisp_coda_stop is 0)
+           ((R:SylStructure.parent.syl_out < 8.6)
+            ((0.555092 0.30006))
+            ((0.552673 -0.0263481)))
+           ((0.903186 0.519185))))
+         ((R:Segment.nn.ph_cplace is p)
+          ((0.563915 0.204967))
+          ((R:Segment.nn.ph_cvox is -)
+           ((ph_ctype is s)
+            ((0.67653 0.227681))
+            ((0.550623 0.435079)))
+           ((R:SylStructure.parent.position_type is initial)
+            ((0.93428 0.732003))
+            ((0.84114 0.423214)))))))))))
+   ((R:Segment.n.ph_ctype is s)
+    ((ph_ctype is s)
+     ((0.693376 -1.02719))
+     ((R:Segment.n.ph_cplace is v)
+      ((ph_ctype is r)
+       ((0.539799 -0.344524))
+       ((0.858576 0.154275)))
+      ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 1.2)
+       ((lisp_onset_glide is 0)
+        ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+         ((ph_ctype is n)
+          ((R:Segment.nn.ph_cplace is a)
+           ((0.64604 -0.643797))
+           ((0.739746 -0.450649)))
+          ((ph_ctype is f)
+           ((0.657043 -0.462107))
+           ((0.798438 -0.19569))))
+         ((R:SylStructure.parent.syl_out < 8.4)
+          ((lisp_coda_stop is 0)
+           ((0.766789 -0.0484781))
+           ((0.717203 -0.322113)))
+          ((R:SylStructure.parent.position_type is single)
+           ((0.508168 -0.412874))
+           ((0.703458 -0.291121)))))
+        ((0.574827 -0.65022)))
+       ((0.801765 -0.120813)))))
+    ((ph_ctype is n)
+     ((R:Segment.n.ph_ctype is f)
+      ((R:Segment.n.ph_cplace is b)
+       ((0.797652 0.623764))
+       ((R:Segment.n.ph_cplace is a)
+        ((R:Segment.n.seg_onsetcoda is coda)
+         ((0.675567 0.288251))
+         ((0.854197 0.626272)))
+        ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+         ((0.660394 -0.225466))
+         ((0.65275 0.0487195)))))
+      ((R:Segment.n.ph_ctype is n)
+       ((0.685613 -0.512227))
+       ((0.736366 -0.104066))))
+     ((R:Segment.n.ph_ctype is r)
+      ((R:SylStructure.parent.position_type is initial)
+       ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.1)
+        ((0.98185 0.152471))
+        ((0.851907 0.788208)))
+       ((ph_ctype is f)
+        ((0.76106 0.406474))
+        ((R:Segment.n.ph_cplace is a)
+         ((1.01348 -0.0422549))
+         ((0.786777 -0.714839)))))
+      ((ph_cplace is b)
+       ((R:SylStructure.parent.syl_out < 10.4)
+        ((0.799025 0.0992277))
+        ((0.851068 -0.115896)))
+       ((R:Segment.n.ph_cplace is p)
+        ((0.669855 -0.655488))
+        ((ph_ctype is r)
+         ((R:Segment.n.ph_cplace is a)
+          ((1.00772 0.130892))
+          ((0.635981 -0.35826)))
+         ((R:Segment.n.ph_ctype is l)
+          ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+           ((0.746089 -0.286007))
+           ((0.89158 0.154432)))
+          ((R:Segment.n.ph_cplace is b)
+           ((1.04971 -0.0449782))
+           ((R:SylStructure.parent.syl_out < 9.8)
+            ((R:Segment.n.ph_ctype is f)
+             ((R:Segment.n.seg_onsetcoda is coda)
+              ((1.4144 0.143658))
+              ((0.781116 -0.281483)))
+             ((ph_vlng is 0)
+              ((0.755959 -0.33462))
+              ((0.81024 -0.615287))))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+             ((0.7426 -0.24342))
+             ((R:Segment.n.ph_ctype is f)
+              ((R:Segment.n.ph_cplace is a)
+               ((R:SylStructure.parent.position_type is single)
+                ((0.578639 -0.322097))
+                ((0.55826 -0.663238)))
+               ((0.616575 -0.713688)))
+              ((0.759572 -0.314116))))))))))))))
+  ((R:Segment.n.ph_ctype is f)
+   ((ph_ctype is 0)
+    ((R:Segment.p.ph_ctype is r)
+     ((R:SylStructure.parent.parent.word_numsyls < 2.2)
+      ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+       ((0.733193 -0.180968))
+       ((0.563111 -0.467934)))
+      ((0.426244 -0.758137)))
+     ((ph_vlng is a)
+      ((R:Segment.n.ph_cplace is b)
+       ((R:Segment.nn.ph_cvox is +)
+        ((0.680234 0.059855))
+        ((R:SylStructure.parent.position_type is single)
+         ((0.980851 0.443893))
+         ((0.715307 0.112865))))
+       ((R:Segment.p.ph_cplace is a)
+        ((0.851224 0.695863))
+        ((R:Segment.nn.ph_cvox is -)
+         ((0.75892 0.195772))
+         ((0.630633 0.478738)))))
+      ((R:Segment.n.seg_onsetcoda is coda)
+       ((R:Segment.n.ph_cplace is b)
+        ((R:Segment.nn.ph_cplace is 0)
+         ((0.815979 -0.477579))
+         ((0.851491 -0.168622)))
+        ((R:SylStructure.parent.position_type is single)
+         ((R:Segment.nn.ph_cvox is +)
+          ((1.14265 0.717697))
+          ((0.814726 0.291482)))
+         ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+          ((0.512322 -0.0749096))
+          ((0.488216 0.112774)))))
+       ((R:SylStructure.parent.position_type is final)
+        ((0.693071 -0.200708))
+        ((R:Segment.p.ph_cvox is +)
+         ((0.489147 -0.378728))
+         ((0.695396 -0.525028)))))))
+    ((ph_vlng is s)
+     ((0.464234 -0.162706))
+     ((R:Segment.p.ph_cvox is +)
+      ((R:SylStructure.parent.parent.word_numsyls < 2.2)
+       ((0.566845 -0.616918))
+       ((0.92747 -0.26777)))
+      ((0.632833 -0.858295)))))
+   ((R:Segment.n.ph_vrnd is 0)
+    ((R:Segment.p.ph_ctype is r)
+     ((ph_vlng is 0)
+      ((0.845308 -0.23426))
+      ((R:SylStructure.parent.syl_out < 4.8)
+       ((R:Segment.n.ph_ctype is n)
+        ((0.484602 -0.850587))
+        ((0.535398 -0.586652)))
+       ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+        ((ph_vlng is a)
+         ((0.368898 -0.799533))
+         ((lisp_coda_stop is 0)
+          ((0.387923 -1.11431))
+          ((0.407377 -0.859849))))
+        ((R:Segment.n.ph_cplace is a)
+         ((ph_vlng is a)
+          ((0.382367 -0.787669))
+          ((0.522121 -0.687376)))
+         ((0.361185 -0.853639))))))
+     ((ph_vlng is a)
+      ((ph_ctype is 0)
+       ((R:Segment.n.ph_ctype is s)
+        ((R:Segment.p.ph_cvox is +)
+         ((R:Segment.p.ph_cplace is d)
+          ((0.502849 -0.232866))
+          ((R:SylStructure.parent.position_type is initial)
+           ((0.641714 -0.0545426))
+           ((R:SylStructure.parent.parent.word_numsyls < 2.6)
+            ((0.613913 0.373746))
+            ((R:Segment.n.ph_cplace is v)
+             ((0.581158 0.310101))
+             ((0.628758 -0.068165))))))
+         ((R:SylStructure.parent.position_type is mid)
+          ((0.459281 -0.553794))
+          ((0.728208 -0.138806))))
+        ((R:Segment.p.ph_cplace is v)
+         ((0.32179 -0.728364))
+         ((R:Segment.p.ph_cplace is l)
+          ((0.562971 -0.550272))
+          ((R:SylStructure.parent.position_type is initial)
+           ((0.937298 -0.0246324))
+           ((R:Segment.p.ph_cvox is +)
+            ((R:Segment.n.ph_ctype is n)
+             ((R:Segment.n.ph_cplace is a)
+              ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+               ((0.434029 -0.404793))
+               ((1.05548 -0.103717)))
+              ((0.408372 -0.556145)))
+             ((0.712335 -0.118776)))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+             ((0.379593 -0.658075))
+             ((0.549207 -0.494876))))))))
+       ((R:SylStructure.parent.position_type is final)
+        ((0.597124 -0.649729))
+        ((0.628822 -1.03743))))
+      ((ph_ctype is s)
+       ((R:Segment.n.ph_ctype is r)
+        ((R:SylStructure.parent.syl_out < 8.4)
+         ((0.760328 0.31651))
+         ((0.738363 -0.0177161)))
+        ((R:Segment.n.ph_ctype is l)
+         ((0.649328 -0.108791))
+         ((0.594945 -0.712753))))
+       ((ph_vlng is s)
+        ((R:Segment.n.ph_ctype is s)
+         ((R:Segment.n.ph_cplace is v)
+          ((R:Segment.nn.ph_cplace is a)
+           ((0.583211 0.0724331))
+           ((0.434605 -0.229857)))
+          ((R:Segment.p.ph_cplace is a)
+           ((R:SylStructure.parent.position_type is single)
+            ((0.785502 -0.00061573))
+            ((0.544995 -0.432984)))
+           ((R:Segment.nn.ph_cplace is 0)
+            ((0.507071 -0.715041))
+            ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+             ((0.506404 -0.573733))
+             ((0.62466 -0.3356))))))
+         ((R:Segment.p.ph_cplace is l)
+          ((0.571756 -0.819693))
+          ((lisp_coda_stop is 0)
+           ((R:SylStructure.parent.position_type is initial)
+            ((0.906891 -0.352911))
+            ((R:Segment.n.ph_ctype is r)
+             ((0.620335 -0.445714))
+             ((R:SylStructure.parent.parent.word_numsyls < 2.5)
+              ((R:Segment.p.ph_cvox is +)
+               ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+                ((0.484057 -0.781483))
+                ((0.653917 -0.615429)))
+               ((0.754814 -0.531845)))
+              ((0.493988 -0.881596)))))
+           ((0.792979 -0.32648)))))
+        ((R:Segment.p.ph_cvox is +)
+         ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+          ((lisp_coda_stop is 0)
+           ((0.913526 -0.195111))
+           ((0.56564 -0.64867)))
+          ((R:SylStructure.parent.position_type is single)
+           ((R:Segment.n.ph_cplace is a)
+            ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+             ((0.790882 -0.488954))
+             ((0.780221 -0.185138)))
+            ((0.487794 -0.691338)))
+           ((R:Segment.p.ph_ctype is n)
+            ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+             ((0.595729 -0.771698))
+             ((0.57908 -1.06592)))
+            ((R:Segment.pp.ph_vfront is 0)
+             ((0.591417 -0.784735))
+             ((0.486298 -0.436971))))))
+         ((ph_vlng is 0)
+          ((0.629869 -0.960652))
+          ((R:Segment.n.ph_ctype is r)
+           ((R:Segment.nn.ph_cplace is 0)
+            ((0.591783 -0.671576))
+            ((R:Segment.nn.ph_cvox is +)
+             ((0.365135 -0.822844))
+             ((0.428573 -0.988434))))
+           ((lisp_coda_stop is 0)
+            ((R:Segment.p.ph_cplace is a)
+             ((R:Segment.n.ph_cplace is a)
+              ((0.428189 -0.730057))
+              ((0.337443 -0.861764)))
+             ((0.57354 -0.494602)))
+            ((0.497606 -0.414451))))))))))
+    ((ph_vlng is l)
+     ((R:Segment.pp.ph_vfront is 1)
+      ((0.937199 0.833877))
+      ((R:SylStructure.parent.syl_out < 12.7)
+       ((0.729202 0.344121))
+       ((0.71086 0.101855))))
+     ((syl_initial is 0)
+      ((R:Segment.p.ph_ctype is r)
+       ((R:Segment.nn.ph_cplace is a)
+        ((0.844815 0.175273))
+        ((0.662523 -0.297527)))
+       ((ph_vlng is 0)
+        ((R:Segment.p.ph_ctype is s)
+         ((R:SylStructure.parent.syl_out < 14.6)
+          ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+           ((0.665332 -0.610529))
+           ((0.42276 -0.848942)))
+          ((0.427946 -0.980726)))
+         ((R:SylStructure.parent.position_type is single)
+          ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+           ((0.523367 -0.825038))
+           ((0.635654 -0.535303)))
+          ((R:SylStructure.parent.position_type is final)
+           ((0.515996 -0.707614))
+           ((ph_cplace is a)
+            ((lisp_coda_stop is 0)
+             ((0.689738 0.0446601))
+             ((0.698347 -0.268593)))
+            ((R:Segment.nn.ph_cplace is a)
+             ((0.706504 -0.659172))
+             ((0.775589 -0.201769)))))))
+        ((0.79472 -0.0539192))))
+      ((ph_ctype is s)
+       ((R:SylStructure.parent.position_type is single)
+        ((R:Segment.p.ph_ctype is f)
+         ((0.641302 0.532411))
+         ((R:Segment.n.ph_vrnd is +)
+          ((0.800655 0.325651))
+          ((0.894711 0.0487864))))
+        ((R:SylStructure.parent.position_type is initial)
+         ((R:Segment.nn.ph_cplace is a)
+          ((0.618082 -0.0190591))
+          ((0.733637 0.156329)))
+         ((ph_cplace is a)
+          ((R:SylStructure.parent.parent.word_numsyls < 2.3)
+           ((0.372869 -0.0827845))
+           ((0.494988 0.0882778)))
+          ((0.593526 -0.335404)))))
+       ((R:Segment.p.ph_cvox is +)
+        ((R:Segment.p.ph_ctype is n)
+         ((R:SylStructure.parent.syl_out < 5.4)
+          ((1.0207 -0.152517))
+          ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+           ((0.711277 -0.513467))
+           ((0.509207 -0.726794))))
+         ((ph_cplace is g)
+          ((0.545188 -0.568352))
+          ((R:Segment.p.ph_cplace is a)
+           ((ph_ctype is n)
+            ((0.61149 -0.325094))
+            ((R:SylStructure.parent.position_type is single)
+             ((R:Segment.p.ph_ctype is r)
+              ((0.525282 0.395446))
+              ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+               ((0.85778 0.0760293))
+               ((0.704055 0.290369))))
+             ((R:Segment.pp.ph_vfront is 0)
+              ((0.590093 0.136983))
+              ((0.734563 -0.0570759)))))
+           ((R:Segment.pp.ph_vfront is 2)
+            ((0.519485 -0.477174))
+            ((0.707546 -0.13584))))))
+        ((R:SylStructure.parent.position_type is single)
+         ((R:Segment.p.ph_ctype is f)
+          ((0.797877 0.00462775))
+          ((R:Segment.pp.ph_vfront is 1)
+           ((0.852184 -0.259914))
+           ((0.65313 -0.492506))))
+         ((R:SylStructure.parent.position_type is initial)
+          ((0.662516 -0.45585))
+          ((lisp_onset_glide is 0)
+           ((0.652534 -0.652428))
+           ((0.482818 -0.885728))))))))))))
+ ((syl_initial is 0)
+  ((ph_cplace is 0)
+   ((R:SylStructure.parent.position_type is single)
+    ((R:Segment.n.ph_ctype is f)
+     ((R:Segment.p.ph_cplace is a)
+      ((R:Segment.n.ph_cplace is a)
+       ((R:Segment.pp.ph_vfront is 0)
+        ((1.06157 1.30945))
+        ((1.12041 1.85843)))
+       ((1.05622 0.921414)))
+      ((R:Segment.nn.ph_cvox is -)
+       ((1.03073 0.916168))
+       ((1.06857 0.452851))))
+     ((R:Segment.p.ph_ctype is r)
+      ((R:Segment.n.ph_cplace is v)
+       ((1.22144 0.672433))
+       ((R:Segment.p.ph_cplace is l)
+        ((0.859749 -0.315152))
+        ((R:Segment.nn.ph_cvox is -)
+         ((0.89862 0.131037))
+         ((0.760033 -0.121252)))))
+      ((R:SylStructure.parent.syl_out < 8.8)
+       ((R:SylStructure.parent.syl_out < 0.8)
+        ((1.06821 1.63716))
+        ((R:Segment.n.ph_cplace is a)
+         ((R:Segment.p.ph_cvox is +)
+          ((1.04477 0.581686))
+          ((R:Segment.nn.ph_cvox is +)
+           ((0.769059 0.301576))
+           ((0.953428 0.0764058))))
+         ((R:Segment.p.ph_cplace is a)
+          ((1.01367 0.507761))
+          ((1.2827 0.945031)))))
+       ((R:Segment.n.ph_cplace is l)
+        ((0.618397 -0.0873608))
+        ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+         ((R:Segment.p.ph_cvox is +)
+          ((0.817182 0.477262))
+          ((0.792181 -0.0592145)))
+         ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+          ((R:SylStructure.parent.syl_out < 16)
+           ((0.995411 0.497843))
+           ((0.784087 0.152266)))
+          ((1.11816 0.716352))))))))
+    ((R:Segment.n.ph_ctype is f)
+     ((R:SylStructure.parent.position_type is final)
+      ((1.35724 1.06028))
+      ((R:Segment.p.ph_ctype is r)
+       ((R:SylStructure.parent.syl_out < 8.6)
+        ((0.511716 -0.0833005))
+        ((0.492142 -0.30212)))
+       ((R:Segment.n.ph_cplace is b)
+        ((0.53059 0.00266551))
+        ((R:SylStructure.parent.parent.word_numsyls < 2.3)
+         ((ph_vlng is l)
+          ((0.433396 0.821463))
+          ((0.66915 0.415614)))
+         ((0.501369 0.154721))))))
+     ((R:SylStructure.parent.position_type is final)
+      ((R:Segment.n.ph_ctype is s)
+       ((1.03896 0.524706))
+       ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+        ((1.15147 0.428386))
+        ((R:Segment.p.ph_cplace is a)
+         ((0.919929 0.0314637))
+         ((0.716168 -0.366629)))))
+      ((R:SylStructure.parent.R:Syllable.n.syl_break is 4)
+       ((0.816778 0.408786))
+       ((lisp_onset_glide is 0)
+        ((R:Segment.p.ph_ctype is n)
+         ((R:Segment.n.ph_ctype is s)
+          ((0.532911 -0.153851))
+          ((0.633518 -0.762353)))
+         ((R:Segment.p.ph_cvox is -)
+          ((R:Segment.p.ph_cplace is g)
+           ((0.618376 -0.593197))
+           ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+            ((R:Segment.pp.ph_vfront is 0)
+             ((R:Segment.n.ph_ctype is n)
+              ((0.554085 -0.058903))
+              ((R:Segment.p.ph_cplace is a)
+               ((0.59842 -0.174458))
+               ((0.585539 -0.349335))))
+             ((0.500857 -0.416613)))
+            ((R:SylStructure.parent.syl_out < 7)
+             ((0.616683 -0.00213272))
+             ((0.631444 -0.141773)))))
+          ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+           ((0.5198 -0.151901))
+           ((ph_vlng is s)
+            ((0.677428 0.203522))
+            ((0.780789 0.375429))))))
+        ((R:Segment.nn.ph_cplace is a)
+         ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+          ((0.594604 -0.27832))
+          ((0.736114 -0.422756)))
+         ((R:Segment.p.ph_cplace is a)
+          ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+           ((0.512186 -0.732785))
+           ((0.550759 -0.506471)))
+          ((0.47297 -0.791841)))))))))
+   ((R:Segment.p.ph_ctype is 0)
+    ((R:SylStructure.parent.position_type is final)
+     ((lisp_coda_stop is 0)
+      ((ph_ctype is f)
+       ((R:Segment.nn.ph_cplace is 0)
+        ((1.00978 0.366105))
+        ((0.80682 -0.0827529)))
+       ((R:Segment.n.ph_cplace is a)
+        ((R:Segment.nn.ph_cvox is -)
+         ((1.07097 1.77503))
+         ((1.14864 1.14754)))
+        ((R:Segment.n.ph_vrnd is -)
+         ((0.883474 0.286471))
+         ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+          ((1.22264 0.884142))
+          ((1.03401 0.658192))))))
+      ((ph_cplace is a)
+       ((R:SylStructure.parent.syl_out < 6.4)
+        ((R:SylStructure.parent.syl_out < 0.6)
+         ((1.07956 0.602849))
+         ((1.12301 0.0555897)))
+        ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+         ((0.898888 -0.17527))
+         ((0.940932 0.274301))))
+       ((1.10093 -0.68098))))
+     ((R:Segment.n.ph_ctype is s)
+      ((ph_cplace is v)
+       ((0.639932 -1.33353))
+       ((R:SylStructure.parent.position_type is single)
+        ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+         ((lisp_coda_stop is 0)
+          ((0.822882 -0.131692))
+          ((0.971957 -0.385365)))
+         ((R:Segment.nn.ph_cvox is -)
+          ((1.06611 0.183678))
+          ((lisp_coda_stop is 0)
+           ((0.967183 0.0925019))
+           ((0.876026 -0.230108)))))
+        ((ph_ctype is f)
+         ((R:SylStructure.parent.syl_out < 13)
+          ((0.589198 -0.655594))
+          ((0.476651 -0.926625)))
+         ((R:SylStructure.parent.syl_out < 5)
+          ((0.682936 -0.227662))
+          ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+           ((R:Segment.nn.ph_cplace is a)
+            ((0.447309 -0.700998))
+            ((0.626113 -0.468853)))
+           ((0.657893 -0.383607)))))))
+      ((ph_ctype is r)
+       ((R:Segment.nn.ph_cvox is -)
+        ((1.15158 1.15233))
+        ((R:Segment.n.ph_vrnd is -)
+         ((1.05554 0.533749))
+         ((0.955478 0.0841894))))
+       ((ph_ctype is l)
+        ((R:Segment.n.ph_ctype is 0)
+         ((R:Segment.nn.ph_cplace is a)
+          ((0.766431 0.28943))
+          ((1.48633 1.09574)))
+         ((R:SylStructure.parent.position_type is single)
+          ((1.01777 0.474653))
+          ((0.545859 -0.402743))))
+        ((R:SylStructure.parent.syl_out < 4.8)
+         ((R:Segment.n.ph_vc is +)
+          ((ph_ctype is n)
+           ((0.776645 -0.433859))
+           ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+            ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+             ((0.776179 0.23435))
+             ((R:SylStructure.parent.parent.word_numsyls < 2.2)
+              ((0.744272 -0.0859672))
+              ((0.782605 0.115647))))
+            ((0.626541 -0.167615))))
+          ((R:Segment.n.seg_onsetcoda is coda)
+           ((1.28499 0.864144))
+           ((ph_cplace is a)
+            ((0.926103 0.0435837))
+            ((0.839172 -0.189514)))))
+         ((R:Segment.n.ph_ctype is n)
+          ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.1)
+           ((0.973489 -0.203415))
+           ((0.777589 -0.849733)))
+          ((ph_ctype is n)
+           ((R:SylStructure.parent.position_type is initial)
+            ((R:Segment.n.ph_vc is +)
+             ((0.743482 -0.53384))
+             ((0.619309 -0.0987861)))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+             ((1.15555 0.0786295))
+             ((1.06689 0.681662))))
+           ((R:Segment.n.ph_ctype is r)
+            ((R:SylStructure.parent.syl_out < 8.9)
+             ((0.752079 -0.237421))
+             ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+              ((0.664182 -0.041521))
+              ((0.772712 0.103499))))
+            ((R:Segment.n.seg_onsetcoda is coda)
+             ((R:SylStructure.parent.position_type is mid)
+              ((R:SylStructure.parent.parent.word_numsyls < 3.3)
+               ((0.715944 -0.275113))
+               ((0.675729 0.202848)))
+              ((R:Segment.n.ph_vrnd is -)
+               ((R:SylStructure.parent.syl_out < 8.3)
+                ((ph_ctype is s)
+                 ((0.82747 -0.116723))
+                 ((0.689586 -0.303909)))
+                ((R:SylStructure.parent.syl_out < 17.7)
+                 ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+                  ((0.659686 -0.621268))
+                  ((ph_cplace is a)
+                   ((0.861741 -0.285324))
+                   ((0.507102 -0.444082))))
+                 ((0.850664 -0.269084))))
+               ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+                ((0.878643 -0.255833))
+                ((0.98882 0.115252)))))
+             ((ph_cplace is a)
+              ((R:SylStructure.parent.syl_out < 13)
+               ((0.850625 -0.289333))
+               ((0.788154 -0.44844)))
+              ((0.70482 -0.630276))))))))))))
+    ((R:Segment.p.ph_ctype is l)
+     ((R:SylStructure.parent.position_type is single)
+      ((0.873748 -0.21639))
+      ((lisp_coda_stop is 0)
+       ((0.71002 0.428132))
+       ((0.703501 0.015833))))
+     ((ph_vlng is 0)
+      ((R:Segment.p.ph_ctype is r)
+       ((R:SylStructure.parent.position_type is initial)
+        ((0.907151 -0.494409))
+        ((ph_ctype is s)
+         ((0.782539 -0.398555))
+         ((R:Segment.p.ph_cplace is 0)
+          ((0.767435 -0.298857))
+          ((0.767046 0.151217)))))
+       ((ph_cplace is a)
+        ((R:Segment.n.ph_ctype is r)
+         ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+          ((0.689367 0.0195991))
+          ((0.64446 -0.256648)))
+         ((R:Segment.n.ph_vc is +)
+          ((ph_ctype is s)
+           ((R:Segment.nn.ph_cvox is +)
+            ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+             ((0.59482 -0.214443))
+             ((0.745691 0.0292177)))
+            ((0.523103 -0.391245)))
+           ((R:Segment.p.ph_cvox is +)
+            ((R:Segment.p.ph_cplace is a)
+             ((0.524304 -0.428306))
+             ((0.605117 -0.165604)))
+            ((R:Segment.p.ph_ctype is f)
+             ((0.491251 -0.455353))
+             ((lisp_coda_stop is 0)
+              ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+               ((0.175021 -1.02136))
+               ((0.264113 -0.976809)))
+              ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+               ((0.704803 -0.716976))
+               ((0.300317 -0.924727)))))))
+          ((ph_ctype is f)
+           ((R:SylStructure.parent.syl_out < 13)
+            ((R:Segment.n.ph_ctype is s)
+             ((0.731994 -0.711044))
+             ((0.768008 -0.415076)))
+            ((0.691821 -0.803284)))
+           ((R:Segment.nn.ph_cplace is 0)
+            ((R:Segment.n.ph_cplace is a)
+             ((0.569567 -0.993506))
+             ((0.689849 -0.761696)))
+            ((0.386818 -1.14744))))))
+        ((R:Segment.p.seg_onsetcoda is coda)
+         ((R:Segment.p.ph_cplace is a)
+          ((0.746337 -0.866206))
+          ((0.532751 -1.22185)))
+         ((ph_cplace is l)
+          ((0.74942 -0.820648))
+          ((0.685988 -0.298146))))))
+      ((0.812766 0.17291))))))
+  ((R:SylStructure.parent.position_type is mid)
+   ((ph_ctype is r)
+    ((0.577775 -0.54714))
+    ((R:Segment.n.ph_ctype is f)
+     ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+      ((0.370448 0.00076407))
+      ((0.460385 0.20631)))
+     ((R:Segment.p.ph_cvox is -)
+      ((ph_vlng is 0)
+       ((0.615959 -0.57434))
+       ((0.50852 -0.197814)))
+      ((R:Segment.n.ph_ctype is 0)
+       ((1.34281 0.477163))
+       ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+        ((0.59975 -0.1342))
+        ((0.640294 -0.32653)))))))
+   ((R:Segment.n.ph_ctype is f)
+    ((R:SylStructure.parent.position_type is initial)
+     ((0.758739 0.311943))
+     ((R:Segment.n.seg_onsetcoda is coda)
+      ((R:Segment.p.ph_ctype is f)
+       ((1.28746 1.99771))
+       ((R:Segment.pp.ph_vfront is 1)
+        ((1.42474 1.76925))
+        ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+         ((0.979414 1.37583))
+         ((1.00321 1.06671)))))
+      ((1.15222 0.852004))))
+    ((R:Segment.p.ph_ctype is 0)
+     ((R:Segment.n.ph_ctype is s)
+      ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+       ((0.664807 -0.0880262))
+       ((0.573589 0.217234)))
+      ((ph_ctype is s)
+       ((ph_cplace is l)
+        ((0.800348 0.66579))
+        ((ph_cplace is a)
+         ((0.859133 1.46854))
+         ((R:SylStructure.parent.position_type is single)
+          ((0.692229 1.23671))
+          ((0.552426 0.923928)))))
+       ((R:SylStructure.parent.syl_out < 9.2)
+        ((R:SylStructure.parent.position_type is single)
+         ((R:SylStructure.parent.syl_out < 3.6)
+          ((1.01673 1.26824))
+          ((0.848274 0.92375)))
+         ((R:SylStructure.parent.R:Syllable.n.syl_break is 1)
+          ((R:Segment.nn.ph_cplace is a)
+           ((0.788163 0.818855))
+           ((0.822028 1.01227)))
+          ((0.8365 0.483313))))
+        ((lisp_coda_stop is 0)
+         ((R:Segment.nn.ph_cvox is +)
+          ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+           ((0.807795 0.670829))
+           ((0.773774 0.435486)))
+          ((0.849529 0.103561)))
+         ((0.858848 0.763836))))))
+     ((R:Segment.n.ph_vrnd is -)
+      ((ph_vlng is 0)
+       ((R:SylStructure.parent.position_type is final)
+        ((ph_cplace is a)
+         ((R:Segment.nn.ph_cvox is -)
+          ((0.691915 -0.42124))
+          ((R:Segment.p.ph_cplace is a)
+           ((0.773696 0.354001))
+           ((0.65495 -0.14321))))
+         ((0.610433 -0.479739)))
+        ((R:Segment.p.ph_ctype is r)
+         ((R:SylStructure.parent.R:Syllable.n.syl_break is 0)
+          ((0.560921 0.384674))
+          ((0.895267 0.746476)))
+         ((R:Segment.p.ph_ctype is l)
+          ((0.704694 0.568012))
+          ((R:Segment.p.ph_cplace is b)
+           ((1.34739 0.539049))
+           ((R:Segment.p.ph_ctype is s)
+            ((R:SylStructure.parent.syl_out < 12.9)
+             ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+              ((0.807285 0.151429))
+              ((0.988033 0.383763)))
+             ((0.878655 0.102291)))
+            ((ph_ctype is n)
+             ((0.759582 -0.315096))
+             ((R:SylStructure.parent.syl_out < 8.8)
+              ((R:Segment.pp.ph_vfront is 0)
+               ((0.846546 0.000647117))
+               ((R:Segment.pp.ph_vfront is 1)
+                ((0.586216 0.150701))
+                ((0.793898 0.379041))))
+              ((lisp_coda_stop is 0)
+               ((ph_ctype is f)
+                ((0.74736 -0.31103))
+                ((0.715751 -0.00576581)))
+               ((0.914486 0.17528))))))))))
+       ((1.24204 0.908819)))
+      ((ph_ctype is s)
+       ((ph_cplace is a)
+        ((0.864408 1.35528))
+        ((R:Segment.n.seg_onsetcoda is coda)
+         ((0.85602 0.344576))
+         ((0.869622 0.659223))))
+       ((R:Segment.nn.ph_cvox is -)
+        ((R:Segment.n.ph_ctype is s)
+         ((R:Segment.nn.ph_cplace is 0)
+          ((0.942964 1.27475))
+          ((0.978218 0.650268)))
+         ((R:SylStructure.parent.syl_out < 3.9)
+          ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+           ((1.32463 1.05026))
+           ((0.896966 0.417727)))
+          ((R:Segment.p.ph_cplace is a)
+           ((R:SylStructure.parent.R:Syllable.nn.syl_break is 0)
+            ((0.776698 0.195369))
+            ((0.969518 0.432394)))
+           ((0.799096 -0.0203318)))))
+        ((ph_cplace is a)
+         ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+          ((0.680861 -0.315846))
+          ((R:SylStructure.parent.R:Syllable.nn.syl_break is 1)
+           ((0.954393 0.0965487))
+           ((0.884928 0.372884))))
+         ((lisp_coda_stop is 0)
+          ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+           ((R:SylStructure.parent.position_type is final)
+            ((1.03696 0.565834))
+            ((0.906661 0.277961)))
+           ((R:SylStructure.parent.position_type is final)
+            ((0.778429 -0.0967381))
+            ((0.863993 0.314023))))
+          ((R:Segment.p.ph_cplace is a)
+           ((R:SylStructure.parent.R:Syllable.p.stress is 0)
+            ((0.898898 0.571009))
+            ((0.830278 0.787486)))
+           ((1.1101 0.333888)))))))))))))
+;; RMSE 0.7726 Correlation is 0.5943 Mean (abs) Error 0.5752 (0.5160)
+
+))
+
+(provide 'f2bdurtreeZ)

CosyVoice-ttsfrd/resource/festival/f2bf0lr.scm

@@ -0,0 +1,314 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   First attempt at a linear regression model to predict F0 values.
+;;;   This is an attempt to reimplement the work in Black and
+;;;   Hunt ICSLP96, though this model probably isn't as good.
+;;;
+
+;;;start
+;;; R2 = 0.251, F(74, 12711) = 57.5, Prob>F = 0.000
+;;; RMSE = 27.877
+;;;mid
+;;; R2 = 0.332, F(74, 12711) = 85.6, Prob>F = 0.000
+;;; RMSE = 28.293
+;;;end
+;;; R2 = 0.292, F(74, 12711) = 70.8, Prob>F = 0.000
+;;; RMSE = 27.139
+
+(define (emph_syl syl)
+  (if (string-equal (item.feat syl "tobi_accent") "NONE")
+      0.0
+      (if (string-equal (item.feat 
+			 syl "R:SylStructure.parent.R:Token.parent.EMPH") "1")
+	  2.0
+	  0.0)))
+
+(set! f2b_f0_lr_start
+'(
+( Intercept 160.584956 )
+( R:SylStructure.parent.R:Token.parent.EMPH 10.0 )
+( pp.tobi_accent 10.081770 (H*) )
+( pp.tobi_accent 3.358613 (!H*) )
+( pp.tobi_accent 4.144342 (*? X*? H*!H* * L+H* L+!H*) )
+( pp.tobi_accent -1.111794 (L*) )
+( pp.tobi_accent 19.646313 (L*+H L*+!H) )
+( p.tobi_accent 32.081029 (H*) )
+( p.tobi_accent 18.090033 (!H*) )
+( p.tobi_accent 23.255280 (*? X*? H*!H* * L+H* L+!H*) )
+( p.tobi_accent -9.623577 (L*) )
+( p.tobi_accent 26.517095 (L*+H L*+!H) )
+( tobi_accent 5.221081 (H*) )
+( tobi_accent 10.159194 (!H*) )
+( tobi_accent 3.645511 (*? X*? H*!H* * L+H* L+!H*) )
+( tobi_accent -5.720030 (L*) )
+( tobi_accent -6.355773 (L*+H L*+!H) )
+( n.tobi_accent -5.691933 (H*) )
+( n.tobi_accent 8.265606 (!H*) )
+( n.tobi_accent 0.861427 (*? X*? H*!H* * L+H* L+!H*) )
+( n.tobi_accent 1.270504 (L*) )
+( n.tobi_accent 3.499418 (L*+H L*+!H) )
+( nn.tobi_accent -3.785701 (H*) )
+( nn.tobi_accent 7.013446 (!H*) )
+( nn.tobi_accent 2.637494 (*? X*? H*!H* * L+H* L+!H*) )
+( nn.tobi_accent -0.392176 (L*) )
+( nn.tobi_accent -2.957502 (L*+H L*+!H) )
+( pp.tobi_endtone -3.531153 (L-L%) )
+( pp.tobi_endtone 0.131156 (L-) )
+( pp.tobi_endtone 2.729199 (H-L% !H-L% -X?) )
+( pp.tobi_endtone 8.258756 (L-H%) )
+( pp.tobi_endtone 5.836487 (H-) )
+( pp.tobi_endtone 11.213440 (!H- H-H%) )
+(  R:Syllable.p.tobi_endtone -28.081359 (L-L%) )
+(  R:Syllable.p.tobi_endtone -20.553145 (L-) )
+(  R:Syllable.p.tobi_endtone -5.442577 (H-L% !H-L% -X?) )
+(  R:Syllable.p.tobi_endtone -6.585836 (L-H%) )
+(  R:Syllable.p.tobi_endtone 8.537044 (H-) )
+(  R:Syllable.p.tobi_endtone 4.243342 (!H- H-H%) )
+( tobi_endtone -9.333926 (L-L%) )
+( tobi_endtone -0.346711 (L-) )
+( tobi_endtone -0.507352 (H-L% !H-L% -X?) )
+( tobi_endtone -0.937483 (L-H%) )
+( tobi_endtone 9.472265 (H-) )
+( tobi_endtone 14.256898 (!H- H-H%) )
+( n.tobi_endtone -13.084253 (L-L%) )
+( n.tobi_endtone -1.060688 (L-) )
+( n.tobi_endtone -7.947205 (H-L% !H-L% -X?) )
+( n.tobi_endtone -5.471592 (L-H%) )
+( n.tobi_endtone -0.095669 (H-) )
+( n.tobi_endtone 4.933708 (!H- H-H%) )
+( nn.tobi_endtone -14.993470 (L-L%) )
+( nn.tobi_endtone -3.784284 (L-) )
+( nn.tobi_endtone -15.505132 (H-L% !H-L% -X?) )
+( nn.tobi_endtone -11.352400 (L-H%) )
+( nn.tobi_endtone -5.551627 (H-) )
+( nn.tobi_endtone -0.661581 (!H- H-H%) )
+( pp.old_syl_break -3.367677 )
+( p.old_syl_break 0.641755 )
+( old_syl_break -0.659002 )
+( n.old_syl_break 1.217358 )
+( nn.old_syl_break 2.974502 )
+( pp.stress 1.588098 )
+( p.stress 3.693430 )
+( stress 2.009843 )
+( n.stress 1.645560 )
+( nn.stress 1.926870 )
+( syl_in 1.048362 )
+( syl_out 0.315553 )
+( ssyl_in -2.096079 )
+( ssyl_out 0.303531 )
+( asyl_in -4.257915 )
+( asyl_out -2.422424 )
+( last_accent -0.397647 )
+( next_accent -0.418613 )
+( sub_phrases -5.472055 )
+))
+
+(set! f2b_f0_lr_mid
+'(
+( Intercept 169.183377 )
+( R:SylStructure.parent.R:Token.parent.EMPH 10.0 )
+( pp.tobi_accent 4.923247 (H*) )
+( pp.tobi_accent 0.955474 (!H*) )
+( pp.tobi_accent 1.193597 (*? X*? H*!H* * L+H* L+!H*) )
+( pp.tobi_accent 1.501383 (L*) )
+( pp.tobi_accent 7.992120 (L*+H L*+!H) )
+( p.tobi_accent 16.603350 (H*) )
+( p.tobi_accent 11.665814 (!H*) )
+( p.tobi_accent 13.063298 (*? X*? H*!H* * L+H* L+!H*) )
+( p.tobi_accent -2.288798 (L*) )
+( p.tobi_accent 29.168430 (L*+H L*+!H) )
+( tobi_accent 34.517868 (H*) )
+( tobi_accent 22.349656 (!H*) )
+( tobi_accent 23.551548 (*? X*? H*!H* * L+H* L+!H*) )
+( tobi_accent -14.117284 (L*) )
+( tobi_accent -5.978760 (L*+H L*+!H) )
+( n.tobi_accent -1.914945 (H*) )
+( n.tobi_accent 5.249441 (!H*) )
+( n.tobi_accent -1.929947 (*? X*? H*!H* * L+H* L+!H*) )
+( n.tobi_accent -3.287877 (L*) )
+( n.tobi_accent -4.980375 (L*+H L*+!H) )
+( nn.tobi_accent -6.147251 (H*) )
+( nn.tobi_accent 8.408949 (!H*) )
+( nn.tobi_accent 3.193500 (*? X*? H*!H* * L+H* L+!H*) )
+( nn.tobi_accent 1.323099 (L*) )
+( nn.tobi_accent 9.148058 (L*+H L*+!H) )
+( pp.tobi_endtone 4.255273 (L-L%) )
+( pp.tobi_endtone -1.033377 (L-) )
+( pp.tobi_endtone 11.992045 (H-L% !H-L% -X?) )
+( pp.tobi_endtone 6.989573 (L-H%) )
+( pp.tobi_endtone 2.598854 (H-) )
+( pp.tobi_endtone 12.178307 (!H- H-H%) )
+(  R:Syllable.p.tobi_endtone -4.397973 (L-L%) )
+(  R:Syllable.p.tobi_endtone -6.157077 (L-) )
+(  R:Syllable.p.tobi_endtone 5.530608 (H-L% !H-L% -X?) )
+(  R:Syllable.p.tobi_endtone 6.938086 (L-H%) )
+(  R:Syllable.p.tobi_endtone 6.162763 (H-) )
+(  R:Syllable.p.tobi_endtone 8.035727 (!H- H-H%) )
+( tobi_endtone -19.357902 (L-L%) )
+( tobi_endtone -13.877759 (L-) )
+( tobi_endtone -6.176061 (H-L% !H-L% -X?) )
+( tobi_endtone -7.328882 (L-H%) )
+( tobi_endtone 12.694193 (H-) )
+( tobi_endtone 30.923398 (!H- H-H%) )
+( n.tobi_endtone -17.727785 (L-L%) )
+( n.tobi_endtone -2.539592 (L-) )
+( n.tobi_endtone -8.126830 (H-L% !H-L% -X?) )
+( n.tobi_endtone -8.701685 (L-H%) )
+( n.tobi_endtone -1.006439 (H-) )
+( n.tobi_endtone 6.834498 (!H- H-H%) )
+( nn.tobi_endtone -15.407530 (L-L%) )
+( nn.tobi_endtone -2.974196 (L-) )
+( nn.tobi_endtone -12.287673 (H-L% !H-L% -X?) )
+( nn.tobi_endtone -7.621437 (L-H%) )
+( nn.tobi_endtone -0.458837 (H-) )
+( nn.tobi_endtone 3.170632 (!H- H-H%) )
+( pp.old_syl_break -4.196950 )
+( p.old_syl_break -5.176929 )
+( old_syl_break 0.047922 )
+( n.old_syl_break 2.153968 )
+( nn.old_syl_break 2.577074 )
+( pp.stress -2.368192 )
+( p.stress 1.080493 )
+( stress 1.135556 )
+( n.stress 2.447219 )
+( nn.stress 1.318122 )
+( syl_in 0.291663 )
+( syl_out -0.411814 )
+( ssyl_in -1.643456 )
+( ssyl_out 0.580589 )
+( asyl_in -5.649243 )
+( asyl_out 0.489823 )
+( last_accent 0.216634 )
+( next_accent 0.244134 )
+( sub_phrases -5.758156 )
+))
+
+
+(set! f2b_f0_lr_end
+'(
+( Intercept 169.570381 )
+( R:SylStructure.parent.R:Token.parent.EMPH 10.0 )
+( pp.tobi_accent 3.594771 (H*) )
+( pp.tobi_accent 0.432519 (!H*) )
+( pp.tobi_accent 0.235664 (*? X*? H*!H* * L+H* L+!H*) )
+( pp.tobi_accent 1.513892 (L*) )
+( pp.tobi_accent 2.474823 (L*+H L*+!H) )
+( p.tobi_accent 11.214208 (H*) )
+( p.tobi_accent 9.619350 (!H*) )
+( p.tobi_accent 9.084690 (*? X*? H*!H* * L+H* L+!H*) )
+( p.tobi_accent 0.519202 (L*) )
+( p.tobi_accent 26.593112 (L*+H L*+!H) )
+( tobi_accent 25.217589 (H*) )
+( tobi_accent 13.759851 (!H*) )
+( tobi_accent 17.635192 (*? X*? H*!H* * L+H* L+!H*) )
+( tobi_accent -12.149974 (L*) )
+( tobi_accent 13.345913 (L*+H L*+!H) )
+( n.tobi_accent 4.944848 (H*) )
+( n.tobi_accent 7.398383 (!H*) )
+( n.tobi_accent 1.683011 (*? X*? H*!H* * L+H* L+!H*) )
+( n.tobi_accent -6.516900 (L*) )
+( n.tobi_accent -6.768201 (L*+H L*+!H) )
+( nn.tobi_accent -4.335797 (H*) )
+( nn.tobi_accent 5.656462 (!H*) )
+( nn.tobi_accent 0.263288 (*? X*? H*!H* * L+H* L+!H*) )
+( nn.tobi_accent 1.022002 (L*) )
+( nn.tobi_accent 6.702368 (L*+H L*+!H) )
+( pp.tobi_endtone 10.274958 (L-L%) )
+( pp.tobi_endtone 3.129947 (L-) )
+( pp.tobi_endtone 15.476240 (H-L% !H-L% -X?) )
+( pp.tobi_endtone 10.446935 (L-H%) )
+( pp.tobi_endtone 6.104384 (H-) )
+( pp.tobi_endtone 14.182688 (!H- H-H%) )
+(  R:Syllable.p.tobi_endtone 1.767454 (L-L%) )
+(  R:Syllable.p.tobi_endtone -1.040077 (L-) )
+(  R:Syllable.p.tobi_endtone 18.438093 (H-L% !H-L% -X?) )
+(  R:Syllable.p.tobi_endtone 8.750018 (L-H%) )
+(  R:Syllable.p.tobi_endtone 5.000340 (H-) )
+(  R:Syllable.p.tobi_endtone 10.913437 (!H- H-H%) )
+( tobi_endtone -12.637935 (L-L%) )
+( tobi_endtone -13.597961 (L-) )
+( tobi_endtone -6.501965 (H-L% !H-L% -X?) )
+( tobi_endtone 8.747483 (L-H%) )
+( tobi_endtone 15.165833 (H-) )
+( tobi_endtone 50.190326 (!H- H-H%) )
+( n.tobi_endtone -16.965781 (L-L%) )
+( n.tobi_endtone -5.222475 (L-) )
+( n.tobi_endtone -7.358555 (H-L% !H-L% -X?) )
+( n.tobi_endtone -7.833168 (L-H%) )
+( n.tobi_endtone 4.701087 (H-) )
+( n.tobi_endtone 10.349902 (!H- H-H%) )
+( nn.tobi_endtone -15.369483 (L-L%) )
+( nn.tobi_endtone -2.207161 (L-) )
+( nn.tobi_endtone -9.363835 (H-L% !H-L% -X?) )
+( nn.tobi_endtone -7.052374 (L-H%) )
+( nn.tobi_endtone 2.207854 (H-) )
+( nn.tobi_endtone 5.271546 (!H- H-H%) )
+( pp.old_syl_break -4.745862 )
+( p.old_syl_break -5.685178 )
+( old_syl_break -2.633291 )
+( n.old_syl_break 1.678340 )
+( nn.old_syl_break 2.274729 )
+( pp.stress -2.747198 )
+( p.stress 0.306724 )
+( stress -0.565613 )
+( n.stress 2.838327 )
+( nn.stress 1.285244 )
+( syl_in 0.169955 )
+( syl_out -1.045661 )
+( ssyl_in -1.487774 )
+( ssyl_out 0.752405 )
+( asyl_in -5.081677 )
+( asyl_out 3.016218 )
+( last_accent 0.312900 )
+( next_accent 0.837992 )
+( sub_phrases -5.397805 )
+
+))
+
+;; groups
+;; tobi_accent_1 25.217589 (H*) )
+;; tobi_accent_2 13.759851 (!H*) )
+;; tobi_accent_3 17.635192 (*? X*? H*!H* * L+H* L+!H*) )
+;; tobi_accent_4 -12.149974 (L*) )
+;; tobi_accent_5 13.345913 (L*+H L*+!H) )
+
+;; tobi_endtone_1 10.274958 (L-L%) )
+;; tobi_endtone_2 3.129947 (L-) )
+;; tobi_endtone_3 15.476240 (H-L% !H-L% -X?) )
+;; tobi_endtone_4 10.446935 (L-H%) )
+;; tobi_endtone_5 6.104384 (H-) )
+;; tobi_endtone_6 14.182688 (!H- H-H%) )
+
+(provide 'f2bf0lr)
+

CosyVoice-ttsfrd/resource/festival/festival.el

@@ -0,0 +1,282 @@
+;;;
+;;;  File: festival.el
+;;;  Emacs Lisp
+;;;
+;;;  Alan W Black  CSTR ([email protected]) June 1996
+;;;
+;;;  Provide an emacs mode for interfacing to the festival speech
+;;;  synthesizer system
+;;;
+;;;  I've looked at many examples from the emacs Lisp directory
+;;;  copying relevant bits from here and there, so this can only
+;;;  reasonably inherit the GNU licence (GPL)
+;;;
+;;;  Setup:
+;;;  In your .emacs add the following 2 lines to get a Say menu:
+;;;
+;;;  (autoload 'say-minor-mode "festival" "Menu for using Festival." t)
+;;;  (say-minor-mode t)
+;;;  (setq auto-mode-alist 
+;;;     (append '(("\\.festivalrc$" . scheme-mode)) auto-mode-alist))
+;;;
+;;;  The following gives you pretty colors in emacs-19 if you are into
+;;;  such things 
+;;;  ;;;  Some colors for scheme mode
+;;;  (hilit-set-mode-patterns
+;;;   '(scheme-mode)
+;;;   '(
+;;;     (";.*" nil comment)
+;;;     (hilit-string-find ?\\ string)
+;;;     ("^\\s *(def\\s +" "\\()\\|nil\\)" defun)
+;;;     ("^\\s *(defvar\\s +\\S +" nil decl)
+;;;     ("^\\s *(set\\s +\\S +" nil decl)
+;;;     ("^\\s *(defconst\\s +\\S +" nil define)
+;;;     ("^\\s *(\\(provide\\|require\\).*$" nil include)
+;;;     ("(\\(let\\*?\\|cond\\|if\\|or\\|and\\|map\\(car\\|concat\\)\\|prog[n1*]?\\|while\\|lambda\\|function\\|Parameter\\|set\\([qf]\\|car\\|cdr\\)?\\|nconc\\|eval-when-compile\\|condition-case\\|unwind-protect\\|catch\\|throw\\|error\\)[ \t\n]" 1 keyword)))
+;;;  
+;;;
+;;;--------------------------------------------------------------------
+;;;               Copyright (C) Alan W Black 1996
+;;; This code is distributed in the hope that it will be useful,
+;;; but WITHOUT ANY WARRANTY. No author or distributor accepts
+;;; responsibility to anyone for the consequences of using this code
+;;; or for whether it serves any particular purpose or works at all,
+;;; unless explicitly stated in a written agreement.
+;;;
+;;; Everyone is granted permission to copy, modify and redistribute
+;;; this code, but only under the conditions described in the GNU
+;;; Emacs General Public License.  A copy of this license is
+;;; distrubuted with GNU Emacs so you can know your rights and
+;;; responsibilities.  It should be in a file named COPYING.  Among
+;;; other things, the copyright notice and this notice must be
+;;; preserved on all copies.
+;;;--------------------------------------------------------------------
+;;;  
+
+(defvar festival-program-name "festival")
+
+(defvar festival-process nil)
+
+(defvar festival-tmp-file
+  (format "/tmp/festival-emacs-tmp-%s" (user-real-login-name))
+ "Filename to save input for Festivial.")
+
+(defun festival-fast () 
+  (interactive)
+  (festival-send-command '(Parameter.set 'Duration.Stretch 0.8)))
+(defun festival-slow () 
+  (interactive)
+  (festival-send-command '(Parameter.set 'Duration.Stretch 1.2)))
+(defun festival-ndur () 
+  (interactive)
+  (festival-send-command '(Parameter.set 'Duration.Stretch 1.0)))
+(defun festival-intro () 
+  (interactive)
+  (festival-send-command '(intro)))
+
+(defun festival-gsw () 
+  (interactive)
+  (festival-send-command '(voice_gsw_diphone)))
+(defun festival-rab () 
+  (interactive)
+  (festival-send-command '(voice_rab_diphone)))
+(defun festival-ked () 
+  (interactive)
+  (festival-send-command '(voice_ked_diphone)))
+(defun festival-kal () 
+  (interactive)
+  (festival-send-command '(voice_kal_diphone)))
+(defun festival-don () 
+  (interactive)
+  (festival-send-command '(voice_don_diphone)))
+(defun festival-welsh () 
+  (interactive)
+  (festival-send-command '(voice_welsh_hl)))
+(defun festival-spanish () 
+  (interactive)
+  (festival-send-command '(voice_spanish_el)))
+
+(defun festival-say-string (string)
+   "Send string to festival and have it said"
+   (interactive "sSay: ")
+   (festival-start-process)
+   (process-send-string festival-process 
+			(concat "(SayText " (format "%S" string) ")
+")))
+
+(defun festival-send-command (cmd)
+   "Send command to festival"
+   (interactive "px")
+   (festival-start-process)
+   (process-send-string festival-process (format "%S
+" cmd)))
+
+(defun festival-process-status ()
+  (interactive)
+  (if festival-process
+      (message (format "Festival process status: %s" 
+		       (process-status festival-process)))
+    (message (format "Festival process status: NONE"))))
+
+(defun festival-start-process ()
+  "Check status of process and start it if necessary"
+  (interactive )
+  (let ((process-connection-type t))
+    (if (and festival-process
+	     (eq (process-status festival-process) 'run))
+	't
+      ;;(festival-kill-festival t)
+      (message "Starting new synthesizer process...")
+      (sit-for 0)
+      (setq festival-process
+	    (start-process "festival" (get-buffer-create "*festival*")
+			   festival-program-name)))
+    ))
+
+(defun festival-kill-process ()
+  "Kill festival sub-process"
+  (interactive)
+  (if festival-process
+      (kill-process festival-process))
+  (setq festival-process nil)
+  (message "Festival process killed"))
+
+(defun festival-send-string (string)
+  "Send given string to fesitval process."
+  (interactive)
+  (festival-start-process)
+  (process-send-string festival-process string))
+
+(defun festival-say-region (reg-start reg-end)
+  "Send given region to festival for saying.  This saves the region
+as a file in /tmp and then tells festival to say that file.  The
+major mode is *not* passed as text mode name to Festival."
+  (interactive "r")
+  (write-region reg-start reg-end festival-tmp-file)
+  (festival-send-command (list 'tts festival-tmp-file nil)))
+
+(defun festival-say-buffer ()
+  "Send given region to festival for saying.  This saves the region
+as a file in /tmp and then tells festival to say that file.  The
+major-mode is passed as a text mode to Festival."
+  (interactive)
+  (write-region (point-min) (point-max) festival-tmp-file)
+  ;; Because there may by sgml-like sub-files mentioned 
+  ;; ensure festival tracks the buffer's default-directory
+  (festival-send-command (list 'cd (expand-file-name default-directory)))
+  (if (equal "-mode" (substring (format "%S" major-mode) -5 nil))
+      (if (equal "sgml" (substring (format "%S" major-mode) 0 -5))
+	  (festival-send-command 
+	   (list 'tts festival-tmp-file "sable"))
+	(festival-send-command 
+	 (list 'tts festival-tmp-file 
+	       (substring (format "%S" major-mode) 0 -5))))
+    (festival-send-command (list 'tts festival-tmp-file nil))))
+
+;;
+;; say-minor-mode provides a menu offering various speech synthesis commands
+;;
+(defvar say-minor-mode nil)
+
+(defun say-minor-mode (arg)
+  "Toggle say minor mode.
+With arg, turn say-minor-mode on iff arg is positive."
+  (interactive "P")
+  (setq say-minor-mode
+	(if (if (null arg) (not say-minor-mode)
+	      (> (prefix-numeric-value arg) 0))
+	    t))
+  (force-mode-line-update))
+
+(setq say-params-menu (make-sparse-keymap "Pitch/Duration"))
+(fset 'say-params-menu (symbol-value 'say-params-menu))
+(define-key say-params-menu [say-fast] '("Fast" . festival-fast))
+(define-key say-params-menu [say-slow] '("Slow" . festival-slow))
+(define-key say-params-menu [say-ndur] '("Normal Dur" . festival-ndur))
+
+(setq say-lang-menu (make-sparse-keymap "Select language"))
+(fset 'say-lang-menu (symbol-value 'say-lang-menu))
+(define-key say-lang-menu [say-lang-spain1] '("Spanish el" . festival-spanish))
+(define-key say-lang-menu [say-lang-welsh1] '("Welsh hl" . festival-welsh))
+(define-key say-lang-menu [say-lang-eng5] '("English gsw" . festival-gsw))
+(define-key say-lang-menu [say-lang-eng4] '("English don" . festival-don))
+(define-key say-lang-menu [say-lang-eng3] '("English rab" . festival-rab))
+(define-key say-lang-menu [say-lang-eng2] '("English ked" . festival-ked))
+(define-key say-lang-menu [say-lang-eng1] '("English kal" . festival-kal))
+;(define-key say-params-menu [say-set-dur-stretch] 
+;  '("Set Duration Stretch" . festival-set-dur-stretch))
+;(define-key say-params-menu [say-high] '("High" . festival-high))
+;(define-key say-params-menu [say-low] '("Low" . festival-low))
+;(define-key say-params-menu [say-npit] '("Normal Pitch" . festival-npit))
+;(define-key say-params-menu [say-set-pitch-stretch] 
+;  '("Set Pitch Stretch" . festival-set-pitch-stretch))
+
+(setq say-minor-mode-map (make-sparse-keymap))
+(setq say-menu (make-sparse-keymap "SAY"))
+(define-key say-minor-mode-map [menu-bar SAY] (cons "Say" say-menu))
+(define-key say-minor-mode-map [menu-bar SAY festival-intro] '("Festival Intro" . festival-intro))
+(define-key say-minor-mode-map [menu-bar SAY festival-process-status] '("Festival status" . festival-process-status))
+(define-key say-minor-mode-map [menu-bar SAY festival-kill-process] '("Kill Festival" . festival-kill-process))
+(define-key say-minor-mode-map [menu-bar SAY festival-start-process] '("(Re)start Festival" . festival-start-process))
+;;(define-key say-menu [separator-process] '("--"))
+;;(define-key say-menu [params] '("Pitch/Durations" . say-params-menu))
+(define-key say-menu [separator-buffers] '("--"))
+(define-key say-menu [festival-send-command] '("Festival eval command" . festival-send-command))
+(define-key say-menu [say-lang-menu] '("Select language" . say-lang-menu))
+(define-key say-menu [festival-say-buffer] '("Say buffer" . festival-say-buffer))
+(define-key say-menu [festival-say-region] '("Say region" . festival-say-region))
+
+
+(setq minor-mode-map-alist
+      (cons
+       (cons 'say-minor-mode say-minor-mode-map)
+       minor-mode-map-alist))
+
+(or (assq 'say-minor-mode minor-mode-alist)
+              (setq minor-mode-alist
+                    (cons '(say-minor-mode "") minor-mode-alist)))
+
+;;;
+;;;  A FESTIVAL inferior mode  (copied from prolog.el)
+;;;
+(defvar inferior-festival-mode-map nil)
+
+(defun inferior-festival-mode ()
+  "Major mode for interacting with an inferior FESTIVAL process.
+
+The following commands are available:
+\\{inferior-festival-mode-map}
+
+Entry to this mode calls the value of `festival-mode-hook' with no arguments,
+if that value is non-nil.  Likewise with the value of `comint-mode-hook'.
+`festival-mode-hook' is called after `comint-mode-hook'.
+
+You can send text to the inferior FESTIVAL from other buffers
+using the commands `send-region', `send-string'
+
+Return at end of buffer sends line as input.
+Return not at end copies rest of line to end and sends it.
+\\[comint-kill-input] and \\[backward-kill-word] are kill commands, imitating normal Unix input editing.
+\\[comint-interrupt-subjob] interrupts the shell or its current subjob if any.
+\\[comint-stop-subjob] stops. \\[comint-quit-subjob] sends quit signal."
+  (interactive)
+  (require 'comint)
+  (comint-mode)
+  (setq major-mode 'inferior-festival-mode
+	mode-name "Inferior FESTIVAL"
+	comint-prompt-regexp "^festival> ")
+  (if inferior-festival-mode-map nil
+    (setq inferior-festival-mode-map (copy-keymap comint-mode-map))
+    (festival-mode-commands inferior-festival-mode-map))
+  (use-local-map inferior-festivalr-mode-map)
+  (run-hooks 'festival-mode-hook))
+
+;;;###autoload
+(defun run-festival ()
+  "Run an inferior FESTIVAL process, input and output via buffer *festival*."
+  (interactive)
+  (require 'comint)
+  (switch-to-buffer (make-comint "festival" festival-program-name))
+  (inferior-festival-mode))
+
+(provide 'festival)

CosyVoice-ttsfrd/resource/festival/festival.scm

@@ -0,0 +1,633 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  General Festival Scheme specific functions
+;;;  Including definitions of various standard variables.
+
+;; will be set automatically on start-up
+(defvar festival_version "unknown"
+  "festival_version
+ A string containing the current version number of the system.")
+
+;; will be set automatically on start-up
+(defvar festival_version_number '(x x x)
+  "festival_version_number
+ A list of major, minor and subminor version numbers of the current
+ system.  e.g. (1 0 12).")
+
+(define (apply_method method utt)
+"(apply_method METHOD UTT)
+Apply the appropriate function to utt defined in parameter."
+  (let ((method_val (Parameter.get method)))
+    (cond
+     ((null method_val)
+      nil)   ;; should be an error, but I'll let you off at present
+     ((and (symbol? method_val) (symbol-bound? method_val))
+      (apply (symbol-value method_val) (list utt)))
+     ((member (typeof method_val) '(subr closure))
+      (apply method_val (list utt)))
+     (t      ;; again is probably an error
+      nil))))
+
+(define (require_module l)
+  "(require_module l)
+Check that certain compile-time modules are included in this installation.
+l may be a single atom or list of atoms.  Each item in l must appear in
+*modules* otherwise an error is throw."
+  (if (consp l)
+      (mapcar require_module l)
+      (if (not (member_string l *modules*))
+	  (error (format nil "module %s required, but not compiled in this installation\n" l))))
+  t)
+
+;;;  Feature Function Functions
+(define (utt.features utt relname func_list)
+"(utt.features UTT RELATIONNAME FUNCLIST)
+  Get vectors of feature values for each item in RELATIONNAME in UTT.
+  [see Features]"
+  (mapcar 
+   (lambda (s) 
+     (mapcar (lambda (f) (item.feat s f)) func_list))
+   (utt.relation.items utt relname)))
+
+(define (utt.type utt)
+"(utt.type UTT)
+  Returns the type of UTT."
+  (intern (utt.feat utt 'type)))
+
+(define (utt.save.segs utt filename)
+"(utt.save.segs UTT FILE)
+  Save segments of UTT in a FILE in xlabel format."
+  (let ((fd (fopen filename "w")))
+    (format fd "#\n")
+    (mapcar
+     (lambda (info)
+       (format fd "%2.4f 100 %s\n" (car info) (car (cdr info))))
+     (utt.features utt 'Segment '(segment_end name)))
+    (fclose fd)
+    utt))
+
+(define (utt.save.words utt filename)
+"(utt.save.words UTT FILE)
+  Save words of UTT in a FILE in xlabel format."
+  (let ((fd (fopen filename "w")))
+    (format fd "#\n")
+    (mapcar
+     (lambda (info)
+       (format fd "%2.4f 100 %s\n" (car info) (car (cdr info))))
+     (utt.features utt 'Word '(word_end name)))
+    (fclose fd)
+    utt))
+
+(define (utt.resynth labfile f0file)
+"(utt.resynth LABFILE F0FILE)
+Resynthesize an utterance from a label file and F0 file (in any format
+supported by the Speech Tool Library).   This loads, synthesizes and
+plays the utterance."
+  (let (u f0 f0_item)
+    (set! u (Utterance SegF0)) ; need some u to start with
+    (utt.relation.load u 'Segment labfile)
+    (utt.relation.create u 'f0)
+    (set! f0 (track.load f0file))
+    (set! f0_item (utt.relation.append u 'f0))
+    (item.set_feat f0_item "name" "f0")
+    (item.set_feat f0_item "f0" f0)
+
+    ;; emulabel may have flipped pau to H#
+    (mapcar
+     (lambda (s)
+       (cond
+	((string-matches (item.name s) "[hH]#")
+	 (item.set_feat s "name" "pau"))
+	((string-matches (item.name s) "#.*")
+	 (item.set_feat s "name" (string-after (item.name s) "#")))))
+     (utt.relation.items u 'Segment))
+
+    (Wave_Synth u)
+    (utt.play u)
+    u))
+
+(define (utt.relation.present utt relation)
+"(utt.relation.present UTT RELATIONNAME)
+Returns t if UTT caontains a relation called RELATIONNAME, nil otherwise."
+  (if (member_string relation (utt.relationnames utt))
+      t
+      nil))
+
+(define (utt.relation.leafs utt relation)
+"(utt.relation.leafs UTT RELATIONNAME)
+Returns a list of all the leafs in this relation."
+  (let ((leafs nil))
+    (mapcar
+     (lambda (i)
+       (if (not (item.down (item.relation i relation)))
+	   (set! leafs (cons i leafs))))
+     (utt.relation.items utt relation))
+    (reverse leafs)))
+
+(define (utt.relation.first utt relation)
+"(utt.relation.first UTT RELATIONNAME)
+Returns a the first item in this relation."
+  (utt.relation utt relation))
+
+(define (utt.relation.last utt relation)
+"(utt.relation.last UTT RELATIONNAME)
+Returns a the last item in this relation."
+  (let ((i (utt.relation.first utt relation)))
+    (while (item.next i)
+	   (set! i (item.next i)))
+    i))
+
+(define (item.feat.present item feat)
+  "(item.feat.present item feat)
+nil if feat doesn't existing in this item, non-nil otherwise."
+  (and item (assoc_string feat (item.features item))))
+
+(define (item.relation.append_daughter parent relname daughter)
+"(item.relation.append_daughter parent relname daughter)
+Make add daughter to parent as a new daughter in relname."
+   (item.append_daughter (item.relation parent relname) daughter))
+
+(define (item.relation.insert si relname newsi direction)
+"(item.relation.insert si relname newsi direction)
+Insert newsi in relation relname with respect to direction.  If
+direction is ommited after is assumed, valid directions are after
+before, above and below.  Note you should use 
+item.relation.append_daughter for tree adjoining.  newsi maybe
+a item itself of a LISP description of one."
+   (item.insert 
+    (item.relation si relname)
+    newsi
+    direction))
+
+(define (item.relation.daughters parent relname)
+  "(item.relation.daughters parent relname)
+Return a list of all daughters of parent by relname."
+  (let ((d1 (item.daughter1 (item.relation parent relname)))
+	(daughters))
+    (while d1
+	   (set! daughters (cons d1 daughters))
+	   (set! d1 (item.next d1)))
+    (reverse daughters)))
+
+(define (item.daughters p)
+  "(item.daughters parent)
+Return a list of all daughters of parent."
+  (item.relation.daughters p (item.relation.name p)))
+
+(define (item.relation.parent si relname)
+  "(item.relation.parent item relname)
+Return the parent of this item in this relation."
+  (item.parent (item.relation si relname)))
+
+(define (item.relation.daughter1 si relname)
+  "(item.relation.daughter1 item relname)
+Return the first daughter of this item in this relation."
+  (item.daughter1 (item.relation si relname)))
+
+(define (item.relation.daughter2 si relname)
+  "(item.relation.daughter2 item relname)
+Return the second daughter of this item in this relation."
+  (item.daughter2 (item.relation si relname)))
+
+(define (item.relation.daughtern si relname)
+  "(item.relation.daughtern item relname)
+Return the final daughter of this item in this relation."
+  (item.daughtern (item.relation si relname)))
+
+(define (item.relation.next si relname)
+  "(item.relation.next item relname)
+Return the next item in this relation."
+  (item.next (item.relation si relname)))
+
+(define (item.relation.prev si relname)
+  "(item.relation.prev item relname)
+Return the previous item in this relation."
+  (item.prev (item.relation si relname)))
+
+(define (item.relation.first si relname)
+  "(item.relation.first item relname)
+Return the most previous item from this item in this relation."
+  (let ((n (item.relation si relname)))
+    (while (item.prev n)
+     (set! n (item.prev n)))
+    n))
+
+(define (item.leafs si)
+  "(item.relation.leafs item relname)
+Return a list of the leafs of this item in this relation."
+  (let ((ls nil)
+	(pl (item.first_leaf si))
+	(ll (item.next_leaf (item.last_leaf si))))
+    (while (and pl (not (equal? pl ll)))
+	   (set! ls (cons pl ls))
+	   (set! pl (item.next_leaf pl)))
+    (reverse ls)))
+
+(define (item.relation.leafs si relname)
+  "(item.relation.leafs item relname)
+Return a list of the leafs of this item in this relation."
+  (item.leafs (item.relation si relname)))
+
+(define (item.root s)
+  "(item.root s)
+Follow parent link until s has no parent."
+  (cond
+   ((item.parent s) 
+    (item.root (item.parent s)))
+   (t s)))
+
+(define (item.parent_to s relname)
+  "(item.parent_to s relname)
+Find the first ancestor of s in its current relation that is also in
+relname.  s is treated as an ancestor of itself so if s is in relname
+it is returned.  The returned value is in will be in relation relname
+or nil if there isn't one."
+  (cond
+   ((null s) s)
+   ((member_string relname (item.relations s)) 
+    (item.relation s relname))
+   (t (item.parent_to (item.parent s) relname))))
+
+(define (item.daughter1_to s relname)
+  "(item.daughter1_to s relname)
+Follow daughter1 links of s in its current relation until an item
+is found that is also in relname, is s is in relname it is returned.
+The return item is returned in relation relname, or nil if there is
+nothing in relname."
+  (cond
+   ((null s) s)
+   ((member_string relname (item.relations s)) (item.relation s relname))
+   (t (item.daughter1_to (item.daughter1 s) relname))))
+
+(define (item.daughtern_to s relname)
+  "(item.daughter1_to s relname)
+Follow daughtern links of s in its current relation until an item
+is found that is also in relname, is s is in relname it is returned.
+The return item is returned in relation relname, or nil if there is
+nothing in relname."
+  (cond
+   ((null s) s)
+   ((member_string relname (item.relations s)) (item.relation s relname))
+   (t (item.daughtern_to (item.daughtern s) relname))))
+
+(define (item.name s)
+"(item.name ITEM)
+  Returns the name of ITEM. [see Accessing an utterance]"
+  (item.feat s "name"))
+
+(define (utt.wave utt)
+  "(utt.wave UTT)
+Get waveform from wave (R:Wave.first.wave)."
+  (item.feat (utt.relation.first utt "Wave") "wave"))
+
+(define (utt.wave.rescale . args)
+ "(utt.wave.rescale UTT FACTOR NORMALIZE)
+Modify the gain of the waveform in UTT by GAIN.  If NORMALIZE is
+specified and non-nil the waveform is maximized first."
+  (wave.rescale (utt.wave (nth 0 args)) (nth 1 args) (nth 2 args))
+  (nth 0 args))
+
+(define (utt.wave.resample utt rate)
+  "(utt.wave.resample UTT RATE)\
+Resample waveform in UTT to RATE (if it is already at that rate it remains
+unchanged)."
+  (wave.resample (utt.wave utt) rate)
+  utt)
+
+(define (utt.import.wave . args)
+  "(utt.import.wave UTT FILENAME APPEND)
+Load waveform in FILENAME into UTT in R:Wave.first.wave.  If APPEND
+is specified and non-nil append this to the current waveform."
+  (let ((utt (nth 0 args))
+	(filename (nth 1 args))
+	(append (nth 2 args)))
+    (if (and append (member 'Wave (utt.relationnames utt)))
+        (wave.append (utt.wave utt) (wave.load filename))
+	(begin
+	  (utt.relation.create utt 'Wave)
+	  (item.set_feat
+	   (utt.relation.append utt 'Wave)
+	   "wave"
+	   (wave.load filename))))
+    utt))
+
+(define (utt.save.wave . args)
+  "(utt.save.wave UTT FILENAME FILETYPE)
+Save waveform in UTT in FILENAME with FILETYPE (if specified) or
+using global parameter Wavefiletype."
+  (wave.save 
+   (utt.wave (nth 0 args))
+   (nth 1 args)
+   (nth 2 args))
+  (nth 0 args))
+
+(define (utt.play utt)
+  "(utt.play UTT)
+Play waveform in utt by current audio method."
+  (wave.play (utt.wave utt))
+  utt)
+
+(define (utt.save.track utt filename relation feature)
+  "(utt.save.track utt filename relation feature)
+DEPRICATED use trace.save instead."
+  (format stderr "utt.save.track: DEPRICATED use track.save instead\n")
+  (track.save 
+   (item.feat
+    (utt.relation.first utt relation)
+    feature)
+   filename)
+  utt)
+
+(define (utt.import.track utt filename relation fname)
+  "(utt.import.track UTT FILENAME RELATION FEATURE_NAME)
+Load track in FILENAME into UTT in R:RELATION.first.FEATURE_NAME.
+Deletes RELATION if it already exists. (you maybe want to use track.load
+directly rather than this legacy function."
+  (utt.relation.create utt relation)
+  (item.set_feat
+   (utt.relation.append utt relation)
+   fname
+   (track.load filename))
+  utt)
+
+(define (wagon_predict item tree)
+"(wagon_predict ITEM TREE)
+Predict with given ITEM and CART tree and return the prediction
+(the last item) rather than whole probability distribution."
+ (car (last (wagon item tree))))
+
+(define (phone_is_silence phone)
+  (member_string 
+   phone
+   (car (cdr (car (PhoneSet.description '(silences)))))))
+
+(define (phone_feature phone feat)
+"(phone_feature phone feat)
+Return the feature for given phone in current phone set, or 0
+if it doesn't exist."
+  (let ((ph (intern phone)))
+    (let ((fnames (cadr (assoc 'features (PhoneSet.description))))
+	  (fvals (cdr (assoc ph (cadr (assoc 'phones (PhoneSet.description)))))))
+      (while (and fnames (not (string-equal feat (car (car fnames)))))
+	     (set! fvals (cdr fvals))
+	     (set! fnames (cdr fnames)))
+      (if fnames
+	  (car fvals)
+	  0))))
+
+(defvar server_max_clients 10
+  "server_max_clients
+In server mode, the maximum number of clients supported at any one
+time.  When more that this number of clients attach simulaneous
+the last ones are denied access.  Default value is 10.
+[see Server/client API]")
+
+(defvar server_port 1314
+  "server_port
+In server mode the inet port number the server will wait for connects
+on.  The default value is 1314. [see Server/client API]")
+
+(defvar server_log_file t
+  "server_log_file
+If set to t server log information is printed to standard output
+of the server process.  If set to nil no output is given.  If set
+to anything else the value is used as the name of file to which
+server log information is appended.  Note this value is checked at
+server start time, there is no way a client may change this.
+[see Server/client API]")
+
+(defvar server_passwd nil
+  "server_passwd
+If non-nil clients must send this passwd to the server followed by
+a newline before they can get a connection.  It would be normal
+to set this for the particular server task.
+[see Server/client API]")
+
+(defvar server_access_list '(localhost)
+  "server_access_list
+If non-nil this is the exhaustive list of machines and domains
+from which clients may access the server.  This is a list of REGEXs
+that client host must match.  Remember to add the backslashes before
+the dots. [see Server/client API]")
+
+(defvar server_deny_list nil
+  "server_deny_list
+If non-nil this is a list of machines which are to be denied access
+to the server absolutely, irrespective of any other control features.
+The list is a list of REGEXs that are used to matched the client hostname.
+This list is checked first, then server_access_list, then passwd.
+[see Server/client API]")
+
+(define (def_feature_docstring fname fdoc)
+"(def_feature_docstring FEATURENAME FEATUREDOC)
+As some feature are used directly of stream items with no
+accompanying feature function, the features are just values on the feature
+list.  This function also those features to have an accompanying
+documentation string."
+  (let ((fff (assoc fname ff_docstrings)))
+    (cond
+     (fff  ;; replace what's already there
+      (set-cdr! fff fdoc))
+     (t
+      (set! ff_docstrings (cons (cons fname fdoc) ff_docstrings))))
+    t))
+
+(define (linear_regression item model)
+  "(linear_regression ITEM MODEL)
+Use linear regression MODEL on ITEM.  MODEL consists of a list
+of features, weights and optional map list.  E.g. ((Intercept 100)
+(tobi_accent 10 (H* !H*)))."
+  (let ((intercept (if (equal? 'Intercept (car (car model))) 
+                       (car (cdr (car model))) 0))
+        (mm (if (equal? 'Intercept (car (car model))) 
+                (cdr model) model)))
+  (apply + 
+   (cons intercept
+   (mapcar
+    (lambda (f)
+     (let ((ff (item.feat item (car f))))
+      (if (car (cdr (cdr f)))
+         (if (member_string ff (car (cdr (cdr f))))
+           (car (cdr f))
+           0)
+         (* (parse-number ff) (car (cdr f))))))
+    mm)))))
+
+(defvar help
+ "The Festival Speech Synthesizer System: Help
+
+Getting Help
+  (doc '<SYMBOL>)   displays help on <SYMBOL>
+  (manual nil)      displays manual in local netscape
+  C-c               return to top level
+  C-d or (quit)     Exit Festival
+(If compiled with editline)
+  M-h               displays help on current symbol  
+  M-s               speaks help on current symbol  
+  M-m               displays relevant manula page in local netscape
+  TAB               Command, symbol and filename completion
+  C-p or up-arrow   Previous command
+  C-b or left-arrow Move back one character
+  C-f or right-arrow 
+                    Move forward one character
+  Normal Emacs commands work for editing command line
+
+Doing stuff
+  (SayText TEXT)      Synthesize text, text should be surrounded by
+                      double quotes
+  (tts FILENAME nil)  Say contexts of file, FILENAME should be 
+                      surrounded by double quotes
+  (voice_rab_diphone) Select voice (Britsh Male)
+  (voice_kal_diphone) Select voice (American Male)
+")
+
+(define (festival_warranty)
+"(festival_warranty)
+  Display Festival's copyright and warranty. [see Copying]"
+ (format t
+   (string-append
+    "    The Festival Speech Synthesis System: "
+    festival_version
+"
+                Centre for Speech Technology Research                  
+                     University of Edinburgh, UK                       
+                       Copyright (c) 1996-2014
+                        All Rights Reserved.                           
+                                                                       
+  Permission is hereby granted, free of charge, to use and distribute  
+  this software and its documentation without restriction, including   
+  without limitation the rights to use, copy, modify, merge, publish,  
+  distribute, sublicense, and/or sell copies of this work, and to      
+  permit persons to whom this work is furnished to do so, subject to   
+  the following conditions:                                            
+   1. The code must retain the above copyright notice, this list of    
+      conditions and the following disclaimer.                         
+   2. Any modifications must be clearly marked as such.                
+   3. Original authors' names are not deleted.                         
+   4. The authors' names are not used to endorse or promote products   
+      derived from this software without specific prior written        
+      permission.                                                      
+                                  
+  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        
+  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      
+  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   
+  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     
+  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   
+  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          
+  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       
+  THIS SOFTWARE.                                                       
+")))
+
+(define (intro)
+"(intro)
+ Synthesize an introduction to the Festival Speech Synthesis System."
+  (tts (path-append libdir "../examples/intro.text") nil))
+
+(define (intro-spanish)
+"(intro-spanish)
+ Synthesize an introduction to the Festival Speech Synthesis System
+ in spanish.  Spanish voice must already be selected for this."
+  (tts (path-append libdir "../examples/spintro.text") nil))
+
+(define (na_play FILENAME)
+"(play_wave FILENAME)
+Play given wavefile"
+ (utt.play (utt.synth (eval (list 'Utterance 'Wave FILENAME)))))
+
+;;; Some autoload commands
+(autoload manual-sym "festdoc" "Show appropriate manual section for symbol.")
+(autoload manual "festdoc" "Show manual section.")
+
+(autoload display "display" "Graphically display utterance.")
+
+(autoload festtest "festtest" "Run tests of Festival.")
+
+(defvar diphone_module_hooks nil
+  "diphone_module_hooks
+  A function or list of functions that will be applied to the utterance
+  at the start of the diphone module.  It can be used to map segment 
+  names to those that will be used by the diphone database itself.
+  Typical use specifies _ and $ for consonant clusters and syllable 
+  boundaries, mapping to dark ll's etc.  Reduction and tap type 
+  phenomena should probabaly be done by post lexical rules though the 
+  distinction is not a clear one.")
+
+(def_feature_docstring
+  'Segment.diphone_phone_name
+  "Segment.diphone_phone_name
+  This is produced by the diphone module to contain the desired phone
+  name for the desired diphone.  This adds things like _ if part of 
+  a consonant or $ to denote syllable boundaries.  These are generated
+  on a per voice basis by function(s) specified by diphone_module_hooks.
+  Identification of dark ll's etc. may also be included.  Note this is not
+  necessarily the name of the diphone selected as if it is not found
+  some of these characters will be removed and fall back values will be
+  used.")
+
+(def_feature_docstring
+  'Syllable.stress
+  "Syllable.stress
+  The lexical stress of the syllable as specified from the lexicon entry
+  corresponding to the word related to this syllable.")
+
+;;;
+;;;  I tried some tests on the resulting speed both runtime and loadtime
+;;;  but compiled files don't seem to make any significant difference
+;;;
+(define (compile_library)
+  "(compile_library)
+Compile all the scheme files in the library directory."
+  (mapcar
+   (lambda (file)
+     (format t "compile ... %s\n" file)
+     (compile-file (string-before file ".scm")))
+   (list
+     "synthesis.scm" "siod.scm" "init.scm" "lexicons.scm"
+     "festival.scm" "gsw_diphone.scm" "intonation.scm" "duration.scm"
+     "pos.scm" "phrase.scm" "don_diphone.scm" "rab_diphone.scm"
+     "voices.scm" "tts.scm" "festdoc.scm" "languages.scm" "token.scm"
+     "mbrola.scm" "display.scm" "postlex.scm" "tokenpos.scm"
+     "festtest.scm" "cslush.scm" "ducs_cluster.scm" "sucs.scm"
+     "web.scm" "cart_aux.scm"
+     "lts_nrl.scm" "lts_nrl_us.scm" "email-mode.scm"
+     "mrpa_phones.scm" "radio_phones.scm" "holmes_phones.scm"
+     "mrpa_durs.scm" "klatt_durs.scm" "gswdurtreeZ.scm"
+     "tobi.scm" "f2bf0lr.scm"))
+  t)
+
+;;; For mlsa resynthesizer
+(defvar mlsa_alpha_param 0.42)
+(defvar mlsa_beta_param 0.0)
+
+(provide 'festival)

CosyVoice-ttsfrd/resource/festival/festtest.scm

@@ -0,0 +1,72 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   Some basic functions used in tests for Festival
+;;;   
+
+(define (test_words text)
+"(test_words TEXT)
+prints TEXT, Synthesizes TEXT and outputs the words in it."
+  (format t "Word test: %s\n  " text)
+  (set! utt1 (utt.synth (eval (list 'Utterance 'Text text))))
+  (mapcar
+   (lambda (word) (format t "%s " (car word)))
+   (utt.features utt1 'Word '(name)))
+  (format t "\n")
+  t)
+
+(define (test_segments text)
+"(test_segments TEXT)
+prints TEXT, Synthesizes TEXT and outputs the segments in it."
+  (format t "Segment test: %s\n  " text)
+  (set! utt1 (utt.synth (eval (list 'Utterance 'Text text))))
+  (mapcar
+   (lambda (word) (format t "%s " (car word)))
+   (utt.features utt1 'Segment '(name)))
+  (format t "\n")
+)
+
+(define (test_phrases text)
+"(test_phrases TEXT)
+prints TEXT, Synthesizes TEXT and outputs the words and phrase breaks."
+  (format t "Phrase test: %s \n  " text)
+  (set! utt1 (utt.synth (eval (list 'Utterance 'Text text))))
+  (mapcar
+   (lambda (phrase) 
+     (mapcar (lambda (w) (format t "%s " (car (car w)))) (cdr phrase))
+     (format t "%s\n  " (car (car phrase))))
+   (utt.relation_tree utt1 'Phrase))
+  (format t "\n")
+  t)
+
+(provide 'festtest)

CosyVoice-ttsfrd/resource/festival/fringe.scm

@@ -0,0 +1,108 @@
+
+
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;; DO NOT EDIT THIS FILE ON PAIN OF MORE PAIN.
+ ;;; 
+ ;;; The master copy of this file is in ../../speech_tools/lib/siod/fringe.scm
+ ;;; and is copied here at build time.
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+
+
+
+
+
+
+
+
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Talking to fringe.
+
+(defvar fringe_verbose nil
+  "fringe_verbose
+  If this is set true, all subsequent fringe connections will
+  print a trace of what they are doing.")
+
+;;; Aliases which are better suited to command line use.
+
+(defvar fringe_name "fringe"
+  "fringe_name
+  The name of the last name passed to \[fringe_setup\].")
+
+(defvar fringe_connection nil
+  "fringe_connection
+  A connection to fringe, used by the command line fringe functions.")
+
+(define (fringe_setup &opt name)
+  "(fringe_setup &opt name)
+  Connect to fringe."
+
+  (fringe_read_server_table)
+  (if (not name) (set! name fringe_name))
+  (set! fringe_connection (fringe_server "fringe"))
+  (set! fringe_name name)
+  )
+
+(define (fringe command)
+  "(fringe COMMAND)
+  Send COMMAND to the fringe server \[fringe_connection\]
+  For command line use, use (fringe_comand_string...) in scripts. "
+  (if (not fringe_connection) (fringe_setup))
+  (let ((val (fringe_command_string fringe_connection command)))
+    (if (or (null val) (consp val))
+	nil
+	val)
+    )
+  )
+  
+(define (fringel package operation args)
+  "(fringel PACKAGE OPERATION ARGS)
+  Send a command to the fringe server \[fringe_connection\].
+  For command line use, use (fringe_comand...) in scripts. "
+
+  (if (not fringe_connection) (fringe_setup))
+  (let ((val (fringe_command fringe_connection package operation args)))
+    (if (or (null val) (consp val))
+	nil
+	val)
+    )
+  )
+
+(provide 'fringe)

CosyVoice-ttsfrd/resource/festival/gswdurtreeZ.scm

@@ -0,0 +1,947 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   A tree to predict zcore durations build from gsw 450 (timit)
+;;;   doesn't use actual phonemes so it can have better generalizations
+;;;
+
+;; pre Sue's changes to mrpa_phones (on traing data)
+;; RMSE 0.79102 Correlation is 0.610184 Mean (abs) Error 0.605081 (0.509517)
+;; Post with balance
+;; train test spit --stop 19 --balance 16
+;; RMSE 0.841861 Correlation is 0.526064 Mean (abs) Error 0.646614 (0.539288)
+;; on training data
+;; RMSE 0.784032 Correlation is 0.619165 Mean (abs) Error 0.602819 (0.501332)
+;;
+;; Oct 29th 1997
+;; stepwise (but its over trained)
+;; RMSE 0.8322 Correlation is 0.5286 Mean (abs) Error 0.6375 (0.5350)
+;;
+;; May 11th 1998
+;; new architecture, full new train on f2b on test data
+;; in zscore domain
+;; RMSE 0.8076 Correlation is 0.5307 Mean (abs) Error 0.6113 (0.5278)
+;; in absolute domain
+;; RMSE 0.0276 Correlation 0.7468 Mean (abs) error 0.0203 (0.0187)
+;;
+;; May 18th 1998
+;; various corrections f2bdur.bbz.H0.S50.tree no names zscore
+;; in zscore domain
+;; RMSE 0.8049 Correlation is 0.6003 Mean (abs) Error 0.6008 (0.5357)
+;; in absolute domain
+;; RMSE 0.0268 Correlation 0.7766 Mean (abs) error 0.0196 (0.0183)
+
+(set! gsw_duration_cart_tree
+'
+((name is #)
+ ((emph_sil is +)
+  ((0.0 -0.5))
+  ((p.R:SylStructure.parent.parent.pbreak is BB)
+   ((0.0 2.0))  
+   ((0.0 0.0))))
+
+((R:SylStructure.parent.accented is 0)
+ ((n.ph_ctype is 0)
+  ((p.ph_vlng is 0)
+   ((R:SylStructure.parent.syl_codasize < 1.5)
+    ((p.ph_ctype is n)
+     ((ph_ctype is f)
+      ((0.559208 -0.783163))
+      ((1.05215 -0.222704)))
+     ((ph_ctype is s)
+      ((R:SylStructure.parent.syl_break is 2)
+       ((0.589948 0.764459))
+       ((R:SylStructure.parent.asyl_in < 0.7)
+        ((1.06385 0.567944))
+        ((0.691943 0.0530272))))
+      ((ph_vlng is l)
+       ((pp.ph_vfront is 1)
+        ((1.06991 0.766486))
+        ((R:SylStructure.parent.syl_break is 1)
+         ((0.69665 0.279248))
+         ((0.670353 0.0567774))))
+       ((p.ph_ctype is s)
+        ((seg_onsetcoda is coda)
+         ((0.828638 -0.038356))
+         ((ph_ctype is f)
+          ((0.7631 -0.545853))
+          ((0.49329 -0.765994))))
+        ((R:SylStructure.parent.parent.gpos is det)
+         ((R:SylStructure.parent.last_accent < 0.3)
+          ((R:SylStructure.parent.sub_phrases < 1)
+           ((0.811686 0.160195))
+           ((0.799015 0.713958)))
+          ((0.731599 -0.215472)))
+         ((ph_ctype is r)
+          ((0.673487 0.092772))
+          ((R:SylStructure.parent.asyl_in < 1)
+           ((0.745273 0.00132813))
+           ((0.75457 -0.334898)))))))))
+    ((pos_in_syl < 0.5)
+     ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+      ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+       ((0.902446 -0.041618))
+       ((R:SylStructure.parent.sub_phrases < 2.3)
+        ((0.900629 0.262952))
+        ((1.18474 0.594794))))
+      ((seg_onset_stop is 0)
+       ((R:SylStructure.parent.position_type is mid)
+        ((0.512323 -0.760444))
+        ((R:SylStructure.parent.syl_out < 6.8)
+         ((pp.ph_vlng is a)
+          ((0.640575 -0.450449))
+          ((ph_ctype is f)
+           ((R:SylStructure.parent.sub_phrases < 1.3)
+            ((0.862876 -0.296956))
+            ((R:SylStructure.parent.syl_out < 2.4)
+             ((0.803215 0.0422868))
+             ((0.877856 -0.154465))))
+           ((R:SylStructure.parent.syl_out < 3.6)
+            ((R:SylStructure.parent.syl_out < 1.2)
+             ((0.567081 -0.264199))
+             ((0.598043 -0.541738)))
+            ((0.676843 -0.166623)))))
+         ((0.691678 -0.57173))))
+       ((R:SylStructure.parent.parent.gpos is cc)
+        ((1.15995 0.313289))
+        ((pp.ph_vfront is 1)
+         ((0.555993 0.0695819))
+         ((R:SylStructure.parent.asyl_in < 1.2)
+          ((R:SylStructure.parent.sub_phrases < 2.7)
+           ((0.721635 -0.367088))
+           ((0.71919 -0.194887)))
+          ((0.547052 -0.0637491)))))))
+     ((ph_ctype is s)
+      ((R:SylStructure.parent.syl_break is 0)
+       ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+        ((0.650007 -0.333421))
+        ((0.846301 -0.165383)))
+       ((0.527756 -0.516332)))
+      ((R:SylStructure.parent.syl_break is 0)
+       ((p.ph_ctype is s)
+        ((0.504414 -0.779112))
+        ((0.812498 -0.337611)))
+       ((pos_in_syl < 1.4)
+        ((0.513041 -0.745807))
+        ((p.ph_ctype is s)
+         ((0.350582 -1.04907))
+         ((0.362 -0.914974))))))))
+   ((R:SylStructure.parent.syl_break is 0)
+    ((ph_ctype is n)
+     ((R:SylStructure.parent.position_type is initial)
+      ((pos_in_syl < 1.2)
+       ((0.580485 0.172658))
+       ((0.630973 -0.101423)))
+      ((0.577937 -0.360092)))
+     ((R:SylStructure.parent.syl_out < 2.9)
+      ((R:SylStructure.parent.syl_out < 1.1)
+       ((R:SylStructure.parent.position_type is initial)
+        ((0.896092 0.764189))
+        ((R:SylStructure.parent.sub_phrases < 3.6)
+         ((ph_ctype is s)
+          ((0.877362 0.555132))
+          ((0.604511 0.369882)))
+         ((0.799982 0.666966))))
+       ((seg_onsetcoda is coda)
+        ((p.ph_vlng is a)
+         ((R:SylStructure.parent.last_accent < 0.4)
+          ((0.800736 0.240634))
+          ((0.720606 0.486176)))
+         ((1.18173 0.573811)))
+        ((0.607147 0.194468))))
+      ((ph_ctype is r)
+       ((0.88377 0.499383))
+       ((R:SylStructure.parent.last_accent < 0.5)
+        ((R:SylStructure.parent.position_type is initial)
+         ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+          ((0.62798 0.0737318))
+          ((0.787334 0.331014)))
+         ((ph_ctype is s)
+          ((0.808368 0.0929299))
+          ((0.527948 -0.0443271))))
+        ((seg_coda_fric is 0)
+         ((p.ph_vlng is a)
+          ((0.679745 0.517681))
+          ((R:SylStructure.parent.sub_phrases < 1.1)
+           ((0.759979 0.128316))
+           ((0.775233 0.361383))))
+         ((R:SylStructure.parent.last_accent < 1.3)
+          ((0.696255 0.054136))
+          ((0.632425 0.246742))))))))
+    ((pos_in_syl < 0.3)
+     ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+      ((0.847602 0.621547))
+      ((ph_ctype is s)
+       ((0.880645 0.501679))
+       ((R:SylStructure.parent.sub_phrases < 3.3)
+        ((R:SylStructure.parent.sub_phrases < 0.3)
+         ((0.901014 -0.042049))
+         ((0.657493 0.183226)))
+        ((0.680126 0.284799)))))
+     ((ph_ctype is s)
+      ((p.ph_vlng is s)
+       ((0.670033 -0.820934))
+       ((0.863306 -0.348735)))
+      ((ph_ctype is n)
+       ((R:SylStructure.parent.asyl_in < 1.2)
+        ((0.656966 -0.40092))
+        ((0.530966 -0.639366)))
+       ((seg_coda_fric is 0)
+        ((1.04153 0.364857))
+        ((pos_in_syl < 1.2)
+         ((R:SylStructure.parent.syl_out < 3.4)
+          ((0.81503 -0.00768613))
+          ((0.602665 -0.197753)))
+         ((0.601844 -0.394632)))))))))
+  ((n.ph_ctype is f)
+   ((pos_in_syl < 1.5)
+    ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+     ((pos_in_syl < 0.1)
+      ((1.63863 0.938841))
+      ((R:SylStructure.parent.position_type is initial)
+       ((0.897722 -0.0796637))
+       ((nn.ph_vheight is 0)
+        ((0.781081 0.480026))
+        ((0.779711 0.127175)))))
+     ((ph_ctype is r)
+      ((p.ph_ctype is s)
+       ((0.581329 -0.708767))
+       ((0.564366 -0.236212)))
+      ((ph_vlng is a)
+       ((p.ph_ctype is r)
+        ((0.70992 -0.273389))
+        ((R:SylStructure.parent.parent.gpos is in)
+         ((0.764696 0.0581338))
+         ((nn.ph_vheight is 0)
+          ((0.977737 0.721904))
+          ((R:SylStructure.parent.sub_phrases < 2.2)
+           ((pp.ph_vfront is 0)
+            ((0.586708 0.0161206))
+            ((0.619949 0.227372)))
+           ((0.707285 0.445569))))))
+       ((ph_ctype is n)
+        ((R:SylStructure.parent.syl_break is 1)
+         ((nn.ph_vfront is 2)
+          ((0.430295 -0.120097))
+          ((0.741371 0.219042)))
+         ((0.587492 0.321245)))
+        ((p.ph_ctype is n)
+         ((0.871586 0.134075))
+         ((p.ph_ctype is r)
+          ((0.490751 -0.466418))
+          ((R:SylStructure.parent.syl_codasize < 1.3)
+           ((R:SylStructure.parent.sub_phrases < 2.2)
+            ((p.ph_ctype is s)
+             ((0.407452 -0.425925))
+             ((0.644771 -0.542809)))
+            ((0.688772 -0.201899)))
+           ((ph_vheight is 1)
+            ((nn.ph_vheight is 0)
+             ((0.692018 0.209018))
+             ((0.751345 -0.178136)))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+             ((R:SylStructure.parent.asyl_in < 1.5)
+              ((0.599633 -0.235593))
+              ((0.60042 0.126118)))
+             ((p.ph_vlng is a)
+              ((0.7148 -0.174812))
+              ((R:SylStructure.parent.parent.gpos is content)
+               ((0.761296 -0.231509))
+               ((0.813081 -0.536405)))))))))))))
+    ((ph_ctype is n)
+     ((0.898844 0.163343))
+     ((p.ph_vlng is s)
+      ((seg_coda_fric is 0)
+       ((0.752921 -0.45528))
+       ((0.890079 -0.0998025)))
+      ((ph_ctype is f)
+       ((0.729376 -0.930547))
+       ((ph_ctype is s)
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+         ((0.745052 -0.634119))
+         ((0.521502 -0.760176)))
+        ((R:SylStructure.parent.syl_break is 1)
+         ((0.766575 -0.121355))
+         ((0.795616 -0.557509))))))))
+   ((p.ph_vlng is 0)
+    ((p.ph_ctype is r)
+     ((ph_vlng is 0)
+      ((0.733659 -0.402734))
+      ((R:SylStructure.parent.sub_phrases < 1.5)
+       ((ph_vlng is s)
+        ((0.326176 -0.988478))
+        ((n.ph_ctype is s)
+         ((0.276471 -0.802536))
+         ((0.438283 -0.900628))))
+       ((nn.ph_vheight is 0)
+        ((ph_vheight is 2)
+         ((0.521 -0.768992))
+         ((0.615436 -0.574918)))
+        ((ph_vheight is 1)
+         ((0.387376 -0.756359))
+         ((pos_in_syl < 0.3)
+          ((0.417235 -0.808937))
+          ((0.384043 -0.93315)))))))
+     ((ph_vlng is a)
+      ((ph_ctype is 0)
+       ((n.ph_ctype is s)
+        ((p.ph_ctype is f)
+         ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+          ((0.415908 -0.428493))
+          ((pos_in_syl < 0.1)
+           ((0.790441 0.0211071))
+           ((0.452465 -0.254485))))
+         ((p.ph_ctype is s)
+          ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+           ((0.582447 -0.389966))
+           ((0.757648 0.185781)))
+          ((R:SylStructure.parent.sub_phrases < 1.4)
+           ((0.628965 0.422551))
+           ((0.713613 0.145576)))))
+        ((seg_onset_stop is 0)
+         ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+          ((pp.ph_vfront is 1)
+           ((0.412363 -0.62319))
+           ((R:SylStructure.parent.syl_out < 3.6)
+            ((0.729259 -0.317324))
+            ((0.441633 -0.591051))))
+          ((R:SylStructure.parent.syl_break is 1)
+           ((R:SylStructure.parent.sub_phrases < 2.7)
+            ((0.457728 -0.405607))
+            ((0.532411 -0.313148)))
+           ((R:SylStructure.parent.last_accent < 0.3)
+            ((1.14175 0.159416))
+            ((0.616396 -0.254651)))))
+         ((R:SylStructure.parent.position_type is initial)
+          ((0.264181 -0.799896))
+          ((0.439801 -0.551309)))))
+       ((R:SylStructure.parent.position_type is final)
+        ((0.552027 -0.707084))
+        ((0.585661 -0.901874))))
+      ((ph_ctype is s)
+       ((pos_in_syl < 1.2)
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+         ((pp.ph_vfront is 1)
+          ((0.607449 0.196466))
+          ((0.599662 0.00382414)))
+         ((0.64109 -0.12859)))
+        ((pp.ph_vfront is 1)
+         ((0.720484 -0.219339))
+         ((0.688707 -0.516734))))
+       ((ph_vlng is s)
+        ((n.ph_ctype is s)
+         ((R:SylStructure.parent.parent.gpos is content)
+          ((R:SylStructure.parent.position_type is single)
+           ((0.659206 0.159445))
+           ((R:SylStructure.parent.parent.word_numsyls < 3.5)
+            ((R:SylStructure.parent.sub_phrases < 2)
+             ((0.447186 -0.419103))
+             ((0.631822 -0.0928561)))
+            ((0.451623 -0.576116))))
+          ((ph_vheight is 3)
+           ((0.578626 -0.64583))
+           ((0.56636 -0.4665))))
+         ((R:SylStructure.parent.parent.gpos is in)
+          ((0.771516 -0.217292))
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.688571 -0.304382))
+           ((R:SylStructure.parent.parent.gpos is content)
+            ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+             ((n.ph_ctype is n)
+              ((0.556085 -0.572203))
+              ((0.820173 -0.240338)))
+             ((R:SylStructure.parent.parent.word_numsyls < 2.2)
+              ((0.595398 -0.588171))
+              ((0.524737 -0.95797))))
+            ((R:SylStructure.parent.sub_phrases < 3.9)
+             ((0.371492 -0.959427))
+             ((0.440479 -0.845747)))))))
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+         ((p.ph_ctype is f)
+          ((0.524088 -0.482247))
+          ((nn.ph_vheight is 1)
+           ((0.587666 -0.632362))
+           ((ph_vlng is l)
+            ((R:SylStructure.parent.position_type is final)
+             ((0.513286 -0.713117))
+             ((0.604613 -0.924308)))
+            ((R:SylStructure.parent.syl_codasize < 2.2)
+             ((0.577997 -0.891342))
+             ((0.659804 -1.15252))))))
+         ((pp.ph_vlng is s)
+          ((ph_ctype is f)
+           ((0.813383 -0.599624))
+           ((0.984027 -0.0771909)))
+          ((p.ph_ctype is f)
+           ((R:SylStructure.parent.parent.gpos is in)
+            ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+             ((0.313572 -1.03242))
+             ((0.525854 -0.542799)))
+            ((R:SylStructure.parent.syl_out < 2.8)
+             ((0.613007 -0.423979))
+             ((0.570258 -0.766379))))
+           ((R:SylStructure.parent.syl_break is 1)
+            ((R:SylStructure.parent.parent.gpos is to)
+             ((0.364585 -0.792895))
+             ((ph_vlng is l)
+              ((0.69143 -0.276816))
+              ((0.65673 -0.523721))))
+            ((R:SylStructure.parent.syl_out < 3.6)
+             ((R:SylStructure.parent.position_type is initial)
+              ((0.682096 -0.488102))
+              ((0.406364 -0.731758)))
+             ((0.584694 -0.822229)))))))))))
+    ((n.ph_ctype is r)
+     ((R:SylStructure.parent.position_type is initial)
+      ((p.ph_vlng is a)
+       ((0.797058 1.02334))
+       ((ph_ctype is s)
+        ((1.0548 0.536277))
+        ((0.817253 0.138201))))
+      ((R:SylStructure.parent.sub_phrases < 1.1)
+       ((R:SylStructure.parent.syl_out < 3.3)
+        ((0.884574 -0.23471))
+        ((0.772063 -0.525292)))
+       ((nn.ph_vfront is 1)
+        ((1.25254 0.417485))
+        ((0.955557 -0.0781996)))))
+     ((pp.ph_vfront is 0)
+      ((ph_ctype is f)
+       ((n.ph_ctype is s)
+        ((R:SylStructure.parent.parent.gpos is content)
+         ((R:SylStructure.parent.R:Syllable.p.syl_break is 0)
+          ((0.583506 -0.56941))
+          ((0.525949 -0.289362)))
+         ((0.749316 -0.0921038)))
+        ((p.ph_vlng is s)
+         ((0.734234 0.139463))
+         ((0.680119 -0.0708717))))
+       ((ph_vlng is s)
+        ((ph_vheight is 1)
+         ((0.908712 -0.618971))
+         ((0.55344 -0.840495)))
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 1.2)
+         ((pos_in_syl < 1.2)
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.838715 0.00913392))
+           ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+            ((ph_vheight is 2)
+             ((0.555513 -0.512523))
+             ((R:SylStructure.parent.position_type is initial)
+              ((0.758711 0.121704))
+              ((0.737555 -0.25637))))
+            ((R:SylStructure.parent.syl_out < 3.1)
+             ((n.ph_ctype is s)
+              ((0.611756 -0.474522))
+              ((1.05437 -0.247206)))
+             ((R:SylStructure.parent.syl_codasize < 2.2)
+              ((R:SylStructure.parent.position_type is final)
+               ((0.567761 -0.597866))
+               ((0.785599 -0.407765)))
+              ((0.575598 -0.741256))))))
+          ((ph_ctype is s)
+           ((n.ph_ctype is s)
+            ((0.661069 -1.08426))
+            ((0.783184 -0.39789)))
+           ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+            ((R:SylStructure.parent.sub_phrases < 2.6)
+             ((0.511323 -0.666011))
+             ((0.691878 -0.499492)))
+            ((ph_ctype is r)
+             ((0.482131 -0.253186))
+             ((0.852955 -0.372832))))))
+         ((0.854447 -0.0936489)))))
+      ((R:SylStructure.parent.position_type is final)
+       ((0.685939 -0.249982))
+       ((R:SylStructure.parent.syl_out < 3.2)
+        ((0.989843 0.18086))
+        ((0.686805 -0.0402908)))))))))
+ ((R:SylStructure.parent.syl_out < 2.4)
+  ((R:SylStructure.parent.syl_out < 0.2)
+   ((seg_onsetcoda is coda)
+    ((ph_ctype is s)
+     ((R:SylStructure.parent.syl_break is 4)
+      ((pp.ph_vlng is 0)
+       ((0.959737 1.63203))
+       ((1.20714 0.994933)))
+      ((n.ph_ctype is 0)
+       ((R:SylStructure.parent.syl_break is 2)
+        ((0.864809 0.214457))
+        ((0.874278 0.730381)))
+       ((pp.ph_vfront is 0)
+        ((seg_coda_fric is 0)
+         ((1.20844 -0.336221))
+         ((1.01357 0.468302)))
+        ((0.658106 -0.799121)))))
+     ((n.ph_ctype is f)
+      ((ph_ctype is f)
+       ((1.26332 0.0300613))
+       ((ph_vlng is d)
+        ((1.02719 1.1649))
+        ((ph_ctype is 0)
+         ((R:SylStructure.parent.asyl_in < 1.2)
+          ((1.14048 2.2668))
+          ((ph_vheight is 1)
+           ((1.15528 1.50375))
+           ((1.42406 2.07927))))
+         ((R:SylStructure.parent.sub_phrases < 1.1)
+          ((0.955892 1.10243))
+          ((R:SylStructure.parent.syl_break is 2)
+           ((1.32682 1.8432))
+           ((1.27582 1.59853)))))))
+      ((n.ph_ctype is 0)
+       ((ph_ctype is n)
+        ((R:SylStructure.parent.syl_break is 2)
+         ((1.45399 1.12927))
+         ((1.05543 0.442376)))
+        ((R:SylStructure.parent.syl_break is 4)
+         ((R:SylStructure.parent.position_type is final)
+          ((ph_ctype is f)
+           ((1.46434 1.76508))
+           ((0.978055 0.7486)))
+          ((1.2395 2.30826)))
+         ((ph_ctype is 0)
+          ((0.935325 1.69917))
+          ((nn.ph_vfront is 1)
+           ((1.20456 1.31128))
+           ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+            ((nn.ph_vheight is 0)
+             ((1.16907 0.212421))
+             ((0.952091 0.653094)))
+            ((p.ph_ctype is 0)
+             ((1.05502 1.25802))
+             ((0.818731 0.777568))))))))
+       ((ph_ctype is f)
+        ((p.ph_ctype is 0)
+         ((1.03918 0.163941))
+         ((0.737545 -0.167063)))
+        ((R:SylStructure.parent.position_type is final)
+         ((n.ph_ctype is n)
+          ((R:SylStructure.parent.last_accent < 0.5)
+           ((R:SylStructure.parent.sub_phrases < 2.8)
+            ((0.826207 -0.000859005))
+            ((0.871119 0.273433)))
+           ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+            ((1.17405 1.05694))
+            ((0.858394 0.244916))))
+          ((R:SylStructure.parent.syl_codasize < 2.2)
+           ((p.ph_ctype is 0)
+            ((1.14092 1.21187))
+            ((R:SylStructure.parent.syl_break is 2)
+             ((1.02653 0.59865))
+             ((0.94248 1.1634))))
+           ((seg_coda_fric is 0)
+            ((1.07441 0.292935))
+            ((1.15736 0.92574)))))
+         ((ph_vlng is s)
+          ((R:SylStructure.parent.syl_break is 2)
+           ((1.34638 1.23484))
+           ((0.951514 2.02008)))
+          ((ph_ctype is 0)
+           ((p.ph_ctype is r)
+            ((0.806106 0.697089))
+            ((R:SylStructure.parent.syl_break is 2)
+             ((1.10891 0.992197))
+             ((1.04657 1.51093))))
+           ((1.18165 0.520952)))))))))
+    ((p.ph_vlng is 0)
+     ((pos_in_syl < 0.7)
+      ((R:SylStructure.parent.position_type is final)
+       ((ph_ctype is r)
+        ((0.966357 0.185827))
+        ((ph_ctype is s)
+         ((0.647163 0.0332298))
+         ((0.692972 -0.534917))))
+       ((ph_ctype is s)
+        ((0.881521 0.575107))
+        ((p.ph_ctype is f)
+         ((0.8223 -0.111275))
+         ((R:SylStructure.parent.last_accent < 0.3)
+          ((0.969188 0.09447))
+          ((0.894438 0.381947))))))
+      ((p.ph_ctype is f)
+       ((0.479748 -0.490108))
+       ((0.813125 -0.201268))))
+     ((ph_ctype is s)
+      ((0.908566 1.20397))
+      ((R:SylStructure.parent.last_accent < 1.2)
+       ((0.88078 0.636568))
+       ((0.978087 1.07763))))))
+   ((pos_in_syl < 1.3)
+    ((R:SylStructure.parent.syl_break is 0)
+     ((pos_in_syl < 0.1)
+      ((R:SylStructure.parent.position_type is initial)
+       ((p.ph_ctype is n)
+        ((0.801651 -0.0163359))
+        ((ph_ctype is s)
+         ((n.ph_ctype is r)
+          ((0.893307 1.07253))
+          ((p.ph_vlng is 0)
+           ((0.92651 0.525806))
+           ((0.652444 0.952792))))
+         ((p.ph_vlng is 0)
+          ((seg_onsetcoda is coda)
+           ((0.820151 0.469117))
+           ((p.ph_ctype is f)
+            ((0.747972 -0.0716448))
+            ((ph_ctype is f)
+             ((0.770882 0.457137))
+             ((0.840905 0.102492)))))
+          ((R:SylStructure.parent.syl_out < 1.1)
+           ((0.667824 0.697337))
+           ((0.737967 0.375114))))))
+       ((ph_vheight is 1)
+        ((0.624353 0.410671))
+        ((R:SylStructure.parent.asyl_in < 0.8)
+         ((0.647905 -0.331055))
+         ((p.ph_ctype is s)
+          ((0.629039 -0.240616))
+          ((0.749277 -0.0191273))))))
+      ((ph_vheight is 3)
+       ((p.ph_ctype is s)
+        ((0.626922 0.556537))
+        ((0.789357 0.153892)))
+       ((seg_onsetcoda is coda)
+        ((n.ph_ctype is 0)
+         ((R:SylStructure.parent.parent.word_numsyls < 3.4)
+          ((0.744714 0.123242))
+          ((0.742039 0.295753)))
+         ((seg_coda_fric is 0)
+          ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+           ((ph_vheight is 1)
+            ((0.549715 -0.341018))
+            ((0.573641 -0.00893114)))
+           ((nn.ph_vfront is 2)
+            ((0.67099 -0.744625))
+            ((0.664438 -0.302803))))
+          ((p.ph_vlng is 0)
+           ((0.630028 0.113815))
+           ((0.632794 -0.128733)))))
+        ((ph_ctype is r)
+         ((0.367169 -0.854509))
+         ((0.94334 -0.216179))))))
+     ((n.ph_ctype is f)
+      ((ph_vlng is 0)
+       ((1.3089 0.46195))
+       ((R:SylStructure.parent.syl_codasize < 1.3)
+        ((1.07673 0.657169))
+        ((pp.ph_vlng is 0)
+         ((0.972319 1.08222))
+         ((1.00038 1.46257)))))
+      ((p.ph_vlng is l)
+       ((1.03617 0.785204))
+       ((p.ph_vlng is a)
+        ((R:SylStructure.parent.position_type is final)
+         ((1.00681 0.321168))
+         ((0.928115 0.950834)))
+        ((ph_vlng is 0)
+         ((pos_in_syl < 0.1)
+          ((R:SylStructure.parent.position_type is final)
+           ((0.863682 -0.167374))
+           ((nn.ph_vheight is 0)
+            ((p.ph_ctype is f)
+             ((0.773591 -0.00374425))
+             ((R:SylStructure.parent.syl_out < 1.1)
+              ((0.951802 0.228448))
+              ((1.02282 0.504252))))
+            ((1.09721 0.736476))))
+          ((R:SylStructure.parent.position_type is final)
+           ((1.04302 0.0590974))
+           ((0.589208 -0.431535))))
+         ((n.ph_ctype is 0)
+          ((1.27879 1.00642))
+          ((ph_vlng is s)
+           ((R:SylStructure.parent.asyl_in < 1.4)
+            ((0.935787 0.481652))
+            ((0.9887 0.749861)))
+           ((R:SylStructure.parent.syl_out < 1.1)
+            ((R:SylStructure.parent.position_type is final)
+             ((0.921307 0.0696307))
+             ((0.83675 0.552212)))
+            ((0.810076 -0.0479225))))))))))
+    ((ph_ctype is s)
+     ((n.ph_ctype is s)
+      ((0.706959 -1.0609))
+      ((p.ph_ctype is n)
+       ((0.850614 -0.59933))
+       ((n.ph_ctype is r)
+        ((0.665947 0.00698725))
+        ((n.ph_ctype is 0)
+         ((R:SylStructure.parent.position_type is initial)
+          ((0.762889 -0.0649044))
+          ((0.723956 -0.248899)))
+         ((R:SylStructure.parent.sub_phrases < 1.4)
+          ((0.632957 -0.601987))
+          ((0.889114 -0.302401)))))))
+     ((ph_ctype is f)
+      ((R:SylStructure.parent.syl_codasize < 2.2)
+       ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+        ((R:SylStructure.parent.syl_out < 1.1)
+         ((0.865267 0.164636))
+         ((0.581827 -0.0989051)))
+        ((nn.ph_vfront is 2)
+         ((0.684459 -0.316836))
+         ((0.778854 -0.0961191))))
+       ((R:SylStructure.parent.syl_out < 1.1)
+        ((p.ph_ctype is s)
+         ((0.837964 -0.429437))
+         ((0.875304 -0.0652743)))
+        ((0.611071 -0.635089))))
+      ((p.ph_ctype is r)
+       ((R:SylStructure.parent.syl_out < 1.1)
+        ((0.762012 0.0139361))
+        ((0.567983 -0.454845)))
+       ((R:SylStructure.parent.syl_codasize < 2.2)
+        ((ph_ctype is l)
+         ((1.18845 0.809091))
+         ((R:SylStructure.parent.position_type is initial)
+          ((ph_ctype is n)
+           ((0.773548 -0.277092))
+           ((1.01586 0.281001)))
+          ((p.ph_ctype is 0)
+           ((1.06831 0.699145))
+           ((0.924189 0.241873)))))
+        ((R:SylStructure.parent.syl_break is 0)
+         ((ph_ctype is n)
+          ((0.592321 -0.470784))
+          ((0.778688 -0.072112)))
+         ((n.ph_ctype is s)
+          ((1.08848 0.0733489))
+          ((1.25674 0.608371))))))))))
+  ((pos_in_syl < 0.7)
+   ((p.ph_vlng is 0)
+    ((R:SylStructure.parent.position_type is mid)
+     ((ph_ctype is 0)
+      ((ph_vheight is 2)
+       ((0.456225 -0.293282))
+       ((0.561529 -0.0816115)))
+      ((0.6537 -0.504024)))
+     ((ph_ctype is s)
+      ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+       ((1.31586 0.98395))
+       ((R:SylStructure.parent.position_type is single)
+        ((0.816869 0.634789))
+        ((R:SylStructure.parent.syl_out < 4.4)
+         ((1.05578 0.479029))
+         ((R:SylStructure.parent.asyl_in < 0.4)
+          ((1.11813 0.143214))
+          ((0.87178 0.406834))))))
+      ((n.ph_ctype is n)
+       ((R:SylStructure.parent.last_accent < 0.6)
+        ((0.838154 -0.415599))
+        ((0.924024 0.110288)))
+       ((seg_onsetcoda is coda)
+        ((nn.ph_vfront is 2)
+         ((0.670096 0.0314187))
+         ((n.ph_ctype is f)
+          ((1.00363 0.693893))
+          ((R:SylStructure.parent.syl_out < 6)
+           ((0.772363 0.215675))
+           ((0.920313 0.574068)))))
+        ((R:SylStructure.parent.position_type is final)
+         ((0.673837 -0.458142))
+         ((R:SylStructure.parent.sub_phrases < 2.8)
+          ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+           ((0.894817 0.304628))
+           ((ph_ctype is n)
+            ((0.787302 -0.23094))
+            ((R:SylStructure.parent.asyl_in < 1.2)
+             ((ph_ctype is f)
+              ((R:SylStructure.parent.last_accent < 0.5)
+               ((1.12278 0.326954))
+               ((0.802236 -0.100616)))
+              ((0.791255 -0.0919132)))
+             ((0.95233 0.219053)))))
+          ((R:SylStructure.parent.position_type is initial)
+           ((ph_ctype is f)
+            ((1.0616 0.216118))
+            ((0.703216 -0.00834086)))
+           ((ph_ctype is f)
+            ((1.22277 0.761763))
+            ((0.904811 0.332721))))))))))
+    ((ph_vheight is 0)
+     ((p.ph_vlng is s)
+      ((0.873379 0.217178))
+      ((n.ph_ctype is r)
+       ((0.723915 1.29451))
+       ((n.ph_ctype is 0)
+        ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+         ((R:SylStructure.parent.sub_phrases < 4)
+          ((seg_coda_fric is 0)
+           ((p.ph_vlng is l)
+            ((0.849154 0.945261))
+            ((0.633261 0.687498)))
+           ((0.728546 0.403076)))
+          ((0.850962 1.00255)))
+         ((0.957999 1.09113)))
+        ((0.85771 0.209045)))))
+     ((ph_vheight is 2)
+      ((0.803401 -0.0544067))
+      ((0.681353 0.256045)))))
+   ((n.ph_ctype is f)
+    ((ph_ctype is s)
+     ((p.ph_vlng is 0)
+      ((0.479307 -0.9673))
+      ((0.700477 -0.351397)))
+     ((ph_ctype is f)
+      ((0.73467 -0.6233))
+      ((R:SylStructure.parent.syl_break is 0)
+       ((p.ph_ctype is s)
+        ((0.56282 0.266234))
+        ((p.ph_ctype is r)
+         ((0.446203 -0.302281))
+         ((R:SylStructure.parent.sub_phrases < 2.7)
+          ((ph_ctype is 0)
+           ((0.572016 -0.0102436))
+           ((0.497358 -0.274514)))
+          ((0.545477 0.0482177)))))
+       ((ph_vlng is s)
+        ((0.805269 0.888495))
+        ((ph_ctype is n)
+         ((0.869854 0.653018))
+         ((R:SylStructure.parent.sub_phrases < 2.2)
+          ((0.735031 0.0612886))
+          ((0.771859 0.346637))))))))
+    ((R:SylStructure.parent.syl_codasize < 1.4)
+     ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.3)
+      ((R:SylStructure.parent.position_type is initial)
+       ((0.743458 0.0411808))
+       ((1.13068 0.613305)))
+      ((pos_in_syl < 1.2)
+       ((R:SylStructure.parent.R:Syllable.p.syl_break is 1)
+        ((1.11481 0.175467))
+        ((0.937893 -0.276407)))
+       ((0.74264 -0.550878))))
+     ((pos_in_syl < 3.4)
+      ((seg_onsetcoda is coda)
+       ((ph_ctype is r)
+        ((n.ph_ctype is s)
+         ((0.714319 -0.240328))
+         ((p.ph_ctype is 0)
+          ((0.976987 0.330352))
+          ((1.1781 -0.0816682))))
+        ((ph_ctype is l)
+         ((n.ph_ctype is 0)
+          ((1.39137 0.383533))
+          ((0.725585 -0.324515)))
+         ((ph_vheight is 3)
+          ((ph_vlng is d)
+           ((0.802626 -0.62487))
+           ((n.ph_ctype is r)
+            ((0.661091 -0.513869))
+            ((R:SylStructure.parent.position_type is initial)
+             ((R:SylStructure.parent.parent.word_numsyls < 2.4)
+              ((0.482285 0.207874))
+              ((0.401601 -0.0204711)))
+             ((0.733755 0.397372)))))
+          ((n.ph_ctype is r)
+           ((p.ph_ctype is 0)
+            ((pos_in_syl < 1.2)
+             ((0.666325 0.271734))
+             ((nn.ph_vheight is 0)
+              ((0.642401 -0.261466))
+              ((0.783684 -0.00956571))))
+            ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+             ((0.692225 -0.381895))
+             ((0.741921 -0.0898767))))
+           ((nn.ph_vfront is 2)
+            ((ph_ctype is s)
+             ((0.697527 -1.12626))
+             ((n.ph_ctype is s)
+              ((ph_vlng is 0)
+               ((R:SylStructure.parent.sub_phrases < 2.4)
+                ((0.498719 -0.906926))
+                ((0.635342 -0.625651)))
+               ((0.45886 -0.385089)))
+              ((0.848596 -0.359702))))
+            ((p.ph_vlng is a)
+             ((p.ph_ctype is 0)
+              ((0.947278 0.216904))
+              ((0.637933 -0.394349)))
+             ((p.ph_ctype is r)
+              ((R:SylStructure.parent.syl_break is 0)
+               ((0.529903 -0.860573))
+               ((0.581378 -0.510488)))
+              ((ph_vlng is 0)
+               ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+                ((seg_onset_stop is 0)
+                 ((R:SylStructure.parent.syl_break is 0)
+                  ((p.ph_vlng is d)
+                   ((0.768363 0.0108428))
+                   ((ph_ctype is s)
+                    ((0.835756 -0.035054))
+                    ((ph_ctype is f)
+                     ((p.ph_vlng is s)
+                      ((0.602016 -0.179727))
+                      ((0.640126 -0.297341)))
+                     ((0.674628 -0.542602)))))
+                  ((ph_ctype is s)
+                   ((0.662261 -0.60496))
+                   ((0.662088 -0.432058))))
+                 ((R:SylStructure.parent.syl_out < 4.4)
+                  ((0.582448 -0.389079))
+                  ((ph_ctype is s)
+                   ((0.60413 -0.73564))
+                   ((0.567153 -0.605444)))))
+                ((R:SylStructure.parent.R:Syllable.p.syl_break is 2)
+                 ((0.761115 -0.827377))
+                 ((ph_ctype is n)
+                  ((0.855183 -0.275338))
+                  ((R:SylStructure.parent.syl_break is 0)
+                   ((0.788288 -0.802801))
+                   ((R:SylStructure.parent.syl_codasize < 2.2)
+                    ((0.686134 -0.371234))
+                    ((0.840184 -0.772883)))))))
+               ((pos_in_syl < 1.2)
+                ((R:SylStructure.parent.syl_break is 0)
+                 ((n.ph_ctype is n)
+                  ((0.423592 -0.655006))
+                  ((R:SylStructure.parent.syl_out < 4.4)
+                   ((0.595269 -0.303751))
+                   ((0.478433 -0.456882))))
+                 ((0.688133 -0.133182)))
+                ((seg_onset_stop is 0)
+                 ((1.27464 0.114442))
+                 ((0.406837 -0.167545))))))))))))
+       ((ph_ctype is r)
+        ((0.462874 -0.87695))
+        ((R:SylStructure.parent.R:Syllable.n.syl_onsetsize < 0.2)
+         ((0.645442 -0.640572))
+         ((0.673717 -0.321322)))))
+      ((0.61008 -0.925472))))))))
+;; RMSE 0.8085 Correlation is 0.5899 Mean (abs) Error 0.6024 (0.5393)
+
+
+))
+
+(provide 'gswdurtreeZ)

CosyVoice-ttsfrd/resource/festival/hts.scm

@@ -0,0 +1,522 @@
+;;  ----------------------------------------------------------------  ;;
+;;                 Nagoya Institute of Technology and                 ;;
+;;                     Carnegie Mellon University                     ;;
+;;                         Copyright (c) 2002                         ;;
+;;                        All Rights Reserved.                        ;;
+;;                                                                    ;;
+;;  Permission is hereby granted, free of charge, to use and          ;;
+;;  distribute this software and its documentation without            ;;
+;;  restriction, including without limitation the rights to use,      ;;
+;;  copy, modify, merge, publish, distribute, sublicense, and/or      ;;
+;;  sell copies of this work, and to permit persons to whom this      ;;
+;;  work is furnished to do so, subject to the following conditions:  ;;
+;;                                                                    ;;
+;;    1. The code must retain the above copyright notice, this list   ;;
+;;       of conditions and the following disclaimer.                  ;;
+;;                                                                    ;;
+;;    2. Any modifications must be clearly marked as such.            ;;
+;;                                                                    ;;
+;;    3. Original authors' names are not deleted.                     ;;
+;;                                                                    ;;
+;;    4. The authors' names are not used to endorse or promote        ;;
+;;       products derived from this software without specific prior   ;;
+;;       written permission.                                          ;;
+;;                                                                    ;;
+;;  NAGOYA INSTITUTE OF TECHNOLOGY, CARNEGIE MELLON UNIVERSITY AND    ;;
+;;  THE CONTRIBUTORS TO THIS WORK DISCLAIM ALL WARRANTIES WITH        ;;
+;;  REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF      ;;
+;;  MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL NAGOYA INSTITUTE   ;;
+;;  OF TECHNOLOGY, CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS    ;;
+;;  BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR   ;;
+;;  ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR        ;;
+;;  PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER    ;;
+;;  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR  ;;
+;;  PERFORMANCE OF THIS SOFTWARE.                                     ;;
+;;                                                                    ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;      Generic HTS support code and specific features                ;;
+;;           http://hts.ics.nitech.ac.jp                              ;;
+;;             Author :  Alan W Black <[email protected]>                ;;
+;;             Date   :  August 2002 (and April 2004)                 ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                                                                    ;;
+;;  Still has language specific features in here, that will have to   ;;
+;;  move out to the voices                                            ;;
+;;                                                                    ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar hts_synth_pre_hooks nil)
+(defvar hts_synth_post_hooks nil)
+(defvar hts_engine_params nil)
+
+(defvar hts_duration_stretch 0)
+(defvar hts_f0_mean 0)
+(defvar hts_f0_std 1)
+(defvar hts_fw_factor 0.42)
+(defvar hts_total_length 0.0)
+(defvar hts_uv_threshold 0.5)
+(defvar hts_use_phone_align 0)
+
+(defSynthType HTS
+  (let ((featfile (make_tmp_filename))
+	(mcepfile (make_tmp_filename))
+	(f0file (make_tmp_filename))
+	(wavfile (make_tmp_filename))
+	(labfile (make_tmp_filename)))
+
+    (apply_hooks hts_synth_pre_hooks utt)
+
+    (set! hts_output_params
+	  (list
+	   (list "-labelfile" featfile)
+	   (list "-om" mcepfile)
+	   (list "-of" f0file)
+	   (list "-or" wavfile)
+		 (list "-od" labfile))
+		)
+
+    (hts_dump_feats utt hts_feats_list featfile)
+
+    (HTS_Synthesize utt)
+
+    (delete-file featfile)
+    (delete-file mcepfile)
+    (delete-file f0file)
+    (delete-file wavfile)
+    (delete-file labfile)
+
+    (apply_hooks hts_synth_post_hooks utt)
+    utt)
+)
+
+(define (hts_feats_output ofd s)
+  "This  is bad as it makes decisions about what the feats are"
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  SEGMENT
+
+;  boundary
+  (format ofd "%10.0f %10.0f " 
+	  (* 10000000 (item.feat s "segment_start"))
+	  (* 10000000 (item.feat s "segment_end")))
+
+;  pp.name
+  (format ofd "%s" (if (string-equal "0" (item.feat s "p.p.name"))
+		       "x" (item.feat s "p.p.name")))
+;  p.name
+  (format ofd "^%s" (if (string-equal "0" (item.feat s "p.name"))
+			"x" (item.feat s "p.name")))
+;  c.name
+  (format ofd "-%s" (if (string-equal "0" (item.feat s "name"))
+			"x" (item.feat s "name")))
+;  n.name
+  (format ofd "+%s" (if (string-equal "0" (item.feat s "n.name"))
+			"x" (item.feat s "n.name")))
+;  nn.name
+  (format ofd "=%s" (if (string-equal "0" (item.feat s "n.n.name"))
+			"x" (item.feat s "n.n.name")))
+
+;  position in syllable (segment)
+  (format ofd "@")
+  (format ofd "%s" (if (string-equal "pau" (item.feat s "name"))
+		       "x" (+ 1 (item.feat s "pos_in_syl"))))
+  (format ofd "_%s" (if (string-equal "pau" (item.feat s "name"))
+			"x" (- (item.feat s "R:SylStructure.parent.R:Syllable.syl_numphones") 
+			       (item.feat s "pos_in_syl"))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  SYLLABLE
+
+;; previous syllable
+
+;  p.stress
+  (format ofd "/A:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.R:Syllable.stress")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.p.stress")))
+;  p.accent
+  (format ofd "_%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.R:Syllable.accented")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.p.accented")))
+;  p.length
+  (format ofd "_%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.R:Syllable.syl_numphones")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.p.syl_numphones")))
+;; current syllable
+
+;  c.stress
+  (format ofd "/B:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.stress")))
+;  c.accent
+  (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.accented")))
+;  c.length
+  (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.syl_numphones")))
+
+;  position in word (syllable)
+  (format ofd "@%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1 (item.feat s "R:SylStructure.parent.R:Syllable.pos_in_word"))))
+  (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (- 
+	       (item.feat s "R:SylStructure.parent.parent.R:Word.word_numsyls")
+	       (item.feat s "R:SylStructure.parent.R:Syllable.pos_in_word"))))
+
+;  position in phrase (syllable)
+    (format ofd "&%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.syl_in"))))
+    (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.syl_out"))))
+
+;  position in phrase (stressed syllable)
+    (format ofd "#%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.ssyl_in"))))
+    (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.ssyl_out"))))
+
+;  position in phrase (accented syllable)
+    (format ofd "$%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.asyl_in"))))
+    (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1
+		 (item.feat s "R:SylStructure.parent.R:Syllable.asyl_out"))))
+
+;  distance from stressed syllable
+    (format ofd "!%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.lisp_distance_to_p_stress")))
+    (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.lisp_distance_to_n_stress")))
+
+;  distance from accented syllable 
+    (format ofd ";%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.lisp_distance_to_p_accent")))
+    (format ofd "-%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.lisp_distance_to_n_accent")))
+
+;  name of the vowel of current syllable
+    (format ofd "|%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.R:Syllable.syl_vowel")))
+
+;; next syllable
+  (format ofd "/C:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.R:Syllable.stress")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.n.stress")))
+;  n.accent
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.R:Syllable.accented")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.n.accented")))
+;  n.length
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.R:Syllable.syl_numphones")
+	      (item.feat s "R:SylStructure.parent.R:Syllable.n.syl_numphones"))) 
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;  WORD
+
+;;;;;;;;;;;;;;;;;;
+;; previous word
+
+;  p.gpos
+  (format ofd "/D:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.parent.R:Word.gpos")
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.p.gpos")))
+;  p.lenght (syllable)
+  (format ofd "_%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.parent.R:Word.word_numsyls")
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.p.word_numsyls")))
+
+;;;;;;;;;;;;;;;;;
+;; current word
+
+;  c.gpos
+  (format ofd "/E:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.gpos")))
+;  c.lenght (syllable)
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.word_numsyls")))
+
+;  position in phrase (word)
+  (format ofd "@%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (+ 1 (item.feat s "R:SylStructure.parent.parent.R:Word.pos_in_phrase"))))
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.words_out")))
+
+;  position in phrase (content word)
+  (format ofd "&%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.content_words_in")))
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.content_words_out")))
+
+;  distance from content word in phrase
+  (format ofd "#%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.lisp_distance_to_p_content")))
+  (format ofd "+%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.lisp_distance_to_n_content")))
+
+;;;;;;;;;;;;;;
+;; next word
+
+;  n.gpos
+  (format ofd "/F:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.parent.R:Word.gpos")
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.n.gpos")))
+;  n.lenghte (syllable)
+  (format ofd "_%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.parent.R:Word.word_numsyls")
+	      (item.feat s "R:SylStructure.parent.parent.R:Word.n.word_numsyls")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;  PHRASE
+
+;;;;;;;;;;;;;;;;;;;;
+;; previous phrase
+
+;  length of previous phrase (syllable)
+  (format ofd "/G:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_syls_in_phrase")
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.p.lisp_num_syls_in_phrase")))
+
+;  length of previous phrase (word)
+  (format ofd "_%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "p.R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_words_in_phrase")
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.p.lisp_num_words_in_phrase")))
+
+;;;;;;;;;;;;;;;;;;;;
+;; current phrase
+
+;  length of current phrase (syllable)
+  (format ofd "/H:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_syls_in_phrase")))
+
+;  length of current phrase (word)
+  (format ofd "=%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      "x"
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_words_in_phrase")))
+
+;  position in major phrase (phrase)
+  (format ofd "@%s" 
+	  (+ 1 (item.feat s "R:SylStructure.parent.R:Syllable.sub_phrases")))
+  (format ofd "=%s" 
+	  (- 
+	   (item.feat s "lisp_total_phrases")
+	   (item.feat s "R:SylStructure.parent.R:Syllable.sub_phrases")))
+
+;  type of tobi endtone of current phrase
+  (format ofd "|%s" 
+	  (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.daughtern.R:SylStructure.daughtern.tobi_endtone"))
+
+;;;;;;;;;;;;;;;;;;;;
+;; next phrase
+
+;  length of next phrase (syllable)
+  (format ofd "/I:%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_syls_in_phrase")
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.n.lisp_num_syls_in_phrase")))
+
+;  length of next phrase (word)
+  (format ofd "=%s" 
+	  (if (string-equal "pau" (item.feat s "name"))
+	      (item.feat s "n.R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_words_in_phrase")
+	      (item.feat s "R:SylStructure.parent.parent.R:Phrase.parent.n.lisp_num_words_in_phrase")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;  UTTERANCE
+
+;  length (syllable)
+  (format ofd "/J:%s" (item.feat s "lisp_total_syls"))
+
+;  length (word)
+  (format ofd "+%s" (item.feat s "lisp_total_words"))
+
+;  length (phrase)
+  (format ofd "-%s" (item.feat s "lisp_total_phrases"))
+
+  (format ofd "\n")
+
+)
+
+(define (hts_dump_feats utt feats ofile)
+  (let ((ofd (fopen ofile "w")))
+    (mapcar
+     (lambda (s)
+       (hts_feats_output ofd s))
+     (utt.relation.items utt 'Segment))
+    (fclose ofd)
+    ))
+
+
+;;
+;;  Extra features
+;;  From Segment items refer by 
+;;
+;;  R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_syls_in_phrase
+;;  R:SylStructure.parent.parent.R:Phrase.parent.lisp_num_words_in_phrase
+;;  lisp_total_words
+;;  lisp_total_syls
+;;  lisp_total_phrases
+;;
+;;  The last three will act on any item
+
+(define (distance_to_p_content i)
+  (let ((c 0) (rc 0 ) (w (item.relation.prev i "Phrase")))
+    (while w
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "contentp"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+      (set! w (item.prev w)))
+      )
+    rc))
+
+(define (distance_to_n_content i)
+  (let ((c 0) (rc 0) (w (item.relation.next i "Phrase")))
+    (while w
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "contentp"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+      (set! w (item.next w)))
+      )
+    rc))
+
+(define (distance_to_p_accent i)
+  (let ((c 0) (rc 0 ) (w (item.relation.prev i "Syllable")))
+    (while (and w (member_string (item.feat w "syl_break") '("0" "1")))
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "accented"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+        (set! w (item.prev w)))
+        )
+        rc))
+
+(define (distance_to_n_accent i)
+  (let ((c 0) (rc 0 ) (w (item.relation.next i "Syllable")))
+    (while (and w (member_string (item.feat w "p.syl_break") '("0" "1")))
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "accented"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+        (set! w (item.next w)))
+        )
+        rc))
+
+(define (distance_to_p_stress i)
+  (let ((c 0) (rc 0 ) (w (item.relation.prev i "Syllable")))
+    (while (and w (member_string (item.feat w "syl_break") '("0" "1")))
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "stress"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+        (set! w (item.prev w)))
+        )
+        rc))
+
+(define (distance_to_n_stress i)
+  (let ((c 0) (rc 0 ) (w (item.relation.next i "Syllable")))
+    (while (and w (member_string (item.feat w "p.syl_break") '("0" "1")))
+      (set! c (+ 1 c))
+      (if (string-equal "1" (item.feat w "stress"))
+      (begin
+        (set! rc c)
+        (set! w nil))
+        (set! w (item.next w)))
+        )
+        rc))
+
+(define (num_syls_in_phrase i)
+  (apply 
+   +
+   (mapcar
+    (lambda (w)
+      (length (item.relation.daughters w 'SylStructure)))
+    (item.relation.daughters i 'Phrase))))
+
+(define (num_words_in_phrase i)
+  (length (item.relation.daughters i 'Phrase)))
+
+(define (total_words w)
+  (length
+   (utt.relation.items (item.get_utt w) 'Word)))
+
+(define (total_syls s)
+  (length
+   (utt.relation.items (item.get_utt s) 'Syllable)))
+
+(define (total_phrases s)
+  (length
+   (utt.relation_tree (item.get_utt s) 'Phrase)))
+
+(provide 'hts)

CosyVoice-ttsfrd/resource/festival/init.scm

@@ -0,0 +1,157 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Initialisation file -- loaded before anything else
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;  Basic siod library (need this before load_library or require works)
+(load (path-append libdir "siod.scm"))
+
+(defvar home-directory (or (getenv "HOME") "/")
+  "home-directory
+   Place looked at for .festivalrc etc.")
+
+;;;  User startup initialization, can be used to override load-path
+;;;  to allow alternate basic modules to be loaded.
+(if (probe_file (path-append home-directory ".siodvarsrc"))
+    (load (path-append home-directory ".siodvarsrc")))
+
+(if (probe_file (path-append home-directory ".festivalvarsrc"))
+    (load (path-append home-directory ".festivalvarsrc")))
+
+;;;  A chance to set various variables to a local setting e.g.
+;;;  lexdir, voices_dir audio etc etc.
+(if (probe_file (path-append libdir "sitevars.scm"))
+    (load (path-append libdir "sitevars.scm")))
+
+;;; CSTR siod extensions
+(require 'cstr)
+
+;;;  Festival specific definitions
+(require 'festival)
+
+;;;  Dealing with module descriptions
+(require 'module_description)
+
+;;;  Web related definitions
+(require 'web)
+
+;;;  Utterance types and support
+(require 'synthesis)
+
+;;;  Some default parameters
+(Parameter.def 'Wavefiletype 'riff)
+
+;;; Set default audio method
+(cond
+ ((member 'nas *modules*)
+  (Parameter.def 'Audio_Method 'netaudio))
+ ((member 'esd *modules*)
+  (Parameter.def 'Audio_Method 'esdaudio))
+ ((member 'sun16audio *modules*)
+  (Parameter.def 'Audio_Method 'sun16audio))
+ ((member 'freebsd16audio *modules*)
+  (Parameter.def 'Audio_Method 'freebsd16audio))
+ ((member 'linux16audio *modules*)
+  (Parameter.def 'Audio_Method 'linux16audio))
+ ((member 'irixaudio *modules*)
+  (Parameter.def 'Audio_Method 'irixaudio))
+ ((member 'macosxaudio *modules*)
+  (Parameter.def 'Audio_Method 'macosxaudio))
+ ((member 'win32audio *modules*)
+  (Parameter.def 'Audio_Method 'win32audio))
+ ((member 'os2audio *modules*)
+  (Parameter.def 'Audio_Method 'os2audio))
+ ((member 'mplayeraudio *modules*)
+  (Parameter.def 'Audio_Method 'mplayeraudio))
+ (t  ;; can't find direct support so guess that /dev/audio for 8k ulaw exists
+  (Parameter.def 'Audio_Method 'sunaudio)))
+;;;  If you have an external program to play audio add its definition
+;;;  in siteinit.scm
+
+;;; The audio spooler doesn't work under Windows so redefine audio_mode
+(if (member 'mplayeraudio *modules*)
+      (define (audio_mode param) param)
+)
+
+;;; Intonation
+(require 'intonation)
+
+;;; Duration
+(require 'duration)
+
+;;;  A large lexicon
+(require 'lexicons)
+(require 'pauses)
+
+;;;  Part of speech prediction
+(require 'pos)
+
+;;; Phrasing (dependent on pos)
+(require 'phrase)
+
+;;; POstlexical rules
+(require 'postlex)
+
+;;; Different voices
+(require 'voices)  ;; sets voice_default
+(require 'languages)
+
+;;; Some higher level functions
+(require 'token)
+(require 'tts)
+
+;;;
+;;;  Local site initialization, if the file exists load it
+;;;
+(if (probe_file (path-append libdir "siteinit.scm"))
+    (load (path-append libdir "siteinit.scm")))
+
+;;;  User initialization, if a user has a personal customization
+;;;  file loaded it
+(if (probe_file (path-append home-directory ".siodrc"))
+    (load (path-append home-directory ".siodrc")))
+
+(if (probe_file (path-append home-directory ".festivalrc"))
+    (load (path-append home-directory ".festivalrc")))
+
+;;; Default voice (have to do something cute so autoloads still work)
+(eval (list voice_default))
+
+(provide 'init)
+
+
+
+
+

CosyVoice-ttsfrd/resource/festival/intonation.scm

@@ -0,0 +1,187 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Basic Intonation modules.  These call appropriate sub-modules
+;;;  depending on the chosen intonation methods
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;  These modules should predict intonation events/labels
+;;;  based on information in the phrase and word streams
+
+; to detect prespecified accents (feature "accent" in 'Word relation)
+; AS 5/29/00
+
+(define (tobi_accent_prespecified utt)
+  (let ((tobi_found nil)
+	(words (utt.relation.items utt 'Word)))
+    
+    (while (and words (not tobi_found))
+; feature "accent" might be prespecified on words or tokens, AS 05/29/00
+	   (if (item.feat.present (car words) 'accent)
+	       (set! tobi_found t)
+; if Token relation exists, check tokens as well
+               (if (not (null (item.parent (item.relation (car words) 'Token))))
+                   (if (item.feat.present (item.parent (item.relation (car words) 'Token)) 'accent)
+                       (set! tobi_found t)
+                       (set! words (cdr words)))
+                   (set! words (cdr words)))))
+    tobi_found))
+
+(set! int_accent_cart_tree_no_accent
+'((NONE)))
+
+(define (Intonation utt)
+"(Intonation utt)                                
+Select between different intonation modules depending on the Parameter
+Int_Method.  Currently offers three types: Simple, hats on each content
+word; ToBI, a tree method for predicting ToBI accents; and Default a
+really bad method with a simple downward sloping F0.  This is the first
+of a two-stage intonation prediction process.  This adds accent-like
+features to syllables, the second, Int_Targets generates the F0 contour
+itself. [see Intonation]"
+
+; AS 5/29/00: Hack to avoid prediction of further accent labels
+; on utterance chunks that have already been annotated with
+; accent labels
+; use CART that doesn't assign any labels when using Intonation_Tree
+
+(if (tobi_accent_prespecified utt)
+    (progn
+     (set! int_accent_cart_tree_save int_accent_cart_tree)  
+     (set! int_accent_cart_tree int_accent_cart_tree_no_accent)
+     (Intonation_Tree utt)
+     (set! int_accent_cart_tree int_accent_cart_tree_save))
+
+  (let ((rval (apply_method 'Int_Method utt)))
+    (Parameter.get 'Int_Method)
+    (cond   
+     (rval rval) ;; new style
+     ((eq 'Simple (Parameter.get 'Int_Method))
+      (Intonation_Simple utt))
+     ((eq 'ToBI (Parameter.get 'Int_Method))
+      (format t "Using Intonation_Tree")
+      (Intonation_Tree utt))
+     ((eq 'General (Parameter.get 'Int_Method))
+      (Intonation_Simple utt))  ;; yes this is a duplication
+     (t
+      (Intonation_Default utt))))))
+
+
+;;;  These modules should create an actual F0 contour based on the
+;;;  the existing intonational events/labels etc
+;;;  Specifically this is called after durations have been predicted
+ 
+(define (Int_Targets utt)
+"(Int_Targets utt)
+The second stage in F0 prediction.  This generates F0 targets 
+related to segments using one of three methods, a simple hat, 
+linear regression based on ToBI markings, and a simple declining
+slope.  This second part deals with actual F0 values and durations,
+while the previous section only deals with accent (and boundary tone)
+assignment. [see Intonation]"
+  (let ((rval (apply_method 'Int_Target_Method utt)))
+    (cond
+     (rval rval) ;; new style
+     ((eq 'Simple (Parameter.get 'Int_Method))
+      (Int_Targets_Simple utt))
+     ((eq 'ToBI (Parameter.get 'Int_Method))
+      (Int_Targets_LR utt))
+     ((eq 'General (Parameter.get 'Int_Method))
+      (Int_Targets_General utt))
+     (t
+      (Int_Targets_Default utt)))))
+
+;;;
+;;;  A tree that adds accents (H) to all content words
+;;;  simple but better than nothing at all
+;;;
+(set! simple_accent_cart_tree
+ '
+  ((R:SylStructure.parent.gpos is content)
+   ((stress is 1)
+    ((Accented))
+    ((position_type is single)
+     ((Accented))
+     ((NONE))))
+   ((NONE))))
+
+(defvar duffint_params '((start 130) (end 110))
+  "duffint_params
+Default parameters for Default (duff) intonation target generation.
+This is an assoc list of parameters.  Two parameters are supported
+start specifies the start F0 in Hertz for an utterance, and end specifies
+the end.")
+
+;;;
+;;;  For simple testing, this function adds fixed duration and 
+;;;  monotone intonation to a set of phones
+;;;
+(defvar FP_F0 120
+"FP_F0
+In using Fixed_Prosody as used in Phones type utterances and hence
+SayPhones, this is the value in Hertz for the monotone F0.")
+(defvar FP_duration 100
+"FP_duration
+In using Fixed_Prosody as used in Phones type utterances and hence
+SayPhones, this is the fix value in ms for phone durations.")
+
+(define (Fixed_Prosody utt)
+"(Fixed_Prosody UTT)
+Add fixed duration and fixed monotone F0 to the sgements in UTT.
+Uses values of FP_duration and FP_F0 as fixed values."
+  (let (utt1
+	(dur_stretch (Parameter.get 'Duration_Stretch))
+	(orig_duffint_params duffint_params))
+    (Parameter.set 'Duration_Stretch (/ FP_duration 100.0))
+    (set! duffint_params (list (list 'start FP_F0) (list 'end FP_F0)))
+
+    (set! utt1 (Duration_Default utt))
+    (set! utt1 (Int_Targets_Default utt1))
+
+    ;; Reset Parameter values back
+    (Parameter.set 'Duration_Stretch dur_stretch)
+    (set! duffint_params orig_duffint_params)
+
+    utt1
+    )
+)
+
+(define (segment_dpitch seg)
+"(segment_dpitch UTT SEG)
+Returns delta pitch, this pitch minus previous pitch."
+  (- 
+   (parse-number (item.feat utt seg 'seg_pitch))
+   (parse-number (item.feat utt seg 'R:Segment.p.seg_pitch))))
+
+(provide 'intonation)

CosyVoice-ttsfrd/resource/festival/java.scm

@@ -0,0 +1,39 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1998                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Functions specific to supporting a Java client
+;;;
+
+;; none required yet
+
+(provide 'java)

CosyVoice-ttsfrd/resource/festival/languages.scm

@@ -0,0 +1,122 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Specification of voices and some major choices of synthesis
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  This should use some sort of database description for voices so
+;;;  new voices will become automatically available.
+;;;
+
+(define (language_british_english)
+"(language_british_english)
+Set up language parameters for British English."
+  (require 'voices)
+  ;;  Will get more elaborate, with different choices of voices in language
+
+  (set! male1 voice_rab_diphone)
+  (if (symbol-bound? 'voice_don_diphone)
+      (set! male2 voice_don_diphone))
+  (if (symbol-bound? 'voice_gsw_diphone)
+      (set! male3 voice_gsw_diphone))
+  (if (symbol-bound? 'voice_gsw_450)
+      (set! male4 voice_gsw_450))
+
+  (male1)
+  (Parameter.set 'Language 'britishenglish)
+)
+
+(define (language_american_english)
+"(language_american_english)
+Set up language parameters for Aemerican English."
+  (require 'voices)
+  (if (symbol-bound? 'voice_kal_diphone)
+      (set! female1 voice_kal_diphone))
+  (if (symbol-bound? 'voice_kal_diphone)
+      (set! male1 voice_kal_diphone))
+
+  (male1)
+  (Parameter.set 'Language 'americanenglish)
+)
+
+(define (language_scots_gaelic)
+"(language_scots_gaelic)
+Set up language parameters for Scots Gaelic."
+  (error "Scots Gaelic not yet supported.")
+
+  (Parameter.set 'Language 'scotsgaelic)
+)
+
+(define (language_welsh)
+"(language_welsh)
+Set up language parameters for Welsh."
+
+  (set! male1 voice_welsh_hl)
+
+  (male1)
+  (Parameter.set 'Language 'welsh)
+)
+
+(define (language_castillian_spanish)
+"(language_spanish)
+Set up language parameters for Castillian Spanish."
+
+  (voice_el_diphone)
+  (set! male1 voice_el_diphone)
+
+  (Parameter.set 'Language 'spanish)
+)
+
+(define (select_language language)
+  (cond
+   ((or (equal? language 'britishenglish)
+	(equal? language 'english))  ;; we all know its the *real* English
+    (language_british_english))
+   ((equal? language 'americanenglish)
+    (language_american_english))
+   ((equal? language 'scotsgaelic)
+    (language_scots_gaelic))
+   ((equal? language 'welsh)
+    (language_welsh))
+   ((equal? language 'spanish)
+    (language_castillian_spanish))
+   ((equal? language 'klingon)
+    (language_klingon))
+   (t
+    (print "Unsupported language, using English")
+    (language_british_english))))
+
+(defvar language_default language_british_english)
+
+(provide 'languages)

CosyVoice-ttsfrd/resource/festival/lts.scm

@@ -0,0 +1,212 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1998                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Functions specific to supporting a trained LTS rules
+;;;
+
+(define (lts_rules_predict word feats)
+  (let ((dcword (downcase word))
+	(syls) (phones))
+    (if (string-matches dcword "[a-z]*")
+	(begin
+	  (set! phones 
+		(cdr (reverse (cdr (reverse (lts_predict dcword))))))
+	  (set! phones (add_lex_stress word feats phones))
+	  (set! syls (lex.syllabify.phstress phones))
+;;	  (set! syls (add_lex_stress word syls))
+	  )
+	(set! syls nil))
+    (format t "word %l phones %l\n" word syls)
+    (list word nil syls)))
+
+;(define (add_lex_stress word syls)
+;  (cond
+;   ((> (length syls) 1)
+;      (set-car! (cdr (nth (- (length syls) 2) syls)) 1))
+;   ((word-is-content word english_guess_pos)
+;      (set-car! (cdr (car syls)) 1)))
+;  syls)
+
+(define (word-is-content word guess_pos)
+  (cond
+   ((null guess_pos)
+    t)
+   ((member_string word (cdr (car guess_pos)))
+    nil)
+   (t
+    (word-is-content word (cdr guess_pos)))))
+
+(defvar lts_pos nil)
+
+(define (lts_predict word rules)
+  "(lts_predict word rules)
+Return list of phones related to word using CART trees."
+  (let ((utt (make_let_utt (enworden (wordexplode word)))))
+    (predict_phones utt rules)
+    (cdr (reverse (cdr (reverse ;; remove #'s
+      (mapcar 
+       (lambda (p) (intern (item.name p)))
+       (utt.relation.items utt 'PHONE))))))
+    )
+)
+
+(define (wordexplode lets)
+  (if (consp lets)
+      lets
+      (symbolexplode lets)))
+
+(define (make_let_utt letters)
+"(make_let_utt letters)
+Build an utterances from th4ese letters."
+  (let ((utt (Utterance Text "")))
+    (utt.relation.create utt 'LTS)
+    (utt.relation.create utt 'LETTER)
+    (utt.relation.create utt 'PHONE)
+    ;; Create letter stream
+    (mapcar
+     (lambda (l)
+       (let ((lsi (utt.relation.append utt 'LETTER)))
+	 (item.set_feat lsi "pos" lts_pos)
+	 (item.set_name lsi l)))
+     letters)
+    utt))
+
+(define (predict_phones utt rules)
+  "(predict_phones utt)
+Predict phones using CART."
+  (add_new_phone utt (utt.relation.first utt 'LETTER) '#)
+  (mapcar
+   (lambda (lsi)
+     (let ((tree (car (cdr (assoc_string (item.name lsi) rules)))))
+       (if (not tree)
+	   (format t "failed to find tree for %s\n" (item.name lsi))
+	   (let ((p (wagon_predict lsi tree)))
+;	     (format t "predict %s %s\n" (item.name lsi) p)
+	     (cond
+	      ((string-matches p ".*-.*-.*-.*") ; a quad one
+	       (add_new_phone utt lsi (string-before p "-"))
+	       (add_new_phone utt lsi (string-before (string-after p "-") "-"))
+	       (add_new_phone utt lsi (string-before (string-after (string-after p "-") "-") "-"))
+	       (add_new_phone utt lsi (string-after (string-after (string-after p "-") "-") "-")))
+	      ((string-matches p ".*-.*-.*") ; a triple one
+	       (add_new_phone utt lsi (string-before p "-"))
+	       (add_new_phone utt lsi (string-before (string-after p "-") "-"))
+	       (add_new_phone utt lsi (string-after (string-after p "-") "-")))
+	      ((string-matches p ".*-.*");; a double one
+	       (add_new_phone utt lsi (string-before p "-"))
+	       (add_new_phone utt lsi (string-after p "-")))
+	      (t
+	       (add_new_phone utt lsi p)))))))
+   (reverse (cdr (reverse (cdr (utt.relation.items utt 'LETTER))))))
+  (add_new_phone utt (utt.relation.last utt 'LETTER) '#)
+  utt)
+
+(define (add_new_phone utt lsi p)
+  "(add_new_phone utt lsi p)
+Add new phone linking to letter, ignoreing it if its _epsilon_."
+  (if (not (equal? p '_epsilon_))
+      (let ((psi (utt.relation.append utt 'PHONE)))
+	(item.set_name psi p)
+	(item.relation.append_daughter
+	 (utt.relation.append utt 'LTS lsi)
+	 'LTS psi)
+	)))
+
+(define (enworden lets)
+  (cons '# (reverse (cons '# (reverse lets)))))
+
+;;; Lexical stress assignment
+;;;
+
+(define (add_lex_stress word pos phones tree)
+  "(add_lex_stress word syls)
+Predict lexical stress by decision tree."
+  (let ((utt (Utterance Text ""))
+	(si)
+	(nphones))
+    (utt.relation.create utt 'Letter)
+    (set! si (utt.relation.append utt 'Letter))
+    (item.set_feat si 'pos pos)
+    (item.set_feat si 'numsyls (count_syls phones))
+    (item.set_feat si 'sylpos 1)
+    (set! nphones (add_lex_stress_syl phones si tree))
+;    (format t "%l\n" phones)
+;    (format t "%l\n" nphones)
+    nphones))
+
+(define (count_syls phones)
+  (cond
+   ((null phones) 0)
+   ((string-matches (car phones) "[aeiou@].*")
+    (+ 1 (count_syls (cdr phones))))
+   (t (count_syls (cdr phones)))))
+
+(define (add_lex_stress_syl phones si tree)
+  "(add_lex_stress_syl phones si tree)
+Add lexical stressing."
+  (cond
+   ((null phones) nil)
+   ((string-matches (car phones) "[aeiou@].*")
+    (item.set_feat si 'phone (car phones))
+    (item.set_feat si 'name (car phones))
+    (item.set_feat si 'num2end 
+			 (- (+ 1 (item.feat si 'numsyls))
+			    (item.feat si 'sylpos)))
+    (set! stress (wagon_predict si tree))
+    (item.set_feat si 'sylpos
+			 (+ 1 (item.feat si 'sylpos)))
+    (cons
+     (if (not (string-equal stress "0"))
+	 (string-append (car phones) stress)
+	 (car phones))
+     (add_lex_stress_syl (cdr phones) si tree)))
+   (t 
+    (cons
+     (car phones)
+     (add_lex_stress_syl (cdr phones) si tree)))))
+
+;;; Morphological analysis
+
+
+;(define (wfst_stemmer)
+;  (wfst.load 'stemmer "/home/awb/projects/morpho/engstemmer.wfst")
+;  (wfst.load 'stemmerL "/home/awb/projects/morpho/engstemmerL.wfst")
+;  t)
+
+;(define (stem word)
+;  (wfst.transduce 'stemmer (enworden (symbolexplode word))))
+
+;(define (stemL word)
+;  (wfst.transduce 'stemmerL (enworden (symbolexplode word))))
+
+(provide 'lts)

CosyVoice-ttsfrd/resource/festival/module_description.scm

@@ -0,0 +1,117 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  
+;;;  Handle module descriptions.
+;;;  
+
+(defvar *module-descriptions* nil
+  "*module-descriptions*
+   An association list recording the description objects for proclaimed
+   modules.")
+
+(define (set_module_description mod desc)
+  "(set_module_description MOD DESC)
+   Set the description for the module named MOD."
+  (let ((entry (assoc mod *module-descriptions*)))
+    (if entry
+	(set-cdr! entry (cons desc nil))
+	(set! *module-descriptions* (cons (cons mod (cons desc nil)) 
+					  *module-descriptions*))
+	)
+    )
+  )
+
+(define (module_description mod)
+  "(module_description MOD)
+   Returns the description record of the module named by symbol MOD"
+  (let ((entry (assoc mod *module-descriptions*)))
+    (if entry
+	(car (cdr entry))
+	nil
+	)
+    )
+  )
+
+(defmac (proclaim form)
+  "(proclaim NAME &opt DESCRIPTION...)
+   Anounce the availability of a module NAME. DESCRIPTION
+   is a description in a fixed format."
+  (let ((name (car (cdr form)))
+	(description (cdr form))
+	)
+    (list 'proclaim-real (list 'quote name) (list 'quote description))
+    )
+  )
+
+(define (proclaim-real name description)
+  (set! *modules* (cons name *modules*))
+;  (if description
+;      (set_module_description name (create_module_description description))
+;      )
+  )
+
+(define (describe_module mod)
+  "(describe_module MOD)
+   Describe the module named by the symbol MOD."
+
+  (let ((entry (module_description mod)))
+    (format t "---------------------\n")
+    (if entry
+	(print_module_description entry)
+	(format t "No description for %l\n" mod)
+	)
+    (format t "---------------------\n")
+    )
+  )
+
+(define (describe_all_modules)
+  "(describe_all_modules)
+   Print descriptions of all proclaimed modules"
+  (format t "---------------------\n")
+  (let ((p *module-descriptions*))
+    (while p
+	   (print_module_description (car (cdr (car p))))
+	   (format t "---------------------\n")
+	   (set! p (cdr p))
+	   )
+    )
+  )
+
+(proclaim 
+ module_description 1.1 
+ "CSTR"  "Richard Caley <[email protected]>"
+  ( "Handle module descriptions from C++ and from Scheme."
+   )
+  )
+
+(provide 'module_description)

CosyVoice-ttsfrd/resource/festival/mrpa_allophones.scm

@@ -0,0 +1,111 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                                                                       ;;
+;;                Centre for Speech Technology Research                  ;;
+;;                     University of Edinburgh, UK                       ;;
+;;                       Copyright (c) 1996,1997                         ;;
+;;                        All Rights Reserved.                           ;;
+;;                                                                       ;;
+;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;  this software and its documentation without restriction, including   ;;
+;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;  the following conditions:                                            ;;
+;;   1. The code must retain the above copyright notice, this list of    ;;
+;;      conditions and the following disclaimer.                         ;;
+;;   2. Any modifications must be clearly marked as such.                ;;
+;;   3. Original authors' names are not deleted.                         ;;
+;;   4. The authors' names are not used to endorse or promote products   ;;
+;;      derived from this software without specific prior written        ;;
+;;      permission.                                                      ;;
+;;                                                                       ;;
+;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;  THIS SOFTWARE.                                                       ;;
+;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;  A definition of the extended mrpa phone set used for some diphone sets
+;;
+
+(defPhoneSet
+  mrpa_allophones
+  ;;;  Phone Features
+  (;; vowel or consonant
+   (vc + -)  
+   ;; vowel length: short long dipthong schwa
+   (vlng s l d a 0)
+   ;; vowel height: high mid low
+   (vheight 1 2 3 -)
+   ;; vowel frontness: front mid back
+   (vfront 1 2 3 -)
+   ;; lip rounding
+   (vrnd + -)
+   ;; consonant type: stop fricative affricative nasal liquid
+   (ctype s f a n l 0)
+   ;; place of articulation: labial alveolar palatal labio-dental
+   ;;                         dental velar
+   (cplace l a p b d v 0)
+   ;; consonant voicing
+   (cvox + -)
+   )
+  ;; Phone set members
+  (
+   (uh  +   s   2   3   -   0   0   +)
+   (e   +   s   2   1   -   0   0   +)
+   (a   +   s   3   1   -   0   0   +)
+   (o   +   s   3   3   -   0   0   +)
+   (i   +   s   1   1   -   0   0   +)
+   (u   +   s   1   3   +   0   0   +)
+   (ii  +   l   1   1   -   0   0   +)
+   (uu  +   l   2   3   +   0   0   +)
+   (oo  +   l   3   2   -   0   0   +)
+   (aa  +   l   3   1   -   0   0   +)
+   (@@  +   l   2   2   -   0   0   +)
+   (ai  +   d   3   1   -   0   0   +)
+   (ei  +   d   2   1   -   0   0   +)
+   (oi  +   d   3   3   -   0   0   +)
+   (au  +   d   3   3   +   0   0   +)
+   (ou  +   d   3   3   +   0   0   +)
+   (e@  +   d   2   1   -   0   0   +)
+   (i@  +   d   1   1   -   0   0   +)
+   (u@  +   d   3   1   -   0   0   +)
+   (@   +   a   -   -   -   0   0   +)
+   (p   -   0   -   -   +   s   l   -)
+   (t   -   0   -   -   +   s   a   -)
+   (k   -   0   -   -   +   s   p   -)
+   (b   -   0   -   -   +   s   l   +)
+   (d   -   0   -   -   +   s   a   +)
+   (g   -   0   -   -   +   s   p   +)
+   (s   -   0   -   -   +   f   a   -)
+   (z   -   0   -   -   +   f   a   +)
+   (sh  -   0   -   -   +   f   p   -)
+   (zh  -   0   -   -   +   f   p   +)
+   (f   -   0   -   -   +   f   b   -)
+   (v   -   0   -   -   +   f   b   +)
+   (th  -   0   -   -   +   f   d   -)
+   (dh  -   0   -   -   +   f   d   +)
+   (ch  -   0   -   -   +   a   a   -)
+   (jh  -   0   -   -   +   a   a   +)
+   (h   -   0   -   -   +   a   v   -)
+   (m   -   0   -   -   +   n   l   +)
+   (n   -   0   -   -   +   n   d   +)
+   (ng  -   0   -   -   +   n   v   +)
+   (l   -   0   -   -   +   l   d   +)
+   (ll   -   0   -   -   +   l   d   +)
+   (y   -   0   -   -   +   l   a   +)
+   (r   -   0   -   -   +   l   p   +)
+   (w   -   0   -   -   +   l   l   +)
+   (#   -   0   -   -   -   0   0   -)
+   )
+  )
+
+(PhoneSet.silences '(#))
+
+(provide 'mrpa_allophones)

CosyVoice-ttsfrd/resource/festival/mrpa_durs.scm

@@ -0,0 +1,136 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  mrpa average phoneme durations from gsw 450
+;;;
+(set! phoneme_durations 
+'(
+(u 0.067)
+(i@ 0.146)
+(h 0.067)
+(uu 0.105)
+(uh 0.090)
+(v 0.053)
+(oo 0.145)
+(i 0.060)
+(jh 0.097)
+(ii 0.095)
+(w 0.066)
+(k 0.088)
+(+ 0.036)
+(y 0.051)
+(l 0.067)
+(zh 0.080)
+(ng 0.072)
+(m 0.070)
+(z 0.079)
+(## 0.256)
+(au 0.162)
+(a 0.118)
+(n 0.065)
+(o 0.102)
+(ai 0.156)
+(b 0.071)
+(ou 0.129)
+(ch 0.119)
+(p 0.094)
+(oi 0.165)
+(# 0.040)
+(e@ 0.131)
+(d 0.052)
+(dh 0.032)
+(e 0.091)
+(r 0.062)
+(sh 0.101)
+(@@ 0.149)
+(ei 0.131)
+(f 0.091)
+(s 0.093)
+(g 0.066)
+(u@ 0.120)
+(aa 0.173)
+(t 0.073)
+(th 0.080)
+(@ 0.054)
+))
+
+(set! gsw_durs
+'(
+(#    0.200 0.100)
+(h    0.061 0.028)
+(i@   0.141 0.061)
+(u    0.067 0.024)
+(uu   0.107 0.044)
+(uh   0.087 0.025)
+(v    0.051 0.019)
+(oo   0.138 0.046)
+(i    0.058 0.023)
+(ii   0.092 0.035)
+(w    0.054 0.023)
+(jh   0.094 0.024)
+(k    0.089 0.034)
+(y    0.048 0.025)
+(l    0.056 0.026)
+(zh   0.077 0.030)
+(ng   0.064 0.024)
+(m    0.063 0.021)
+(z    0.072 0.029)
+(a    0.120 0.036)
+(au   0.171 0.046)
+(n    0.059 0.025)
+(ou   0.134 0.039)
+(b    0.073 0.021)
+(o    0.094 0.037)
+(ai   0.137 0.047)
+(ch   0.128 0.039)
+(oi   0.183 0.050)
+(p    0.101 0.032)
+(e@   0.144 0.061)
+(d    0.048 0.021)
+(dh   0.031 0.016)
+(e    0.092 0.035)
+(r    0.053 0.025)
+(sh   0.108 0.031)
+(f    0.095 0.033)
+(@@   0.147 0.035)
+(ei   0.130 0.042)
+(s    0.102 0.037)
+(u@   0.140 0.057)
+(th   0.093 0.050)
+(g    0.064 0.021)
+(aa   0.155 0.045)
+(t    0.070 0.034)
+(@    0.046 0.020)
+))
+
+(provide 'mrpa_durs)

CosyVoice-ttsfrd/resource/festival/mrpa_phones.scm

@@ -0,0 +1,114 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;                                                                       ;;
+;;                Centre for Speech Technology Research                  ;;
+;;                     University of Edinburgh, UK                       ;;
+;;                       Copyright (c) 1996,1997                         ;;
+;;                        All Rights Reserved.                           ;;
+;;                                                                       ;;
+;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;  this software and its documentation without restriction, including   ;;
+;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;  the following conditions:                                            ;;
+;;   1. The code must retain the above copyright notice, this list of    ;;
+;;      conditions and the following disclaimer.                         ;;
+;;   2. Any modifications must be clearly marked as such.                ;;
+;;   3. Original authors' names are not deleted.                         ;;
+;;   4. The authors' names are not used to endorse or promote products   ;;
+;;      derived from this software without specific prior written        ;;
+;;      permission.                                                      ;;
+;;                                                                       ;;
+;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;  THIS SOFTWARE.                                                       ;;
+;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;;  A definition of the mrpa phone set 
+;;
+
+(defPhoneSet
+  mrpa
+  ;;;  Phone Features
+  (;; vowel or consonant
+   (vc + -)  
+   ;; vowel length: short long dipthong schwa
+   (vlng s l d a 0)
+   ;; vowel height: high mid low
+   (vheight 1 2 3 0)
+   ;; vowel frontness: front mid back
+   (vfront 1 2 3 0)
+   ;; lip rounding
+   (vrnd + - 0)
+   ;; consonant type: stop fricative affricate nasal lateral approximant
+   (ctype s f a n l r 0)
+   ;; place of articulation: labial alveolar palatal labio-dental
+   ;;                         dental velar glottal
+   (cplace l a p b d v g 0)
+   ;; consonant voicing
+   (cvox + - 0)
+   )
+  ;; Phone set members
+  (
+   (uh  +   s   2   3   -   0   0   0)
+   (e   +   s   2   1   -   0   0   0)
+   (a   +   s   3   1   -   0   0   0)
+   (o   +   s   2   3   +   0   0   0)
+   (i   +   s   1   1   -   0   0   0)
+   (u   +   s   1   3   +   0   0   0)
+   (ii  +   l   1   1   -   0   0   0)
+   (uu  +   l   1   3   +   0   0   0)
+   (oo  +   l   3   3   +   0   0   0)
+   (aa  +   l   3   3   -   0   0   0)
+   (@@  +   l   2   2   -   0   0   0)
+   (ai  +   d   3   2   -   0   0   0)
+   (ei  +   d   2   1   -   0   0   0)
+   (oi  +   d   3   3   +   0   0   0)
+   (au  +   d   3   2   +   0   0   0)
+   (ou  +   d   2   2   -   0   0   0)
+   (e@  +   d   2   1   -   0   0   0)
+   (i@  +   d   1   1   -   0   0   0)
+   (u@  +   d   3   1   +   0   0   0)
+   (@   +   a   2   2   -   0   0   0)
+   (p   -   0   0   0   0   s   l   -)
+   (t   -   0   0   0   0   s   a   -)
+   (k   -   0   0   0   0   s   v   -)
+   (b   -   0   0   0   0   s   l   +)
+   (d   -   0   0   0   0   s   a   +)
+   (g   -   0   0   0   0   s   v   +)
+   (s   -   0   0   0   0   f   a   -)
+   (z   -   0   0   0   0   f   a   +)
+   (sh  -   0   0   0   0   f   p   -)
+   (zh  -   0   0   0   0   f   p   +)
+   (f   -   0   0   0   0   f   b   -)
+   (v   -   0   0   0   0   f   b   +)
+   (th  -   0   0   0   0   f   d   -)
+   (dh  -   0   0   0   0   f   d   +)
+   (ch  -   0   0   0   0   a   p   -)
+   (jh  -   0   0   0   0   a   p   +)
+   (h   -   0   0   0   0   f   g   -)
+   (m   -   0   0   0   0   n   l   +)
+   (n   -   0   0   0   0   n   a   +)
+   (ng  -   0   0   0   0   n   v   +)
+   (l   -   0   0   0   0   l   a   +)
+   (y   -   0   0   0   0   r   p   +)
+   (r   -   0   0   0   0   r   a   +)
+   (w   -   0   0   0   0   r   l   +)
+   (#   -   0   0   0   0   0   0   -)
+   )
+  )
+
+(PhoneSet.silences '(#))
+
+(provide 'mrpa_phones)
+
+
+
+

CosyVoice-ttsfrd/resource/festival/ogimarkup-mode.scm

@@ -0,0 +1,191 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  An example tts text mode for reading OGI's CSLU toolkit mark up
+;;;
+;;;  Note not all tokens do something in festival but  all are removed 
+;;;  from the actual text 
+;;;
+
+(defvar ogimarkup_eou_tree 
+'((n.name matches "<.*")
+  ((1))
+((n.whitespace matches ".*\n.*\n\\(.\\|\n\\)*") ;; A significant break (2 nls)
+  ((1))
+  ((punc in ("?" ":" "!"))
+   ((1))
+   ((punc is ".")
+    ;; This is to distinguish abbreviations vs periods
+    ;; These are heuristics
+    ((name matches "\\(.*\\..*\\|[A-Z][A-Za-z]?[A-Za-z]?\\|etc\\)")  ;; an abbreviation
+     ((n.whitespace is " ")
+      ((0))                  ;; if abbrev single space isn't enough for break
+      ((n.name matches "[A-Z].*")
+       ((1))
+       ((0))))
+     ((n.whitespace is " ")  ;; if it doesn't look like an abbreviation
+      ((n.name matches "[A-Z].*")  ;; single space and non-cap is no break
+       ((1))
+       ((0)))
+      ((1))))
+    ((0)))))))
+
+(define (ogimarkup_init_func)
+ "Called on starting ogimarkup text mode."
+ (set! ogimarkup_in_tag nil)
+ (set! ogimarkup_tagtokens "")
+ (set! ogimarkup_previous_t2w_func token_to_words)
+ (set! english_token_to_words ogimarkup_token_to_words)
+ (set! token_to_words ogimarkup_token_to_words)
+ (set! ogimarkup_previous_eou_tree eou_tree)
+ (set! eou_tree ogimarkup_eou_tree))
+
+(define (ogimarkup_exit_func)
+ "Called on exit ogimarkup text mode."
+ (Parameter.set 'Duration_Stretch 1.0)
+ (set! token_to_words ogimarkup_previous_t2w_func)
+ (set! english_token_to_words ogimarkup_previous_t2w_func)
+ (set! eou_tree ogimarkup_previous_eou_tree))
+
+(define (ogimarkup_token_to_words token name)
+  "(ogimarkup_token_to_words token name)
+OGI markup specific token to word rules.  Tags may have optional
+argument e.g. <slow> or <slow 0.6> which means the tag may be over
+a number of tokens."
+  (let (tag (arg nil) (rval nil))
+  (cond
+   ((string-matches name "<.*")
+    (set! ogimarkup_tagtokens "")
+    (set! tag (string-after name "<"))
+    (if (string-matches tag ".*>$")
+	(set! tag (string-before tag ">"))
+	(if (string-matches (set! arg (item.feat token "n.name"))
+			    ".*>$")
+	    (set! arg (string-before arg ">"))))
+    (set! ogimarkup_in_tag tag)
+    (cond
+     ((string-equal tag "slow")
+      (Parameter.set 'Duration_Stretch 1.3))
+     ((string-equal tag "SLOW")
+      (Parameter.set 'Duration_Stretch 2.0))
+     ((string-equal tag "normal")
+      (Parameter.set 'Duration_Stretch 1.0))
+     ((string-matches tag "FAST")
+      (Parameter.set 'Duration_Stretch 0.5))
+     ((string-matches tag "fast")
+      (Parameter.set 'Duration_Stretch 0.8))
+     ((string-matches tag"spell")
+      ;; This ain't really right as we'll get an utterance break here
+      (set! rval (symbolexplode arg)))
+     ((string-matches tag "phone")
+      ;; This ain't really right as we'll get an utterance break here
+      (item.set_feat token "token_pos" "digits")  ;; canonical phone number
+      (set! rval (ogimarkup_previous_t2w_func token arg)))
+     ((string-matches tag "male")
+      (if (and (member 'OGIresLPC *modules*)
+	       (symbol-bound? 'voice_aec_diphone))
+	  (voice_aec_diphone)
+	  (voice_kal_diphone)))
+     ((string-matches tag "Male")
+      (if (and (member 'OGIresLPC *modules*)
+	       (symbol-bound? 'voice_mwm_diphone))
+	  (voice_mwm_diphone)
+	  (voice_cmu_us_rms_cg)))
+     ((string-matches tag "MALE")
+      (if (and (member 'OGIresLPC *modules*)
+	       (symbol-bound? 'voice_jph_diphone))
+	  (voice_jph_diphone)
+	  (voice_rab_diphone)))
+     ((string-matches tag "FT")
+      t)  ;; do nothing until the end of this tag
+     ((string-matches (downcase tag) "female") 
+      ;; only one female voice so map female Female FEMALE to it
+      (if (and (member 'OGIresLPC *modules*)
+	       (symbol-bound? 'voice_tll_diphone))
+	  (voice_tll_diphone)
+	  (voice_cmu_us_slt_arctic_hts))))
+    (if (string-matches name ".*>$")
+	(set! ogimarkup_in_tag nil))
+    rval ;; mostly nil
+    )
+   ((string-matches name ".*>$")
+    (set! ogimarkup_tagtokens 
+	  (string-append
+	   ogimarkup_tagtokens
+	   (ogimarkup_get_token_string token t)))  ;; delete final >
+    (if (string-equal ogimarkup_in_tag "FT")
+	(ogimarkup_festival_eval ogimarkup_tagtokens))
+    (set! ogimarkup_in_tag nil)   ;; end of tag
+    nil)
+   (ogimarkup_in_tag
+    (set! ogimarkup_tagtokens
+	  (string-append
+	   ogimarkup_tagtokens
+	   (ogimarkup_get_token_string token nil)))
+    nil)                          ;; still in tag
+   (t  ;; for all other cases
+     (ogimarkup_previous_t2w_func token name)))))
+
+(set! tts_text_modes
+   (cons
+    (list
+      'ogimarkup   ;; mode name
+      (list         ;; ogimarkup mode params
+       (list 'init_func ogimarkup_init_func)
+       (list 'exit_func ogimarkup_exit_func)))
+    tts_text_modes))
+
+(define (ogimarkup_get_token_string token delend)
+  "(ogimarkup_get_token_string TOKEN DELEND)
+return string for token including whitespace and punctuation.  If DELEND
+is true remove > from the name."
+  (string-append
+   (item.feat token "whitespace")
+   (item.feat token "prepunctuation")  
+   (if delend
+       (string-before 
+	(item.feat token "name") ">")
+       (item.feat token "name"))
+   (if (string-equal "0" (item.feat token "punc"))
+       ""
+       (item.feat token "punc"))))
+
+(define (ogimarkup_festival_eval tagtokens)
+"(ogimarkup_festival_eval TAGTOKENS
+Take a string of the tokens within the tag and read an s-expression from
+it and then evaluate it."
+  (let ((com "") (command nil))
+    (set! command (read-from-string tagtokens))
+    (eval command)))
+
+(provide 'ogimarkup-mode)

CosyVoice-ttsfrd/resource/festival/pauses.scm

@@ -0,0 +1,242 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Predicting pause insertion
+
+(define (Pauses utt)
+"(Pauses utt)                                
+Insert pauses where required."
+  (let ((rval (apply_method 'Pause_Method utt)))
+    (cond
+     (rval rval) ;; new style
+     (t
+      (Classic_Pauses utt))))
+  (Pause_optional_deleting_B_X utt))
+
+(define (Classic_Pauses utt)
+  "(Pauses UTT)
+Predict pause insertion."
+  (let ((words (utt.relation.items utt 'Word)) lastword tpname)
+    (if words
+	(begin
+	  (insert_initial_pause utt)   ;; always have a start pause
+	  (set! lastword (car (last words)))
+	  (mapcar
+	   (lambda (w)
+	     (let ((pbreak (item.feat w "pbreak"))
+		   (emph (item.feat w "R:Token.parent.EMPH")))
+	       (cond
+		((or (string-equal "B" pbreak)
+		     (string-equal "BB" pbreak))
+		 (insert_pause utt w))
+;		((string-equal emph "1")
+;		 (insert_pause utt w))
+		((equal? w lastword)
+		 (insert_pause utt w)))))
+	   words)
+	  ;; The embarrassing bit.  Remove any words labelled as punc or fpunc
+	  (mapcar
+	   (lambda (w)
+	     (let ((pos (item.feat w "pos")))
+	       (if (or (string-equal "punc" pos)
+		       (string-equal "fpunc" pos))
+		   (let ((pbreak (item.feat w "pbreak"))
+			 (wp (item.relation w 'Phrase)))
+		     (if (and (string-matches pbreak "BB?")
+			      (item.relation.prev w 'Word))
+			 (item.set_feat 
+			  (item.relation.prev w 'Word) "pbreak" pbreak))
+		     (item.relation.remove w 'Word)
+		     ;; can't refer to w as we've just deleted it
+		     (item.relation.remove wp 'Phrase)))))
+	   words)
+          ;; 12/01/2006 V.Strom: Even more embarrasing: Delete all silences
+          ;; that are followed by a silence.  These silence sequences 
+          ;; emerge if 'punc of phrase-final words consists of more than one 
+          ;; character, e.g. period+quote.  That in turn causes problems in 
+          ;; build_utts: the 2nd silence ends up with no features but its name, 
+          ;; because there is no corresponding 2nd silence in the phone 
+          ;; segmentation to align with.
+          ;; This schould be fixed in the functions below, but it is easier for
+          ;; me to clean up at the end:
+          (set! sil (car (car (cdr (car (PhoneSet.description '(silences)))))))
+          (set! seg (item.next(utt.relation.first utt 'Segment)))
+          (while seg
+             (if(and(equal? sil (item.name seg))
+                    (equal? sil (item.name (item.prev seg))))
+                (item.delete (item.prev seg)))
+             (set! seg (item.next seg)))))
+  utt))
+
+(define (insert_pause utt word)
+"(insert_pause UTT WORDITEM)
+Insert a silence segment after the last segment in WORDITEM in UTT."
+  (let ((lastseg (find_last_seg word))
+	(silence (car (car (cdr (car (PhoneSet.description '(silences))))))))
+    (if lastseg
+	(item.relation.insert 
+	 lastseg 'Segment (list silence) 'after))))
+
+(define (insert_initial_pause utt)
+"(insert_initial_pause UTT)
+Always have an initial silence if the utterance is non-empty.
+Insert a silence segment after the last segment in WORDITEM in UTT."
+  (let ((firstseg (car (utt.relation.items utt 'Segment)))
+	(silence (car (car (cdr (car (PhoneSet.description '(silences))))))))
+    (if firstseg
+	(item.relation.insert 
+	 firstseg 'Segment (list silence) 'before))))
+
+(define (insert_final_pause utt)
+"(insert_final_pause UTT)
+Always have a final silence if the utterance is non-empty."
+  (let ((lastseg (utt.relation.last utt 'Segment))
+        (silence (car (car (cdr (car (PhoneSet.description '(silences))))))))
+    (set! silence (format nil "%l" silence)) ; to make the symbol a string
+    ;(format t "silence is %l\n" silence)
+    ;(format t "lastseg is %l\n" (item.name lastseg))
+    (if lastseg
+       (if (not(equal? (item.name lastseg) silence))
+          (begin
+             (format t "iserted final pause %s\n" silence)
+             (item.relation.insert lastseg 'Segment (list silence) 'after))))))
+     
+
+(define (find_last_seg word)
+;;; Find the segment that is immediately at this end of this word
+;;; If this word is punctuation it might not have any segments
+;;; so we have to check back until we find a word with a segment in it
+  (cond
+   ((null word)
+    nil)  ;; there are no segs (don't think this can happen)
+   (t
+    (let ((lsyl (item.relation.daughtern word 'SylStructure)))
+    (if lsyl
+	(item.relation.daughtern lsyl 'SylStructure)
+	(find_last_seg (item.relation.prev word 'Word)))))))
+
+(define (Unisyn_Pauses utt)
+  "(Unisyn_Pauses UTT)
+Predict pause insertion in a Unisyn utterance structure."
+  (let ((words (utt.relation.items utt 'Word)) lastword tpname)
+    (if words
+	(begin
+	  (us_insert_initial_pause utt)   ;; always have a start pause
+	  (set! lastword (car (last words)))
+	  (mapcar
+	   (lambda (w)
+	     (let ((pbreak (item.feat w "pbreak"))
+		   (emph (item.feat w "R:Token.parent.EMPH")))
+	       (cond
+		((or (string-equal "B" pbreak)
+		     (string-equal "BB" pbreak))
+		 (us_insert_pause utt w))
+;		((string-equal emph "1")
+;		 (us_insert_pause utt w))
+		((equal? w lastword)
+		 (us_insert_pause utt w)))))
+	   words)
+	  ;; The embarrassing bit.  Remove any words labelled as punc or fpunc
+	  (mapcar
+	   (lambda (w)
+	     (let ((pos (item.feat w "pos")))
+	       (if (or (string-equal "punc" pos)
+		       (string-equal "fpunc" pos))
+		   (let ((pbreak (item.feat w "pbreak"))
+			 (wp (item.relation w 'Phrase)))
+		     (if (and (string-matches pbreak "BB?")
+			      (item.relation.prev w 'Word))
+			 (item.set_feat 
+			  (item.relation.prev w 'Word) "pbreak" pbreak))
+		     (item.relation.remove w 'Word)
+		     ;; can't refer to w as we've just deleted it
+		     (item.relation.remove wp 'Phrase)))))
+	   words)))
+  utt))
+
+(define (us_insert_pause utt word)
+"(us_insert_pause UTT WORDITEM)
+Insert a silence segment after the last segment in WORDITEM in UTT."
+  (let ((lastseg (us_find_last_seg word))
+	(silence "pau"))
+    (if lastseg
+	(item.relation.insert 
+	 lastseg 'Segment (list silence) 'after))))
+
+(define (us_insert_initial_pause utt)
+"(us_insert_initial_pause UTT)
+Always have an initial silence if the utterance is non-empty.
+Insert a silence segment after the last segment in WORDITEM in UTT."
+  (let ((firstseg (utt.relation.first utt 'Segment))
+	(silence "pau"))
+    (if firstseg
+	(item.relation.insert 
+	 firstseg 'Segment (list silence) 'before))))
+
+(define (us_find_last_seg word)
+;;; Find the segment that is immediately at this end of this word
+;;; If this word is punctuation it might not have any segments
+;;; so we have to check back until we find a word with a segment in it
+  (cond
+   ((null word)
+    nil)  ;; there are no segs (don't think this can happen)
+   (t
+    (if (item.daughtern_to (item.relation word 'WordStructure) 'Syllable)
+	(item.daughtern_to 
+	 (item.relation
+	  (item.daughtern_to (item.relation word 'WordStructure) 'Syllable)
+	  'SylStructure)
+	 'Segment)
+	(us_find_last_seg (item.relation.prev word 'Word))))))
+
+(define (Pause_optional_deleting_B_X utt)
+"(Pause_optional_deleting_B_X utt)
+
+Delete all phone symbols starting with 'B_' from the segemt relation 
+(a B_150 e.g. is a 150ms pause) if symbol 'Pause_delete_B_X is defined.  
+"
+; The B_X never occur in the phone segmentation but are predicted by 
+; some pause methods, in particular the default I used to produce the 
+; .utt files for the 2009 test sentences for the  Blizzard challange.
+; Some participants complained about them and I had to fix it quickly.
+   (if (symbol-bound? 'Pause_delete_B_X)
+      (let(seg )
+         (set! seg (item.next(utt.relation.first utt 'Segment)))
+         (while seg
+             (set! next_seg (item.next seg))
+             ;(format t "segment %l\n" (item.name seg))
+             (if(string-matches (item.name seg) "B_[0-9]*")
+                 (item.delete seg))
+             (set! seg next_seg)))))
+
+(provide 'pauses)

CosyVoice-ttsfrd/resource/festival/postlex.scm

@@ -0,0 +1,587 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1997                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Postlexical rules
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;           Modifed for CSTR HTS Voice Library                           ;;
+;;                 Author :  Junichi Yamagishi ([email protected])    ;;
+;;                 Date   :  Sept 2008                                    ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(define (PostLex utt)
+"(PostLex utt)
+Apply post lexical rules to segment stream.  These may be almost
+arbitrary rules as specified by the particular voice, through the
+postlex_hooks variable.  A number of standard post lexical rule
+sets are provided including reduction, posessives etc.  These
+rules are also used to mark standard segments with their cluster
+information used in creating diphone names."
+(let ((rval (apply_method 'PostLex_Method utt)))
+  (cond
+   (rval rval) ;; new style 
+   (t   ;; should only really need this one
+    (apply_hooks postlex_rules_hooks utt)))
+  utt
+))
+
+(define (Classic_PostLex utt)
+  "(Classic_PostLex utt)
+Apply post lexical rules (both builtin and those specified in 
+postlex_rules_hooks)."
+  (Builtin_PostLex utt)  ;; haven't translated all the rules yet
+  (apply_hooks postlex_rules_hooks utt)
+  utt
+)  
+
+(defvar postlex_rules_hooks nil
+"postlex_rules_hooks
+A function or list of functions which encode post lexical rules.
+This will be voice specific, though some rules will be shared across
+languages.")
+
+;;;  Mapping of full vowels to reduced vowels, this should be part
+;;;  of the phoneset definitions
+(defvar postlex_vowel_reduce_table
+  '((mrpa
+     ((uh @) (i @) (a @) (e @) (u @) (o @) (oo @)))
+    (radio
+     ((ah ax el en em) 
+      (ih ax) 
+;      (er axr ax) 
+;      (iy ih) 
+;      (ey ax) 
+      (aa ax) 
+      (ae ax) 
+      (eh ax))))
+"postlex_vowel_reduce_table
+Mapping of vowels to their reduced form.  This in an assoc list of
+phoneset name to an assoc list of full vowel to reduced form.")
+
+(defvar postlex_vowel_reduce_cart_tree nil
+"postlex_vowel_reduce_cart_tree
+CART tree for vowel reduction.")
+
+(defvar postlex_vowel_reduce_cart_tree_hand
+  '((stress is 0)
+    ((p.syl_break < 2)
+     ((syl_break < 2)
+      ((1))
+      ((0)))
+     ((0)))
+    ((0)))
+"postlex_vowel_reduce_cart_tree_hand
+A CART tree for vowel reduction.  This is hand-written.")
+
+(defvar postlex_vowel_reduce_cart_data
+'
+((R:SylStructure.parent.gpos is cc)
+ (((0 0.993548) (1 0.00645161) 0))
+ ((p.R:SylStructure.parent.gpos is md)
+  (((0 0.903226) (1 0.0967742) 0))
+  ((p.R:SylStructure.parent.gpos is det)
+   ((n.R:SylStructure.parent.gpos is content)
+    ((last_accent < 2.5)
+     ((next_accent < 2.5)
+      ((next_accent < 1.2)
+       ((n.syl_break is 4)
+        (((0 0.967213) (1 0.0327869) 0))
+        ((syl_break is 4)
+         (((0 0.952381) (1 0.047619) 0))
+         ((n.syl_break is 4)
+          (((0 0.953488) (1 0.0465116) 0))
+          ((position_type is single)
+           (((0 0.947368) (1 0.0526316) 0))
+           ((accented is 0)
+            ((n.accented is 0)
+             (((0 0.857143) (1 0.142857) 0))
+             (((0 0.415385) (1 0.584615) 1)))
+            (((0 0.974359) (1 0.025641) 0)))))))
+       (((0 0.968254) (1 0.031746) 0)))
+      (((0 0.969697) (1 0.030303) 0)))
+     (((0 0.976744) (1 0.0232558) 0)))
+    (((0 0.990291) (1 0.00970874) 0)))
+   ((next_accent < 108.5)
+    ((p.R:SylStructure.parent.gpos is pps)
+     (((0 0.828947) (1 0.171053) 0))
+     ((R:SylStructure.parent.gpos is det)
+      ((accented is 0)
+       (((0 0.0599572) (1 0.940043) 1))
+       (((0 0.949367) (1 0.0506329) 0)))
+      ((p.R:SylStructure.parent.gpos is cc)
+       (((0 0.880952) (1 0.119048) 0))
+       ((p.R:SylStructure.parent.gpos is wp)
+        (((0 0.875) (1 0.125) 0))
+        ((p.R:SylStructure.parent.gpos is in)
+         ((n.syl_break is 4)
+          (((0 0.961538) (1 0.0384615) 0))
+          ((next_accent < 2.5)
+           ((syl_break is 4)
+            (((0 0.95122) (1 0.0487805) 0))
+            ((next_accent < 1.2)
+             ((accented is 0)
+              ((n.stress is 0)
+               (((0 0.788462) (1 0.211538) 0))
+               ((R:SylStructure.parent.R:Word.p.gpos is content)
+                (((0 0.863636) (1 0.136364) 0))
+                ((position_type is single)
+                 (((0 0.729167) (1 0.270833) 0))
+                 (((0 0.4) (1 0.6) 1)))))
+              (((0 0.983871) (1 0.016129) 0)))
+             (((0 0.96) (1 0.04) 0))))
+           (((0 0.963636) (1 0.0363636) 0))))
+         ((position_type is single)
+          ((syl_break is 4)
+           (((0 0.993865) (1 0.00613497) 0))
+           ((p.R:SylStructure.parent.gpos is to)
+            (((0 0.984375) (1 0.015625) 0))
+            ((syl_break is 1)
+             ((accented is 0)
+              ((n.R:SylStructure.parent.gpos is in)
+               (((0 0.869565) (1 0.130435) 0))
+               ((R:SylStructure.parent.gpos is content)
+                (((0 0.861789) (1 0.138211) 0))
+                ((p.R:SylStructure.parent.gpos is content)
+                 ((p.syl_break is 4)
+                  (((0 0.858065) (1 0.141935) 0))
+                  ((R:SylStructure.parent.gpos is in)
+                   ((p.syl_break is 1)
+                    ((n.R:SylStructure.parent.gpos is det)
+                     (((0 0.659574) (1 0.340426) 0))
+                     ((p.stress is 0)
+                      (((0 0.422222) (1 0.577778) 1))
+                      (((0 0.582278) (1 0.417722) 0))))
+                    ((n.accented is 0)
+                     ((n.R:SylStructure.parent.gpos is content)
+                      (((0 0.65) (1 0.35) 0))
+                      ((p.stress is 0)
+                       (((0 0.464286) (1 0.535714) 1))
+                       (((0 0.538462) (1 0.461538) 0))))
+                     (((0 0.803279) (1 0.196721) 0))))
+                   ((n.R:SylStructure.parent.gpos is det)
+                    (((0 0.952381) (1 0.047619) 0))
+                    ((n.syl_break is 4)
+                     (((0 0.833333) (1 0.166667) 0))
+                     ((p.stress is 0)
+                      ((p.syl_break is 1)
+                       ((n.syl_break is 1)
+                        (((0 0.740741) (1 0.259259) 0))
+                        ((R:SylStructure.parent.gpos is aux)
+                         (((0 0.478261) (1 0.521739) 1))
+                         (((0 0.769231) (1 0.230769) 0))))
+                       (((0 0.755556) (1 0.244444) 0)))
+                      (((0 0.797619) (1 0.202381) 0)))))))
+                 (((0 0.870968) (1 0.129032) 0)))))
+              (((0 0.983806) (1 0.0161943) 0)))
+             (((0 0.977778) (1 0.0222222) 0)))))
+          ((next_accent < 21.6)
+           ((p.stress is 0)
+            ((R:SylStructure.parent.R:Word.p.gpos is md)
+             (((0 0.961538) (1 0.0384615) 0))
+             ((position_type is mid)
+              (((0 0.977612) (1 0.0223881) 0))
+              ((n.R:SylStructure.parent.gpos is det)
+               (((0 0.916667) (1 0.0833333) 0))
+               ((R:SylStructure.parent.R:Word.n.gpos is 0)
+                (((0 0.915493) (1 0.084507) 0))
+                ((R:SylStructure.parent.R:Word.n.gpos is pps)
+                 (((0 0.884615) (1 0.115385) 0))
+                 ((n.stress is 0)
+                  ((n.syl_break is 4)
+                   (((0 0.986755) (1 0.013245) 0))
+                   ((p.syl_break is 4)
+                    (((0 0.977011) (1 0.0229885) 0))
+                    ((n.syl_break is 4)
+                     (((0 0.965517) (1 0.0344828) 0))
+                     ((last_accent < 1.2)
+                      ((last_accent < 0.1)
+                       (((0 0.910448) (1 0.0895522) 0))
+                       ((next_accent < 1.2)
+                        ((R:SylStructure.parent.R:Word.n.gpos is in)
+                         (((0 0.82) (1 0.18) 0))
+                         ((n.syl_break is 0)
+                          ((R:SylStructure.parent.R:Word.p.gpos is content)
+                           (((0 0.819672) (1 0.180328) 0))
+                           (((0 0.444444) (1 0.555556) 1)))
+                          (((0 0.785714) (1 0.214286) 0))))
+                        (((0 0.836364) (1 0.163636) 0))))
+                      (((0 0.962025) (1 0.0379747) 0))))))
+                  ((stress is 0)
+                   ((n.syl_break is 4)
+                    (((0 0.21875) (1 0.78125) 1))
+                    ((R:SylStructure.parent.R:Word.p.gpos is aux)
+                     (((0 0.259259) (1 0.740741) 1))
+                     ((p.syl_break is 1)
+                      (((0 0.243094) (1 0.756906) 1))
+                      ((R:SylStructure.parent.R:Word.p.gpos is det)
+                       (((0 0.290323) (1 0.709677) 1))
+                       ((R:SylStructure.parent.R:Word.p.gpos is in)
+                        (((0 0.3) (1 0.7) 1))
+                        ((syl_break is 1)
+                         (((0 0.289157) (1 0.710843) 1))
+                         ((p.syl_break is 4)
+                          (((0 0.352941) (1 0.647059) 1))
+                          ((n.syl_break is 0)
+                           (((0 0.311475) (1 0.688525) 1))
+                           ((syl_break is 4)
+                            (((0 0.4) (1 0.6) 1))
+                            (((0 0.581395) (1 0.418605) 0)))))))))))
+                   (((0 1) (1 0) 0)))))))))
+            ((stress is 0)
+             ((R:SylStructure.parent.R:Word.n.gpos is 0)
+              (((0 0.121212) (1 0.878788) 1))
+              ((next_accent < 2.4)
+               ((R:SylStructure.parent.gpos is content)
+                ((position_type is mid)
+                 (((0 0.176895) (1 0.823105) 1))
+                 ((p.syl_break is 1)
+                  (((0 0.229167) (1 0.770833) 1))
+                  ((syl_break is 4)
+                   (((0 0.242775) (1 0.757225) 1))
+                   ((p.syl_break is 0)
+                    ((n.R:SylStructure.parent.gpos is in)
+                     (((0 0.253521) (1 0.746479) 1))
+                     ((R:SylStructure.parent.R:Word.p.gpos is in)
+                      (((0 0.262774) (1 0.737226) 1))
+                      ((last_accent < 2.1)
+                       ((n.R:SylStructure.parent.gpos is aux)
+                        (((0 0.304348) (1 0.695652) 1))
+                        ((next_accent < 1.2)
+                         ((n.R:SylStructure.parent.gpos is cc)
+                          (((0 0.291667) (1 0.708333) 1))
+                          ((syl_break is 1)
+                           ((n.syl_break is 4)
+                            (((0 0.344828) (1 0.655172) 1))
+                            ((R:SylStructure.parent.R:Word.p.gpos is det)
+                             (((0 0.364706) (1 0.635294) 1))
+                             ((n.syl_break is 4)
+                              (((0 0.384615) (1 0.615385) 1))
+                              ((last_accent < 1.2)
+                               ((p.accented is 0)
+                                (((0 0.584906) (1 0.415094) 0))
+                                ((n.accented is 0)
+                                 ((R:SylStructure.parent.R:Word.p.gpos is content)
+                                  (((0 0.41) (1 0.59) 1))
+                                  (((0 0.6) (1 0.4) 0)))
+                                 (((0 0.333333) (1 0.666667) 1))))
+                               (((0 0.380952) (1 0.619048) 1))))))
+                           ((p.accented is 0)
+                            (((0 0.183673) (1 0.816327) 1))
+                            ((n.R:SylStructure.parent.gpos is content)
+                             ((n.stress is 0)
+                              (((0 0.295455) (1 0.704545) 1))
+                              ((R:SylStructure.parent.R:Word.p.gpos is content)
+                               ((n.syl_break is 1)
+                                (((0 0.5) (1 0.5) 0))
+                                (((0 0.40625) (1 0.59375) 1)))
+                               (((0 0.333333) (1 0.666667) 1))))
+                             (((0 0.2) (1 0.8) 1))))))
+                         (((0 0.3) (1 0.7) 1))))
+                       (((0 0.302326) (1 0.697674) 1)))))
+                    (((0 0.25) (1 0.75) 1))))))
+                (((0 0.173913) (1 0.826087) 1)))
+               (((0 0.166667) (1 0.833333) 1))))
+             (((0 1) (1 0) 0))))
+           (((0 0.2) (1 0.8) 1)))))))))
+    (((0 0.15) (1 0.85) 1)))))))
+
+(defvar postlex_mrpa_r_cart_tree
+'((name is r)
+   ((R:Segment.n.ph_vc is -)
+    ((delete))
+    ((nil)))
+   ((nil)))
+"postlex_mrpa_r_cart_tree
+For remove final R when not between vowels.")
+
+
+;; Changed this to actually work... (Rob 09/12/04)
+;; Changed this to delete the syllable when schwa is unneccesary (awb 19/07/04)
+(define (postlex_apos_s_check utt)
+  "(postlex_apos_s_check UTT)
+Deal with possesive s for English (American and British).  Delete
+schwa of 's if previous is not an alveolar or palatal fricative or affricative, and
+change voiced to unvoiced s if previous is not voiced."
+  (mapcar
+   (lambda (syl)
+     ; word is 's
+     (if (string-equal "'s" (item.feat 
+			     syl "R:SylStructure.parent.name"))
+         (begin
+           ;; de-voice if last phone of previous word is unvoiced
+           (if (string-equal 
+                "-"
+                (item.feat syl "p.R:SylStructure.daughtern.ph_cvox"))
+               (item.set_name 
+                (item.relation.daughtern syl 'SylStructure)
+                "s"))  ;; change it from "z" to "s"
+	   ; if the previous seg is a aveolar or palatal, 
+           ; fricative or affricate don't delete schwa otherwise delete it
+           (if (and 
+                (member_string 
+                 (item.feat syl "p.R:SylStructure.daughtern.ph_ctype") '(f a))
+                (member_string 
+                 (item.feat syl "p.R:SylStructure.daughtern.ph_cplace") '(a p)))
+               (begin
+                 t)
+               (begin
+                 ;; delete the schwa
+                 (item.delete (item.relation.daughter1 syl 'SylStructure))
+                 ;; attach orphaned s/z to previous word
+                 (item.relation.append_daughter
+                  (item.prev syl)
+                  'SylStructure
+                  (item.relation.daughtern syl 'SylStructure))
+                 ;; delete the now empty syllable
+                 (item.delete syl))))))
+   ;; never happens to if 's is first in an utterance
+   (cdr (utt.relation.items utt 'Syllable)))
+  utt)
+
+;; Changed this to work the other way round, too.  Volker 10/08/06
+(define (postlex_the_vs_thee utt)
+"(postlex_the_vs_thee utt)
+Unnreduce the schwa in \"the\" when a vowel follows.
+Reduce the vowel in \"the\" when no vowel follows (this 
+requires a lexicon entry for \"the\" with feature \"reduced\",
+otherwise there will be no reduction)."
+(let ((fullform (cadr (car (caar (cdr (cdar (lex.lookup_all 'thee)))))))
+      (reducedform (cadr(car(caar(cddr(lex.lookup 'the '(reduced)))))))
+       seg)
+
+  (mapcar
+   (lambda (word)
+     (if (string-equal "the" (downcase (item.feat word "name")))
+         (begin
+           (set! seg (item.relation (item.daughtern (item.relation.daughtern word 'SylStructure)) 'Segment))
+           (if (string-equal "+" (item.feat (item.next seg) 'ph_vc))
+               (item.set_feat seg 'name fullform)
+               (item.set_feat seg 'name reducedform)))))
+   (utt.relation.items utt 'Word)))
+utt)
+
+(define (postlex_the_vs_thee_changeflag utt)
+"(postlex_the_vs_thee_changeflag utt)
+Unnreduce the schwa in \"the\" when a vowel follows.
+Reduce the vowel in \"the\" when no vowel follows (this
+requires a lexicon entry for \"the\" with feature \"reduced\",
+otherwise there will be no reduction)."
+(let ((fullform (cadr (car (caar (cdr (cdar (lex.lookup_all 'thee)))))))
+      (reducedform (cadr(car(caar(cddr(lex.lookup 'the '(reduced)))))))
+       seg)
+
+  (mapcar
+   (lambda (word)
+     (if (string-equal "the" (downcase (item.feat word "name")))
+         (begin
+           (set! seg (item.relation (item.daughtern (item.relation.daughtern word 'SylStructure)) 'Segment))
+           (if (string-equal "+" (item.feat (item.next seg) 'ph_vc))
+               (item.set_feat seg 'reducable 0)
+               (item.set_feat seg 'reducable 1)))))
+   (utt.relation.items utt 'Word)))
+utt)
+
+
+;;  For Multisyn voices only.  Volker 14/08/06
+(define (postlex_a utt)
+"(postlex_a utt)
+If POS of \"a\" is \"nn\" and segment feature \"reducable\", set it to 0.
+This is a bugfix, but still requires the target cost function to add a 
+penalty if a candidate is reducable but the target is not.  expro_target_cost
+does that."
+(let(seg)
+  (mapcar
+    (lambda(word)
+;;       (format t "%s\t%s\n" (item.feat word 'name)(item.feat word 'pos))
+       (if(and(string-equal "a" (downcase (item.feat word "name")))
+              (string-equal "nn" (item.feat word "pos")))
+          (begin
+             (set! seg (item.relation (item.daughtern (item.relation.daughtern word
+'SylStructure)) 'Segment))
+;;             (format t "should not be reducable\n")
+             (if (eq 1 (parse-number (item.feat seg 'reducable)))
+                (item.set_feat seg 'reducable 0))))
+    )
+    (utt.relation.items utt 'Word)))
+utt)
+
+
+
+(define (postlex_unilex_vowel_reduction utt)
+"(postlex_unilex_vowel_reduction utt)
+Perform vowel reduction based on unilex specification of what can be reduced."
+(let ()
+  (mapcar
+   (lambda (seg)
+     (if (and (eq? (parse-number (item.feat seg "reducable")) 1)
+	      (not (> (parse-number (item.feat seg "R:SylStructure.parent.stress")) 0)))
+	 (if (not (and (seg_word_final seg)
+		       (string-equal (item.feat (item.next seg) 'ph_vc) "+")))
+	     (item.set_feat seg "name" (item.feat seg "reducedform")))))
+   (utt.relation.items utt 'Segment)))
+utt)
+
+
+
+
+(define (seg_word_final seg)
+"(seg_word_final seg)
+Is this segment word final?"
+  (let ((this_seg_word (item.parent (item.relation.parent  seg 'SylStructure)))
+	(silence (car (cadr (car (PhoneSet.description '(silences))))))
+	next_seg_word)
+    (if (item.next seg)
+	(set! next_seg_word (item.parent (item.relation.parent (item.next seg) 'SylStructure))))
+    (if (or (equal? this_seg_word next_seg_word)
+	     (string-equal (item.feat seg "name") silence))
+	nil
+	t)))
+
+
+
+;; imported from postlex_intervoc_r.scm   Volker 14/08/06
+(define (postlex_intervoc_r utt)
+"(postlex_intervoc_r UTT)
+
+Remove any word-final /r/ which is phrase-final or not going 
+to be inter-vocalic i.e. the following words does not start 
+with a vowel. 
+
+NOTE: in older versions of unilex-rpx.out for Festival, there 
+is no word-final /r/.
+
+"
+(let (word next_word last_phone following_phone)
+   (set! word  (utt.relation.first utt 'Word))
+
+   (while word
+      (set! next_word (item.next word))
+      (set! last_phone (item.daughtern
+                          (item.daughtern(item.relation word 'SylStructure))))
+      (if next_word
+         (begin
+
+            (set! following_phone (item.daughter1
+                                     (item.daughter1
+                                        (item.relation next_word 'SylStructure))))
+            ; last_phone and following_phone should always be defined at this point,
+            ; but since the upgrade to Fedora and characters no longer being in ISO
+            ; but in UTF8, the pound sterling is no longer treated correctly. 
+            ; Probably (Token utt) should be fixed.
+
+            (if (and following_phone  last_phone)
+               (begin
+                  (format t "%s\t%s %s %s %s\n" (item.name word)
+                                       (item.name last_phone)
+                                       (item.name following_phone)
+                                       (item.feat following_phone 'ph_vc)
+                                       (item.feat word 'pbreak))
+                  (if(and(equal? "r" (item.name last_phone))
+                         (or(not(equal? "NB" (item.feat word 'pbreak)))
+                            (equal? "-" (item.feat following_phone 'ph_vc))))
+                     (begin
+                        (format t "\t\t\t/r/ in \"%s %s\"  deleted\n"
+                                  (item.name word)(item.name next_word))
+                        (item.delete last_phone))))))
+            (if(and last_phone (equal? "r" (item.name last_phone)))
+               (begin
+                  (format t "\t\t\tutterance-final /r/ deleted\n")
+                  (item.delete last_phone)))
+         )
+
+      (set! word (item.next word))))
+   utt)
+
+
+(define (postlex_stop_deletion utt)
+"(postlex_stop_deletion utt)
+
+Delete any stop or affricative (phone which has a closure) 
+immediately followed by another stop or affricative.
+
+Also save the identity of the deleted phone for the 
+context cost functions.  Consider:
+
+backtrack /b a k t r a k/ -> /b a t r a k/
+(actually Jenny reduces : /b a k_cl k t_cl t r a k/ -> /b a k_cl t r a k/)
+If we then look for a diphone /a t/ we want to favour
+candidates coming from the same context i.e. which 
+are actually a reduced /a k t/.  In the data base, 
+the 1st /a/ gets the feature right_context=k and the 
+/t/ gets the fearture left_context=k.
+
+"
+(let(seg next_seg prev_seg)
+   (set! seg (utt.relation.first utt 'Segment))
+   (while seg
+      (set! prev_seg (item.prev seg))
+      (if prev_seg
+         (begin
+           ;(format t "%s %s %s\n" (item.name seg)
+           ;                       (item.feat seg 'ph_ctype)
+           ;                       (item.feat seg 'p.ph_ctype))
+            (if(and(or(equal? "s" (item.feat seg 'ph_ctype))
+                      (equal? "a" (item.feat seg 'ph_ctype)))
+                   (or(equal? "s" (item.feat seg 'p.ph_ctype))
+                      (equal? "a" (item.feat seg 'p.ph_ctype)))
+                    ; When there are 3 stops in a row, and after the 1st has been
+                    ; deleted, this prevents the 2nd to be deleted as well:
+                   (equal? 0 (item.feat prev_seg 'left_context)))
+               (begin
+                  (set! prev_prev_seg (item.prev prev_seg))
+                  (format t "postlex_stop_deletion: %s in %s\n"
+                            (item.name prev_seg)
+                            (item.name(item.parent(item.relation.parent prev_seg
+                                                                'SylStructure))))
+                  (if prev_prev_seg 
+                     (begin
+                       ;(format t "setting left_context of %s and right context of %s to %s\n"
+                       ;              (item.name seg)
+                       ;              (item.name prev_prev_seg)
+                       ;              (item.name prev_seg))
+                        (item.set_feat seg 'left_context (item.name prev_seg))
+                        (item.set_feat prev_prev_seg 'right_context (item.name prev_seg))))
+                  (if(and(item.next seg)
+                         (equal? (item.name seg) (item.name prev_seg)))
+                     (begin
+                       ;(format t "setting left_context of %s to %s\n"
+                       ;              (item.name (item.next seg)
+                       ;              (item.name prev_seg))
+                         
+                        (item.set_feat (item.next seg) 'left_context (item.name prev_seg))))
+                  (item.delete prev_seg)))))
+      (set! seg (item.next seg))))
+utt)
+
+(provide 'postlex)

CosyVoice-ttsfrd/resource/festival/sable-latin.ent

@@ -0,0 +1,171 @@
+<!-- 
+
+NOTE: THIS IS A WORKING DOCUMENT. NOTHING IN HERE SHOULD BE
+TAKEN AS FINAL.
+
+This is an initial proposal for a Latin 1 and assorted
+other characters entity set for SABLE. It is based on the 
+equivalent set for HTML 3.
+
+-->
+<!-- Portions of this text are copyright ISO:
+
+     (C) International Organization for Standardization 1986
+     Permission to copy in any form is granted for use with
+     conforming SGML systems and applications as defined in
+     ISO 8879, provided this notice is included in all copies.
+-->
+<!--	Character entity set. Typical invocation:
+	<!ENTITY % HTMLlat1 PUBLIC
+	   "-//W3O//ENTITIES W3 Latin 1 for HTML//EN">
+	%HTMLlat1;
+-->
+<!--	Modified for use in HTML
+	$Id: sable-latin.ent,v 1.2 2001/04/04 13:12:35 awb Exp $ =
+
+-->
+<!--    Modified to add characters in the range &161; to &191; in
+	the ISO Latin-1 character set, which could only be referred =
+
+	to by numeric references. Entity names based on relevant entities in
+        ISO 8879-1986//ENTITIES Numeric and Special Graphic//EN"
+        Also added the standard lt gt amp entities from HTML 2.0
+        Chris Lilley, 13 March 1995
+        =
+
+        This covers all of Latin 1, but we are still unable to display a =
+
+        Trade Mark (TM)
+-->      
+
+<!ENTITY AElig  "&#198;" > <!-- capital AE diphthong (ligature) -->
+<!ENTITY Aacute "&#193;" > <!-- capital A, acute accent -->
+<!ENTITY Acirc  "&#194;" > <!-- capital A, circumflex accent -->
+<!ENTITY Agrave "&#192;" > <!-- capital A, grave accent -->
+<!ENTITY Aring  "&#197;" > <!-- capital A, ring -->
+<!ENTITY Atilde "&#195;" > <!-- capital A, tilde -->
+<!ENTITY Auml   "&#196;" > <!-- capital A, dieresis or umlaut mark -->
+<!ENTITY Ccedil "&#199;" > <!-- capital C, cedilla -->
+<!ENTITY ETH    "&#208;" > <!-- capital Eth, Icelandic -->
+<!ENTITY Eacute "&#201;" > <!-- capital E, acute accent -->
+<!ENTITY Ecirc  "&#202;" > <!-- capital E, circumflex accent -->
+<!ENTITY Egrave "&#200;" > <!-- capital E, grave accent -->
+<!ENTITY Euml   "&#203;" > <!-- capital E, dieresis or umlaut mark -->
+<!ENTITY Iacute "&#205;" > <!-- capital I, acute accent -->
+<!ENTITY Icirc  "&#206;" > <!-- capital I, circumflex accent -->
+<!ENTITY Igrave "&#204;" > <!-- capital I, grave accent -->
+<!ENTITY Iuml   "&#207;" > <!-- capital I, dieresis or umlaut mark -->
+<!ENTITY Ntilde "&#209;" > <!-- capital N, tilde -->
+<!ENTITY Oacute "&#211;" > <!-- capital O, acute accent -->
+<!ENTITY Ocirc  "&#212;" > <!-- capital O, circumflex accent -->
+<!ENTITY Ograve "&#210;" > <!-- capital O, grave accent -->
+<!ENTITY Oslash "&#216;" > <!-- capital O, slash -->
+<!ENTITY Otilde "&#213;" > <!-- capital O, tilde -->
+<!ENTITY Ouml   "&#214;" > <!-- capital O, dieresis or umlaut mark -->
+<!ENTITY THORN  "&#222;" > <!-- capital THORN, Icelandic -->
+<!ENTITY Uacute "&#218;" > <!-- capital U, acute accent -->
+<!ENTITY Ucirc  "&#219;" > <!-- capital U, circumflex accent -->
+<!ENTITY Ugrave "&#217;" > <!-- capital U, grave accent -->
+<!ENTITY Uuml   "&#220;" > <!-- capital U, dieresis or umlaut mark -->
+<!ENTITY Yacute "&#221;" > <!-- capital Y, acute accent -->
+<!ENTITY aacute "&#225;" > <!-- small a, acute accent -->
+<!ENTITY acirc  "&#226;" > <!-- small a, circumflex accent -->
+<!ENTITY aelig  "&#230;" > <!-- small ae diphthong (ligature) -->
+<!ENTITY agrave "&#224;" > <!-- small a, grave accent -->
+<!ENTITY aring  "&#229;" > <!-- small a, ring -->
+<!ENTITY atilde "&#227;" > <!-- small a, tilde -->
+<!ENTITY auml   "&#228;" > <!-- small a, dieresis or umlaut mark -->
+<!ENTITY ccedil "&#231;" > <!-- small c, cedilla -->
+<!ENTITY eacute "&#233;" > <!-- small e, acute accent -->
+<!ENTITY ecirc  "&#234;" > <!-- small e, circumflex accent -->
+<!ENTITY egrave "&#232;" > <!-- small e, grave accent -->
+<!ENTITY eth    "&#240;" > <!-- small eth, Icelandic -->
+<!ENTITY euml   "&#235;" > <!-- small e, dieresis or umlaut mark -->
+<!ENTITY iacute "&#237;" > <!-- small i, acute accent -->
+<!ENTITY icirc  "&#238;" > <!-- small i, circumflex accent -->
+<!ENTITY igrave "&#236;" > <!-- small i, grave accent -->
+<!ENTITY iuml   "&#239;" > <!-- small i, dieresis or umlaut mark -->
+<!ENTITY ntilde "&#241;" > <!-- small n, tilde -->
+<!ENTITY oacute "&#243;" > <!-- small o, acute accent -->
+<!ENTITY ocirc  "&#244;" > <!-- small o, circumflex accent -->
+<!ENTITY ograve "&#242;" > <!-- small o, grave accent -->
+<!ENTITY oslash "&#248;" > <!-- small o, slash -->
+<!ENTITY otilde "&#245;" > <!-- small o, tilde -->
+<!ENTITY ouml   "&#246;" > <!-- small o, dieresis or umlaut mark -->
+<!ENTITY szlig  "&#223;" > <!-- small sharp s, German (sz ligature) -->
+<!ENTITY thorn  "&#254;" > <!-- small thorn, Icelandic -->
+<!ENTITY uacute "&#250;" > <!-- small u, acute accent -->
+<!ENTITY ucirc  "&#251;" > <!-- small u, circumflex accent -->
+<!ENTITY ugrave "&#249;" > <!-- small u, grave accent -->
+<!ENTITY uuml   "&#252;" > <!-- small u, dieresis or umlaut mark -->
+<!ENTITY yacute "&#253;" > <!-- small y, acute accent -->
+<!ENTITY yuml   "&#255;" > <!-- small y, dieresis or umlaut mark -->
+<!-- =
+
+     Ones that aren't accented characters, and so not in ISO Added Latin =
+1.
+
+     umlaut. macron, acute, cedilla
+     were not in ISO Numeric and Special Graphic
+     either; I took their names from the numeric entity list in
+     http://www.hpl.hp.co.uk/people/dsr/html/latin1.html =
+
+     Chris Lilley, 13 March 1995  =
+
+-->    
+
+<!ENTITY iexcl   "&#161;" > <!-- inverted exclamation mark &161; -->
+<!ENTITY cent    "&#162;" > <!-- cent sign &162; -->
+<!ENTITY pound   "&#163;" > <!-- pound sterling sign &163; -->
+<!ENTITY curren  "&#164;" > <!-- general currency sign &164; -->
+<!ENTITY yen     "&#165;" > <!-- yen sign &165; -->
+<!ENTITY brvbar  "&#166;" > <!-- broken (vertical) bar &166; -->
+<!ENTITY sect    "&#167;" > <!-- section sign &167; -->
+<!ENTITY umlaut  "&#168;" > <!-- umlaut (dieresis) &168; -->
+<!ENTITY copy    "&#169;" > <!-- copyright sign &169; -->
+<!ENTITY ordf    "&#170;" > <!-- ordinal indicator, feminine &170; -->
+<!ENTITY laquo   "&#171;" > <!-- angle quotation mark, left &171; -->
+<!ENTITY not     "&#172;" > <!-- not sign &172; -->
+<!ENTITY shy     "&#173;" > <!-- soft hyphen &173;-->
+<!ENTITY reg     "&#174;" > <!-- registered trademark &174; -->
+<!ENTITY macron  "&#175;" > <!-- macron &175; -->
+<!ENTITY deg     "&#176;" > <!-- degree sign &176; -->
+<!ENTITY plusmn  "&#177;" > <!-- plus-or-minus sign &177; -->
+<!ENTITY sup2    "&#178;" > <!-- superscript two &178; -->
+<!ENTITY sup3    "&#179;" > <!-- superscript three &179; -->
+<!ENTITY acute   "&#180;" > <!-- acute accent &180; -->
+<!ENTITY micro   "&#181;" > <!-- micro sign &181; -->
+<!ENTITY para    "&#182;" > <!-- pilcrow (paragraph sign) &182; -->
+<!ENTITY middot  "&#183;" > <!-- middle dot (centred decimal point) &183; -->
+<!ENTITY cedilla "&#184;" > <!-- cedilla accent &184; -->
+<!ENTITY sup1    "&#185;" > <!-- superscript one -->
+<!ENTITY ordm    "&#186;" > <!-- ordinal indicator, masculine -->
+<!ENTITY raquo   "&#187;" > <!-- angle quotation mark, right -->
+<!ENTITY frac14  "&#188;" > <!-- fraction one-quarter -->
+<!ENTITY frac12  "&#189;" > <!-- fraction one-half -->
+<!ENTITY frac34  "&#190;" > <!-- fraction three-quarters -->
+<!ENTITY iquest  "&#191;" > <!-- inverted question mark -->
+<!-- the odd ones tucked in amongst the accented letters -->
+<!ENTITY times   "&#215;" > <!-- multiply sign -->
+<!ENTITY divide  "&#247;" > <!-- divide sign -->
+
+<!ENTITY amp "&#38;" > <!-- ampersand          -->
+<!ENTITY gt "&#62;"  > <!-- greater than       -->
+<!ENTITY lt "&#60;"  > <!-- less than          -->
+<!ENTITY quot "&#34;" > <!-- double quote       -->
+
+<!--
+        Should the dollar sign and such like also be given entity names?
+        There are suitable ones around. For example, people using =
+
+        internationalised keyboards in various countries might not be =
+
+        readily able to access some of these characters.
+        =
+
+        On such grounds, I suggest entity names for these:
+        ! " # $ %  ' ( ) * + , - . / : ;  =3D  ? [ \ ] ^ _ ` { | } ~
+        Lastly, what about &tab; for those whose editors convert all
+        tabs to spaces?
+
+-->

CosyVoice-ttsfrd/resource/festival/sable-mode.scm

@@ -0,0 +1,560 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 1998                            ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;  Festival (1.3.X) support for SABLE 0.2 the SGML/XML based mark up    ;;
+;;;  language.                                                            ;;
+;;;                                                                       ;;
+;;;  This is XML version requiring Edinburgh's LTG's rxp XML parser as    ;;
+;;;  distributed with Festival                                            ;;
+;;;                                                                       ;;
+
+(require_module 'rxp)
+
+;;(set! auto-text-mode-alist
+;;      (cons
+;;       (cons "\\.sable$" 'sable)
+;;       auto-text-mode-alist))
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; Remember where to find these two XML entities.                        ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(xml_register_id "-//SABLE//DTD SABLE speech mark up//EN"
+		(path-append libdir "Sable.v0_2.dtd")
+		)
+
+(xml_register_id "-//SABLE//ENTITIES Added Latin 1 for SABLE//EN"
+		 (path-append libdir  "sable-latin.ent")
+		 )
+
+;; (print (xml_registered_ids))
+
+(defvar SABLE_RXDOUBLE "-?\\(\\([0-9]+\\.[0-9]*\\)\\|\\([0-9]+\\)\\|\\(\\.[0-9]+\\)\\)\\([eE][---+]?[0-9]+\\)?")
+
+(defvar sable_pitch_base_map
+  '((highest 1.2)
+    (high 1.1)
+    (medium 1.0)
+    (default 1.0)
+    (low 0.9)
+    (lowest 0.8)))
+(defvar sable_pitch_med_map
+  '((highest 1.2)
+    (high 1.1)
+    (medium 1.0)
+    (default 1.0)
+    (low 0.9)
+    (lowest 0.8)))
+(defvar sable_pitch_range_map
+  '((largest 1.2)
+    (large 1.1)
+    (medium 1.0)
+    (default 1.0)
+    (small 0.9)
+    (smallest 0.8)))
+(defvar sable_rate_speed_map
+  '((fastest 1.5)
+    (fast 1.2)
+    (medium 1.0)
+    (default 1.0)
+    (slow 0.8)
+    (slowest 0.6)))
+(defvar sable_volume_level_map
+  '((loudest 2.0) 
+    (loud 1.5)
+    (default 1.0)
+    (medium 1.0)
+    (quiet 0.5)))
+
+(define (sable_init_globals)
+  (set! utts nil)
+  (set! sable_omitted_mode nil)
+  (set! sable_word_features_stack nil)
+  (set! sable_pitch_context nil)
+  (set! sable_vol_context nil)
+  (set! sable_vol_type 'no_change)
+  (set! sable_vol_factor 1.0)
+  (set! sable_current_language 'britishenglish)
+  (set! sable_unsupported_language nil)
+  (set! sable_language_stack nil)
+  (set! sable_current_speaker 'voice_kal_diphone)
+  (set! sable_speaker_stack nil)
+)
+
+(define (sable_token_to_words token name)
+  "(sable_token_to_words utt token name)
+SABLE mode token specific analysis."
+  (cond
+   ((or sable_omitted_mode sable_unsupported_language)
+    ;; don't say anything (whole utterance)
+    nil)
+   ((string-equal "1" (item.feat token "done_sable_sub"))
+    ;; to catch recursive calls this when splitting up sub expressions
+    (sable_previous_token_to_words token name))
+   ((and (not (string-equal "0" (item.feat token "sable_sub")))
+	 (string-equal "0" (item.feat token "p.sable_sub")))
+    (let (words (sub (item.feat token "sable_sub")))
+      (item.set_feat token "done_sable_sub" "1")
+      (set! words 
+	    (apply append
+		   (mapcar
+		    (lambda (w)
+		      (set! www (sable_previous_token_to_words token w))
+		      www)
+		    (read-from-string sub))))
+      (item.set_feat token "done_sable_sub" "0")
+      words))
+   ((string-equal "1" (item.feat token "sable_ignore"))
+    ;; don't say anything (individual word)
+    nil)
+   ((string-equal "1" (item.feat token "sable_ipa"))
+    ;; Each token is an IPA phone
+    (item.set_feat token "phonemes" (sable-map-ipa name))
+    (list name))
+   ((string-equal "1" (item.feat token "sable_literal"))
+    ;; Only deal with spell here
+    (let ((subwords) (subword))
+      (item.set_feat token "pos" token.letter_pos)
+      (mapcar
+       (lambda (letter)
+	 ;; might be symbols or digits
+	 (set! subword (sable_previous_token_to_words token letter))
+	 (if subwords
+	     (set! subwords (append subwords subword))
+	     (set! subwords subword)))
+       (symbolexplode name))
+      subwords))
+   ((not (string-equal "0" (item.feat token "token_pos")))
+    ;; bypass the prediction stage, if English
+    (if (member_string (Parameter.get 'Language)
+		       '(britishenglish americanenglish))
+	(builtin_english_token_to_words token name)
+	(sable_previous_token_to_words token name)))
+   ;; could be others here later
+   (t  
+    (sable_previous_token_to_words token name))))
+
+(defvar sable_elements
+'(
+  ("(SABLE" (ATTLIST UTT)
+    (eval (list sable_current_speaker))  ;; so we know what state we start in
+    (sable_setup_voice_params)
+    nil
+  )
+  (")SABLE" (ATTLIST UTT)
+    (xxml_synth UTT)  ;;  Synthesis the remaining tokens
+    nil
+  )
+  ;; Utterance break elements
+  ("(LANGUAGE" (ATTLIST UTT)
+   ;; Status: probably complete 
+   (xxml_synth UTT)
+   (set! sable_language_stack 
+	 (cons 
+	  (list sable_current_language sable_unsupported_language)
+	  sable_language_stack))
+   ;; Select a new language
+   (let ((language (upcase (car (xxml_attval "ID" ATTLIST)))))
+     (cond
+      ((or (string-equal language "SPANISH")
+	   (string-equal language "ES"))
+       (set! sable_current_language 'spanish)
+       (set! sable_unsupported_language nil)
+       (select_language 'spanish))
+      ((or (string-equal language "ENGLISH")
+	   (string-equal language "EN"))
+       (set! sable_current_language 'britishenglish)
+       (set! sable_unsupported_language nil)
+       (select_language 'britishenglish))
+      (t  ;; skip languages you don't know
+       ;; BUG: if current language isn't English this wont work
+       (apply_hooks tts_hooks
+		    (eval (list 'Utterance 'Text
+				(string-append "Some text in " language))))
+       (set! sable_unsupported_language t)))
+     nil))
+  (")LANGUAGE" (ATTLIST UTT)
+   (xxml_synth UTT)
+   (set! sable_unsupported_language (car (cdr (car sable_language_stack))))
+   (set! sable_current_language (car (car sable_language_stack)))
+   (set! sable_language_stack (cdr sable_language_stack))
+   (if (not sable_omitted_mode)
+       (begin
+	 (select_language sable_current_language)
+	 (sable_setup_voice_params)))
+   nil)
+  ("(SPEAKER" (ATTLIST UTT)
+   ;; Status: GENDER/AGE ignored, should be done by sable-def-speaker 
+   ;;         function to define Festival voices to SABLE
+   (xxml_synth UTT)
+   (set! sable_speaker_stack (cons sable_current_speaker sable_speaker_stack))
+   (cond
+    ((not equal? sable_current_language 'britishenglish)
+     (print "SABLE: choosen unknown voice, current voice unchanged"))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male1)
+     (set! sable_current_speaker 'voice_kal_diphone)
+     (voice_kal_diphone))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male2)
+     (set! sable_current_speaker 'voice_cmu_us_rms_cg)
+     (voice_cmu_us_rms_cg))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male3)
+     (set! sable_current_speaker 'voice_ked_diphone)
+     (voice_ked_diphone))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male4)
+     (set! sable_current_speaker 'voice_rab_diphone)
+     (voice_rab_diphone))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male5)
+     (set! sable_current_speaker 'voice_cmu_us_awb_cg)
+     (voice_cmu_us_awb_cg))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'female1)
+     (set! sable_current_speaker 'voice_cmu_us_slt_cg)
+     (voice_us1_mbrola))
+   (t
+      (set! sable_current_speaker (intern (string-append "voice_" (car (xxml_attval "NAME" ATTLIST)))))
+      (eval (list sable_current_speaker))))
+    (sable_setup_voice_params)
+   nil)
+  (")SPEAKER" (ATTLIST UTT)
+   (xxml_synth UTT)
+   (set! sable_utt UTT)
+   (set! sable_current_speaker (car sable_speaker_stack))
+   (set! sable_speaker_stack (cdr sable_speaker_stack))
+   (eval (list sable_current_speaker))
+   (sable_setup_voice_params)
+   nil)
+  ("BREAK" (ATTLIST UTT)
+   ;; Status: probably complete
+   ;; may cause an utterance break
+   (let ((level (upcase (car (xxml_attval "LEVEL" ATTLIST)))))
+     (cond
+      ((null UTT) nil)
+      ((string-equal "LARGE" level)
+       (xxml_synth UTT)
+       nil)
+      (t
+       (let ((last_token (utt.relation.last UTT'Token)))
+	 (if last_token
+	     (item.set_feat last_token "pbreak" "B"))
+	 UTT)))))
+  ("(DIV" (ATLIST UTT)
+   ;; Status: probably complete
+   (xxml_synth UTT)
+   nil)
+  ("AUDIO" (ATTLIST UTT)
+   ;; Status: MODE (background) ignored, only insertion supported
+   ;; mime type of file also ignored, as its LEVEL
+   (let ((tmpfile (make_tmp_filename)))
+     ;; ignoring mode-background (and will for sometime)
+     ;; ignoring level option
+     (xxml_synth UTT)  ;; synthesizing anything ready to be synthesized
+     (get_url (car (xxml_attval "SRC" ATTLIST)) tmpfile)
+     (apply_hooks tts_hooks
+		  (eval (list 'Utterance 'Wave tmpfile)))
+     (delete-file tmpfile)
+     nil))
+  ("(EMPH" (ATTLIST UTT)
+   ;; Status: nesting makes no difference, levels ignored
+   ;; Festival is particularly bad at adding specific emphasis
+   ;; that's what happens when you use statistical methods that
+   ;; don't include any notion of emphasis
+   ;; This is *not* recursive and only one level of EMPH supported
+   (sable_push_word_features)
+   (set! xxml_word_features 
+	 (cons (list "dur_stretch" 1.6)
+	       (cons
+		(list "EMPH" "1") xxml_word_features)))
+   UTT)
+  (")EMPH" (ATTLIST UTT)
+   (set! xxml_word_features (sable_pop_word_features))
+   UTT)
+  ("(PITCH" (ATTLIST UTT)
+   ;; Status: probably complete
+   ;; At present festival requires an utterance break here
+   (xxml_synth UTT)
+   (set! sable_pitch_context (cons int_lr_params sable_pitch_context))
+   (let ((base (sable_interpret_param
+		(car (xxml_attval "BASE" ATTLIST))
+		sable_pitch_base_map
+		(cadr (assoc 'target_f0_mean int_lr_params))
+		sable_pitch_base_original))
+	 (med (sable_interpret_param
+	       (car (xxml_attval "MED" ATTLIST))
+	       sable_pitch_med_map
+	       (cadr (assoc 'target_f0_mean int_lr_params))
+	       sable_pitch_med_original))
+	 (range (sable_interpret_param
+		 (car (xxml_attval "RANGE" ATTLIST))
+		 sable_pitch_range_map
+		 (cadr (assoc 'target_f0_std int_lr_params))
+		 sable_pitch_range_original))
+	 (oldmean (cadr (assoc 'target_f0_mean int_lr_params))))
+     ;; Festival (if it supports anything) supports mean and std
+     ;; so we treat base as med if med doesn't seem to do anything
+     (if (equal? med oldmean)
+	 (set! med base))
+     (set! int_lr_params
+	   (cons
+	    (list 'target_f0_mean med)
+	    (cons
+	     (list 'target_f0_std range)
+	     int_lr_params)))
+   nil))
+  (")PITCH" (ATTLIST UTT)
+   (xxml_synth UTT)
+   (set! int_lr_params (car sable_pitch_context))
+   (set! sable_pitch_context (cdr sable_pitch_context))
+   nil)
+  ("(RATE" (ATTLIST UTT)
+   ;; Status: can't deal with absolute word per minute SPEED.
+   (sable_push_word_features)
+   ;; can't deal with words per minute value
+   (let ((rate (sable_interpret_param
+		(car (xxml_attval "SPEED" ATTLIST))
+		sable_rate_speed_map
+		(sable_find_fval "dur_stretch" xxml_word_features 1.0)
+		sable_rate_speed_original)))
+     (set! xxml_word_features 
+	   (cons (list "dur_stretch" (/ 1.0 rate)) xxml_word_features))
+     UTT))
+  (")RATE" (ATTLIST UTT)
+   (set! xxml_word_features (sable_pop_word_features))
+   UTT)
+  ("(VOLUME" (ATTLIST UTT)
+   ;; Status: probably complete
+   ;; At present festival requires an utterance break here
+   (xxml_synth UTT)
+   (set! sable_vol_context (cons (list sable_vol_type sable_vol_factor)
+				 sable_vol_context))
+   (let ((level (sable_interpret_param
+		(car (xxml_attval "LEVEL" ATTLIST))
+		sable_volume_level_map
+		sable_vol_factor
+		1.0)))
+     (cond
+      ((string-matches (car (xxml_attval "LEVEL" ATTLIST)) ".*%")
+       (set! sable_vol_type 'relative))
+      ((string-matches (car (xxml_attval "LEVEL" ATTLIST))  SABLE_RXDOUBLE)
+       (set! sable_vol_type 'absolute))
+      (t
+       (set! sable_vol_type 'relative)))
+     (set! sable_vol_factor level))
+   nil)
+  (")VOLUME" (ATTLIST UTT)
+   (xxml_synth UTT)
+   (set! sable_vol_type (car (car sable_vol_context)))
+   (set! sable_vol_factor (car (cdr (car sable_vol_context))))
+   (set! sable_vol_context (cdr sable_vol_context))
+   nil)
+  ("(ENGINE" (ATTLIST UTT)
+   ;; Status: probably complete
+   (xxml_synth UTT)
+   (if (string-matches (car (xxml_attval "ID" ATTLIST)) "festival.*")
+       (let ((datastr ""))
+	 (mapcar
+	  (lambda (c) (set! datastr (string-append datastr " " c)))
+	  (xxml_attval "DATA" ATTLIST))
+	 (apply_hooks tts_hooks (eval (list 'Utterance 'Text datastr)))
+	 (set! sable_omitted_mode t)) ;; ignore contents 
+       ;; else 
+       ;;  its not relevant to me
+       )
+   nil)
+  (")ENGINE" (ATTLIST UTT)
+   (xxml_synth UTT)
+   (set! sable_omitted_mode nil)
+   nil)
+  ("MARKER" (ATTLIST UTT)
+   ;; Status: does nothing
+   ;; Can't support this without low-level control of audio spooler
+   (format t "SABLE: marker \"%s\"\n" 
+	   (car (xxml_attval "MARK" ATTLIST)))
+   UTT)
+  ("(PRON" (ATTLIST UTT)
+   ;; Status: IPA currently ignored
+   (sable_push_word_features)
+   ;; can't deal with words per minute value
+   (let ((ipa (xxml_attval "IPA" ATTLIST))
+	 (sub (xxml_attval "SUB" ATTLIST)))
+     (cond
+      (ipa
+       (format t "SABLE: ipa ignored\n")
+       (set! xxml_word_features 
+	     (cons (list "sable_ignore" "1") xxml_word_features)))
+      (sub
+       (set! xxml_word_features 
+	     (cons (list "sable_sub" (format nil "%l" sub))
+		   xxml_word_features))
+       (set! xxml_word_features 
+	     (cons (list "sable_ignore" "1") xxml_word_features))))
+     UTT))
+  (")PRON" (ATTLIST UTT)
+   (set! xxml_word_features (sable_pop_word_features))
+   UTT)
+  ("(SAYAS" (ATTLIST UTT)
+   ;; Status: only a few of the types are dealt with
+   (sable_push_word_features)
+    (set! sable_utt UTT)
+   ;; can't deal with words per minute value
+   (let ((mode (downcase (car (xxml_attval "MODE" ATTLIST))))
+	 (modetype (car (xxml_attval "MODETYPE" ATTLIST))))
+     (cond
+      ((string-equal mode "literal")
+       (set! xxml_word_features 
+	     (cons (list "sable_literal" "1") xxml_word_features)))
+      ((string-equal mode "phone")
+       (set! xxml_word_features 
+	     (cons (list "token_pos" "digits") xxml_word_features)))
+      ((string-equal mode "ordinal")
+       (set! xxml_word_features 
+	     (cons (list "token_pos" "ordinal") xxml_word_features)))
+      ((string-equal mode "cardinal")
+       (set! xxml_word_features 
+	     (cons (list "token_pos" "cardinal") xxml_word_features)))
+      (t
+       ;; blindly trust festival to get it right 
+       t))
+     UTT))
+  (")SAYAS" (ATTLIST UTT)
+   (set! xxml_word_features (sable_pop_word_features))
+   UTT)
+
+	     
+))
+
+(define (sable_init_func)
+  "(sable_init_func)
+Initialisation for SABLE mode"
+  (sable_init_globals)
+  (voice_kal_diphone)
+  (set! sable_previous_elements xxml_elements)
+  (set! xxml_elements sable_elements)
+  (set! sable_previous_token_to_words english_token_to_words)
+  (set! english_token_to_words sable_token_to_words)
+  (set! token_to_words sable_token_to_words))
+
+(define (sable_exit_func)
+  "(sable_exit_func)
+Exit function for SABLE mode"
+  (set! xxml_elements sable_previous_elements)
+  (set! token_to_words sable_previous_token_to_words)
+  (set! english_token_to_words sable_previous_token_to_words))
+
+(define (sable_push_word_features)
+"(sable_push_word_features)
+Save current word features on stack."
+  (set! sable_word_features_stack 
+	(cons xxml_word_features sable_word_features_stack)))
+
+(define (sable_adjust_volume utt)
+  "(sable_adjust_volume utt)
+Amplify or attenutate signale based on value of sable_vol_factor
+and sable_vol_type (absolute or relative)."
+  (set! utts (cons utt utts))
+  (cond
+   ((equal? sable_vol_type 'no_change)
+    utt)
+   ((equal? sable_vol_type 'absolute)
+    (utt.wave.rescale utt sable_vol_factor 'absolute))
+   ((equal? sable_vol_type 'relative)
+    (utt.wave.rescale utt sable_vol_factor))
+   (t
+    (format stderr "SABLE: volume unknown type \"%s\"\n" sable_vol_type)
+    utt))
+   utt)
+
+(define (sable_pop_word_features)
+"(sable_pop_word_features)
+Pop word features from stack."
+  (let ((r (car sable_word_features_stack)))
+    (set! sable_word_features_stack (cdr sable_word_features_stack))
+    r))
+
+(define (sable_find_fval feat flist def)
+  (cond
+   ((null flist) def)
+   ((string-equal feat (car (car flist)))
+    (car (cdr (car flist))))
+   (t
+    (sable_find_fval feat (cdr flist) def))))
+
+(define (sable_interpret_param ident map original current)
+"(sable_interpret_param IDENT MAP ORIGINAL CURRENT)
+If IDENT is in map return ORIGINAL times value in map, otherwise
+treat IDENT of the form +/-N% and modify CURRENT accordingly."
+  (let ((mm (assoc ident map)))
+    (cond 
+     (mm
+      (* original (car (cdr mm))))
+     ((string-matches ident SABLE_RXDOUBLE)
+      (parse-number ident))
+     ((string-matches ident ".*%")
+      (+ current (* current (/ (parse-number (string-before ident "%")) 
+			       100.0))))
+;;     ((string-matches ident ".*%")
+;;      (* current (/ (parse-number (string-before ident "%")) 100.0)))
+     ((not ident) current)
+     (t
+      (format stderr "SABLE: modifier \"%s\" not of float, tag or +/-N\n"
+	      ident)
+      current))))
+
+(define (sable_setup_voice_params)
+"(sable_setup_voice_params)
+Set up original values for various voice parameters."
+ (set! sable_pitch_base_original (cadr (assoc 'target_f0_mean int_lr_params)))
+ (set! sable_pitch_med_original (cadr (assoc 'target_f0_mean int_lr_params)))
+ (set! sable_pitch_range_original (cadr (assoc 'target_f0_std int_lr_params)))
+ (set! sable_rate_speed_original 1.0)
+ (if (and after_synth_hooks (not (consp after_synth_hooks)))
+     (set! after_synth_hooks 
+	   (cons after_synth_hooks (list sable_adjust_volume)))
+     (set! after_synth_hooks 
+	   (append after_synth_hooks (list sable_adjust_volume))))
+)
+
+;;; Declare the new mode to Festival
+(set! tts_text_modes
+   (cons
+    (list
+      'sable   ;; mode name
+      (list         
+       (list 'init_func sable_init_func)
+       (list 'exit_func sable_exit_func)
+       '(analysis_type xml)
+       ))
+    tts_text_modes))
+
+(provide 'sable-mode)

CosyVoice-ttsfrd/resource/festival/scfg_wsj_wp20.gram

@@ -0,0 +1,523 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-*-mode:scheme-*-
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  A Stochastic context free grammar for the wp20 tag set with 19 
+;;;  nonterminals
+;;;
+;;;  This was trained from 10,000 sentences (00-04) of the UPenn WSJ tree
+;;;  bank using the inside-outside algorithm seeded with the bracketing from
+;;;  the treebank.  The implementation is the scfg_ suite in the
+;;   speech tools and is based on the paper "Inside-Outside 
+;;;  Reestimation from partially bracketed corpora", F Pereira and 
+;;;  Y. Schabes. pp 128-135, 30th ACL, Newark, Delaware 1992.
+;;;
+;;;  This grammar with 19 nonterminals was trained for 174 passes 
+;;;  using a fifth of training data each time.  It was tested against 
+;;;  independent data both bracketed and unbracketed.  After training,
+;;;  all rules with a probability less than 1.0e-6 were pruned.
+;;;
+;;;  On an unseen test set of 686 sentences (from wsj/05/) this gets
+;;;  92.2397% bracketing accuracy and 29.5918% sentences fully correct
+;;;
+;;;  previous best 15_20 grammar
+;;;  90.2377% bracketing accuracy and 24.7813% sentences fully correct
+;;;
+;;;  Training this grammar took a long time.  This is best grammar
+;;;  by testing grammars varying the number of non-terminals from 11-25
+;;;  as the number of NTs increases the time for training also increases
+;;;  This 19_20 grammar took 20 days on a Sun Ultra 1 140, but I also
+;;;  had to search 11-18 to confirm this is best, which was done with a
+;;;  collection of Ultra 140s 170s and Pentium Pros (Linux and FreeBSD)
+;;;
+(0.00593452 NT00 NT00 NT00)
+(0.0319023 NT00 NT00 NT13)
+(0.00105452 NT00 NT00 NT18)
+(0.00061816 NT00 NT02 NT10)
+(0.000399698 NT00 NT02 NT12)
+(0.0383818 NT00 NT05 NT00)
+(0.00011458 NT00 NT06 NT03)
+(0.00164298 NT00 NT06 NT17)
+(0.00153884 NT00 NT07 NT07)
+(0.00118244 NT00 NT07 NT12)
+(0.00171642 NT00 NT07 NT13)
+(0.00031308 NT00 NT07 NT17)
+(0.0949408 NT00 NT09 NT18)
+(0.000932166 NT00 NT10 NT03)
+(0.000150288 NT00 NT10 NT17)
+(0.0152371 NT00 NT12 NT18)
+(0.73409 NT00 NT14 NT13)
+(0.0403652 NT00 NT14 NT18)
+(0.000195643 NT00 NT16 NT07)
+(0.0134222 NT00 NT18 NT13)
+(0.015624 NT00 NT18 NT18)
+(0.00251118 NT01 NT01 NT07)
+(0.00354571 NT01 NT01 NT11)
+(0.22337 NT01 NT01 NT16)
+(0.0467048 NT01 NT02 NT05)
+(0.000518329 NT01 NT04 NT01)
+(0.000100574 NT01 NT06 NT05)
+(0.0480904 NT01 NT07 NT05)
+(0.000358197 NT01 NT11 NT11)
+(0.00278007 NT01 NT16 NT05)
+(0.000179198 NT01 NT16 NT15)
+(0.00140099 NT01 n)
+(0.00228587 NT01 v)
+(0.524988 NT01 dt)
+(0.00128028 NT01 in)
+(0.0660845 NT01 j)
+(0.0131026 NT01 cd)
+(0.00584238 NT01 r)
+(0.0548382 NT01 prp)
+(0.000445004 NT01 wdt)
+(0.00135794 NT01 wp)
+(0.000195991 NT01 wrb)
+(0.000264526 NT02 NT01 NT01)
+(0.00243627 NT02 NT01 NT02)
+(0.613543 NT02 NT01 NT07)
+(0.00180865 NT02 NT01 NT11)
+(0.0042804 NT02 NT01 NT16)
+(0.0392418 NT02 NT02 NT07)
+(0.026104 NT02 NT02 NT12)
+(0.000916683 NT02 NT02 NT16)
+(0.00158862 NT02 NT04 NT01)
+(0.000206161 NT02 NT04 NT02)
+(0.00343189 NT02 NT04 NT16)
+(0.000417113 NT02 NT07 NT05)
+(0.0988457 NT02 NT07 NT07)
+(0.000931386 NT02 NT07 NT11)
+(0.00073236 NT02 NT07 NT12)
+(0.000153421 NT02 NT10 NT13)
+(0.00163484 NT02 NT11 NT02)
+(0.0379562 NT02 NT11 NT07)
+(0.0149 NT02 NT11 NT11)
+(0.00105811 NT02 NT11 NT12)
+(0.000175184 NT02 NT16 NT02)
+(0.0403395 NT02 NT16 NT07)
+(0.00297703 NT02 NT16 NT12)
+(0.0875026 NT02 n)
+(0.00496719 NT02 v)
+(0.000409658 NT02 dt)
+(0.00239978 NT02 j)
+(0.010203 NT02 r)
+(0.000194628 NT02 pdt)
+(0.000377009 NT03 NT04 NT02)
+(0.11551 NT03 NT08 NT13)
+(0.347629 NT03 NT09 NT13)
+(0.484911 NT03 NT10 NT13)
+(0.00188291 NT03 NT11 NT12)
+(0.0495461 NT03 NT17 NT13)
+(0.00918797 NT04 NT03 NT05)
+(0.000303954 NT04 NT04 NT02)
+(0.00284848 NT04 NT04 NT04)
+(0.00710115 NT04 NT04 NT12)
+(0.000597744 NT04 NT04 NT15)
+(0.000377075 NT04 NT04 NT16)
+(0.00130088 NT04 NT09 NT05)
+(0.00175428 NT04 NT10 NT13)
+(0.000127716 NT04 NT15 NT04)
+(0.00013648 NT04 NT15 NT06)
+(0.00045093 NT04 NT15 NT07)
+(0.000626479 NT04 NT15 NT16)
+(0.000563588 NT04 NT16 NT15)
+(0.0232089 NT04 NT17 NT05)
+(0.000138094 NT04 NT17 NT15)
+(0.00094009 NT04 n)
+(0.671108 NT04 v)
+(0.0150619 NT04 punc)
+(0.00056566 NT04 dt)
+(0.144629 NT04 r)
+(0.00270621 NT04 prp)
+(0.0449587 NT04 to)
+(0.0543755 NT04 md)
+(0.00839747 NT04 wdt)
+(0.00813689 NT04 wp)
+(0.000560496 NT05 NT07 NT05)
+(0.000901219 NT05 NT15 NT07)
+(0.180172 NT05 punc)
+(0.533041 NT05 cc)
+(0.285244 NT05 pos)
+(0.00164003 NT06 NT00 NT13)
+(0.00222915 NT06 NT01 NT06)
+(0.275903 NT06 NT01 NT07)
+(0.00191616 NT06 NT01 NT11)
+(0.00316549 NT06 NT01 NT12)
+(0.000730143 NT06 NT01 NT14)
+(0.000559842 NT06 NT02 NT06)
+(0.0236744 NT06 NT02 NT07)
+(0.00284929 NT06 NT02 NT09)
+(0.155052 NT06 NT02 NT12)
+(0.00387995 NT06 NT02 NT14)
+(0.0161403 NT06 NT02 NT18)
+(0.000110944 NT06 NT04 NT01)
+(0.00237845 NT06 NT04 NT02)
+(0.00625142 NT06 NT04 NT06)
+(0.00118802 NT06 NT04 NT08)
+(0.000132901 NT06 NT04 NT10)
+(0.000192545 NT06 NT04 NT11)
+(0.000199118 NT06 NT06 NT01)
+(0.0081704 NT06 NT06 NT12)
+(0.00198439 NT06 NT06 NT14)
+(0.000889455 NT06 NT06 NT18)
+(0.00142038 NT06 NT07 NT05)
+(0.0820095 NT06 NT07 NT07)
+(0.000112894 NT06 NT07 NT09)
+(0.0220243 NT06 NT07 NT12)
+(0.000133911 NT06 NT07 NT14)
+(0.00100807 NT06 NT07 NT17)
+(0.000191764 NT06 NT08 NT13)
+(0.000340112 NT06 NT10 NT08)
+(0.000126776 NT06 NT10 NT09)
+(0.0136266 NT06 NT10 NT12)
+(0.00867414 NT06 NT10 NT13)
+(0.00341334 NT06 NT10 NT18)
+(0.00154851 NT06 NT11 NT12)
+(0.00104947 NT06 NT12 NT12)
+(0.000219189 NT06 NT14 NT05)
+(0.00313879 NT06 NT14 NT13)
+(0.000745073 NT06 NT15 NT02)
+(0.000433144 NT06 NT15 NT06)
+(0.000159867 NT06 NT15 NT16)
+(0.00124313 NT06 NT16 NT02)
+(0.00918606 NT06 NT16 NT07)
+(0.00373496 NT06 NT16 NT12)
+(0.014053 NT06 NT18 NT13)
+(0.0155714 NT06 n)
+(0.00123379 NT06 punc)
+(0.0152764 NT06 dt)
+(0.00123486 NT06 j)
+(0.00359625 NT06 r)
+(0.212966 NT06 prp)
+(0.00199168 NT06 cc)
+(0.0383471 NT06 wdt)
+(0.0182587 NT06 wp)
+(0.00204833 NT06 wrb)
+(0.0109929 NT06 ex)
+(0.0011995 NT07 NT05 NT16)
+(0.119588 NT07 NT07 NT07)
+(0.000353596 NT07 NT07 NT11)
+(0.000177793 NT07 NT07 NT12)
+(0.00101956 NT07 NT11 NT11)
+(0.000357614 NT07 NT15 NT01)
+(0.00084812 NT07 NT15 NT06)
+(0.0182872 NT07 NT16 NT07)
+(0.00018607 NT07 NT16 NT11)
+(0.856315 NT07 n)
+(0.000736333 NT07 v)
+(0.000645479 NT08 NT00 NT09)
+(0.000990156 NT08 NT01 NT02)
+(0.0410251 NT08 NT01 NT07)
+(0.0013863 NT08 NT01 NT09)
+(0.000242552 NT08 NT01 NT12)
+(0.00174478 NT08 NT01 NT14)
+(0.000596656 NT08 NT01 NT16)
+(0.00130945 NT08 NT02 NT07)
+(0.166303 NT08 NT02 NT09)
+(0.0143253 NT08 NT02 NT12)
+(0.0113813 NT08 NT02 NT14)
+(0.000597887 NT08 NT02 NT16)
+(0.0133053 NT08 NT03 NT09)
+(0.0109076 NT08 NT03 NT17)
+(0.000211313 NT08 NT04 NT01)
+(0.0105796 NT08 NT04 NT02)
+(0.00440181 NT08 NT04 NT04)
+(0.00203737 NT08 NT04 NT06)
+(0.213275 NT08 NT04 NT08)
+(0.0781169 NT08 NT04 NT09)
+(0.0190657 NT08 NT04 NT10)
+(0.00319326 NT08 NT04 NT12)
+(0.000693766 NT08 NT04 NT15)
+(0.00112226 NT08 NT04 NT16)
+(0.00117025 NT08 NT06 NT02)
+(0.00807496 NT08 NT06 NT08)
+(0.0183971 NT08 NT06 NT09)
+(0.00127343 NT08 NT06 NT14)
+(0.0322725 NT08 NT06 NT17)
+(0.00396897 NT08 NT07 NT07)
+(0.0154729 NT08 NT07 NT09)
+(0.000708139 NT08 NT07 NT10)
+(0.00186499 NT08 NT07 NT11)
+(0.000701346 NT08 NT07 NT14)
+(0.0116278 NT08 NT08 NT09)
+(0.0965117 NT08 NT10 NT09)
+(0.000142086 NT08 NT10 NT12)
+(0.000210725 NT08 NT10 NT14)
+(0.00336223 NT08 NT11 NT07)
+(0.00183799 NT08 NT11 NT09)
+(0.00109249 NT08 NT11 NT11)
+(0.000880671 NT08 NT11 NT12)
+(0.0032493 NT08 NT12 NT08)
+(0.0372072 NT08 NT12 NT09)
+(0.00113127 NT08 NT12 NT12)
+(0.00892231 NT08 NT15 NT02)
+(0.00383754 NT08 NT15 NT06)
+(0.000528365 NT08 NT15 NT07)
+(0.0060705 NT08 NT15 NT08)
+(0.00853698 NT08 NT15 NT10)
+(0.0349777 NT08 NT15 NT14)
+(0.000202857 NT08 NT16 NT06)
+(0.00709689 NT08 NT16 NT07)
+(0.000240097 NT08 NT16 NT08)
+(0.0401819 NT08 NT16 NT09)
+(0.00124754 NT08 NT16 NT14)
+(0.00862498 NT08 n)
+(0.0115193 NT08 v)
+(0.000974267 NT08 in)
+(0.0169837 NT08 j)
+(0.00626434 NT08 r)
+(0.00437851 NT08 prp)
+(0.0062359 NT09 NT01 NT07)
+(0.000165196 NT09 NT01 NT14)
+(0.00151872 NT09 NT02 NT04)
+(0.000660061 NT09 NT02 NT15)
+(0.000434321 NT09 NT02 NT16)
+(0.00805872 NT09 NT03 NT09)
+(0.000180982 NT09 NT04 NT08)
+(0.050609 NT09 NT04 NT09)
+(0.000307442 NT09 NT04 NT15)
+(0.00281491 NT09 NT04 NT17)
+(0.000295911 NT09 NT06 NT15)
+(0.00133828 NT09 NT07 NT11)
+(0.0235741 NT09 NT12 NT09)
+(0.00121997 NT09 NT12 NT12)
+(0.00391762 NT09 NT15 NT01)
+(0.173027 NT09 NT15 NT02)
+(0.000462089 NT09 NT15 NT06)
+(0.0276663 NT09 NT15 NT07)
+(0.210483 NT09 NT15 NT08)
+(0.000177004 NT09 NT15 NT09)
+(0.243402 NT09 NT15 NT10)
+(0.0174403 NT09 NT15 NT11)
+(0.00646962 NT09 NT15 NT12)
+(0.155174 NT09 NT15 NT14)
+(0.00930502 NT09 NT15 NT17)
+(0.000311399 NT09 NT16 NT02)
+(0.0052031 NT09 NT16 NT07)
+(0.00742336 NT09 NT16 NT09)
+(0.000409254 NT09 in)
+(0.0019424 NT09 j)
+(0.0393282 NT09 r)
+(0.00016039 NT09 prp)
+(0.00268682 NT10 NT01 NT07)
+(0.00173594 NT10 NT01 NT09)
+(0.00550051 NT10 NT01 NT10)
+(0.00269002 NT10 NT01 NT11)
+(0.00881491 NT10 NT01 NT12)
+(0.0158503 NT10 NT02 NT02)
+(0.00229071 NT10 NT02 NT07)
+(0.00765082 NT10 NT02 NT09)
+(0.00102327 NT10 NT02 NT11)
+(0.474288 NT10 NT02 NT12)
+(0.0119086 NT10 NT02 NT14)
+(0.000270767 NT10 NT02 NT15)
+(0.00425023 NT10 NT02 NT16)
+(0.0533347 NT10 NT04 NT02)
+(0.00286524 NT10 NT04 NT06)
+(0.0687658 NT10 NT04 NT10)
+(0.0157381 NT10 NT04 NT12)
+(0.000809508 NT10 NT05 NT12)
+(0.00188343 NT10 NT06 NT04)
+(0.000155481 NT10 NT06 NT09)
+(0.00569591 NT10 NT06 NT14)
+(0.00233367 NT10 NT06 NT17)
+(0.000189475 NT10 NT07 NT05)
+(0.018548 NT10 NT07 NT07)
+(0.00472354 NT10 NT07 NT09)
+(0.0121145 NT10 NT07 NT11)
+(0.0698482 NT10 NT07 NT12)
+(0.000402661 NT10 NT07 NT16)
+(0.00183044 NT10 NT07 NT17)
+(0.00166519 NT10 NT10 NT02)
+(0.015445 NT10 NT10 NT09)
+(0.019208 NT10 NT10 NT12)
+(0.000942866 NT10 NT10 NT18)
+(0.00149941 NT10 NT11 NT01)
+(0.00624706 NT10 NT11 NT02)
+(0.0381755 NT10 NT11 NT11)
+(0.00754256 NT10 NT11 NT12)
+(0.00139213 NT10 NT15 NT02)
+(0.000523505 NT10 NT15 NT06)
+(0.0015256 NT10 NT15 NT10)
+(0.00119525 NT10 NT15 NT12)
+(0.00683524 NT10 NT16 NT02)
+(0.000398591 NT10 NT16 NT04)
+(0.0701558 NT10 NT16 NT07)
+(0.00198721 NT10 NT16 NT11)
+(0.0075364 NT10 NT16 NT12)
+(0.0186618 NT10 n)
+(0.000591828 NT10 uh)
+(0.157827 NT11 NT11 NT11)
+(0.0422576 NT11 NT15 NT11)
+(0.00247895 NT11 NT15 NT16)
+(0.000257833 NT11 dt)
+(0.754818 NT11 cd)
+(0.0421123 NT11 r)
+(0.00236916 NT12 NT01 NT07)
+(0.000118511 NT12 NT02 NT16)
+(0.00638739 NT12 NT04 NT02)
+(0.0055731 NT12 NT04 NT04)
+(0.0340903 NT12 NT04 NT12)
+(0.00102031 NT12 NT04 NT15)
+(0.00143793 NT12 NT04 NT16)
+(0.000102621 NT12 NT04 NT17)
+(0.0032774 NT12 NT06 NT04)
+(0.000366976 NT12 NT07 NT07)
+(0.00218153 NT12 NT07 NT11)
+(0.0117989 NT12 NT11 NT07)
+(0.00303601 NT12 NT12 NT12)
+(0.0747798 NT12 NT13 NT03)
+(0.000232806 NT12 NT15 NT01)
+(0.341016 NT12 NT15 NT02)
+(0.0190932 NT12 NT15 NT06)
+(0.100931 NT12 NT15 NT07)
+(0.193386 NT12 NT15 NT10)
+(0.0142796 NT12 NT15 NT11)
+(0.000915196 NT12 NT16 NT07)
+(0.000299768 NT12 NT16 NT11)
+(0.0135637 NT12 NT16 NT12)
+(0.115493 NT12 n)
+(0.00344871 NT12 v)
+(0.0262404 NT12 punc)
+(0.000493049 NT12 in)
+(0.00235382 NT12 j)
+(0.0192274 NT12 r)
+(0.00199831 NT12 prp)
+(0.000209376 NT13 NT11 NT15)
+(0.00188858 NT13 NT13 NT03)
+(0.540855 NT13 punc)
+(0.00804226 NT13 cc)
+(0.000413617 NT14 NT00 NT09)
+(0.0218326 NT14 NT00 NT14)
+(0.000451496 NT14 NT00 NT18)
+(0.00149459 NT14 NT01 NT07)
+(0.00384046 NT14 NT01 NT17)
+(0.00138254 NT14 NT02 NT09)
+(0.0525259 NT14 NT03 NT14)
+(0.000893974 NT14 NT04 NT02)
+(0.000175088 NT14 NT04 NT06)
+(0.000478859 NT14 NT04 NT08)
+(0.00086439 NT14 NT04 NT09)
+(0.00529624 NT14 NT04 NT10)
+(0.000476852 NT14 NT04 NT12)
+(0.00549502 NT14 NT04 NT14)
+(0.0281873 NT14 NT05 NT14)
+(0.76715 NT14 NT06 NT17)
+(0.00303311 NT14 NT07 NT07)
+(0.00027137 NT14 NT07 NT09)
+(0.000748841 NT14 NT07 NT12)
+(0.0874896 NT14 NT07 NT17)
+(0.00416962 NT14 NT09 NT14)
+(0.00175999 NT14 NT10 NT09)
+(0.000710869 NT14 NT11 NT17)
+(0.000723932 NT14 NT12 NT07)
+(0.00440147 NT14 NT12 NT14)
+(0.000761726 NT14 NT14 NT09)
+(0.00084762 NT14 NT14 NT17)
+(0.000323644 NT14 NT15 NT02)
+(0.00264492 NT14 NT15 NT14)
+(0.000238841 NT14 NT16 NT07)
+(0.000126025 NT14 NT16 NT09)
+(0.000217731 NT14 r)
+(0.00024161 NT14 wrb)
+(0.000366989 NT15 NT04 NT04)
+(0.00127143 NT15 NT04 NT15)
+(0.00137902 NT15 NT11 NT07)
+(0.000109067 NT15 NT15 NT04)
+(0.00380199 NT15 NT15 NT06)
+(0.000193842 NT15 NT15 NT15)
+(0.000253898 NT15 NT15 NT16)
+(0.00556123 NT15 v)
+(0.0798535 NT15 punc)
+(0.557206 NT15 in)
+(0.0519477 NT15 cc)
+(0.170466 NT15 of)
+(0.113587 NT15 to)
+(0.0125211 NT15 wrb)
+(0.00146961 NT15 pdt)
+(0.000682686 NT16 NT01 NT16)
+(0.000353409 NT16 NT02 NT02)
+(0.0034721 NT16 NT02 NT05)
+(0.00392739 NT16 NT04 NT04)
+(0.0225952 NT16 NT04 NT16)
+(0.00368407 NT16 NT05 NT16)
+(0.000275916 NT16 NT06 NT05)
+(0.0263102 NT16 NT07 NT05)
+(0.00344251 NT16 NT07 NT12)
+(0.00271063 NT16 NT07 NT16)
+(0.000950873 NT16 NT10 NT13)
+(0.0229124 NT16 NT11 NT07)
+(0.0173136 NT16 NT11 NT11)
+(0.0094147 NT16 NT11 NT16)
+(0.00210054 NT16 NT13 NT03)
+(0.000417271 NT16 NT15 NT01)
+(0.0100377 NT16 NT15 NT11)
+(0.000679194 NT16 NT16 NT05)
+(0.00203961 NT16 NT16 NT11)
+(0.00352444 NT16 NT16 NT12)
+(0.0133536 NT16 NT16 NT16)
+(0.0041124 NT16 n)
+(0.0518387 NT16 v)
+(0.0133556 NT16 punc)
+(0.746857 NT16 j)
+(0.0325454 NT16 cd)
+(0.000994964 NT16 r)
+(0.000325555 NT17 NT03 NT09)
+(0.000431668 NT17 NT03 NT17)
+(0.000283523 NT17 NT04 NT01)
+(0.00308221 NT17 NT04 NT02)
+(0.000106449 NT17 NT04 NT07)
+(0.584517 NT17 NT04 NT08)
+(0.0389749 NT17 NT04 NT09)
+(0.00927257 NT17 NT04 NT10)
+(0.000698039 NT17 NT04 NT11)
+(0.0594712 NT17 NT04 NT14)
+(0.000381951 NT17 NT04 NT16)
+(0.248255 NT17 NT04 NT17)
+(0.000264379 NT17 NT05 NT08)
+(0.00194384 NT17 NT05 NT10)
+(0.000308808 NT17 NT05 NT14)
+(0.000271388 NT17 NT07 NT08)
+(0.000131093 NT17 NT07 NT10)
+(0.00011195 NT17 NT07 NT17)
+(0.000462643 NT17 NT08 NT09)
+(0.00153331 NT17 NT11 NT07)
+(0.00214335 NT17 NT11 NT11)
+(0.000307068 NT17 NT11 NT12)
+(0.000550528 NT17 NT15 NT10)
+(0.000125644 NT17 NT16 NT02)
+(0.000474489 NT17 NT17 NT09)
+(0.00032483 NT17 NT17 NT18)
+(0.045027 NT17 v)
+(0.00425503 NT18 NT07 NT18)
+(0.978831 NT18 NT13 NT00)
+(0.00130119 NT18 NT13 NT03)
+(0.0155958 NT18 NT17 NT13)

CosyVoice-ttsfrd/resource/festival/siteinit.scm

@@ -0,0 +1,65 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997                         ;;
+;;;                        All Rights Reserved.                           ;;
+;;;                                                                       ;;
+;;;  Permission is hereby granted, free of charge, to use and distribute  ;;
+;;;  this software and its documentation without restriction, including   ;;
+;;;  without limitation the rights to use, copy, modify, merge, publish,  ;;
+;;;  distribute, sublicense, and/or sell copies of this work, and to      ;;
+;;;  permit persons to whom this work is furnished to do so, subject to   ;;
+;;;  the following conditions:                                            ;;
+;;;   1. The code must retain the above copyright notice, this list of    ;;
+;;;      conditions and the following disclaimer.                         ;;
+;;;   2. Any modifications must be clearly marked as such.                ;;
+;;;   3. Original authors' names are not deleted.                         ;;
+;;;   4. The authors' names are not used to endorse or promote products   ;;
+;;;      derived from this software without specific prior written        ;;
+;;;      permission.                                                      ;;
+;;;                                                                       ;;
+;;;  THE UNIVERSITY OF EDINBURGH AND THE CONTRIBUTORS TO THIS WORK        ;;
+;;;  DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING      ;;
+;;;  ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT   ;;
+;;;  SHALL THE UNIVERSITY OF EDINBURGH NOR THE CONTRIBUTORS BE LIABLE     ;;
+;;;  FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES    ;;
+;;;  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN   ;;
+;;;  AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,          ;;
+;;;  ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF       ;;
+;;;  THIS SOFTWARE.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Site specific initialisation file
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; If festival's internal audio playing support doesn't work on your
+;; machine you can make Festival use your own program to play waveform
+;; files.  Uncomment the following and change "play" to the name of 
+;; your local program that can play files
+
+;(Parameter.set 'Audio_Required_Format 'riff)
+;(Parameter.set 'Audio_Method 'Audio_Command)
+
+;; Apple OSX (if you can file afplay)
+;(Parameter.set 'Audio_Command "afplay $FILE")
+
+;; SOX (play) often a good alternative on cygwin and linux
+;(Parameter.set 'Audio_Command "play -q $FILE")
+
+;; Windows 7 (when sox's play doesn't work -- but this might not exit)
+;(Parameter.set 'Audio_Command "c:/Windows/System32/WindowsPowerShell/v1.0/powershell -c '(New-Object Media.Soundplayer C:/cygwin'$FILE').PlaySync(); Exit;'")
+
+;; If you want a voice different from the system installed default 
+;; uncomment the following line and change the name to the voice you
+;; want
+
+;(set! voice_default 'voice_cmu_us_awb_arctic_hts)
+
+(provide 'siteinit)
+
+
+
+

CosyVoice-ttsfrd/resource/festival/speech.properties

@@ -0,0 +1,2 @@
+# Register speech engines
+cstr.festival.EngineCentral=cstr.festival.jsapi.EngineCentral