Add files using upload-large-folder tool

pretrained_models/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.                                                       
+

pretrained_models/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)
+        (# #)))
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/dicts/cmu/cmu2ft

@@ -0,0 +1,21 @@
+#!/bin/sh
+#
+#  Converts cmulexicon to Festival format
+#
+#  usage:  cmu2ft cmudict.0.1 cmu_lex.scm
+
+#sed 's/er0/er0 r/' | sed 's/er1/er1 r/' | sed 's/er2/er2 r/' |
+
+echo >$2
+echo ";; CMUDICT-0.4 Converted to Festival lexicon format" >>$2
+cat $1 | tr "[A-Z]" "[a-z]" | sed 's/ah0/ax/g' | 
+tr 2 1 | 
+awk '{if ($1 == "##")
+	 printf(";; %s\n",$0);
+      else if ($1 ~ /^[a-z][a-z]*$/)
+      { printf("(")
+        printf("\"%s\" nil (%s",$1,$2)
+        for (i=3; i <= NF; i++)
+          printf " %s",$i
+        printf "))\n"
+      }} ' >> $2

pretrained_models/CosyVoice-ttsfrd/resource/festival/dicts/cmu/cmudict_compile.scm

@@ -0,0 +1,41 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                         Copyright (c) 2008                            ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Compile the lexicon
+;;;
+
+(load "cmulex.scm")
+(lex.compile "all.scm" "cmudict-0.4.out")
+
+
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/etc/email_filter

@@ -0,0 +1,47 @@
+#!/bin/sh
+###########################################################################
+##                                                                       ##
+##                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.                                                       ##
+##                                                                       ##
+###########################################################################
+##                                                                       ##
+##  Email filter for tts text mode                                       ##
+##  usage: email_filter email_message >filtered_message                  ##
+##                                                                       ##
+##  Extracts the From and Subject lines form the head and the body of    ##
+##  of the message, I suppose it could also do signature extraction      ##
+##                                                                       ##
+###########################################################################
+grep "^From: " $1
+echo 
+grep "^Subject: " $1
+echo
+# delete up to first blank line (i.e. the header)
+sed '1,/^$/ d' $1 

pretrained_models/CosyVoice-ttsfrd/resource/festival/mbrola.scm

@@ -0,0 +1,103 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Support for MBROLA as an external module.
+;;;
+
+;;; You might want to set this in your sitevars.scm
+(defvar mbrola_progname "/cstr/external/mbrola/mbrola"
+  "mbrola_progname
+  The program name for mbrola.")
+(defvar mbrola_database "fr1"
+  "mbrola_database
+ The name of the MBROLA database to usde during MBROLA Synthesis.")
+
+(define (MBROLA_Synth utt)
+  "(MBROLA_Synth UTT)
+  Synthesize using MBROLA as external module.  Basically dump the info
+  from this utterance. Call MBROLA and reload the waveform into utt.
+  [see MBROLA]"
+  (let ((filename (make_tmp_filename))
+	)
+    (save_segments_mbrola utt filename)
+    (system (string-append mbrola_progname " " 
+			   mbrola_database " "
+			   filename " "
+			   filename ".au"))
+    (utt.import.wave utt (string-append filename ".au"))
+    (apply_hooks after_synth_hooks utt)
+    (delete-file filename)
+    (delete-file (string-append filename ".au"))
+    utt))
+
+(define (save_segments_mbrola utt filename)
+  "(save_segments_mbrola UTT FILENAME)
+  Save segment information in MBROLA format in filename.  The format is
+  phone duration (ms) [% position F0 target]*. [see MBROLA]"
+  (let ((fd (fopen filename "w")))
+    (mapcar
+     (lambda (segment) 
+       (save_seg_mbrola_entry 
+	(item.feat segment 'name)
+	(item.feat segment 'segment_start)
+	(item.feat segment 'segment_duration)
+	(mapcar
+	 (lambda (targ_item)
+	   (list
+	    (item.feat targ_item "pos")
+	    (item.feat targ_item "f0")))
+	 (item.relation.daughters segment 'Target)) ;; list of targets
+	fd))
+     (utt.relation.items utt 'Segment))
+    (fclose fd)))
+
+(define (save_seg_mbrola_entry name start dur targs fd)
+  "(save_seg_mbrola_entry ENTRY NAME START DUR TARGS FD)
+  Entry contains, (name duration num_targs start 1st_targ_pos 1st_targ_val)."
+  (format fd "%s %d " name (nint (* dur 1000)))
+  (if targs     ;; if there are any targets
+      (mapcar
+       (lambda (targ) ;; targ_pos and targ_val
+	 (let ((targ_pos (car targ))
+	       (targ_val (car (cdr targ))))
+	                                  
+	   (format fd "%d %d " 
+		   (nint (* 100 (/ (- targ_pos start) dur))) ;; % pos of target
+		   (nint (parse-number targ_val)))           ;; target value
+	   ))
+       targs))
+  (terpri fd)
+  (terpri fd)
+)
+	
+(provide 'mbrola)

pretrained_models/CosyVoice-ttsfrd/resource/festival/mettree.scm

@@ -0,0 +1,88 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Some (experimental) data for investigating metrical trees
+;;;
+
+;;; Set up generation of metrical tree, this includes getting
+;;; a syntactic parse
+;;;
+;;; Use as 
+;;;   (set! utt1 (metsynth (Utterance Text "For afternoon tea")))
+;;;   (utt.relation_tree utt1 'MetricalTree)
+
+(require 'scfg)
+(set! scfg_grammar (load (path-append libdir "scfg_wsj_wp20.gram") t))
+
+(define (mettext utt)
+  (Initialize utt)
+  (Text utt)
+  (Token_POS utt)
+  (Token utt)
+  (POS utt)
+  (print "here1")
+  (Phrasify utt)
+  (print "here2")
+  (ProbParse utt)
+  (print "here3")
+  (auto_metrical_tree utt)
+)
+
+(define (metsynth utt)
+  (mettext utt)
+  (Wave_Synth utt)
+)
+
+;;; Assumed everything is using Roger diphones
+
+;;(lex.create "cmu_mettree")
+;;;(lex.set.phoneset "radio_phones")
+;;(lex.set.phoneset "radio_phones")
+
+(define (setup_cmu_mettree_lex)
+  "(setup_cmu_mettreelex)
+Lexicon derived from the CMU lexicon (cmudict-0.1), around 100,000 entries,
+in the radio phoneset (sort of darpa-like)."
+  (if (not (member_string "cmu_mettree" (lex.list)))
+      (begin
+	(print "making cmu lexicon")
+	(lex.create "cmu_mettree")
+	(lex.set.compile.file (path-append lexdir "cmu_mettree_lex.out"))
+	(lex.set.phoneset "radio")
+	(require 'lts__us)    ;; US English letter to sound rules
+	(lex.set.lts.method 'lts_rules)
+	(lex.set.lts.ruleset 'nrl_us))))
+
+(provide 'mettree)
+
+

pretrained_models/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 <rjc@cstr.ed.ac.uk>"
+  ( "Handle module descriptions from C++ and from Scheme."
+   )
+  )
+
+(provide 'module_description)

pretrained_models/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)

pretrained_models/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)

pretrained_models/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)
+
+
+
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/multisyn/multisyn.scm

@@ -0,0 +1,195 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 2003, 2004                        ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Multisyn top level scheme code  (Korin Richmond and Rob Clark)
+;;;
+
+; Requires
+(require_module 'UniSyn)
+(require_module 'MultiSyn)
+(require 'multisyn_pauses)
+(require 'target_cost)
+
+;; use a global parameter to specify which UnitSelection voice
+;; to use to synthesise a given utterance for now, because the
+;; standard Festival synthesis mainline doesn't accept a voice
+;; parameter.  (This should be set to the current voice object)
+(defvar currentMultiSynVoice nil)
+(defvar relp t)
+(defvar flattenVoice nil)
+
+; extract utt list from a .data file
+(define (load_utt_list filename)
+"(load_utt_list filename)
+Loads a fextvox .data file and extracts an utterance list."
+(let (l entries)
+  (set! entries (load filename t))
+  (mapcar
+   (lambda (d)
+     (set! l (cons (car d) l))
+     t)
+   entries)
+l))
+
+;; SynthType definition, main entry point.
+
+(defSynthType MultiSyn
+  ;(print "Multisyn unit selection synthesis")
+  (defvar MultiSyn_module_hooks nil)
+  (Param.def "unisyn.window_name" "hanning")
+  (Param.def "unisyn.window_factor" 1.0)
+  ;; Unisyn requires these to be set.
+  (set! us_abs_offset 0.0)
+  (set! us_rel_offset 0.0)
+
+  (apply_hooks MultiSyn_module_hooks utt)  ;; 4processing of diphone names
+
+  ;; find appropriate unit sequence and put sythesis
+  ;; parameters in the Unit relation of the utterance structure
+  (voice.getUnits currentMultiSynVoice utt)
+  
+  ;(print "doing concat")
+  (us_unit_concat utt)
+
+  ;(print "doing raw concat")
+
+  (utt.relation.create utt 'SourceSegments)
+
+  (set! do_prosmod (du_voice.prosodic_modification currentMultiSynVoice))
+
+  (if do_prosmod
+      (begin
+	(if (not (member 'f0 (utt.relationnames utt)))
+	    (targets_to_f0 utt))
+	;; temporary fix
+	(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))
+      (begin
+	(utt.copy_relation utt 'SourceCoef 'TargetCoef)
+	(us_mapping utt "linear")))
+
+
+  ;(print "generating wave")
+;; specify something else if you don't want lpc
+  (us_generate_wave utt 'lpc)
+)
+
+
+; target cost scheme code 
+(define (targetcost it1 it2)
+  (Default_Target_Cost it1 it2))
+
+; Evil function which writes the functions to actually load and switch new voices.
+(define (make_voice_definition name srate config_function backoff_rules data_dir config)
+  "(make_voice_definition NAME SRATE CONFIG_FUNCTION BACKOFF_RULES DATA_DIR CONFIG)
+Create the fuction definitions to load and unload a voice."
+  (let ((voice_name (string-append "voice_" name))
+	(free_name (string-append "free_voice_" name))
+	(pre_config_function (string-append config_function "_pre"))
+	(voice_variable (upcase (string-append "voice_" name))))
+
+    (eval (list 'defvar (intern voice_variable) nil))
+
+    (eval (list 'define (list (intern voice_name))
+		(list 'if (intern pre_config_function)
+		      (list (intern pre_config_function) (intern voice_variable)))
+		(list 'if (list 'null (intern voice_variable))
+		      (list 'set! (intern voice_variable)
+			    (list 'multisyn_load_voice_modules
+				  (list 'quote name)
+				  srate
+				  (list 'quote backoff_rules)
+				  data_dir
+				  (list 'quote config))))
+		(list (intern config_function) (intern voice_variable))
+		(list 'set! 'current-voice (list 'quote name))
+		(list 'define_current_voice_reset)
+		(list 'set! 'currentMultiSynVoice (intern voice_variable))
+		))
+
+    (eval (list 'define
+		(list (intern free_name))
+		(list 'cond 
+		      (list (list 'null (intern voice_variable))
+			    (list 'error "Voice not currently loaded!"))
+		      (list (list 'eq? 'currentMultiSynVoice (intern voice_variable))
+			    (list 'error "Can't free current voice!"))
+		      (list 't (list set! (intern voice_variable) 'nil))))))
+  nil)
+		      
+(define (multisyn_load_voice_modules name srate backoff_rules base_dir module_list)
+"(multisyn_add_module voice name srate backoff_rules base_dir module_list)
+Add voice modules to a voice."
+(let (voice)
+  (mapcar
+   (lambda (module_entry)
+     (let ((dirs     (car module_entry))
+	   (utt_list (load_utt_list (path-append base_dir 
+						 (cadr module_entry)))))
+       (if (null voice)
+	   (set! voice (make_du_voice utt_list dirs srate))
+	   (voice.addModule voice utt_list dirs srate))))
+   module_list)
+  (voice.setName voice name)
+  (if flattenVoice 
+      (du_voice.setTargetCost voice "flat")
+      (du_voice.setTargetCost voice t))
+  (du_voice.setJoinCost voice t)
+  (format stderr "Please wait: Initialising multisyn voice.\n")
+  (voice.init voice)
+  (format stderr " Voice loaded successfully!\n")
+  (du_voice.set_ob_pruning_beam voice 0.25)
+  (du_voice.set_pruning_beam voice 0.25)
+  (du_voice.setDiphoneBackoff voice backoff_rules)
+voice))
+
+
+
+
+(define (define_current_voice_reset)
+"(define_current_voice_reset)
+Re-define (current_voice_reset) correctly."
+  (eval (list 'define
+	      (list 'current_voice_reset)
+	      (list 'multisyn_reset_globals))))
+
+(define (multisyn_reset_globals)
+"(multisyn_reset_globals)
+Reset multisyn specific global variables."
+(Param.set 'unisyn.window_symmetric 1))
+
+
+(provide 'multisyn)

pretrained_models/CosyVoice-ttsfrd/resource/festival/multisyn/multisyn_pauses.scm

@@ -0,0 +1,102 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 2003, 2004                        ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Multisyn Pause module (Rob Clark and Korin Richmond)
+;;;
+;;;
+
+(defvar BB_Pause "B_300")
+(defvar B_Pause "B_150")
+(defvar mB_Pause "B_150") ; shouldn't be used
+
+(define (MultiSyn_Pauses utt)
+  "(MultiSyn_Pauses UTT)
+Predict pause insertion in a Multisyn unit selection utterance structure."
+  (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
+		((string-equal pbreak "BB")
+		 (unitselection_pause_insert w BB_Pause))
+		((string-equal pbreak "mB")
+		 (unitselection_pause_insert w mB_Pause))
+		((string-equal pbreak "B")
+		 (unitselection_pause_insert w B_Pause)))))
+	  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.relation.print utt 'Word)
+    ;(utt.relation.print utt 'Segment)
+    utt))
+
+(define (unitselection_pause_insert word pause)
+  "(pause_insert word pause)
+  Insert segments needed for a pause."
+(let ((silence (car (cadr (car (PhoneSet.description '(silences))))))
+      (seg (item.relation (find_last_seg word) 'Segment))
+      pause_item)
+  ;(format stderr "  inserting pause after: %s.\n" (item.name seg))
+  ;(format stderr "  Inserting pause\n")
+; if next seg is not silence insert one.
+  (if (or (not (item.next seg))
+	  (not (string-equal (item.name (item.next seg)) silence)))
+      (item.insert seg (list silence) 'after))
+; insert pause after that if not the end.
+  (if (item.next (item.next seg))
+      (begin
+	(set! pause_item (item.insert (item.next seg) (list pause) 'after))
+;if next seg after that is not silence add one.
+	(if (not (string-equal (item.name (item.next pause_item)) silence))
+	    (item.insert pause_item (list silence) 'after))))))
+
+(provide 'multisyn_pauses)

pretrained_models/CosyVoice-ttsfrd/resource/festival/multisyn/radio_phones_multisyn.scm

@@ -0,0 +1,136 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 1996,1997,2003, 2004              ;;
+;;;                        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 radio phone set used in the BU RADIO FM
+;;;  corpus, some people call this the darpa set.  This one
+;;;  has the closures removed and pauses added for multisyn
+;;;
+
+(defPhoneSet
+  radio_multisyn
+  ;;;  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
+  (
+  ;; multisyn extras
+   (#  - 0 0 0 0 0 0 -)  ;; slience ... 
+   (B_10  - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_20 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_30 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_40 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_50 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_100 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_150 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_200 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_250 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_300 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_400 - 0 0 0 0 0 0 -)  ;; Pauses
+
+   ;; Note these features were set by awb so they are wrong !!!
+   (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  -   a   0   0   0   s   a   +) ;; ??
+   (eh  +   s   2   1   -   0   0   0) ;; get
+   (el  +   s   0   0   0   l   a   +)
+   (em  +   s   0   0   0   n   l   +)
+   (en  +   s   0   0   0   n   a   +)
+   (er  +   a   2   2   -   r   0   0) ;; always followed by r (er-r == axr)
+   (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   -)
+   (hv  -   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   +)
+   (nx  -   0   0   0   0   n   d   +) ;; ???
+   (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   +)
+   (pau -   0   0   0   0   0   0   -)
+   (h#  -   0   0   0   0   0   0   -)
+   (brth -   0   0   0   0   0   0   -)
+  )
+)
+
+(PhoneSet.silences '(# pau h# brth))
+
+(provide 'radio_phones_multisyn)
+
+
+  
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/multisyn/send_xwaves.scm

@@ -0,0 +1,318 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 2003, 2004                        ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; xwaves interface for festival for multisyn (Rob Clark)
+;;;
+;;; This is never loaded by defualt.
+;;; You'd need to change the paths here for this to currently work outside of CSTR.
+;;; If anyone else ends up using it let me know and I'll make it more robust.
+;;;
+
+;; Send commands to xwaves
+
+(defvar send_xwaves_command "/cstr/linux/entropic/esps531.linux/bin/send_xwaves")
+(defvar spectrogram_command "/cstr/linux/entropic/esps531.linux/bin/sgram")
+(defvar data_path "/projects/cougar/data/cstr/nina")
+
+(set! xw_object_count 0)
+(set! xw_active_list nil)
+
+;;
+;; Display a synthesised utterance
+;;
+(define (xwaves_display_utterance utt)
+"(xwaves_display_utterance utt)
+Display join and target information for an utterance."
+  (let ((units (utt.relation.items utt 'Unit))
+	(object (xw_name_object))
+	wavfile specfile segfile diphfile joinfile targfile sourcefile timefile)
+
+    (set! wavfile (xw_make_tmp_filename object))
+    (set! specfile (xw_make_tmp_filename object))
+    (set! segfile (xw_make_tmp_filename object))
+    (set! diphfile (xw_make_tmp_filename object))
+    (set! joinfile (xw_make_tmp_filename object))
+    (set! targfile (xw_make_tmp_filename object))
+    (set! sourcefile (xw_make_tmp_filename object))
+    (set! timefile (xw_make_tmp_filename object))
+    
+    ; display resulting waveform
+    (utt.save.wave utt wavfile 'riff)
+    (xwaves_show_general object wavfile 1500 200 10 10)
+    ; display resulting spectrogram
+    (xw_genspec wavfile specfile)
+    (xwaves_show_general object specfile 1500 400 10 260)
+    ; segments
+    (utt.save.unit_selection_segs utt segfile)
+    (xwaves_show_labels object segfile specfile)
+    ; Unit information
+    (utt.save.unit_selection_info utt diphfile joinfile targfile sourcefile timefile)
+    (xwaves_show_labels object timefile specfile)
+    (xwaves_show_labels object sourcefile specfile)
+    (xwaves_show_labels object targfile specfile)
+    (xwaves_show_labels object joinfile specfile)
+    (xwaves_show_labels object diphfile specfile)
+    ; mark files
+    (xw_register_active object (list wavfile specfile segfile diphfile joinfile sourcefile timefile))
+))
+
+;;
+;; Edit a diphone source
+;;
+
+(define (xwaves_edit_diphone utt id)
+  "(xwaves_edit_diphone utt id)
+Access the source diphone for label correction."
+(let ((diphone nil)
+      segfilename
+      wavefilename
+      (utt (Utterance Text nil))
+      segs
+      (seg nil)
+      (start 0) 
+      end)
+  
+  ;; find unit.
+  (mapcar
+   (lambda (unit)
+     (if (string-equal (format nil "_%s" id) (item.feat unit id))
+	 (set! diphone unit)))
+   (utt.relation.items utt 'Unit))
+  (if (null diphone)
+      (error (format nil "Diphone with id _%s not found in utterance.")))
+  (set! uttname (item.feat diphone "source_utt"))
+  (set! end (item.feat diphone "source_end"))
+
+  (set! segfilename  (format nil "%s/lab/%s.lab" data_path uttname))
+  (set! wavefilename (format nil "%s/wav/%s.wav" data_path uttname))
+  (utt.relation.load utt 'Segment segfilename)
+
+  (set! segs (utt.relation.items utt 'Segment))
+  (while (and segs 
+	      (not (equal? (item.feat (car segs) "end") end)))
+	 (set! segs (cdr segs)))
+  
+  if null seg ...
+
+    (if (item.prev diphone)
+      (set! start (item.feat seg "start"))
+      (set! start 0))
+
+
+))
+  
+  
+
+
+
+;;
+;; Interface with xwaves.
+;;
+
+
+(define (xwaves_show_general object file width height xpos ypos)
+"(xwaves_show_general object file width height xpos ypos)
+Display an wave or track file."
+  (xw_send (format nil "make name %s file %s width %d height %d loc_x %d loc_y %d" object file width height xpos ypos)))
+
+(define (xwaves_show_wave object file)
+"(xwaves_show_wave object file)
+Display a waveform."
+  (xwaves_show_general object file 1500 200 10 10))
+
+(define (xwaves_show_labels object file attachto)
+"(xwaves_show_labels object file attachto)
+Display a label file."
+  (xw_send (format nil "send make signal %s name %s file %s color 125" attachto object file))
+  (xw_send "send activate fields 1 2 3 4 5"))
+
+
+(define (xwaves_attach_xlabel)
+"(xwaves_attach_xlabel)
+Attach xlabel to xwaves."
+  (xw_send "attach function xlabel"))
+
+(define (xwaves_set_markers object left right)
+"(xwaves_set_markers object left right)
+Set the markers."
+  (xw_send (format nil "%s set l_marker_time %f" object left))
+  (xw_send (format nil "%s set r_marker_time %f" object right)))
+
+(define (xwaves_bracket_markers object file)
+"(xwaves_bracket_markers object file)
+Bracket markers."
+  (xw_send (format nil "%s bracket file %s " object file)))
+
+(define (xwaves_close_windows object)
+"(xwaves_close_windows object)
+Close currently open windows related to object or all if nil.."
+(cond
+ ((null object)
+  (xw_send "kill"))
+ (t 
+  (xw_send (format nil "kill name %s" object))))
+(xw_clear_active_list object))
+
+
+(define (xwaves_wait)
+"(xwaves_wait)
+Wait for xwaves continue signal."
+  (xw_send "pause"))
+
+
+;;
+;; Object naming
+;;
+(define (xw_name_object)
+"(xw_name_object)
+Generate a name for this object."
+(let (name)
+  (set! name (string-append "obj" xw_object_count))
+  (set! xw_object_count (+ xw_object_count 1))
+  name))
+
+;;
+;; Temp file lists
+;;
+
+(define (xw_clear_active_list object)
+"(xw_clear_active_list)
+Clear active list of specified object, or all if nil."
+(let (new_active_list)
+(mapcar
+ (lambda (objectlist)
+   (cond
+    ((or (null object)
+	 (string-equal object (car objectlist)))
+     (mapcar
+      (lambda (file)
+	(delete-file file))
+      (cadr objectlist)))
+    (t
+     (set! new_active_list (cons objectlist new_active_list)))))
+ xw_active_list)
+(set! xw_active_list new_active_list))
+nil)
+
+
+(define (xw_register_active object flist)
+  "(xw_register_active object flist)
+Adds  an object and its filenames to the active list."
+  (set! xw_active_list (cons (cons object (list flist)) xw_active_list))
+  nil)
+
+(define (xw_make_tmp_filename object)
+  "(xw_make_tmp_filename)
+make tmp file name which incorporates object name."
+(format nil "%s_%s" (make_tmp_filename) object))
+
+
+;;
+;; Low level xwaves stuff.
+;;
+
+(define (xw_genspec wavfile specfile)
+"(xw_genspec wavfile specfile)
+Generate a spectrogram file."
+  (system (format nil "%s -dHAMMING -o8 -E0.94 -S2 -w8 %s %s\n" spectrogram_command wavfile specfile)))
+
+(define (xw_send command)
+"(xw_send command)
+Send a command to xwaves."
+  (system (format nil "%s %s\n" send_xwaves_command command)))
+
+
+
+;;
+;; General Festival stuff.
+;;
+
+
+(define (utt.save.unit_selection_segs utt filename)
+"(utt.save.unit_selection_segs utt filename)
+  Save unit selection 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 '(source_end name)))
+    (fclose fd)
+    utt))
+
+(define (utt.save.unit_selection_info utt diphfile joinfile targfile sourcefile timefile)
+"(utt.save.unit_selection_info utt diphfile joinfile targfile sourcefile timefile)
+  Save stuff in xlabel format."
+  (let ((fdd (fopen diphfile "w"))
+	(fdj (fopen joinfile "w"))
+	(fdt (fopen targfile "w"))
+	(fds (fopen sourcefile "w"))
+	(fdx (fopen timefile "w"))
+	real_join)
+    (format fdd "#\n")
+    (format fdj "#\n")
+    (format fdt "#\n")
+    (format fds "#\n")
+    (format fdx "#\n")
+    (mapcar
+     (lambda (unit)
+       (set! real_join "")
+       (if (item.next unit)
+	   (if (not (string-equal (item.feat unit 'source_utt)
+				  (item.feat (item.next unit) 'source_utt)))
+	       (set! real_join "*")))
+       (format fdd "%2.4f 100 %s %s\n" 
+	       (item.feat unit 'end)
+	       (item.feat unit 'name)
+	       real_join)
+       (format fdj "%2.4f 100 %s\n" 
+	       (item.feat unit 'end)
+	       (if (item.next unit)
+		   (item.feat (item.next unit) 'join_cost)
+		   0))
+       (format fdt "%2.4f 100 %s\n" 
+	       (item.feat unit 'end)
+	       (item.feat unit 'target_cost))
+       (format fds "%2.4f 100 %s\n" 
+	       (item.feat unit 'end)
+	       (item.feat unit 'source_utt))
+       (format fdx "%2.4f 100 %s\n" 
+	       (item.feat unit 'end)
+	       (item.feat unit 'source_end)))
+     (utt.relation.items utt 'Unit))
+    (fclose fdd)
+    (fclose fdj)
+    (fclose fdt)
+    (fclose fds)
+    (fclose fdx)
+    utt))

pretrained_models/CosyVoice-ttsfrd/resource/festival/multisyn/target_cost.scm

@@ -0,0 +1,410 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 2003, 2004                        ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Multisyn scheme target cost (Rob Clark and Korin Richmond)
+;;;
+;;;
+
+(define (Default_Target_Cost targ cand)
+"(Default_Target_Cost targ cand)
+A Default Target Cost function."
+(let ((cost 0))
+  (mapcar
+   (lambda (row)
+     (set! cost (+ cost (tc_eval_row row targ cand))))
+   target_matrix)
+  (set! cost (/ cost target_matrix_weight))
+  cost))
+
+
+(define (tc_eval_row row targ cand)
+  "(tc_eval_row row targ cand)
+Evaluate a target matrix row."
+(let ((weight (car row))
+      (func (cadr row))
+      (result 0))
+  (set! result (* weight (eval (list func targ cand))))
+  result))
+
+;;
+;; Target cost Matrix
+;;  '(weight function)
+
+(define (get_matrix_weight m)
+  (let ((w 0))
+    (mapcar
+     (lambda (x)
+       (set! w (+ w (car x))))
+     m)
+    w))
+
+
+(set! test_matrix_max_weight 1)
+(set! test_matrix
+'(
+  (10 tc_stress )
+  (5 tc_syl_pos )
+  (5 tc_word_pos)
+  (6 tc_partofspeech)
+  (7 tc_phrase_pos) 
+  (4 tc_left_context)
+  (3 tc_right_context)
+  (25 tc_bad_f0) ;; set to equal 1/3 of total cost (so high because interaction with join) 
+;  (0 tc_segment_score) ;; was 4. turned off until utterances are built for this.
+  (10 tc_bad_duration) ;; was 6
+))
+
+(set! test_matrix_weight (* test_matrix_max_weight (get_matrix_weight test_matrix)))
+
+(set! target_matrix test_matrix)
+(set! target_matrix_weight test_matrix_weight)
+
+
+
+;;
+;; tc_stress
+;;
+;; Compares stress on any vowel which form part of the diphone. stress
+;; conditions must match for a zero target cost.
+;; 
+
+(define (tc_stress targ cand)
+"(tc_stress targ cand)
+Target Cost stressed. 0    - stress patterns match  [ compares: 0 unstressed vs. > 0 stressed ]
+                      1    - stress miss-match.
+"
+(let ((c 0)
+      cand_stress targ_stress)
+  ;(format t "my_is_vowel %l\n" (my_is_vowel targ))
+  ;(format t "phone_is_silence %l\n" (phone_is_silence (item.feat targ 'name)))
+  ;; For first segment
+  (if (and (not (phone_is_silence (item.feat targ 'name)))
+	   (my_is_vowel targ))
+      (begin 
+	(set! cand_stress (item.feat cand "R:SylStructure.parent.stress"))
+	(set! targ_stress (item.feat targ "R:SylStructure.parent.stress"))
+	(if (or (and (eq? cand_stress 0) (> targ_stress 0))
+		(and (eq? targ_stress 0) (> cand_stress 0)))
+	    (set! c 1))))
+  ;; For second segment
+  ;(format t "n.my_is_vowel %l\n" (my_is_vowel (item.next targ)))
+  ;(format t "n.phone_is_silence %l\n" (phone_is_silence (item.feat targ 'n.name)))
+  (if (and (not (phone_is_silence (item.feat targ 'n.name)))
+	   (my_is_vowel (item.next targ)))
+      (begin 
+	(set! cand_stress (item.feat cand "n.R:SylStructure.parent.stress"))
+	(set! targ_stress (item.feat targ "n.R:SylStructure.parent.stress"))
+	(if (or (and (eq? cand_stress 0) (> targ_stress 0))
+		(and (eq? targ_stress 0) (> cand_stress 0)))
+	    (set! c 1))))
+;  (format t "tc_stress: %l\n" c)
+c))
+
+
+;;
+;; tc_syl_position
+;;
+;; Find and compare diphone position in syllabic structure.
+;; Values are: inter - diphone crosses syllable boundary. 
+;;             initial - diphone is syllable initial.
+;;             medial - diphone is syllable medial
+;;             final  - diphone is syllable final
+;; returns 0 for a match 1 for a mismatch.
+;;
+(define (tc_syl_pos targ cand)
+"(tc_syl_pos targ cand)
+Score position in syllable."
+(let ((targ_pos "medial")
+      (cand_pos "medial")
+      (targ_syl (get_syl targ))
+      (targ_next_syl (get_syl (item.next targ)))
+      (cand_syl (get_syl cand))
+      (cand_next_syl (get_syl (item.next cand))))
+  ;; target 
+  (cond
+   ((not (equal? targ_syl targ_next_syl))
+    (set! targ_pos "inter"))
+   ((not (equal? targ_syl (get_syl (item.prev targ))))
+    (set! targ_pos "initial"))
+   ((not (equal? targ_next_syl (get_syl (item.next (item.next targ)))))
+    (set! targ_pos "final")))
+  ;; candidate
+  (cond
+   ((not (equal? cand_syl cand_next_syl))
+    (set! cand_pos "inter"))
+   ((not (equal? cand_syl (get_syl (item.prev cand))))
+    (set! cand_pos "initial"))
+   ((not (equal? cand_next_syl (get_syl (item.next (item.next cand)))))
+    (set! cand_pos "final")))
+;  (format t "targ_syl: %l   cand_syl %l\n" targ_pos cand_pos)
+   (if (equal? targ_pos cand_pos) 0 1)))
+
+;;
+;; tc_word_position
+;;
+;; Find and compare diphone position in word structure
+;; Values are: inter - diphone crosses word boundary. 
+;;             initial - diphone is word initial.
+;;             medial - diphone is word medial
+;;             final  - diphone is word final
+;; returns 0 for a match 1 for a mismatch.
+;;
+(define (tc_word_pos targ cand)
+"(tc_word_pos targ cand)
+Score position in word."
+(let ((targ_pos "medial")
+      (cand_pos "medial")
+      (targ_word (get_word targ))
+      (targ_next_word (get_word (item.next targ)))
+      (cand_word (get_word cand))
+      (cand_next_word (get_word (item.next cand))))
+  ;; target 
+  (cond
+   ((not (equal? targ_word targ_next_word))
+    (set! targ_pos "inter"))
+   ((not (equal? targ_word (get_word (item.prev targ))))
+    (set! targ_pos "initial"))
+   ((not (equal? targ_next_word (get_word (item.next (item.next targ)))))
+    (set! targ_pos "final")))
+  ;; candidate
+  (cond
+   ((not (equal? cand_word cand_next_word))
+    (set! cand_pos "inter"))
+   ((not (equal? cand_word (get_word (item.prev cand))))
+    (set! cand_pos "initial"))
+   ((not (equal? cand_next_word (get_word (item.next (item.next cand)))))
+    (set! cand_pos "final")))
+;  (format t "targ_word: %l   cand_word %l\n" targ_pos cand_pos)
+   (if (equal? targ_pos cand_pos) 0 1)))
+
+
+
+;;
+;; tc_phrase_position
+;;
+;; Position (of word) in phrase
+;; initial/medial/final
+;;
+;; 0 - match, 1 - mismatch
+;;
+(define (tc_phrase_pos targ cand)
+"(tc_phrase_pos targ cand)
+ Score position in phrase."
+(let ((targ_word (get_word targ))
+      (cand_word (get_word cand)))
+  (cond
+   ((and (null targ_word)
+	 (null cand_word))
+    0)
+   ((or (null targ_word)
+	(null cand_word))
+    1)
+   ((string-equal (item.feat targ_word 'pbreak)
+		  (item.feat cand_word 'pbreak))
+    0)
+   (t 1))))
+
+;;
+;; tc_partofspeech
+;;
+;; 
+;;
+(define (tc_partofspeech targ cand)
+"(tc_partofspeech targ cand)
+ Score part of speech."
+(let ((targ_word (get_word targ))
+      (cand_word (get_word cand))
+      targ_pos cand_pos)
+(if targ_word
+    (set! targ_pos (simple_pos (item.feat targ_word 'pos))))
+(if cand_word
+    (set! cand_pos (simple_pos (item.feat cand_word 'pos))))
+  ;(format t "targ_pos %l cand_pos %l\n" targ_pos cand_pos)
+  (if (equal? targ_pos cand_pos) 0 1)))
+
+(define (score_contexts targ_context cand_context)
+  "(score_contexts targ_context cand_context)
+If both context items are nil, then score is 0.
+If both context items are not nil, and are the same, then
+score is 0. Otherwise, score is 1."
+  (if (and targ_context cand_context)
+	(if (equal? (item.feat targ_context "name")
+		    (item.feat cand_context "name"))
+	    0
+	    1)
+      (if (and (equal? targ_context nil)
+	       (equal? cand_context nil))
+	  0
+	  1)))
+
+
+(define (tc_left_context targ cand)
+"(tc_left_context targ cand)
+Score left phonetic context."
+(let ((targ_context (item.prev targ))
+      (cand_context (item.prev cand)))
+  (score_contexts targ_context cand_context)))
+
+;;
+;; tc_right_context
+;;
+;;
+;;
+(define (tc_right_context targ cand)
+"(tc_right_context targ cand)
+Score right phonetic context."
+(let ((targ_context (item.next (item.next targ)))
+      (cand_context (item.next (item.next cand))))
+  (score_contexts targ_context cand_context)))
+
+
+;;
+;; tc_segment_score
+;;
+;; This currently thresholds based on looking at the distributions of the scores.
+;; A nice exp function may be better.
+(define (tc_segment_score targ cand)
+"tc_segment_score targ cand)
+A bad alignment score make a bad segment."
+(let ((score 0))
+  (if (not (phone_is_silence (item.feat cand "name")))
+      (set! score  (+ score (item.feat cand 'score))))
+  (if (not (phone_is_silence (item.feat (item.next cand) "name")))
+      (set! score  (+ score (item.feat (item.next cand) 'score))))
+  (cond
+   ((> score -4000)    ;2000 (x2) is 7.5% 
+    0)
+   ((> score -5000)    ;2500 (x2) is 5.0%
+    0.5)
+   (t 1))))
+   
+;;
+;; tc_bad_duration
+;;
+;; If the segment is marked as having a weird duration penalise it.
+;; We allow bad_dur to be set on the target so resynthesis works 
+;; and so you could ask for really long/short segments.
+;;
+(define (tc_bad_duration targ cand)
+  (if (equal? (item.feat targ "bad_dur")
+	      (item.feat cand "bad_dur"))
+      0
+      1))
+
+
+;;
+;; tc_bad_f0
+;;
+;; If the candidate is deemed to have an inappropriate f0, then penalise it.
+;; 
+;; Specifically, if the targ/cand segment type is expected to be voiced, then
+;; an f0 of zero is bad (results from poor pitch tracking).  In such a case,
+;; the join cost would then favour other units with f0 (since the euclidean
+;; distance between two zeros is very small ;)
+;; We want to avoid that.
+;;
+;; Presumeably, we also want to penalise cases where supposedly voiceless 
+;; candidates have an f0 != 0 (either a consequence of bad pitch tracking
+;; or bad labelling) but that's not done here yet...
+;;
+;; (the function itself has been implemented in C for convenience, and
+;; this stub is left here just for this note ;)
+
+(define (tc_bad_f0 targ cand)
+  (let ((score (temp_tc_bad_f0 targ cand))
+	(name (format nil "%s_%s" 
+		      (item.feat targ "name")
+		      (item.feat (item.next targ) "name"))))
+    (if (not (equal? score 0.0))
+	(format t "f0 score for %s is %f\n" name score))
+    score))
+
+;;
+;; Is a segment a vowel?  ( ph_is_a_vowel doesn't seem to work)
+;;
+(define (my_is_vowel seg)
+  (if seg
+      (if (equal? (item.feat seg 'ph_vc) "+")
+	  t
+	  nil)))
+
+
+
+;; get the syllable from sysstructure in normal utterance
+;;
+(define (get_syl seg)
+  (let (syl)
+    (if seg 
+	(set! syl (item.relation.parent seg 'SylStructure)))
+    syl))
+
+;; get the word from sylstructure in normal utterance
+;;
+(define (get_word seg)
+  (let ((syl (get_syl seg))
+	word)
+    (if syl
+	(set! word (item.parent syl)))
+    word))
+   
+
+;; simple pos
+;;
+(define (simple_pos pos)
+(let (spos)
+  (cond
+   ((member_string pos '(vbd vb vbn vbz vbp vbg))
+    (set! spos "v"))
+   ((member_string pos '(nn nnp nns nnps fw sym ls))
+    (set! spos "n"))
+   ((member_string pos '(dt gin prp cc of to cd md pos wdt wp wrb ex uh pdt))
+    (set! spos "func"))
+   ((member_string pos '(jj jjr jjs 1 2 rb rp rbr rbs))
+    (set! spos "other")))
+  spos))
+
+
+;; debugging
+
+(define (test_target_cost utt1 utt2)
+(let ((segs1 (utt.relation.items utt1 'Segment))
+      (segs2 (utt.relation.items utt2 'Segment))
+      (tc 0))
+  (while (and segs1 segs2)
+	 (set! tc (Default_Target_Cost (car segs1) (car segs2)))
+	 (format t "targ: %l cand: %l cost: %l\n" (item.name (car segs1)) (item.name (car segs2)) tc)
+	 (set! segs1 (cdr segs1))
+	 (set! segs2 (cdr segs2)))))
+
+
+(provide 'target_cost)

pretrained_models/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)

pretrained_models/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)

pretrained_models/CosyVoice-ttsfrd/resource/festival/phoneset.scm

@@ -0,0 +1,134 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  
+;;;  Support code for phone set definitions
+;;;
+
+(defmac (defPhoneSet form)
+  (list 'defPhoneSet_real 
+	(list 'quote (cadr form))
+	(list 'quote (car (cddr form)))
+	(list 'quote (cadr (cddr form)))))
+
+(define (defPhoneSet_real name featdefs phones)
+  "(defPhoneSet NAME FEATTYPES PHONES)
+Define a phone set with given name, feature types and
+list of phones.  This also selects name as the current phoneset."
+  (let (info)
+    (if (not (eq? 'Features (car featdefs)))
+	(begin
+	  ;; Old format that has the same number of phone features for
+	  ;; all phones
+	  (set! info
+		(mapcar 
+		 (lambda (ph)
+		   (let ((fvs
+			  (mapcar
+			   list
+			   (mapcar car featdefs)
+			   (cdr ph))))
+		   (ps_check_fvals
+		    (cons (car ph) (cons (list 'type t) fvs))
+		    (cons t fvs))
+		   (list (car ph) fvs)))
+		 phones)))
+	;; else
+	;;   New format where types are specified so phones may have
+        ;;   different features
+	(set! info
+	 (mapcar 
+	  (lambda (ph)
+	    (let ((fvs 
+		   (cons 
+		    (list 'type (cadr ph))
+		    (mapcar 
+		     list 
+		     (mapcar car (cdr (assoc (cadr ph) (cdr featdefs))))
+		     (cddr ph)))))
+	      (ps_check_fvals 
+	       (cons (car ph) fvs)
+	       (assoc (cadr ph) (cdr featdefs)))
+	      (list (car ph) fvs)))
+	  (cdr phones))))
+    (Param.set 
+     (string-append "phonesets." name)
+     info)
+    (PhoneSet.select name)
+    (list name info)))
+
+(define (ps_check_fvals fvs featdefs)
+  "(ps_check_fvals fvs featdefs)
+Check that feature values in a phone definition are in the defined
+set of possibles."
+  (mapcar 
+   (lambda (fp)
+     (let ((def (cdr (assoc (car fp) (cdr featdefs)))))
+       (cond
+	((not def)
+	 (error "Phoneset definition: phone has no defined type" fvs))
+	((not (member_string (car (cdr fp)) def))
+	 (error 
+	  (format nil "Phoneset definition: phone feature %l is undefined" fp) fvs)))))
+   (cdr (cdr fvs))))
+
+(define (PhoneSet.select name)
+  "(PhoneSet.select name)
+Select named phonset as current."
+  (if (feats.present Param (string-append "phonesets." name))
+      (Param.set "phoneset" (Param.get (string-append "phonesets." name)))
+      (error "no phoneset defined: " name)))
+
+(define (PhoneSet.description name)
+  "(PhoneSet.description)
+Return (lisp) representation of current phoneset."
+  (feats.tolisp (Param.get "phoneset")))
+
+(define (PhoneSet.list)
+  "(PhoneSet.list)
+List of the names of the currently defined phonesets."
+  ;; This isn't a particularly efficient way to get the answer
+  (mapcar car (feats.tolisp (Param.get "phonesets"))))
+
+(define (PhoneSet.silences sils)
+  "(PhoneSet.silences SILLIST)
+Define the silence phones for the currently selected phoneset."
+  (Param.set "phoneset.silences" sils))
+
+(provide 'phoneset)
+
+
+
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/phrase.scm

@@ -0,0 +1,171 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   Phrase boundary prediction.
+;;;   
+;;;   Two methods supported, if POS is enabled we use ngrams for that
+;;;   otherwise we use a CART tree
+;;;
+;;;   Models trained from the IBM/Lancaster Spoken English Corpus and 
+;;;   Boston University's FM Radio Corpus.
+
+;;;
+;;;  Here's a very simple CART tree for predicting phrase breaks
+;;;  based on punctuation only
+;;;
+(set! simple_phrase_cart_tree
+'
+((lisp_token_end_punc in ("?" "." ":"))
+  ((BB))
+  ((lisp_token_end_punc in ("'" "\"" "," ";"))
+   ((B))
+   ((n.name is 0)  ;; end of utterance
+    ((BB))
+    ((NB))))))
+
+(define (token_end_punc word)
+  "(token_end_punc UTT WORD)
+If punctuation at end of related Token and if WORD is last word
+in Token return punc, otherwise 0."
+  (if (item.relation.next word "Token")
+      "0"
+      (item.feat word "R:Token.parent.punc")))
+
+;;;  This is a simple CART tree used after boundaries are predicted
+;;;  by the probabilistic method to get two levels of break
+(set! english_phrase_type_tree
+'((pbreak is NB)
+  ((num_break is 1)
+   ((mB))
+   ((R:Token.parent.EMPH is 1)
+    ((NB))
+    ((n.R:Token.parent.EMPH is 1)
+     ((NB))
+     ((NB)))))
+  ((pbreak is BB)
+   ((BB))
+   ((pbreak is mB)
+    ((mB))
+    ((name in ("." "!" "?"));; only (potentially) change Bs to BBs
+     ((BB))
+     ((B)))))))
+
+(set! f2b_phrase_cart_tree
+'
+((gpos is punc)
+ (((1 0.00238095) (3 0) (4 0.997619) B))
+ (((4 0.00238095) (3 0) (1 0.997619) NB))))
+
+;;;  For more detailed prediction of phrase breaks we use POS and
+;;;  probability distribution of breaks
+;;;  These models were trained using data from the Lancaster/IBM
+;;;  Spoken English Corpus
+
+(require 'pos)   ;; for part of speech map
+
+(defvar pbreak_ngram_dir libdir
+  "pbreak_ngram_dir
+  The directory containing the ngram models for predicting phrase
+  breaks.  By default this is the standard library directory.")
+
+(defvar english_phr_break_params
+  (list
+   ;; The name and filename off the ngram with the a priori ngram model
+   ;; for predicting phrase breaks in the Phrasify module.  This model should 
+   ;; predict probability distributions for B and NB given some context of 
+   ;; part of  speech tags.
+   (list 'pos_ngram_name 'english_break_pos_ngram)
+   (list 'pos_ngram_filename
+	 (path-append pbreak_ngram_dir "sec.ts20.quad.ngrambin"))
+   ;; The name and filename of the ngram  containing the a posteriori ngram
+   ;; for predicting phrase breaks in the Phrasify module.  This module should
+   ;; predict probability distributions for B and NB given previous B and
+   ;; NBs.
+   (list 'break_ngram_name 'english_break_ngram)
+   (list 'break_ngram_filename
+	 (path-append pbreak_ngram_dir "sec.B.hept.ngrambin"))
+   ;; A weighting factor for breaks in the break/non-break ngram.
+   (list 'gram_scale_s 0.05)
+   ;; When Phrase_Method is prob_models, this tree, if set is used to 
+   ;; potentially predict phrase type.  At least some prob_models only
+   ;; predict B or NB, this tree may be used to change some Bs into
+   ;; BBs.  If it is nil, the pbreak value predicted by prob_models
+   ;; remains the same.
+   (list 'phrase_type_tree english_phrase_type_tree)
+   ;; A list of tags used in identifying breaks.  Typically B and NB (and
+   ;; BB).  This should be the alphabet of the ngram identified in
+   ;; break_ngram_name
+   (list 'break_tags '(B NB))
+   (list 'pos_map english_pos_map_wp39_to_wp20)
+   )
+  "english_phr_break_params
+Parameters for English phrase break statistical model.")
+
+(defvar phr_break_params nil
+  "phr_break_params
+Parameters for phrase break statistical model.  This is typcal set by
+a voice selection function to the parameters for a particular model.")
+
+;;;
+;;; Declaration of some features 
+;;; 
+
+(def_feature_docstring 
+  'Word.pbreak
+  "Word.pbreak
+  Result from statistical phrasing module, may be B or NB denoting
+  phrase break or non-phrase break after the word.")
+
+(def_feature_docstring 
+  'Word.pbreak_score
+  "Word.pbreak_score
+  Log likelihood score from statistical phrasing module, for pbreak
+  value.")
+
+(def_feature_docstring 
+  'Word.blevel
+  "Word.blevel
+  A crude translation of phrase break into ToBI like phrase level.
+  Values may be 0,1,2,3,4.")
+
+(define (Phrasify utt)
+"(Phrasify utt)                                
+Construct phrasify over Words module."
+  (let ((rval (apply_method 'Phrasify_Method utt)))
+    (cond
+     (rval rval) ;; new style
+     (t
+      (Classic_Phrasify utt)))))
+
+
+(provide 'phrase)

pretrained_models/CosyVoice-ttsfrd/resource/festival/pos.scm

@@ -0,0 +1,229 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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 part of speech tagger
+;;;
+
+(set! english_guess_pos
+      '((in of for in on that with by at from as if that against about 
+	    before because if under after over into while without
+	    through new between among until per up down)
+	(to to)
+	(det the a an no some this that each another those every all any 
+	     these both neither no many)
+	(md will may would can could should must ought might)
+	(cc and but or plus yet nor)
+	(wp who what where how when)
+	(pps her his their its our their its mine)
+	(aux is am are was were has have had be)
+	(punc "." "," ":" ";" "\"" "'" "(" "?" ")" "!" "[" "]" "{" "}")
+	))
+
+(defvar guess_pos english_guess_pos
+  "guess_pos
+  An assoc-list of simple part of speech tag to list of words in that
+  class.  This basically only contains closed class words all other 
+  words may be assumed to be content words.  This was built from information
+  in the f2b database and is used by the ffeature gpos.")
+
+;;;  A more elaborate part of speech tagger using ngrams works but
+;;;  at present requires a large list of a priori probabilities
+;;;  to work.  If that file exists on your system we'll use it otherwise
+;;;  POS is guessed by the lexicon
+
+;;;  These models were build from the Penn TreeBank, WSJ corpus
+
+(defvar pos_model_dir lexdir
+  "pos_model_dir
+  The directory contains the various models for the POS module.  By
+  default this is the same directory as lexdir.  The directory should
+  contain two models: a part of speech lexicon with reverse log probabilities
+  and an ngram model for the same part of speech tag set.")
+
+(defvar pos_p_start_tag "punc"
+  "pos_p_start_tag
+  This variable's value is the tag most likely to appear before
+  the start of a sentence.  It is used when looking for pos context
+  before an utterance.  Typically it should be some type of punctuation
+  tag.")
+
+(defvar pos_pp_start_tag "n"
+  "pos_pp_start_tag
+  This variable's value is the tag most likely to appear before
+  pos_p_start_tag and any position preceding that.  It is typically
+  some type of noun tag.  This is used to provide pos context for
+  early words in an utterance.")
+
+(defvar pos_supported nil
+  "pos_supported
+  If set to non-nil use part of speech prediction, if nil just get
+  pos information from the lexicon.")
+
+(defvar pos_ngram_name nil
+  "pos_ngram_name
+  The name of a loaded ngram containing the a posteriori ngram model for 
+  predicting part of speech.  The a priori model is held as a 
+  lexicon call poslex.")
+
+(defvar pos_map nil
+  "pos_map
+  If set this should be a reverse assoc-list mapping on part of speech
+  tag set to another.  It is used after using the defined POS models to
+  map the pos feature on each word to a new tagset.")
+
+;;;
+;;;  All the names here don't really allow multiple versions
+;;;  they should be prefixed with english_
+;;;
+
+(if (probe_file (path-append pos_model_dir "wsj.wp39.poslexR"))
+    (begin
+      (lex.create "english_poslex")
+      (lex.set.compile.file 
+       (path-append pos_model_dir "wsj.wp39.poslexR"))
+      (lex.set.phoneset "mrpa")
+      (lex.set.lts.method nil)
+      (set! pos_lex_name "english_poslex")
+      (set! pos_p_start_tag "punc")
+      (set! pos_pp_start_tag "nn")
+      ;; wp39
+      (lex.add.entry '("_OOV_" ((nnp -2.9144) (jj -2.7357) (nn -3.5787)
+				(nns -3.4933) (vbn -3.2486) (vbg -2.9419)
+				(vb  -3.5471) (vbd -3.7896) (vbz -3.7820)
+				(rb  -4.1940) (vbp -3.2755) (nnps -2.1605))
+			       ()))
+      (lex.add.entry '("_number_" 
+		       ((cd -0.35202) (jj -4.1083) (nns -6.4488) (nnp -7.3595))
+		       () ))
+      (lex.add.entry '("," ((punc -0.88488)) () ))
+      (lex.add.entry '("." ((punc -1.1104)) () ))
+      (lex.add.entry '(":" ((punc -4.4236)) () ))
+      (lex.add.entry '("``" ((punc -2.7867)) () ))
+      (lex.add.entry '("`" ((punc -2.7867)) () ))
+      (lex.add.entry '("'" ((punc -2.7867)) () ))
+      (lex.add.entry '("\"" ((punc -2.7867)) () ))
+      (lex.add.entry '("[" ((punc -2.7867)) () ))
+      (lex.add.entry '("]" ((punc -2.7867)) () ))
+      (lex.add.entry '("{" ((punc -2.7867)) () ))
+      (lex.add.entry '("}" ((punc -2.7867)) () ))
+      ;; wp17
+;;      (lex.add.entry '("_OOV_" ((n -3.4109) (j -2.7892) (v -3.7426)) ()))
+;      (lex.add.entry '("_OOV_" ((n -1.968) (j -2.351) (v -2.287)) ()))
+;      (lex.add.entry '("_number_" ((j -0.35202)) ()))
+;      (lex.add.entry '("," ((punc -0.88359)) () ))
+;      (lex.add.entry '("." ((punc -1.1101)) () ))
+;      (lex.add.entry '(":" ((punc -4.4236)) () ))
+;      (lex.add.entry '("``" ((punc -2.7867)) () ))
+;      (lex.add.entry '("`" ((punc -2.7867)) () ))
+;      (lex.add.entry '("'" ((punc -2.7867)) () ))
+;      (lex.add.entry '("\"" ((punc -2.7867)) () ))
+      ;; wp22
+;      (lex.add.entry '("_OOV_" ((n -3.4109) (j -2.7892) (v -3.7426)) ()))
+;      (lex.add.entry '("_number_" ((cd -0.35202) (j -4.1908) (n -7.3890)) ()))
+;      (lex.add.entry '("," ((punc -0.88359)) () ))
+;      (lex.add.entry '("." ((punc -1.1101)) () ))
+;      (lex.add.entry '(":" ((punc -4.4236)) () ))
+;      (lex.add.entry '("``" ((punc -2.7867)) () ))
+      ;; wp18 
+;      (lex.add.entry '("_OOV_" ((n -3.4109) (j -2.7892) (v -3.7426)) ()))
+;      (lex.add.entry '("_number_" ((j -0.35202)) ()))
+;      (lex.add.entry '("`" ((punc -6.539) ) () ))
+;      (lex.add.entry '("``" ((punc -2.399) ) () ))
+;      (lex.add.entry '("," ((punc -0.480) ) () ))
+;      (lex.add.entry '("." ((fpunc -0.012) ) () ))
+;      (lex.add.entry '(":" ((punc -4.100) ) () ))
+
+     (ngram.load 'english_pos_ngram
+	    (path-append pos_model_dir  "wsj.wp39.tri.ngrambin"))
+;      (ngram.load 'english_pos_ngram
+;	    (path-append pos_model_dir  "wsj.wp45.tri.ngram"))
+      (set! pos_supported t)
+      )
+    (set! pos_supported nil))
+
+(setq english_pos_map_wp39_to_wp20
+      '(
+	(( vbd vb vbn vbz vbp vbg ) v)
+	(( nn nnp nns nnps fw sym ls ) n)
+	(( dt ) dt)
+	(( punc fpunc ) punc)
+	(( in ) in)
+	(( jj jjr jjs 1 2 ) j)
+	(( prp ) prp)
+	(( rb rp rbr rbs ) r)
+	(( cc ) cc)
+	(( of ) of)
+	(( to ) to)
+	(( cd ) cd)
+	(( md ) md)
+	(( pos ) pos)
+	(( wdt ) wdt)
+	(( wp ) wp)
+	(( wrb ) wrb)
+	(( ex ) ex)
+	(( uh ) uh)
+	(( pdt ) pdt)
+	))
+
+(defvar pos_map nil
+  "pos_map
+A reverse assoc list of predicted pos tags to some other tag set.  Note
+using this changes the pos tag loosing the actual predicted value.  Rather
+than map here you may find it more appropriate to map tags sets locally
+in the modules that use them (e.g. phrasing and lexicons).")
+
+;;(setq pos_map_remap
+;;      '(
+;;	(( fpunc ) punc)
+;;	(( of ) in)))
+
+(def_feature_docstring 'Word.pos
+  "Word.pos
+  Part of speech tag value returned by the POS tagger module.")
+
+(def_feature_docstring 'Word.pos_score
+  "Word.pos_score
+  Part of speech tag log likelihood from Viterbi search.")
+
+(define (POS utt)
+"(POS utt)                                
+Apply part of speech tagging (and possible parsing too) to Word
+relation."
+  (let ((rval (apply_method 'POS_Method utt)))
+    (cond
+     (rval rval) ;; new style
+     (t
+      (Classic_POS utt)))))
+
+
+(provide 'pos)

pretrained_models/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 (jyamagis@inf.ed.ac.uk)    ;;
+;;                 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)

pretrained_models/CosyVoice-ttsfrd/resource/festival/radio_phones.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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  A definition of the radio phone set used in the BU RADIO FM
+;;;  corpus, some people call this the darpa set.  This one
+;;;  has the closures removed
+;;;
+
+(defPhoneSet
+  radio
+  ;;;  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 !!!
+   (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  -   a   0   0   0   s   a   +) ;; ??
+   (eh  +   s   2   1   -   0   0   0) ;; get
+   (el  +   s   0   0   0   l   a   +)
+   (em  +   s   0   0   0   n   l   +)
+   (en  +   s   0   0   0   n   a   +)
+   (er  +   a   2   2   -   r   0   0) ;; always followed by r (er-r == axr)
+   (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   -)
+   (hv  -   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   +)
+   (nx  -   0   0   0   0   n   d   +) ;; ???
+   (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   +)
+   (pau -   0   0   0   0   0   0   -)
+   (h#  -   0   0   0   0   0   0   -)
+   (brth -   0   0   0   0   0   0   -)
+  )
+)
+
+(PhoneSet.silences '(pau h# brth))
+
+(provide 'radio_phones)
+
+
+  
+

pretrained_models/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?
+
+-->

pretrained_models/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)

pretrained_models/CosyVoice-ttsfrd/resource/festival/scfg.scm

@@ -0,0 +1,62 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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 functions for manipulating a SCFG parse tree
+
+(require_module 'parser)
+
+(define (scfg_simplify tree)
+  "(scfg_brackets_only tree)
+Output only the bracketing and the bottom level pos and words."
+  (cond
+   ((not tree) nil)
+   ((car (cdr (assoc 'pos (car (cdr (car tree))))))
+    ;; terminal node
+    (list
+     (car (cdr (assoc 'pos (car (cdr (car tree))))))
+     (car (car tree))))
+   (t
+    (cons
+     (car (car tree))
+     (mapcar scfg_simplify (cdr tree))))))
+
+(define (scfg_simplify_relation_tree trees)
+  (mapcar scfg_simplify trees))
+
+(defvar scfg_eos_tree eou_tree
+  "scfg_eos_tree
+In MultiProbParse this CART tree is used to define end of sentence
+within an utterance.  It is applied to the token relation.  
+By default it is set to eou_tree.")
+       
+(provide 'scfg)

pretrained_models/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)

pretrained_models/CosyVoice-ttsfrd/resource/festival/singing-mode.scm

@@ -0,0 +1,673 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Festival Singing Mode
+;;;
+;;; Written by Dominic Mazzoni
+;;; Carnegie Mellon University
+;;; 11-752 - "Speech: Phonetics, Prosody, Perception and Synthesis"
+;;; Spring 2001
+;;;
+;;; Extended by Milan Zamazal <pdm@brailcom.org>, 2006:
+;;; - Slur support.
+;;; - Czech support.
+;;; - Some cleanup.
+;;; - Print debugging information only when singing-debug is true.
+;;;
+;;; This code is public domain; anyone may use it freely.
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(require_module 'rxp)
+
+(xml_register_id "-//SINGING//DTD SINGING mark up//EN"
+		(path-append xml_dtd_dir "Singing.v0_1.dtd")
+		)
+
+(xml_register_id "-//SINGING//ENTITIES Added Latin 1 for SINGING//EN"
+		 (path-append xml_dtd_dir  "sable-latin.ent")
+		 )
+
+;; Set this to t to enable debugging messages:
+(defvar singing-debug nil)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; XML parsing functions
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;
+;; singing_xml_targets
+;;
+;; This variable defines the actions that are to be taken when
+;; parsing each of our XML tags: SINGING, PITCH, DURATION, and REST.
+;;
+;; When we get the pitch and duration of each token, we store them
+;; in features of the token.  Later our intonation and duration
+;; functions access these features.
+;;
+
+(defvar singing_xml_elements
+  '(
+    ("(SINGING" (ATTLIST UTT)
+     (set! singing_pitch_att_list nil)
+     (set! singing_dur_att_list nil)
+     (set! singing_global_time 0.0)
+     (set! singing_bpm (get-bpm ATTLIST))
+     (set! singing_bps (/ singing_bpm 50.0)) ;; change this back to 60
+     nil)
+
+    (")SINGING" (ATTLIST UTT)
+     (xxml_synth UTT)  ;;  Synthesize the remaining tokens
+     nil)
+
+    ("(PITCH" (ATTLIST UTT)
+     (set! singing_pitch_att_list ATTLIST)
+     UTT)
+
+    (")PITCH" (ATTLIST UTT)
+     (let ((freq (get-freqs singing_pitch_att_list)))
+       (if singing-debug
+           (begin
+             (print "freqs")
+             (print freq)))
+       (singing-append-feature! UTT 'freq freq))
+     UTT)
+    
+    ("(DURATION" (ATTLIST UTT)
+     (set! singing_dur_att_list ATTLIST)
+     UTT)
+
+    (")DURATION" (ATTLIST UTT)
+     (let ((dur (get-durs singing_dur_att_list)))
+       (if singing-debug
+           (begin
+             (print "durs")
+             (print dur)))
+       (singing-append-feature! UTT 'dur dur))
+     UTT)
+    
+    ("(REST" (ATTLIST UTT)
+     (let ((dur (get-durs ATTLIST)))
+       (if singing-debug
+           (begin
+             (print "rest durs")
+             (print dur)))
+       (singing-append-feature! UTT 'rest (caar dur)))
+     UTT)
+    ))
+
+;;
+;; get-bpm
+;;
+;; Given the attribute list of a SINGING tag, returns the beats
+;; per minute of the song from the BPM parameter.
+;;
+
+(define (get-bpm atts)
+  (parse-number (car (car (cdr (assoc 'BPM atts))))))
+
+;;
+;; get-durs
+;;
+;; Given the attribute list of a DURATION tag, returns a list of
+;; durations in seconds for the syllables of the word enclosed by
+;; this tag.
+;;
+;; It first looks for a BEATS parameter, and converts these to
+;; seconds using BPM, which was set in the SINGING tag.  If this
+;; is not present, it looks for the SECONDS parameter.
+;;
+
+(define (get-durs atts)
+  (let ((seconds (car (car (cdr (assoc 'SECONDS atts)))))
+        (beats (car (car (cdr (assoc 'BEATS atts))))))
+    (if (equal? beats 'X)
+        (mapcar (lambda (lst) (mapcar parse-number lst))
+                (string->list seconds))
+        (mapcar (lambda (lst)
+                  (mapcar (lambda (x) (/ (parse-number x) singing_bps)) lst))
+                (string->list beats)))))
+
+;;
+;; get-freqs
+;;
+;; Given the attribute list of a PITCH tag, returns a list of
+;; frequencies in Hertz for the syllables of the word enclosed by
+;; this tag.
+;;
+;; It first looks for a NOTE parameter, which can contain a MIDI
+;; note of the form "C4", "D#3", or "Ab6", and if this is not
+;; present it looks for the FREQ parameter.
+;;
+
+(define (get-freqs atts)
+  (let ((freqs (car (car (cdr (assoc 'FREQ atts)))))
+        (notes (car (car (cdr (assoc 'NOTE atts))))))
+    (if (equal? notes 'X)
+        (mapcar (lambda (lst) (mapcar parse-number lst))
+                (string->list freqs))
+        (mapcar (lambda (lst) (mapcar note->freq lst))
+                (string->list notes)))))
+
+;;
+;; note->freq
+;;
+;; Converts a string representing a MIDI note such as "C4" and
+;; turns it into a frequency.  We use the convention that
+;; A5=440 (some call this note A3).
+;;
+
+(define (note->freq note)
+  (if singing-debug
+      (format t "note is %l\n" note))
+  (set! note (format nil "%s" note))
+  (if singing-debug
+      (print_string note))
+  (let (l octave notename midinote thefreq)
+    (set! l (string-length note))
+    (set! octave (substring note (- l 1) 1))
+    (set! notename (substring note 0 (- l 1)))
+    (set! midinote (+ (* 12 (parse-number octave))
+                      (notename->midioffset notename)))
+    (set! thefreq (midinote->freq midinote))
+    (if singing-debug
+        (format t "note %s freq %f\n" note thefreq))
+    thefreq))
+
+;;
+;; midinote->freq
+;;
+;; Converts a MIDI note number (1 - 127) into a frequency.  We use
+;; the convention that 69 = "A5" =440 Hz.
+;;
+
+(define (midinote->freq midinote)
+  (* 440.0 (pow 2.0 (/ (- midinote 69) 12))))
+
+;;
+;; notename->midioffset
+;;
+;; Utility function that looks up the name of a note like "F#" and
+;; returns its offset from C.
+;;
+
+(define (notename->midioffset notename)
+  (parse-number (car (cdr (assoc_string notename note_names)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Pitch modification functions
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;
+;; singing_f0_targets
+;;
+;; This function replaces the normal intonation function used in
+;; festival.  For each syllable, it extracts the frequency that
+;; was calculated from the XML tags and stored in the token this
+;; syllable comes from, and sets this frequency as both the start
+;; and end f0 target.  Really straightforward!
+;;
+
+(defvar singing-last-f0 nil)
+(define (singing_f0_targets utt syl)
+  "(singing_f0_targets utt syl)"
+  (let ((start (item.feat syl 'syllable_start))
+        (end (item.feat syl 'syllable_end))
+        (freqs (mapcar parse-number (syl->freq syl)))
+        (durs (syl->durations syl)))
+    (let ((total-durs (apply + durs))
+          (total-time (- end start))
+          (time start)
+          (prev-segment (item.prev (item.relation (item.daughter1 (item.relation syl 'SylStructure)) 'Segment)))
+          (last-f0 singing-last-f0))
+      (if freqs
+          (begin
+            (set! singing-last-f0 (car (last freqs)))
+            (append (if (and last-f0
+                             prev-segment
+                             (item.prev prev-segment)
+                             (string-equal (item.feat prev-segment 'name)
+                                           (car (car (cdr (car (PhoneSet.description '(silences))))))))
+                        (let ((s (item.feat prev-segment "p.end"))
+                              (e (item.feat prev-segment "end")))
+                          (list (list (+ s (* (- e s) 0.8)) last-f0)
+                                (list (+ s (* (- e s) 0.9)) (car freqs)))))
+                    (apply append
+                           (mapcar (lambda (d f)
+                                     (let ((range (* (/ d total-durs) total-time))
+                                           (old-time time))
+                                       (set! time (+ time range))
+                                       (let ((range-fraction (* 0.1 range)))
+                                         (list (list (+ old-time range-fraction) f)
+                                               (list (- time range-fraction) f)))))
+                                   durs freqs))))))))
+
+;;
+;; syl->freq
+;;
+;; Given a syllable, looks up the frequency in its token.  The token
+;; stores a list of all of the frequencies associated with its
+;; syllables, so this syllable grabs the frequency out of the list
+;; corresponding to its index within the word.  (This assumes that
+;; a frequency was given for each syllable, and that a token
+;; corresponds directly to a word.  Singing-mode is not guaranteed
+;; to work at all if either of these things are not true.)
+;;
+
+(define (syl->freq syl)
+  (let ((index (item.feat syl "R:Syllable.pos_in_word"))
+        (freqs (singing-feat syl "R:SylStructure.parent.R:Token.parent.freq")))
+    (nth index freqs)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Duration modification functions
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;
+;; singing_duration_method 
+;;
+;; Calculates the duration of each phone in the utterance, in three
+;; passes.  Consult the three functions it calls, below, to see what
+;; each one does.
+;;
+
+(define (singing_duration_method utt)
+  (mapcar singing_adjcons_syllable (utt.relation.items utt 'Syllable))
+  (singing_do_initial utt (car (utt.relation.items utt 'Token)))
+  (mapcar singing_do_syllable (utt.relation.items utt 'Syllable))
+  (mapcar singing_fix_segment (utt.relation.items utt 'Segment))
+  utt)
+
+;;
+;; singing_adjcons_syllable
+;;
+;; First pass.  Looks at the first phone of each syllable and
+;; adjusts the starting time of this syllable such that the
+;; perceived start time of the first phone is at the beginning
+;; of the originally intended start time of the syllable.
+;;
+;; If this is not done, telling it to say the word "ta" at time
+;; 2.0 actually doesn't "sound" like it says the "t" sound until
+;; about 2.1 seconds.
+;;
+;; This function has a little bit of duplicated code from
+;; singing_do_syllable, below - it could be modularized a little
+;; better.
+;;
+
+(define (singing_adjcons_syllable syl)
+  (let ((totlen (apply + (mapcar (lambda (s)
+                                   (get_avg_duration (item.feat s "name")))
+                                 (item.leafs
+                                  (item.relation syl 'SylStructure)))))
+        (syldur (apply + (syl->durations syl)))
+        ;; figure out the offset of the first phone
+        (phone1 (item.daughter1 (item.relation syl 'SylStructure)))
+        (prevsyl (item.prev (item.relation syl 'Syllable))))
+    (let ((offset (get_duration_offset (item.feat phone1 "name"))))
+      (if singing-debug
+          (format t "offset: %f\n" offset) )
+      (if (< syldur totlen)
+          (set! offset (* offset (/ syldur totlen))))
+      (if singing-debug
+          (format t "Want to adjust syl by %f\n" offset))
+      (if prevsyl
+          (begin
+            (item.set_feat prevsyl 'subtractoffset offset)
+            (item.set_feat syl 'addoffset offset))))))
+
+;;
+;; singing_do_syllable
+;;
+;; Second pass.  For each syllable, adds up the amount of time
+;; that would normally be spent in consonants and vowels, based
+;; on the average durations of these phones.  Then, if the
+;; intended length of this syllable is longer than this total,
+;; stretch only the vowels; otherwise shrink all phones
+;; proportionally.  This function actually sets the "end" time
+;; of each phone using a global "singing_global_time" variable.
+;;
+;; We also handle rests at this point, which are tagged onto the
+;; end of the previous token.
+;;
+
+(defvar singing-max-short-vowel-length 0.11)
+
+(define (singing_do_initial utt token)
+  (if (equal? (item.name token) "")
+      (let ((restlen (car (item.feat token 'rest))))
+        (if singing-debug
+            (format t "restlen %l\n" restlen))
+        (if (> restlen 0)
+            (let ((silence (car (car (cdr (assoc 'silences (PhoneSet.description)))))))
+              (set! singing_global_time restlen)
+              (item.relation.insert (utt.relation.first utt 'Segment) 'Segment
+                                    (list silence (list (list "end" singing_global_time)))
+                                    'before))))))
+
+(define (singing_do_syllable syl)
+  (let ((conslen 0.0)
+        (vowlen 0.0)
+        (segments (item.leafs (item.relation syl 'SylStructure))))
+    ;; if there are no vowels, turn a middle consonant into a vowel;
+    ;; hopefully this works well for languages where syllables may be
+    ;; created by some consonants too
+    (let ((segments* segments)
+          (vowel-found nil))
+      (while (and segments* (not vowel-found))
+        (if (equal? "+" (item.feat (car segments*) "ph_vc"))
+            (set! vowel-found t)
+            (set! segments* (cdr segments*))))
+      (if (not vowel-found)
+          (item.set_feat (nth (nint (/ (- (length segments) 1) 2))
+                              segments)
+                         "singing-vc" "+")))
+    ;; sum up the length of all of the vowels and consonants in
+    ;; this syllable
+    (mapcar (lambda (s)
+              (let ((slen (get_avg_duration (item.feat s "name"))))
+                (if (or (equal? "+" (item.feat s "ph_vc"))
+                        (equal? "+" (item.feat s "singing-vc")))
+                    (set! vowlen (+ vowlen slen))
+                    (set! conslen (+ conslen slen)))))
+            segments)
+    (let ((totlen (+ conslen vowlen))
+          (syldur (apply + (syl->durations syl)))
+          (addoffset (item.feat syl 'addoffset))
+          (subtractoffset (item.feat syl 'subtractoffset))
+          offset)
+      (set! offset (- subtractoffset addoffset))
+      (if singing-debug
+          (format t "Vowlen: %f conslen: %f totlen: %f\n" vowlen conslen totlen))
+      (if (< offset (/ syldur 2.0))
+	  (begin
+            (set! syldur (- syldur offset))
+            (if singing-debug
+                (format t "Offset: %f\n" offset))))
+      (if singing-debug
+          (format t "Syldur: %f\n" syldur))
+      (if (> totlen syldur)
+	  ;; if the total length of the average durations in the syllable is
+	  ;; greater than the total desired duration of the syllable, stretch
+	  ;; the time proportionally for each phone
+	  (let ((stretch (/ syldur totlen)))
+            (mapcar (lambda (s)
+                      (let ((slen (* stretch (get_avg_duration (item.feat s "name")))))
+                        (set! singing_global_time (+ slen singing_global_time))
+                        (item.set_feat s 'end singing_global_time)))
+                    (item.leafs (item.relation syl 'SylStructure))))
+	  ;; otherwise, stretch the vowels and not the consonants
+	  (let ((voweltime (- syldur conslen)))
+            (let ((vowelstretch (/ voweltime vowlen))
+                  (phones (mapcar car (car (cdar (PhoneSet.description '(phones)))))))
+              (mapcar (lambda (s)
+                        (let ((slen (get_avg_duration (item.feat s "name"))))
+                          (if (or (equal? "+" (item.feat s "ph_vc"))
+                                  (equal? "+" (item.feat s "singing-vc")))
+                              (begin
+                                (set! slen (* vowelstretch slen))
+                                ;; If the sound is long enough, better results
+                                ;; may be achieved by using longer versions of
+                                ;; the vowels.
+                                (if (> slen singing-max-short-vowel-length)
+                                    (let ((sname (string-append (item.feat s "name") ":")))
+                                      (if (member_string sname phones)
+                                          (item.set_feat s "name" sname))))))
+                          (set! singing_global_time (+ slen singing_global_time))
+                          (item.set_feat s 'end singing_global_time)))
+                      segments))))))
+  (let ((restlen (car (syl->rest syl))))
+    (if singing-debug
+        (format t "restlen %l\n" restlen))
+    (if (> restlen 0)
+        (let ((lastseg (item.daughtern (item.relation syl 'SylStructure)))
+              (silence (car (car (cdr (assoc 'silences (PhoneSet.description))))))
+              (singing_global_time* singing_global_time))
+          (let ((seg (item.relation lastseg 'Segment))
+                (extra-pause-length 0.00001))
+            (set! singing_global_time (+ restlen singing_global_time))
+            (item.insert seg (list silence (list (list "end" singing_global_time))) 'after)
+            ;; insert a very short extra pause to avoid after-effects, especially
+            ;; after vowels
+            (if (and seg
+                     (equal? (item.feat seg "ph_vc") "+")
+                     (< extra-pause-length restlen))
+                (item.insert seg (list silence (list (list "end" (+ singing_global_time*
+                                                                extra-pause-length))))
+                             'after)))))))
+
+;;
+;; singing_fix_segment
+;;
+;; Third pass.  Finds any segments (phones) that we didn't catch earlier
+;; (say if they didn't belong to a syllable, like silence) and sets them
+;; to zero duration
+;;
+
+(define (singing_fix_segment seg)
+  (if (equal? 0.0 (item.feat seg 'end))
+      (if (equal? nil (item.prev seg))
+          (item.set_feat seg 'end 0.0)
+          (item.set_feat seg 'end (item.feat (item.prev seg) 'end)))
+      (if singing-debug
+          (format t "segment: %s end: %f\n" (item.name seg) (item.feat seg 'end)))))
+  
+;; returns the duration of a syllable (stored in its token)
+(define (syl->durations syl)
+  (let ((index (item.feat syl "R:Syllable.pos_in_word"))
+        (durs (singing-feat syl "R:SylStructure.parent.R:Token.parent.dur")))
+    (mapcar parse-number (nth index durs))))
+
+;; returns the duration of the rest following a syllable
+(define (syl->rest syl)
+  (let ((index (item.feat syl "R:Syllable.pos_in_word"))
+        (durs (singing-feat syl "R:SylStructure.parent.R:Token.parent.dur"))
+        (pauselen (singing-feat syl "R:SylStructure.parent.R:Token.parent.rest")))
+    (if (equal? index (- (length durs) 1))
+        (list (or pauselen 0.0))
+        (list 0.0))))
+
+;; get the average duration of a phone
+(define (get_avg_duration phone)
+  (let ((pd (assoc_string phone phoneme_durations)))
+    (if pd
+	(car (cdr pd))
+	0.08)))
+
+;; get the duration offset of a phone (see the description above)
+(define (get_duration_offset phone)
+  (parse-number (car (cdr (assoc_string phone phoneme_offsets*)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Other utility functions
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (char-quote string)
+  (if (member string '("*" "+" "?" "[" "]" "."))
+      (string-append "[" string "]")
+      string))
+
+(define (split-string string separator)
+  (if (string-matches string (string-append ".+" (char-quote separator) ".+"))
+      (cons (string-before string separator)
+            (split-string (string-after string separator) separator))
+      ;; We have to convert the weird XML attribute value type to string
+      (list (string-append string ""))))
+
+(define (string->list string)
+  (mapcar (lambda (s) (split-string s "+")) (split-string string ",")))
+
+(define (singing-append-feature! utt feature value)
+  (let ((tokens (utt.relation.items utt 'Token)))
+    (if tokens
+        ;; we have to wrap value into a list to work around a Festival bug
+        (item.set_feat (car (last tokens)) feature (list value))
+        (begin
+          (utt.relation.append utt 'Token '("" ((name "") (whitespace "")
+                                                (prepunctuation "") (punc ""))))
+          (item.set_feat (car (last (utt.relation.items utt 'Token))) feature (list value))))))
+
+(define (singing-feat item feature)
+  (let ((value (item.feat item feature)))
+    (if (equal? value 0)
+        nil
+        (car value))))
+
+(define (current-language)
+  (cadr (car (assoc 'language (voice.description current-voice)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Initializing and exiting singing mode
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;
+;; singing_init_func
+;;
+
+(defvar singing_previous_eou_tree nil)
+
+(define (singing_init_func)
+  "(singing_init_func) - Initialization for Singing mode"
+  (if (not (symbol-bound? 'phoneme_durations))
+      (set! phoneme_durations '()))
+  ;; use our intonation function
+  (Parameter.set 'Int_Method 'General)
+  (Parameter.set 'Int_Target_Method Int_Targets_General)
+  (set! int_general_params `((targ_func ,singing_f0_targets)))
+  (set! singing-last-f0 nil)
+  ;; use our duration function
+  (Parameter.set 'Duration_Method singing_duration_method)
+  ;; set phoneme corrections for the current language
+  (let ((language 'english
+;         (cadr (assoc 'language
+;                               (cadr (voice.description current-voice))))
+         ))
+    (set! phoneme_offsets* (cdr (assoc language phoneme_offsets))))
+  ;; avoid splitting to multiple utterances with insertion of unwanted pauses
+  (set! singing_previous_eou_tree eou_tree)
+  (set! eou_tree nil)
+  ;; use our xml parsing function
+  (set! singing_previous_elements xxml_elements)
+  (set! xxml_elements singing_xml_elements))
+
+;;
+;; singing_exit_func
+;;
+
+(define (singing_exit_func)
+  "(singing_exit_func) - Exit function for Singing mode"
+  (set! eou_tree singing_previous_eou_tree)
+  (set! xxml_elements singing_previous_elements))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;
+;; Data tables
+;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar note_names
+  '((C 0)
+    (C# 1)
+    (Db 1)
+    (D 2)
+    (D# 3)
+    (Eb 3)
+    (E 4)
+    (E# 5)
+    (Fb 4)
+    (F 5)
+    (F# 6)
+    (Gb 6)
+    (G 7)
+    (G# 8)
+    (Ab 8)
+    (A 9)
+    (A# 10)
+    (Bb 10)
+    (B 11)
+    (B# 12)
+    (Cb 11)))
+
+;;
+;; The following list contains the offset into each phone that best
+;; represents the perceptual onset of the phone.  This is important
+;; to know to get durations right in singing.  For example, if the
+;; offset for "t" is .060, and you want to start a "t" sound at
+;; time 2.0 seconds, you should actually start the phone playing
+;; at time 1.940 seconds in order for it to sound like the onset of
+;; the "t" is really right at 2.0.
+;;
+;; These were derived empically by looking at and listening to the
+;; waveforms of each phone for mwm's voice.
+;;
+
+(defvar phoneme_offsets
+  `((english (t 0.050)
+             (T 0.050)
+             (d 0.090)
+             (D 0.090)
+             (p 0.080)
+             (b 0.080)
+             (k 0.090)
+             (g 0.100)
+             (9r 0.050) ;; r
+             (l 0.030)
+             (f 0.050)
+             (v 0.050)
+             (s 0.040)
+             (S 0.040)
+             (z 0.040)
+             (Z 0.040)
+             (n 0.040)
+             (N 0.040)
+             (m 0.040)
+             (j 0.090)
+             (E 0.0)
+             (> 0.0)
+             (>i 0.0)
+             (aI 0.0)
+             (& 0.0)
+             (3r 0.0)
+             (tS 0.0)
+             (oU 0.0)
+             (aU 0.0)
+             (A 0.0)
+             (ei 0.0)
+             (iU 0.0)
+             (U 0.0)
+             (@ 0.0)
+             (h 0.0)
+             (u 0.0)
+             (^ 0.0)
+             (I 0.0)
+             (dZ 0.0)
+             (i: 0.0)
+             (w 0.0)
+             (pau 0.0)
+             (brth 0.0)
+             (h# 0.0)
+             )))
+
+(defvar phoneme_offsets* nil)
+
+;;
+;; Declare the new mode to Festival
+;;
+
+(set! tts_text_modes
+      (cons `(singing   ;; mode name
+              ((init_func ,singing_init_func)
+               (exit_func ,singing_exit_func)
+               (analysis_type xml)))
+            tts_text_modes))
+
+(provide 'singing-mode)

pretrained_models/CosyVoice-ttsfrd/resource/festival/siod.scm

@@ -0,0 +1,638 @@
+
+
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;; DO NOT EDIT THIS FILE ON PAIN OF MORE PAIN.
+ ;;; 
+ ;;; The master copy of this file is in ../../speech_tools/lib/siod/siod.scm
+ ;;; and is copied here at build time.
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+
+
+
+
+
+
+
+
+
+
+;; SIOD: Scheme In One Defun                                  -*-mode: view-*-
+;;
+;; *                        COPYRIGHT (c) 1989-1992 BY                       *
+;; *        PARADIGM ASSOCIATES INCORPORATED, CAMBRIDGE, MASSACHUSETTS.      *
+;; *        See the source file SLIB.C for more information.                 *
+;;
+;; A fair amount of modifications and tidy up was done by AWB, particularly
+;;   * adding documentation strings to all functions/variable
+;;   * removing some example functions not relevant to Festival (or siod)
+;;   * addition of new functions (require provide etc)
+
+;(puts  ";; Optional Runtime Library for Release 2.8
+;")
+
+(define list 
+  (lambda n 
+"(list A0 A1 ...)
+Return list containing A0 A1 ..."
+  n))
+
+(define (caar x) 
+"(caar X)
+Return the (car (car X))."
+  (car (car x)))
+(define (cadr x) 
+"(cadr X)
+Return the (car (cdr X))."
+  (car (cdr x)))
+(define (cdar x)
+"(cdar X)
+Return the (cdr (car X))."
+ (cdr (car x)))
+(define (cddr x) 
+"(cddr X)
+Return the (cdr (cdr X))."
+ (cdr (cdr x)))
+
+(define (caddr x) 
+"(caddr X)
+Return the (car (cdr (cdr X)))."
+  (car (cdr (cdr x))))
+(define (cdddr x) 
+"(cdddr X)
+Return the (cdr (cdr (cdr X)))."
+  (cdr (cdr (cdr x))))
+
+(define consp pair?)
+
+(define (replace before after)
+"(replace BEFORE AFTER)
+Destructively replace contents of cons cell BEFORE with those of
+AFTER."
+  (set-car! before (car after))
+  (set-cdr! before (cdr after))
+  after)
+
+(define (prognify forms)
+  (if (null? (cdr forms))
+      (car forms)
+    (cons 'begin forms)))
+
+(define (defmac-macro form)
+"(defmac-macro MACRONAME FORM)
+Define a macro.  Macro expand FORM in-line."
+  (let ((sname (car (cadr form)))
+	(argl (cdr (cadr form)))
+	(fname nil)
+	(body (prognify (cddr form))))
+    (set! fname (symbolconc sname '-macro))
+    (list 'begin
+	  (list 'define (cons fname argl)
+		(list 'replace (car argl) body))
+	  (list 'define sname (list 'quote fname)))))
+
+(define defmac 'defmac-macro)
+
+(defmac (push form)
+  (list 'set! (caddr form)
+	(list 'cons (cadr form) (caddr form))))
+
+(defmac (pop form)
+  (list 'let (list (list 'tmp (cadr form)))
+	(list 'set! (cadr form) '(cdr tmp))
+	'(car tmp)))
+
+;;;  Have to set var-docstrings to nil first as defvar requires it to be set
+(set! var-docstrings nil)
+(define (add-doc-var varname docstring)
+"(add-doc-var VARNAME DOCSTRING)
+  Add document string DOCSTRING to VARNAME.  If DOCSTRING is nil
+  this has no effect.  If VARNAME already has a document string replace
+  it with DOCSTRING."
+ (if (null? docstring)
+     t
+     (let ((lpair (assq varname var-docstrings)))
+       (if lpair
+	   (set-cdr! lpair docstring)
+	   (set! var-docstrings (cons (cons varname docstring) 
+				      var-docstrings))))))
+
+(set! boundp symbol-bound?)
+
+(defmac (defvar form)
+  (begin  ;; always add the documentation string
+    (add-doc-var (cadr form) (car (cdddr form)))
+    (list 'or
+	(list 'symbol-bound? (list 'quote (cadr form)))
+	(list 'define (cadr form) (caddr form)))))
+
+(defvar var-docstrings nil
+  "var-docstrings
+  An assoc-list of variable names and their documentation strings.")
+
+(defmac (defun form)
+  (cons 'define
+	(cons (cons (cadr form) (caddr form))
+	      (cdddr form))))
+
+(defmac (setq form)
+  (let ((l (cdr form))
+	(result nil))
+    (define (loop)
+      (if l
+	  (begin (push (list 'set! (car l) (cadr l)) result)
+		 (set! l (cddr l))
+		 (loop))))
+    (loop)
+    (prognify (reverse result))))
+  
+(define progn begin)
+
+(defun atom (x)
+"(atom X)
+True if X is not a cons cells, nil otherwise."
+  (not (consp x)))
+
+(define eq eq?)
+
+(defmac (cond form)
+  (cond-convert (cdr form)))
+
+(define null null?)
+
+(defun cond-convert (l)
+  (if (null l)
+      ()
+    (if (null (cdar l))
+	(if (null (cdr l))
+	    (caar l)
+	  (let ((rest (cond-convert (cdr l))))
+	    (if (and (consp rest) (eq (car rest) 'or))
+		(cons 'or (cons (caar l) (cdr rest)))
+	      (list 'or (caar l) rest))))
+      (if (or (eq (caar l) 't)
+	      (and (consp (caar l)) (eq (car (caar l)) 'quote)))
+	  (prognify (cdar l))
+	(list 'if
+	      (caar l)
+	      (prognify (cdar l))
+	      (cond-convert (cdr l)))))))
+
+(defmac (+internal-comma form)
+  (error 'comma-not-inside-backquote))
+
+(define +internal-comma-atsign +internal-comma)
+(define +internal-comma-dot +internal-comma)
+
+(defmac (+internal-backquote form)
+  (backquotify (cdr form)))
+
+(defun backquotify (x)
+"(backquote FORM)
+Backquote function for expanding forms in macros."
+  (let (a d aa ad dqp)
+    (cond ((atom x) (list 'quote x))
+	  ((eq (car x) '+internal-comma) (cdr x))
+	  ((or (atom (car x))
+	       (not (or (eq (caar x) '+internal-comma-atsign)
+			(eq (caar x) '+internal-comma-dot))))
+	   (setq a (backquotify (car x)) d (backquotify (cdr x))
+		 ad (atom d) aa (atom a)
+		 dqp (and (not ad) (eq (car d) 'quote)))
+	   (cond ((and dqp (not (atom a)) (eq (car a) 'quote))
+		  (list 'quote (cons (cadr a) (cadr d))))
+		 ((and dqp (null (cadr d)))
+		  (list 'list a))
+		 ((and (not ad) (eq (car d) 'list))
+		  (cons 'list (cons a (cdr d))))
+		 (t (list 'cons a d))))
+	  ((eq (caar x) '+internal-comma-atsign)
+	   (list 'append (cdar x) (backquotify (cdr x))))
+	  ((eq (caar x) '+internal-comma-dot)
+	   (list 'nconc (cdar x)(backquotify (cdr x)))))))
+
+
+(defun append n
+"(append L0 L1 ...)
+Append each list to the first list in turn."
+  (appendl n))
+
+(defun appendl (l)
+  (cond ((null l) nil)
+	((null (cdr l)) (car l))
+	((null (cddr l))
+	 (append2 (car l) (cadr l)))
+	('else
+	 (append2 (car l) (appendl (cdr l))))))
+
+(defun append2 (a b)
+  (if (null a)
+      b
+      (begin
+        (let ((x (reverse a))
+              (y b))
+          (while x
+            (set! y (cons (car x) y))
+            (set! x (cdr x)))
+          y))))
+
+(defun rplacd (a b)
+"(replacd A B)
+Destructively replace the cdr of A with B."
+  (set-cdr! a b)
+  a)
+
+(defun nconc (a b)
+"(nconc A B)
+Destructively append B to A, if A is nil return B."
+  (if (null a)
+      b
+    (rplacd (last a) b)))
+
+(defun last (a)
+"(last A)
+Last (cdr) element in list A."
+  (cond ((null a) (error'null-arg-to-last))
+	((null (cdr a)) a)
+	((last (cdr a)))))
+
+(define (remove i l)
+"(remove ITEM LIST)
+(Non-destructively) remove ITEM from LIST."
+  (cond    
+   ((null l) nil)
+   ((eq? i (car l))
+    (cdr l))
+   (t
+    (cons (car l) (remove i (cdr l))))))
+
+(define (remove-duplicates l)
+"(remove-duplicates LIST)
+Remove duplicate items in LIST."
+ (cond
+  ((null l) l)
+  ((member_string (car l) (cdr l))
+   (remove-duplicates (cdr l)))
+  (t
+   (cons (car l) (remove-duplicates (cdr l))))))
+
+(define (nth n l)
+  "(nth N LIST)
+Returns nth car of LIST, 0 is car."
+  (if (< n 1)
+      (car l)
+      (nth (- n 1) (cdr l))))
+
+(define (position thing l)
+  "(position thing l)
+What position is thing in l, -1 if it doesn't exist."
+  (let ((p 0) (m l))
+    (while (and m (not (equal? thing (car m))))
+      (set! p (+ 1 p))
+      (set! m (cdr m)))
+    (if m p nil)))
+
+(define (nth_cdr n l)
+  "(nth_cdr N LIST)
+Returns nth cdr of LIST, 0 is LIST."
+  (if (< n 1)
+      l
+      (nth_cdr (- n 1) (cdr l))))
+
+(define (<= a b)
+"(<= NUM1 NUM2)
+  Returns t if NUM1 is less than or equal to NUM2, nil otherwise.  An error is
+  given is either argument is not a number."
+  (or (< a b)
+      (equal? a b)))
+
+(define (>= a b)
+"(>= NUM1 NUM2)
+  Returns t if NUM1 is greater than or equal to NUM2, nil otherwise.  
+  An error is given is either argument is not a number."
+  (or (> a b)
+      (equal? a b)))
+
+(define (approx-equal? a b diff)
+  "(approx-equal? a b diff)
+True is the difference between a b is less than diff.  This allows equality
+between floats which may have been written out and read in and hence have
+slightly different precision."
+  (< (if (> a b) (- a b) (- b a)) diff))
+
+(define (assoc_string key alist)
+  "(assoc_string key alist)
+Look up key in alist using string-equal.  This allow indexing by
+string rather than just symbols."
+  (cond
+   ((null alist) nil)
+   ((string-equal key (car (car alist))) (car alist))
+   (t (assoc_string key (cdr alist))))
+)
+
+(defvar *fasdump-hash* t)
+
+(defun fasl-open (filename mode)
+"(fasl-open FILENAME MODE)
+Open fasl FILENAME as MODE. Returns a fasl-table."
+  (list (fopen filename mode)
+	(if (or (equal? mode "rb") *fasdump-hash*)
+	    (cons-array 100))
+	;; If this is set NIL, then already hashed symbols will be
+	;; optimized, and additional ones will not.
+	0))
+
+(defun fasl-close (table)
+"(fasl-close TABLE)
+Close fasl table."
+  (fclose (car table)))
+
+(defun fasload args
+"(fasload FILENAME ARGS)
+Fast load FILENAME."
+  (let ((filename (car args))
+	(head (and (cadr args) (cons nil nil))))
+    (let ((table (fasl-open filename "rb"))
+	  (exp)
+	  (tail head))
+      (while (not (eq table (setq exp (fast-read table))))
+	(cond (head
+	       (setq exp (cons exp nil))
+	       (set-cdr! tail exp)
+	       (setq tail exp))
+	      ('else
+	       (eval exp))))
+      (fasl-close table)
+      (and head (cdr head)))))
+
+(defun fasdump (filename forms)
+"(fasdump FILENAME FORMS)
+Fast dump FORMS into FILENAME."
+  (let ((table (fasl-open filename "wb"))
+	(l forms))
+    (while l
+      (fast-print (car l) table)
+      (set! l (cdr l)))
+    (fasl-close table)))
+
+(defun compile-file (filename)
+"(compile-file FILENAME)
+Compile lisp forms in FILENAME.scm to FILENAME.bin."
+  (let ((forms (load (string-append filename ".scm") t)))
+    (puts "Saving forms
+")
+    (fasdump (string-append filename ".bin")
+	     forms)))
+
+(defvar *properties* (cons-array 100)
+  "*properties*
+Array for holding symbol property lists.")
+
+(defun get (sym key)
+"(get SYM KEY)
+Get property named KEY for SYM."
+  (cdr (assq key (href *properties* sym))))
+
+(defun putprop (sym val key)
+"(putprop SYM VAL KEY)
+Put property VAL named KEY for SYM."
+  (let ((alist (href *properties* sym)))
+    (let ((cell (assq key alist)))
+      (cond (cell
+	     (set-cdr! cell val))
+	    ('else
+	     (hset *properties* sym (cons (cons key val) alist))
+	     val)))))
+
+;;(define (mapcar1 f l1)
+;;  (and l1 (cons (f (car l1)) (mapcar1 f (cdr l1)))))
+
+;; An iterative version of the above
+(define (mapcar1 f l1)
+  (let ((l2 l1) (r nil))
+    (while l2
+      (set! r (cons (f (car l2)) r))
+      (set! l2 (cdr l2)))
+    (reverse r)))
+
+;;(define (mapcar2 f l1 l2)
+;;  (and l1 l2 (cons (f (car l1) (car l2)) (mapcar2 f (cdr l1) (cdr l2)))))
+
+;; An iterative version
+(define (mapcar2 f l1 l2)
+  (let ((a1 l1) (a2 l2) (r nil))
+    (while a1
+      (set! r (cons (f (car a1) (car a2)) r))
+      (set! a1 (cdr a1))
+      (set! a2 (cdr a2)))
+    (reverse r)))
+
+(define (mapcar . args)
+"(mapcar FUNCTION ARGS [ARGS2])
+Apply FUNCTION to each member of ARGS (and [ARGS2]), returning list of
+return values."
+  (cond ((null args)
+	 (error "too few arguments"))
+	((null (cdr args))
+	 (error "too few arguments"))
+	((null (cdr (cdr args)))
+	 (mapcar1 (car args) (car (cdr args))))
+	((null (cdr (cdr (cdr args))))
+	 (mapcar2 (car args) (car (cdr args)) (car (cdr (cdr args)))))
+	('else
+	 (error "two many arguments"))))
+
+;; will be set automatically on start-up
+(defvar libdir '<automatically_set>
+  "libdir
+  The pathname of the run-time libary directory.  Note reseting is 
+  almost definitely not what you want to do.   This value is automatically
+  set at start up from the value specifed at compile-time or the value
+  specifed with --libdir on the command line.  A number of other variables
+  depend on this value.")
+
+(defvar load-path (list libdir)
+  "load-path
+  A list of directories containing .scm files.  Used for various functions
+  such as load_library and require.  Follows the same use as EMACS.  By
+  default it is set up to the compile-time library directory but may be 
+  changed by the user at run time, by adding a user's own library directory
+  or even replacing all of the standard library. [see Site initialization]")
+
+;; will be set automatically on start-up
+(defvar *ostype* 'unknown
+  "*ostype*
+  Contains the name of the operating system type that Festival is running
+  on, e.g. SunOS5, FreeBSD, linux etc.  The value is taken from the Makefile
+  variable OSTYPE at compile time.")
+
+(defvar etc-path (path-append libdir "etc/" *ostype*)
+  "etc-path
+  A list of directories where binaries specific to Festival may be located.
+  This variable is automatically set to LIBDIR/etc/OSTYPE/
+  and that path is added to the end of the UNIX PATH environment variable.")
+
+(define (library_expand_filename fname)
+"(library_expand_filename FILENAME)
+  Search for filename by appending FILENAME to each member of load-path.
+  Full expanded pathname is returned.  If not found in load-path FILENAME
+  is returned."
+  (let ((p load-path)
+	(found nil))
+    (while (and p (null? found))
+      (let ((pot-file (path-append (car p) fname)))
+	(if (probe_file pot-file)
+	    (setq found pot-file))
+	(setq p (cdr p))))
+    (if (null? found)
+	fname
+      found)))
+
+(define (load_library fname)
+"(load_library FILENAME)
+  Load file from library, appends FILENAME to each path in load-path
+  until a valid file is found. If none found loads name itself"
+  (load (library_expand_filename fname)))
+
+(define (fasload_library fname)
+"(fasload_library FILENAME)
+  Load binary file from library"
+  (fasload (library_expand_filename fname)))
+
+(define (member item list)
+"(member ITEM LIST)
+  Returns subset of LIST whose car is ITEM if it exists, nil otherwise."
+  (if (consp list)
+      (if (equal? item (car list))
+	  list
+	(member item (cdr list)))
+    nil))
+
+(define (member_string item list)
+"(member_string STRING LIST)
+  Returns subset of LIST whose car is STRING if it exists, nil otherwise."
+  (if (consp list)
+      (if (string-equal item (car list))
+	  list
+	(member_string item (cdr list)))
+    nil))
+
+(defvar provided nil
+  "provided
+  List of file names (omitting .scm) that have been provided.  This list
+  is checked by the require function to find out if a file needs to be 
+  loaded.  If that file is already in this list it is not loaded.  Typically
+  a file will have (provide 'MYNAME) at its end so that a call to 
+  (require 'MYNAME) will only load MYNAME.scm once.")
+
+(define (require fname)
+"(require FILENAME)
+  Checks if FNAME is already provided (member of variable provided) if not 
+  loads it, appending \".scm\" to FILENAME.  Uses load_library to find 
+  the file."
+ (let ((bname (intern (basename fname))))
+  (if (null? (member bname provided))
+      (progn 
+        ;;; Compiled files aren't faster, so we don't do this
+	; (fasload_library (string-append fname ".bin"))
+       (load_library (string-append fname ".scm"))
+	't)
+    nil)))
+
+(define (request fname)
+"(request FILENAME)
+  Checks if FNAME is already provided (member of variable provided) if not 
+  tries to loads it, appending \".scm\" to FILENAME.  Uses load_library 
+  to find the file. Unlike require, fname isn't found no error occurs"
+ (unwind-protect (require fname)))
+
+(define (provide fname)
+"(provide FILENAME)
+  Adds FNAME to the variable provided (if not already there).  This means
+  that future calls to (require FILENAME) will not cause FILENAME to
+  be re-loaded."
+  (if (null? (member fname provided))
+      (set! provided (cons fname provided))))
+
+(define (apply_hooks hooks obj)
+"(apply_hooks HOOK OBJ)
+  Apply HOOK(s) to OBJ.  HOOK is a function or list of functions that
+  take one argument."
+(cond
+ ((null? hooks) obj)
+ ((consp hooks) 
+  (apply_hooks (cdr hooks) ((car hooks) obj)))
+ (t (hooks obj))))
+
+(define (apply func args)
+"(apply FUNC ARGS)
+Call FUNC with ARGS as arguments."
+  (eval
+   (cons func
+	 (mapcar (lambda (a) (list 'quote a)) args))))
+
+(defmac (autoload form)
+"(autoload FUNCTION FILENAME DOCSTRING)
+Define FUNCTION that when called automatically loads FILENAME
+and calls FUNCTION (assumed to be defined in FILENAME)."
+  (list 'define
+	(cadr form)
+	(list 
+	 'lambda
+	 'n
+	 (list 'let (list (list 'me  (cadr form)))
+	       (list 'require (car (cdr (cdr form))))
+	       (list 'if (list 'eq 'me (cadr form))
+		     (list 'error
+			   (list 'string-append 
+				 "autoload: \""
+				 (car (cdr (cdr form)))
+				 ".scm\" does not define "
+				 (list 'quote (cadr form)))))
+	      
+	       (list 'apply (cadr form) 'n)))))
+
+(define (:backtrace frame)
+"(:backtrace [FRAME])
+This function called *immediately* after an error will display a backtrace
+of the functions evaluated before the error.  With no arguments it
+lists all stack frames, with the (possibly shortened) forms that were
+evaluated at that level.  With a numeric argument it displays
+the form at that level in full.  This function only works at
+top level in the read-eval-print loop (command interpreter).  Note
+that any valid command will leave the backtrace stack empty. Also
+note that backtrace itself does not reset the backtrace, unless you
+make an error in calling it."
+
+"The function is interpreted specially by the read-eval-interpreter
+and hence has no body, its actual body is defined in 
+src/arch/siod-3.0/slib.cc."
+)
+
+(defvar hush_startup nil
+  "hush_startup
+  If set to non-nil, the copyright banner is not displayed at start up.")
+
+(defvar editline_histsize 256
+  "editline_histsize
+  The number of lines to be saved in the users history file when a 
+  Festival session ends.  The histfile is \".festival_history\" in the
+  users home directory.  Note this value is only checked when the 
+  command interpreter is started, hence this should be set in a user's
+  \".festivalrc\" or system init file.  Reseting it at the command
+  interpreter will have no effect.")
+
+(defvar editline_no_echo (getenv "EMACS")
+  "editline_no_echo
+  When running under Emacs as an inferior process, we don't want to 
+  echo the content of the line, only the prompt.")
+
+(defvar ! nil
+  "!
+  In interactive mode, this variable's value is the return value of the
+  previously evaluated expression.")
+
+(provide 'siod)

pretrained_models/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)
+
+
+
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/soleml-mode.scm

@@ -0,0 +1,336 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Support for an SGML based mark-up language used in the SOLE
+;;;  project.  This is all still experimental.
+;;;
+;;;  This currently treats one file as one utterance (to make dealing with
+;;;  the SOLE museaum database easy
+
+(set! soleml_word_features_stack nil)
+(defvar sole_current_node nil)
+
+(define (soleml_token_to_words utt token name)
+  "(soleml_token_to_words utt token name)
+SOLEML mode token specific analysis."
+  (cond
+
+   (t
+    (soleml_previous_token_to_words utt token name))))
+
+(define (voice_soleml)
+"(soleml_voice)
+Speaker specific initialisation for SOLE museum data."
+  (voice_rab_diphone)
+  ;; Utterances only come at end of file
+  (set! eou_tree '((0)))
+)
+
+(defvar soleml_elements
+'(
+  ("(SOLEML" (ATTLIST UTT)
+    ;; required to identify type 
+    (voice_soleml)  ;; so we know what state we start in
+    (set! soleml_utt (Utterance Tokens nil))
+    (utt.stream.create soleml_utt 'Token)
+    (utt.relation.create soleml_utt 'SOLEML)
+    (set! sole_current_node 
+	  (utt.relation_append soleml_utt 'SOLEML (cons "sole-ml" ATTLIST)))
+    soleml_utt
+  )
+  (")SOLEML" (ATTLIST UTT)
+    ;; required to identify end token
+    ;; Don't really want to synthesize this
+    ;; (xxml_synth UTT)  ;;  Synthesis the remaining tokens
+    (set! soleml_utt UTT)	     
+    UTT
+  )
+  ;; Utterance break elements
+  ("(LANGUAGE" (ATTLIST UTT)
+   ;; Select a new language
+   (select_language (car (xxml_attval "NAME" ATTLIST)))
+   UTT)
+  ("(VOICE" (ATTLIST UTT)
+   ;;(xxml_synth UTT)
+   ;; Select a new voice
+   (cond
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male1)
+     (voice_soleml_diphone))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male2)
+     (voice_soleml_diphone))
+    ((equal? (car (xxml_attval "NAME" ATTLIST)) 'male3)
+     (voice_soleml_diphone))
+    (t
+     (print "SOLEML: selecting unknown voice")
+     (voice_soleml_diphone)))
+   UTT)
+  ;; phrase-boundary  // mark on token (??)
+  ;; punct-elem     // mark on token
+  ;; sem-elem
+  ;; text-elem      // ignore
+  ;; rhet-elem  has nucleus and satellite
+  ;; anaphora-elem
+  ;; syn-elem
+  ;; info-struct-elem
+  ;; other-elem
+  ("(PUNCT-ELEM" (ATTLIST UTT) 
+   (soleml_push_word_features)
+   (set! xxml_word_features
+	  (cons (list "punct-elem" "1")
+		(soleml_conv_attlist ATTLIST)))
+   UTT)
+  (")PUNCT-ELEM" (ATTLIST UTT) 
+   (set! xxml_word_features (soleml_pop_word_features))
+   UTT)
+  ("(PHRASE-BOUNDARY" (ATTLIST UTT)
+   (if (string-equal "4" (car (xxml_attval "STRENGTH" ATTLIST)))
+       (begin
+;;	 (xxml_synth UTT)
+	 UTT)
+       (let ((last_token (car (last (utt.stream UTT 'Token)))))
+	 (if last_token
+	     (item.set_feat last_token "pbreak" "B"))
+	 UTT)))
+  ;; For each recursive element simply build a new node
+  ("(RHET-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'rhet-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")RHET-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(RHET-EMPH" (ATTLIST UTT)
+   (let ((sdesc (list 'rhet-emph (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")RHET-EMPH" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(ANAPHORA-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'anaphora-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")ANAPHORA-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(SYN-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'syn-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")SYN-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(CONNECTIVE" (ATTLIST UTT)
+   (let ((sdesc (list 'connective (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")CONNECTIVE" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(TEXT-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'text-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")TEXT-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(SEM-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'sem-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")SEM-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(INFO-STRUCT-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'info-struct-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")INFO-STRUCT-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(OTHER-ELEM" (ATTLIST UTT)
+   (let ((sdesc (list 'other-elem (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")OTHER-ELEM" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(NUCLEUS" (ATTLIST UTT)
+   (let ((sdesc (list 'nucleus (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")NUCLEUS" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ("(SATELLITE" (ATTLIST UTT)
+   (let ((sdesc (list 'satellite (soleml_conv_attlist ATTLIST))))
+     (set! sole_current_node
+	   (node.append_daughter sole_current_node sdesc))
+     UTT))
+  (")SATELLITE" (ATTLIST UTT)
+    (set! sole_current_node (node.parent sole_current_node))
+    UTT)
+  ;; Other control functions (probably not used in SOLE)  
+  ("(CALL" (ATTLIST UTT)
+;;   (xxml_synth UTT)
+   (if (string-matches (car (xxml_attval "ENGID" ATTLIST)) "festival.*")
+       (let ((comstr ""))
+	 (mapcar
+	  (lambda (c) (set! comstr (string-append comstr " " c)))
+	  (xxml_attval "COMMAND" ATTLIST))
+	 (eval (read-from-string comstr))))
+   UTT)
+  ("(DEFINE" (ATTLIST UTT)
+;;    (xxml_synth UTT)
+    (if (not (string-equal "NATIVE" (car (xxml_attval "SCHEME" ATTLIST))))
+	(format t "DEFINE: unsupported SCHEME %s, definition ignored\n"
+		(car (xxml_attval "SCHEME" ATTLIST)))
+	(lex.add.entry
+	 (list
+	  (car (xxml_attval "WORDS" ATTLIST))   ;; head form
+	  nil          ;; pos
+	  (lex.syllabify.phstress (xxml_attval "PRONS" ATTLIST)))))
+    UTT)
+  ("(SOUND" (ATTLIST UTT)
+;;   (xxml_synth UTT)
+   (if (not soleml_omitted_mode)
+       (apply_hooks tts_hooks
+		    (eval (list 'Utterance 'Wave 
+				(car (xxml_attval "SRC" ATTLIST))))))
+   UTT)
+  ("(EMPH" (ATTLIST UTT)
+   ;; 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
+   (soleml_push_word_features)
+   (set! xxml_word_features 
+	 (cons (list "EMPH" "1") xxml_word_features))
+   UTT)
+  (")EMPH" (ATTLIST UTT)
+   (set! xxml_word_features (soleml_pop_word_features))
+   UTT)
+  ("(WORD" (ATTLIST UTT)
+   ;; a word in-line
+   (let ((name   (xxml_attval "NAME" ATTLIST))
+	 (pos    (xxml_attval "POS" ATTLIST))
+	 (accent (xxml_attval "ACCENT" ATTLIST))
+	 (tone   (xxml_attval "TONE" ATTLIST))
+	 (phonemes (xxml_attval "PHONEMES" ATTLIST))
+	 token)
+     (utt.item.insert UTT 'Token)  ;; add new Token
+     (set! token (utt.stream.tail UTT 'Token))
+     (item.set_name token (car name))
+     (if pos (item.set_feat token "pos" (car pos)))
+     (if accent (item.set_feat token "accent" (car accent)))
+     (if tone (item.set_feat token "tone" (car tone)))
+     (if phonemes (item.set_feat token "phonemes" 
+				       (format nil "%l" phonemes)))
+     UTT))
+))
+
+(define (soleml_init_func)
+  "(soleml_init_func)
+Initialisation for SOLEML mode"
+  (voice_soleml)
+  (set! soleml_previous_elements xxml_elements)
+  (set! xxml_elements soleml_elements)
+  (set! xxml_token_hooks soleml_token_function)
+  (set! soleml_previous_token_to_words english_token_to_words)
+  (set! english_token_to_words soleml_token_to_words)
+  (set! token_to_words soleml_token_to_words))
+
+(define (soleml_exit_func)
+  "(soleml_exit_func)
+Exit function for SOLEML mode"
+  (set! xxml_elements soleml_previous_elements)
+  (set! token_to_words soleml_previous_token_to_words)
+  (set! english_token_to_words soleml_previous_token_to_words))
+
+(define (soleml_token_function si)
+"(soleml_token_function si)
+This is called for each token found."
+  (node.append_daughter sole_current_node si))
+
+(define (soleml_push_word_features)
+"(soleml_push_word_features)
+Save current word features on stack."
+  (set! soleml_word_features_stack 
+	(cons xxml_word_features soleml_word_features_stack)))
+
+(define (soleml_pop_word_features)
+"(soleml_pop_word_features)
+Pop word features from stack."
+  (let ((r (car soleml_word_features_stack)))
+    (set! soleml_word_features_stack (cdr soleml_word_features_stack))
+    r))
+
+(define (soleml_conv_attlist alist)
+"(soleml_conv_attlist alist)
+Flatten alist arguments."
+  (cond
+   ((null alist) nil)
+   ((null (car (cdr (car alist))))
+     (soleml_conv_attlist (cdr alist)))
+   ((equal? (length (car (cdr (car alist)))) 1)
+    (cons
+     (list (car (car alist)) (car (car (cdr (car alist)))))
+     (soleml_conv_attlist (cdr alist))))
+   (t
+    (cons
+     (list (car (car alist)) (format nil "%l" (car (cdr (car alist)))))
+     (soleml_conv_attlist (cdr alist))))))
+
+(set! tts_text_modes
+   (cons
+    (list
+      'soleml   ;; mode name
+      (list         ;; email mode params
+       (list 'init_func soleml_init_func)
+       (list 'exit_func soleml_exit_func)
+       '(analysis_type xxml)
+       (list 'filter 
+	     (format nil "%s -D %s " sgml_parse_progname libdir))))
+    tts_text_modes))
+
+(provide 'soleml-mode)

pretrained_models/CosyVoice-ttsfrd/resource/festival/speech.properties

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

pretrained_models/CosyVoice-ttsfrd/resource/festival/synthesis.scm

@@ -0,0 +1,443 @@
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;;                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: Richard Caley (rjc@cstr.ed.ac.uk)             ;;
+ ;;                   Date: Fri Aug 15 1997                               ;;
+ ;; -------------------------------------------------------------------   ;;
+ ;; New synthesis mainline.                                               ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; Hooks to add to the synthesis process.                                ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar default_before_synth_hooks nil
+  "default_before_synth_hooks
+   The default list of functions to be run on all synthesized utterances
+   before synthesis starts.")
+
+(defvar before_synth_hooks default_before_synth_hooks
+  "before_synth_hooks
+   List of functions to be run on synthesised utterances before synthesis
+   starts.")
+
+(defvar default_after_analysis_hooks nil
+  "default_after_analysis_hooks
+   The default list of functions to be run on all synthesized utterances
+   after analysis but before synthesis.")
+
+(defvar after_analysis_hooks default_after_analysis_hooks
+  "after_analysis_hooks
+   List of functions to be applied after analysis and before synthesis.")
+
+(defvar default_after_synth_hooks nil
+  "default_after_synth_hooks
+   The default list of functions to be run on all synthesized utterances
+   after Wave_Synth.  This will normally be nil but if for some reason you
+   need to change the gain or rescale *all* waveforms you could set the
+   function here, in your siteinit.scm.")
+
+(defvar after_synth_hooks default_after_synth_hooks
+  "after_synth_hooks
+   List of functions to be applied after all synthesis modules have been
+   applied.  This is primarily designed to allow waveform manipulation,
+   particularly resampling and volume changes.")
+
+(defvar default_access_strategy 'ondemand
+  "default_access_strategy
+   How to access units from databases.")
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; Macro to define utterance types.                                      ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmac (defUttType form)
+  (list 'defUttType_real 
+	(list 'quote (cadr form))
+	(list 'quote (cddr form))))
+
+(defvar UttTypes nil
+  "UttTypes
+   List of types and functions used by the utt.synth function to call 
+   appropriate methods.")
+
+(define (defUttType_real type form)
+  "(defUttType TYPE . BODY)
+   Define a new utterance type.  TYPE is an atomic type that is specified
+   as the first argument to the function Utterance.  BODY is evaluated
+   with argument utt, when utt.synth is called with an utterance of type
+   TYPE.  You almost always require the function Initialize first.
+   [see Utterance types]"
+  ;;; Yes I am cheating a bit with the macro/function name.
+  ;;; should check about redefining and the syntax of the forms
+  (set! UttTypes
+	(cons 
+	 (cons type form)
+	 UttTypes))
+  type)
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; Macro to define synthesis types.                                      ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defmac (defSynthType form)
+  (list 'defSynthType_real 
+	(list 'quote (cadr form))
+	(list 'quote (cddr form))))
+
+(defvar SynthTypes nil
+  "SynthTypes
+   List of synthesis types and functions used by the utt.synth function to
+   call appropriate methods for wave synthesis.")
+
+(define (defSynthType_real type form)
+  "(defSynthType TYPE . BODY)
+   Define a new wave synthesis type.  TYPE is an atomic type that
+   identifies the type of synthesis. BODY is evaluated with argument
+   utt, when utt.synth is called with an utterance of type TYPE.
+   [see Utterance types]"
+
+  (set! SynthTypes
+	(cons 
+	 (cons type form)
+	 SynthTypes))
+  type)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Some actual Utterance type definitions
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defUttType Words
+  (Initialize utt)
+  (POS utt)
+  (Phrasify utt)
+  (Word utt)
+  (Pauses utt)
+  (Intonation utt)
+  (PostLex utt)
+  (Duration utt)
+  (Int_Targets utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Text
+  (Initialize utt)
+  (Text utt)
+  (Token_POS utt)
+  (Token utt)
+  (POS utt)
+  (Phrasify utt)
+  (Word utt)
+  (Pauses utt)
+  (Intonation utt)
+  (PostLex utt)
+  (Duration utt)
+  (Int_Targets utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Tokens   ;; This is used in tts_file, Tokens will be preloaded
+  (Token_POS utt)    ;; when utt.synth is called
+  (Token utt)        
+  (POS utt)
+  (Phrasify utt)
+  (Word utt)
+  (Pauses utt)
+  (Intonation utt)
+  (PostLex utt)
+  (Duration utt)
+  (Int_Targets utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Concept  ;; rather gradious name for when information has
+  (POS utt)          ;; been preloaded (probably XML) to give a word
+  (Phrasify utt)     ;; relation (SOLE uses this)
+  (Word utt)
+  (Pauses utt)
+  (Intonation utt)
+  (PostLex utt)
+  (Duration utt)
+  (Int_Targets utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Phrase
+  (Initialize utt)
+  (Token_POS utt)
+  (Token utt)        
+  (POS utt)
+  (Phrasify utt)
+  (Word utt)
+  (Pauses utt)
+  (Intonation utt)
+  (PostLex utt)
+  (Duration utt)
+  (Int_Targets utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Segments
+  (Initialize utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType Phones
+  (Initialize utt)
+  (Fixed_Prosody utt)
+  (Wave_Synth utt)
+  )
+
+(defUttType SegF0
+  (Wave_Synth utt)
+  )
+
+(defUttType Wave
+  (Initialize utt))
+
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; And some synthesis types.                                             ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defSynthType Taylor
+  (Taylor_Synthesize utt)
+  )
+
+(defSynthType UniSyn
+  (defvar UniSyn_module_hooks nil)
+  (Param.def "unisyn.window_name" "hanning")
+  (Param.def "unisyn.window_factor" 1.0)
+  (Parameter.def 'us_sigpr 'lpc)
+
+  (apply_hooks UniSyn_module_hooks utt)  ;; for processing of diphone names
+  (us_get_diphones utt)
+  (us_unit_concat utt)
+  
+  (if (not (member 'f0 (utt.relationnames utt)))
+      (targets_to_f0 utt))
+;; temporary fix
+  (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)
+  (cond
+   ((string-equal "td_psola" (Parameter.get 'us_sigpr))
+    ;; Not in standard distribution, so has to be separate function
+    (us_tdpsola_synthesis utt 'analysis_period))
+   (t
+    ;; All the rest 
+    (us_generate_wave utt (Parameter.get 'us_sigpr)
+		      'analysis_period)))
+)
+
+(defSynthType None
+  ;; do nothing
+  utt
+  )
+
+(defSynthType Standard
+  (print "synth method: Standard")
+  
+  (let ((select (Parameter.get 'SelectionMethod)))
+    (if select
+	(progn
+	 (print "select")
+	 (apply select (list utt))
+	 )
+	)
+    )
+
+  (let ((join (Parameter.get 'JoiningMethod)))
+    (if join
+	(progn
+	 (print "join")
+	 (apply join (list utt))
+	 )
+	)
+    )
+
+  (let ((impose (Parameter.get 'ImposeMethod)))
+    (if impose
+	(progn
+	 (print "impose")
+	 (apply impose (list utt))
+	 )
+	)
+    )
+
+  (let ((power (Parameter.get 'PowerSmoothMethod)))
+    (if power
+	(progn
+	 (print "power")
+	 (apply power (list utt))
+	 )
+	)
+    )
+
+  (let ((wavesynthesis (Parameter.get 'WaveSynthesisMethod)))
+    (if wavesynthesis
+	(progn
+	 (print "synthesis")
+	 (apply wavesynthesis (list utt))
+	 )
+	)
+    )
+  )
+
+(defSynthType Minimal
+  (print "synth method: Minimal")
+  
+  (let ((select (Parameter.get 'SelectionMethod)))
+    (if select
+	(progn
+	 (print "select")
+	 (apply select (list utt))
+	 )
+	)
+    )
+
+  (let ((wavesynthesis (Parameter.get 'WaveSynthesisMethod)))
+    (if wavesynthesis
+	(progn
+	 (print "synthesis")
+	 (apply wavesynthesis (list utt "Unit" "Join" "Wave"))
+	 )
+	)
+    )
+  )
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; Finally the actual driver function.                                   ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (utt.synth utt)
+
+  "(utt.synth UTT) 
+    The main synthesis function.  Given UTT it will apply the
+    functions specified for UTT's type, as defined with deffUttType
+    and then those demanded by the voice.  After modules have been
+    applied synth_hooks are applied to allow extra manipulation.
+    [see Utterance types]"
+
+  (apply_hooks before_synth_hooks utt)
+
+  (let ((type (utt.type utt)))
+    (let ((definition (assoc type UttTypes)))
+      (if (null? definition)
+	  (error "Unknown utterance type" type)
+	  (let ((body (eval (cons 'lambda 
+				  (cons '(utt) (cdr definition))))))
+	    (body utt)))))
+
+  (apply_hooks after_synth_hooks utt)
+  utt)
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; And a couple of utility expressions.                                  ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (SayText text)
+"(SayText TEXT)
+TEXT, a string, is rendered as speech."
+   (utt.play (utt.synth (eval (list 'Utterance 'Text text)))))
+
+(define (SynthText text)
+"(SynthText TEXT)
+TEXT, a string, is rendered as speech."
+   (utt.synth (eval (list 'Utterance 'Text text))))
+
+(define (SayPhones phones)
+"(SayPhones PHONES)
+PHONES is a list of phonemes.  This uses the Phones type utterance
+to synthesize and play the given phones.  Fixed duration specified in
+FP_duration and fixed monotone duration (FP_F0) are used to generate
+prosody."
+   (utt.play (utt.synth (eval (list 'Utterance 'Phones phones)))))
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;                                                                       ;;
+ ;; This is the standard synthesis function.  The Wave Synthesis may be   ;;
+ ;; more than a simple module                                             ;;
+ ;;                                                                       ;;
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+
+(define (Wave_Synth utt)
+"(Wave_Synth UTT)
+  Generate waveform from information in UTT, at least a Segment stream
+  must exist.  The actual form of synthesis used depends on the Parameter
+  Synth_Method.   If it is a function that is applied.  If it is atom it
+  should be a SynthType as defined by defSynthType
+  [see Utterance types]"
+  (apply_hooks after_analysis_hooks utt)
+  (let ((method_val (Parameter.get 'Synth_Method)))
+    (cond
+     ((null method_val)
+      (error "Undefined Synth_Method"))
+     ((and (symbol? method_val) (symbol-bound? method_val))
+      ;; Wish there was a function? 
+      (apply (symbol-value method_val) (list utt)))
+     ((member (typeof method_val) '(subr closure))
+      (apply method_val (list utt)))
+     (t  ;; its a defined synthesis type
+      (let ((synthesis_modules (assoc_string method_val SynthTypes)))
+	(if (null? synthesis_modules)
+	    (error (format nil "Undefined SynthType %s\n" method_val))
+	    (let ((body (eval (cons 'lambda 
+				    (cons '(utt) (cdr synthesis_modules))))))
+	      (body utt)))))))
+  utt)
+
+(provide 'synthesis)
+
+
+

pretrained_models/CosyVoice-ttsfrd/resource/festival/tilt.scm

@@ -0,0 +1,972 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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, Kurt Dusterhoff, Janet Hitzeman
+;;;          Date: April 1999
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;   Tilt intonation modules, accent/boundary preditions and F0 generation
+;;;   The F0 generation is done using models as described in 
+;;;   Dusterhoff, K. and Black, A. (1997). "Generating F0 contours for 
+;;;   speech synthesis using the Tilt intonation theory"
+;;;   (http://www.cstr.ed.ac.uk/awb/papers/esca-int97.ps) 
+;;;   Proceedings of ESCA Workshop of Intonation, pp 107-110, September, 
+;;;   Athens, Greece.
+;;;
+;;;   Intonation_Tilt assigns accents and boundaries by a CART tree
+;;;   the c and sil nodes are derived directly duration creation
+;;;
+;;;   Int_Targets_Tilt generates the F0 using the CART trees as
+;;;   described in the paper referenced above.
+;;;
+;;;   THIS CONTAINS *VERY* EXPERIMENTAL CODE
+;;;   it requires a thoroughly clean up and probably split into
+;;;   multiple files
+
+(defvar int_tilt_params nil
+  "int_tilt_params
+Parameters for tilt intonation model.")
+
+(Parameter.def 'tilt_method 'cart)
+
+(define (Intonation_Tilt utt)
+  "(Intonation_Tilt utt)
+Assign accent and boundary IntEvents to each syllable, and fill in
+spaces with silence and connections."
+ (let (accent boundary)
+   ;; Create basic intonation relations
+   (utt.relation.create utt 'Intonation)
+   (utt.relation.create utt 'IntonationSyllable)
+   (mapcar
+    (lambda (syl)
+      ;; If first syllable in phrase add phrase_start
+      (if (string-equal "pau"
+	   (item.feat syl "R:SylStructure.daughter1_to.Segment.p.name"))
+	  (tilt_add_intevent utt syl 'phrase_start))
+
+      (set! accent (wagon_predict syl tilt_a_cart_tree))
+      (set! boundary (wagon_predict syl tilt_b_cart_tree))
+;      (format t "%s: accent %s boundary %s\n"
+;	      (item.feat syl "R:WordStructure.root.name")
+;	      accent
+;	      boundary)
+      (if (not (string-equal accent "0"))
+	  (tilt_add_intevent utt syl accent))
+      (if (not (string-equal boundary "0"))
+	  (if (and (string-equal boundary "afb")
+		   (not (string-equal accent "0")))
+	      (tilt_add_intevent utt syl "fb")  ;; can't have a/afb
+	      (tilt_add_intevent utt syl boundary)))
+
+      ;; If last syllable in phrase add phrase_end
+      (if (string-equal "pau"
+  	   (item.feat syl "R:SylStructure.daughtern_to.Segment.n.name"))
+	  (tilt_add_intevent utt syl 'phrase_end)))
+    (utt.relation.items utt 'Syllable))
+;;   (utt.relation.print utt 'Intonation)
+   utt))
+
+(define (tilt_add_intevent utt syl name)
+"(tilt_add_intevent utt syl name)
+Add a new IntEvent related to syl with name."
+  (let (ie)
+    (set! ie (utt.relation.append utt 'Intonation (list name)))
+    (if (not (item.relation syl 'IntonationSyllable))
+	(utt.relation.append utt 'IntonationSyllable syl))
+    (item.relation.append_daughter syl 'IntonationSyllable ie)
+    (if (not (string-matches name "phrase_.*"))
+	(item.set_feat ie "int_event" 1))
+    ie))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Fo generate through tilt parameters and F0 rendering
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define (Int_Targets_Tilt utt)
+  "(Int_Targets_Tilt utt)
+Assign Tilt parameters to each IntEvent and then generate the 
+F0 contour and assign targets."
+  (utt.relation.set_feat utt "Intonation" "intonation_style" "tilt")
+  (tilt_assign_parameters utt)
+;  (tilt_F0_and_targets utt)  ;; this has to be C++, sorry
+;  (tilt_map_f0_range utt)
+  (tilt_to_f0 utt "f0")
+  (tilt_validate utt)
+  utt
+)
+
+(define (tilt_validate utt)
+  "(tilt_validate utt)
+Checks that the predicted tilt parameter fall with reasonable
+limits and modify them where possible to be more reasonable."
+  (mapcar
+   (lambda (ie)
+     (cond
+      ((string-equal (item.name ie) "phrase_end")
+       ;; check previous event does overflow segments
+       )
+      (t
+       t))
+     )
+   (utt.relation.items utt 'Intonation))
+)
+
+(define (tilt_map_f0_range utt)
+  "(tilt_map_f0_range utt)
+In order fo better trained models to be used for voices which don't
+have the necessary data to train models from the targets may be mapped
+to a different pitch range.  Note this is not optimal as pitch ranges
+don't map that easily, but the the results can sometimes be better than
+using a less sophisticated F0 generation model.  The method used
+is to define the mean and standard deviation of the speaker the
+model was trained on and the mean and standard deciation of the
+desired speaker.  Mapping is by converting the actual F0 value
+to zscores (distance from mean in number of stddev) and back into
+the other domain.  The variable int_tilt_params is used to find
+the values."
+  (let ((target_f0_mean (car (cdr (assoc 'target_f0_mean int_tilt_params))))
+	(target_f0_std (car (cdr (assoc 'target_f0_std int_tilt_params))))
+	(model_f0_std (car (cdr (assoc 'model_f0_std int_tilt_params))))
+	(model_f0_mean (car (cdr (assoc 'model_f0_mean int_tilt_params)))))
+    (if target_f0_mean  ;; only if one is specified
+	 (lambda (targ)
+	   (item.set_name
+	    targ
+	    (+ target_f0_mean
+	       (* target_f0_std
+		  (/ (- (parse-number (item.name targ))
+			model_f0_mean)
+		     model_f0_std)))))
+	 (utt.relation.leafs utt 'Target))))
+
+(define (tilt_assign_parameters utt) 
+  "(tilt_assign_parameters utt)
+Assigned tilt parameters to IntEvents, depending on the value
+of the Parameter tilt_method uses wagon trees (cart) or linear
+regression models (lr)."
+  (let ((method (Parameter.get 'tilt_method)))
+  (cond
+   ((equal? method 'cart)
+    (tilt_assign_parameters_wagon utt))
+   ((equal? method 'lr)
+    (tilt_assign_parameters_lr utt))
+   (t
+    (error "Tilt: unknown tilt param prediction method: " tilt_method)))))
+
+(define (tilt_assign_parameters_wagon utt)
+ "(tilt_assign_parameters_wagon utt)
+Assing parameters (start_f0, tilt, amplitude, peak_pos and duration)
+to each IntEvent.  Uses Wagon trees to predict values"
+  (mapcar
+   (lambda (ie)
+     (let ((param_trees (cdr (assoc_string (item.name ie)
+					   tilt_param_trees))))
+       (item.set_feat ie "time_path" "IntonationSyllable")
+       (if (string-equal "1" (item.feat ie "int_event"))
+	   (item.set_function ie "time" "unisyn_tilt_event_position")
+	   (item.set_function ie "time" "unisyn_tilt_phrase_position"))
+       (cond
+	((null param_trees)  
+	 (format stderr "Tilt: unknown Intonation type %s, ignored\n"
+		 (item.name ie))
+	 ;; *need* to assign default values 
+	 (item.set_feat ie "ev.f0" 100)
+	 (item.set_feat ie "tilt.amp" 20.0)
+	 (item.set_feat ie "tilt.dur" 0.25)
+	 (item.set_feat ie "tilt.tilt" -0.2)
+	 (item.set_feat ie "rel_pos" 0.0)
+	 )
+	(t
+	 (tilt_assign_params_wagon ie param_trees)))))
+   (utt.relation.items utt 'Intonation)))
+
+(define (tilt_assign_params_wagon ie trees)
+  "(tilt_assign_params_wagon ie trees)
+Assign the names parameters to ie using the trees and names in
+trees."
+  (mapcar
+   (lambda (tree)
+     (let ((val (wagon_predict ie (car (cdr tree)))))
+       (item.set_feat ie (car tree) val)))
+   trees))
+
+(define (tilt_assign_parameters_lr utt)
+  "(tilt_assign_parameters_lr utt)
+Assing parameters (start_f0, tilt, amplitude, peak_pos and duration)
+to each IntEvent. Prediction by linear regression models"
+  (mapcar
+   (lambda (ie)
+     (let ((param_lrmodels (cdr (assoc_string (item.name ie)
+				    tilt_param_lrmodels))))
+       (cond
+	((null param_lrmodels)  
+	 (format stderr "Tilt: unknown IntEvent type %s, ignored\n"
+		 (item.name ie))
+	 ;; *need* to assign default values 
+	 (item.set_feat ie "ev.f0" 100)
+	 (item.set_feat ie "tilt.amp" 20.0)
+	 (item.set_feat ie "tilt.dur" 0.25)
+	 (item.set_feat ie "tilt.tilt" -0.2)
+	 (item.set_feat ie "rel_pos" 0.0)
+	 )
+	(t
+	 (tilt_assign_params_lr ie param_lrmodels)))))
+   (utt.relation.items utt 'IntEvent)))
+
+(define (tilt_assign_params_lr ie lrmodels)
+  "(tilt_assign_params_lr ie lrmodels)
+Assign the names parameters to ie using the trees and names in
+trees."
+  (mapcar
+   (lambda (lrm)
+     (let ((val (lr_predict ie (cdr lrm))))
+       (item.set_feat ie (car lrm) val)))
+   lrmodels))
+
+(define (utt.save.tilt_events utt filename)
+"(utt.save.til_events UTT FILENAME)
+Save tilt events in UTT to FILENAME in a format suitable for
+ev_synth."
+  (let ((fd (fopen filename "w")))
+    (format fd "#\n")
+    (mapcar
+     (lambda (ie)
+       (let ((name (item.name ie)))
+	 (cond
+	  ((or (string-equal name "sil")
+	       (string-equal name "c"))
+	   (format fd "   %2.4f   100 %s; tilt: %2.6f\n" 
+		   (item.feat ie 'end)
+		   name 
+		   (item.feat ie "tilt_start_f0")))
+	  (t ;; accent or boundary
+	   (format fd "   %2.4f   100 %s; tilt: %2.6f %2.6f %2.6f %2.6f %2.6f\n" 
+		   (item.feat ie 'end)
+		   name 
+		   (item.feat ie "ev.f0")
+		   (item.feat ie "tilt.amp")
+		   (item.feat ie "tilt.dur")
+		   (item.feat ie "tilt.tilt")
+		   (item.feat ie "rel_pos"))))))
+     (utt.relation.items utt 'IntEvent))
+    (fclose fd)
+    utt))
+
+
+;;;;;
+;;;  Some features which should be pruned
+;;;;;
+
+(def_feature_docstring 'Syllable.lisp_time_to_next_vowel
+  "Syllable.lisp_time_to_next_vowel syl
+  The time from vowel_start to next vowel_start")
+(define (time_to_next_vowel syl)
+  "(time_to_next_vowel syl)
+  The time from vowel_start to next vowel_start"
+  (let (ttnv)
+    (if (string-equal "0" (item.feat syl "n.vowel_start"))
+	(set! ttnv 0.00)
+	(set! ttnv (- (item.feat syl "n.vowel_start")
+		      (item.feat syl "vowel_start"))))
+    ttnv))
+
+(def_feature_docstring 'Syllable.lisp_next_stress
+  "Syllable.lisp_next_stress
+  Number of syllables to next stressed syllable. 0 if this syllable is
+  stressed.  It is effectively assumed the syllable after the last syllable
+  is stressed.")
+(define (next_stress syl)
+  (cond 
+   ((null syl) 0)
+   ((string-equal (item.feat syl 'stress_num) "1")
+    0)
+   (t
+    (+ 1 (next_stress (item.relation.next syl 'Syllable))))))
+
+(def_feature_docstring 'Syllable.lisp_last_stress
+  "Syllable.lisp_last_stress
+  Number of syllables from previous stressed syllable.  0 if this syllable
+  is stressed.  It is effectively assumed that the syllable before the 
+  first syllable is stressed.")
+(define (last_stress syl)
+  (cond 
+   ((null syl) 0)
+   ((string-equal (item.feat syl 'stress_num) "1")
+    0)
+   (t
+    (+ 1 (last_stress (item.relation.prev syl 'Syllable))))))
+
+
+(def_feature_docstring 'SylStructure.lisp_length_to_last_seg
+  "SylStructure.lisp_length_to_last_seg
+  Length from start of the vowel to start of last segment of syllable.")
+(define (length_to_last_seg syl)
+  (- (item.feat syl "daughtern_to.Segment.start")
+     (item.feat syl "vowel_start")))
+
+(def_feature_docstring 'SylStructure.lisp_get_rhyme_length
+  "Syllable.lisp_get_rhyme_length
+  Length from start of the vowel to end of syllable.")
+(define (get_rhyme_length syl)
+  (- (item.feat syl 'end)
+     (item.feat syl 'vowel_start syl)))
+
+(def_feature_docstring 'SylStructure.lisp_get_onset_length
+  "Syllable.lisp_get_onset_length
+  Length from start of syllable to start of vowel.")
+(define (get_onset_length syl)
+  (cond
+   ((< (- (item.feat syl 'vowel_start)
+	  (item.feat syl 'start))
+       0.000)
+    0.000)  ;; just in case
+   (t
+    (- (item.feat syl 'vowel_start)
+       (item.feat syl 'start)))))
+
+(def_feature_docstring 'Syllable.lisp_tilt_accent
+  "Syllable.lisp_tilt_accent
+  Returns \"a\" if there is a tilt accent related to this syllable, 0 
+  otherwise.")
+(define (tilt_accent syl)
+  (let ((events (item.relation.daughters syl 'IntonationSyllable))
+	(r "0"))
+    (mapcar
+     (lambda (i)
+       (if (member_string (item.name i) tilt_accent_list)
+	   (set! r "a")))
+     events)
+    r))
+
+(def_feature_docstring 'Syllable.lisp_tilt_boundary
+  "Syllable.lisp_tilt_boundary
+  Returns boundary label if there is a tilt boundary related to this 
+syllable, 0 otherwise.")
+(define (tilt_boundary syl)
+  (let ((events (item.relation.daughters syl 'IntonationSyllable))
+	(r "0"))
+    (mapcar
+     (lambda (i)
+       (let ((name (item.name i)))
+       (if (member_string name tilt_boundary_list)
+	   (cond
+	    ((string-matches name "a.*")
+	     (set! r (string-after name "a")))
+	    ((string-matches name "m.*")
+	     (set! r (string-after name "m")))
+	    (t
+	     (set! r name))))))
+     events)
+    r))
+
+(def_feature_docstring 'Syllable.lisp_tilt_accented
+  "Syllable.lisp_tilt_accented
+  Returns 1 if there is a tilt accent related to this syllable, 0 
+  otherwise.")
+(define (tilt_accented syl)
+  (let ((events (item.relation.daughters syl 'IntonationSyllable))
+	(r "0"))
+    (mapcar
+     (lambda (i)
+       (if (member_string (item.name i) tilt_accent_list)
+	   (set! r "1")))
+     events)
+    r))
+
+(def_feature_docstring 'Syllable.lisp_tilt_boundaried
+  "Syllable.lisp_tilt_boundaried
+  Returns 1 if there is a tilt boundary related to this syllable, 0 
+  otherwise.")
+(define (tilt_boundaried syl)
+  (let ((events (item.relation.daughters syl 'IntonationSyllable))
+	(r "0"))
+    (mapcar
+     (lambda (i)
+       (if (member_string (item.name i) tilt_boundary_list)
+	   (set! r "1")))
+     events)
+    r))
+
+(def_feature_docstring 'SylStructure.lisp_vowel_height
+  "SylStructure.lisp_vowel_height syl
+Classifies vowels as high, low or mid")
+(define (vowel_height syl)
+  (let ((vh (item.feat syl "daughtern.daughter1.daughter1.df.height")))
+    vh)
+)
+
+(def_feature_docstring 'SylStructure.lisp_vowel_frontness
+  "SylStructure.vowel_frontness syl
+Classifies vowels as front, back or mid")
+(define (vowel_frontness syl)
+  (let ((vf (item.feat syl "daughtern.daughter1.daughter1.df.front")))
+    vf)
+)
+
+(def_feature_docstring 'SylStructure.lisp_vowel_length
+  "SylStructure.vowel_length syl
+Returns the df.length feature of a syllable's vowel")
+(define (vowel_length syl)
+  (let ((vl (item.feat syl "daughtern.daughter1.daughter1.df.length")))
+    vl)
+)
+
+(defvar sonority_vless_obst '("f" "h" "hh" "k" "p" "s" "sh" "t" "th" "ch")
+  "sonority_vless_obst
+List of voiceless obstruents for use in sonority scaling (only good w/ radio_speech)"
+  )
+(defvar sonority_v_obst '("v" "b" "g" "z" "zh" "d" "dh" "jh")
+  "sonority_v_obst
+List of voiced obstruents for use in sonority scaling (only good w/ radio_speech)"
+  )
+(defvar sonority_nas '("m" "n" "ng" "nx" "em" "en")
+  "sonority_nas
+List of nasals (only good w/ radio_speech)"
+  )
+(defvar sonority_liq '("r" "l" "er" "el" "axr")
+  "sonority_liq
+List of liquids (only good w/ radio_speech)"
+  )
+(defvar sonority_glides '("y" "w")
+  "sonority_glides
+List of glides (only good w/ radio_speech)"
+  )
+
+(def_feature_docstring 'SylStructure.lisp_sonority_scale_coda
+  "SylStructure.sonority_scale_coda syl
+Returns value on sonority scale (1 -6, where 6 is most sonorous)
+for the coda of a syllable, based on least sonorant portion.")
+(define (sonority_scale_coda syl)
+  (let ((segs (item.daughters (item.daughtern (item.daughtern syl))))
+	(scale 6))
+    (mapcar
+     (lambda (seg)
+       (cond
+	((member_string (item.name seg) sonority_vless_obst)
+	 (if (> scale 1)
+	     (set! scale 1)))
+	((member_string (item.name seg) sonority_v_obst)
+	 (if (> scale 2)
+	     (set! scale 2)))
+	((member_string (item.name seg) sonority_nas)
+	 (if (> scale 3)
+	     (set! scale 3)))
+	((member_string (item.name seg) sonority_liq)
+	 (if (> scale 4)
+	     (set! scale 4)))
+	((member_string (item.name seg) sonority_glides)
+	 (if (> scale 5)
+	     (set! scale 5)))
+	(t
+	 (if (> scale 6)
+	     (set! scale 6)))
+	)
+       )
+    segs)
+  scale))
+
+(def_feature_docstring 'SylStructure.lisp_sonority_scale_onset
+  "SylStructure.sonority_scale_onset syl
+Returns value on sonority scale (1 -6, where 6 is most sonorous)
+for the onset of a syllable, based on least sonorant portion.")
+(define (sonority_scale_onset syl)
+  (if (string-equal "Onset" (item.feat (item.daughter1 syl) "sylval"))
+      (let ((segs (item.daughters (item.daughter1 syl)))
+	    (scale 6))
+	(mapcar
+	 (lambda (seg)
+	   (cond
+	    ((member_string (item.name seg) sonority_vless_obst)
+	     (if (> scale 1)
+		 (set! scale 1)))
+	    ((member_string (item.name seg) sonority_v_obst)
+	     (if (> scale 2)
+		 (set! scale 2)))
+	    ((member_string (item.name seg) sonority_nas)
+	     (if (> scale 3)
+		 (set! scale 3)))
+	    ((member_string (item.name seg) sonority_liq)
+	     (if (> scale 4)
+		 (set! scale 4)))
+	    ((member_string (item.name seg) sonority_glides)
+	     (if (> scale 5)
+		 (set! scale 5)))
+	    (t (set! scale 6))
+	    )
+	   )
+	 segs)
+	scale)
+      0))
+
+(def_feature_docstring 'SylStructure.lisp_num_postvocalic_c
+  "SylStructure.lisp_num_postvocalic_c
+Finds the number of postvocalic consonants in a syllable.")
+(define (num_postvocalic_c syl)
+  "(num_postvocalic_c syl)
+Finds the number of postvocalic consonants in a syllable."
+  (let (segs (npc 0))
+    (set! segs (item.daughters (item.daughtern (item.daughtern syl))))
+    (mapcar
+     (lambda (seg)
+       (set! npc (+ npc 1))
+       )
+     segs)
+    npc))
+
+
+(def_feature_docstring 'SylStructure.lisp_syl_numphones
+  "SylStructure.lisp_syl_numphones syl
+Finds the number segments in a syllable.")
+(define (syl_numphones syl)
+  (length (mt_segs_from_syl syl))
+  )
+
+(def_feature_docstring 'Segment.lisp_pos_in_syl
+  "Segment.lisp_pos_in_syl seg
+Finds the position in a syllable of a segment - returns a number.")
+(define (pos_in_syl seg)
+  (let ((segments (mt_segs_from_syl 
+		   (item.relation (item.parent_to
+				   (item.relation seg 'SylStructure)
+				   'Syllable)
+				  'SylStructure)))
+	(seg_count 1))
+    (mapcar
+     (lambda (s)
+       (if (not (eqv? s seg))
+	   (set! seg_count (+ 1.0 seg_count))
+	   nil))
+     segs)
+    seg_count))
+
+(def_feature_docstring 'Intonation.lisp_peak_anchor_segment_type
+  "Intonation.peak_anchor_segment_type ie
+Determines whether the segment anchor for a peak
+is the first consonant of a syl - C0 -, the
+vowel of a syl - V0 -, or segments after that
+- C1->X,V1->X. If the segment is in a following syl,
+the return value will be preceded by a 1 - e.g. 1V1")
+(define (peak_anchor_segment_type ie)
+  (let ( syl peak_anchor_num numsegs peak_anchor_type)
+    (set! peak_anchor_num (peak_segment_anchor ie))
+
+
+    (if (> 9 peak_anchor_num)
+	(set! syl (item.relation
+		   (item.parent (item.relation ie "IntonationSyllable")) 
+		   "SylStructure")))
+    (if (> 9 peak_anchor_num)
+	(set! numsegs (item.feat syl "syl_numphones")))
+
+    (cond
+     ((< 9 peak_anchor_num)
+      (set! peak_anchor_type "none"))
+     ((> 0 peak_anchor_num)
+      (set! peak_anchor_type
+	    (string-append
+	     "-1" (get_anchor_value (item.prev syl)
+				    (+ peak_anchor_num 
+				       (item.feat syl "p.syl_numphones"))))))
+     ((< peak_anchor_num numsegs)
+      (set! peak_anchor_type (get_anchor_value syl numsegs)))
+     ((> peak_anchor_num numsegs)
+      (set! peak_anchor_type
+	    (string-append
+	     "1" (get_anchor_value (item.next syl) (- peak_anchor_num numsegs)))))
+      (set! peak_anchor_type "none"))
+;    (format stderr "pat: %s\n" peak_anchor_type)
+    peak_anchor_type))
+
+(define (get_anchor_value sylSyl seg_num)
+  "(get_anchor_value sylSyl seg_num)
+Gets the c/v value of the segment within a syllable."
+  (let ((syl (item.relation sylSyl "SylStructure"))
+	(seg_val "none") segs (ccnt -1) (vcnt -1) (vpis 0))
+    (set! segs (mt_segs_from_syl sylSyl))
+    (mapcar
+     (lambda (seg)
+       (cond
+	((string-equal "consonant" (item.feat seg "df.type"))
+	   (set! vcnt (+ 1 vcnt))
+	   (set! vpis (item.feat seg "pos_in_syl")))
+	(t
+	   (set! ccnt (+ 1 ccnt))))
+       (cond
+	((and
+	  (eq (- seg_num 1.0) (item.feat seg "pos_in_syl"))
+	  ( string-equal "consonant" (item.feat seg "df.type")))
+	 (set! seg_val (string-append "V" vcnt)))
+	((and
+	  (eq (- seg_num 1.0) (item.feat seg "pos_in_syl"))
+	  ( string-equal "vowel" (item.feat seg "df.type")))
+	 (set! seg_val (string-append "C" (- (item.feat seg "pos_in_syl")
+					     vpis) "V" vcnt)))
+	(t nil))
+       )
+     segs)
+  seg_val))
+
+(define (peak_segment_anchor ie)
+  "peak_segment_anchor ie
+Determines what segment acts as the anchor for a peak.
+Returns number of segments from start of accented syllable
+to peak."
+;  (format stderr "accent: %s\n"
+;	  (item.name ie))
+  (let ((pk_pos (item.feat ie "position"))
+	(peak_seg_anchor 11))
+    (if
+     (or
+       (string-equal "phrase_start" (item.name ie))
+       (string-equal "phrase_end" (item.name ie))
+       (string-equal "pause" (item.name ie)))
+     (set! peak_seg_anchor 10)
+     (set! peak_seg_anchor (find_peak_seg_anchor ie pk_pos)))
+    peak_seg_anchor))
+
+(define (find_peak_seg_anchor ie pk_pos)
+  "find_peak_seg_anchor ie pk_pos
+Part of the workings of peak_segment_anchor."
+  (let (( syl (item.relation
+		(item.parent (item.relation ie 'IntonationSyllable))
+		'SylStructure))
+	(seg_anchor 11))
+    (cond
+     ((not (eq 9.0 (segs_to_peak syl pk_pos)))
+      (set! seg_anchor (segs_to_peak syl pk_pos)))
+
+     ((and (item.prev syl)
+	   (not (eq 9.0 (segs_to_peak (item.prev syl) pk_pos))))
+;      (format stderr "%s\n" (item.name (item.prev syl)))
+      (set! seg_anchor (* -1
+			     (- (+ 1 (item.feat syl "p.syl_numphones"))
+			     (segs_to_peak (item.prev syl) pk_pos)))))
+
+     ((and (item.next syl)
+	   (> pk_pos (item.feat syl "n.start")))
+;      (format stderr "%s\n" (item.name (item.next syl)))
+      (set! seg_anchor (+ 1 
+			  (item.feat syl "syl_numphones")
+			  (segs_to_peak (item.next syl) pk_pos))))
+     (t
+       (format stderr "No seg anchor could be found\n")))
+;    (format stderr "seg_anchor: %f\n" seg_anchor)
+    seg_anchor))
+
+(define (segs_to_peak sylSyl pk_pos)
+  "(segs_to_peak sylSyl pk_pos)
+Determines the number of segments from the start of a syllable
+to an intonation peak"
+  (let ((syl (item.relation sylSyl "SylStructure"))
+	(segs_2_peak 9) segs)
+    (set! segs (mt_segs_from_syl syl))
+    (mapcar
+     (lambda (seg)
+;    (format stderr "seg_end: %f  pk: %f\n" (item.feat seg "end")
+;	     pk_pos)
+     (if (eq 1.0 (peak_wi_seg seg pk_pos))
+	 (set! segs_2_peak (item.feat seg "pos_in_syl")))
+;     (format stderr "segs_2_peak: %f\n" segs_2_peak)
+     )
+     segs)
+    segs_2_peak))
+
+(define (peak_wi_seg segment pk_pos)
+  "peak_wi_seg segment pk_pos
+Finds if a peak occurs w/i a segment"
+  (let ((s_start (item.feat segment "start"))
+	(s_end (item.feat segment "end"))
+	(ret 0.0))
+    (if (and (< s_start pk_pos)
+	     (< pk_pos s_end))
+	(set! ret 1.0)
+	nil)
+    ret))
+
+(defvar tilt_accent_list '("a" "arb" "afb" "m" "mfb" "mrb")
+  "tilt_accent_list
+List of events containing accents in tilt model.")
+(defvar tilt_boundary_list '("rb" "arb" "afb" "fb" "mfb" "mrb")
+  "tilt_boundary_list
+List of events containing boundaries in tilt model.")
+
+(def_feature_docstring 'Intonation.lisp_last_tilt_accent
+  "Intonation.lisp_last_tilt_accent
+  Returns the most recent tilt accent.")
+(define (last_tilt_accent intev)
+  (let ((pie (item.relation.prev intev 'Intonation)))
+    (cond
+     ((not pie)
+      "0")
+     ((member_string (item.name pie) tilt_accent_list)
+      (item.name pie))
+     (t (last_tilt_accent pie)))))
+
+(def_feature_docstring 'Intonation.lisp_next_tilt_accent
+  "Intonation.lisp_next_tilt_accent
+  Returns the next tilt accent.")
+(define (next_tilt_accent intev)
+  (let ((nie (item.relation.next intev 'Intonation)))
+    (cond
+     ((not nie) "0")
+     ((member_string (item.name nie) tilt_accent_list)
+      (item.name nie))
+     (t (next_tilt_accent nie)))))
+
+(def_feature_docstring 'Intonation.lisp_last_tilt_boundary
+  "Intonation.lisp_last_tilt_boundary
+  Returns the most recent tilt boundary.")
+(define (last_tilt_boundary intev)
+  (let ((pie (item.relation.prev intev 'Intonation)))
+    (cond
+     ((not pie) "0")
+     ((member_string (item.name pie) tilt_boundary_list)
+      (item.name pie))
+     (t (last_tilt_boundary pie)))))
+
+(def_feature_docstring 'Intonation.lisp_next_tilt_boundary
+  "Intonation.lisp_next_tilt_boundary
+  Returns the next tilt boundary.")
+(define (next_tilt_boundary intev)
+  (let ((nie (item.relation.next intev 'Intonation)))
+    (cond
+     ((not nie) "0")
+     ((member_string (item.name nie) tilt_boundary_list)
+      (item.name nie))
+     (t (next_tilt_boundary nie)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;  Some basic function to metrical tree structure
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(define (mt_syl_from_seg seg)
+  (if seg
+      (item.root (item.relation seg 'SylStructure))
+      nil))
+(define (mt_word_from_syl syl)
+  (if syl
+      (item.root (item.relation syl 'WordStructure))
+      nil))
+(define (mt_word_from_seg seg)
+  (mt_word_from_syl (mt_syl_from_seg seg)))
+
+(define (mt_segs_from_syl s)
+  (cond
+   ((null s) nil)
+   ((member_string 'Segment (item.relations s))
+    (list s))
+   (t
+    (apply
+     append
+     (mapcar mt_segs_from_syl (item.relation.daughters s 'SylStructure))))))
+
+(define (sylmtval s)
+  (let ((syl (mt_syl_from_seg s)))
+    (if syl
+	(item.feat syl "MetricalValue")
+	"0")))
+
+(define (sylpmtval s)
+  (let ((syl (mt_syl_from_seg s)))
+    (if syl
+	(item.feat syl "R:MetricalTree.parent.MetricalValue")
+	"0")))
+
+(define (mt_numsyls w)
+  (let ((s1 (item.daughter1_to (item.relation w 'WordStructure) 'Syllable))
+	(sn (item.daughtern_to (item.relation w 'WordStructure) 'Syllable))
+	(count 1))
+    (while (and s1 (not (equal? s1 sn)))
+	   (set! count (+ 1 count))
+	   (set! s1 (item.next s1)))
+    (if s1
+	count
+	0)))
+
+(define (mt_seg_numsyls s)
+  (let ((w (mt_word_from_seg s)))
+    (if w
+	(mt_num_syls w)
+	0)))
+
+
+;;; These functions should be sort out some time
+    
+;;; Difference between this syl and the next
+;;;  number of closing brackets, number of opening brackets
+;;;  difference between them
+
+(define (mt_close n)
+  "(mt_close n)
+The number of consituents this is the end of, Effectively the
+number of closing brackets after this word."
+  (if (or (not n) (item.next n))
+      0
+      (+ 1 (mt_close (item.parent n)))))
+
+(define (mt_open n)
+  "(mt_open n)
+The number of consituents this is the start of, Effectively the
+number of opening brackets before this word."
+  (if (or (not n) (item.prev n))
+      0
+      (+ 1 (mt_open (item.parent n)))))
+    
+(define (mt_postype syl)
+  "(mt_postype syl)
+Returns single, initial, final or middle."
+  (let ((w (mt_word_from_syl syl))
+	(psw (mt_word_from_syl (item.relation.prev syl 'Syllable)))
+	(nsw (mt_word_from_syl (item.relation.next syl 'Syllable))))
+    (cond
+     ((and (equal? w psw)
+	   (equal? w nsw))
+      'middle)
+     ((and (not (equal? w psw))
+	   (not (equal? w nsw)))
+      'single)
+     ((equal? w psw)
+      'final)
+     (t
+      'initial))))
+
+(define (mt_accent syl)
+  "(mt_accent syl)
+Accent or 0 if none."
+  (let ((a 0))
+    (mapcar
+     (lambda (i)
+       (if (string-matches (item.name i) "^a.*")
+	   (set! a "a")))
+     (item.relation.daughters syl 'IntonationSyllable))
+    a))
+
+(define (mt_break syl)
+  "(mt_break syl)
+Break or 0 if none."
+  (let ((a 0))
+    (mapcar
+     (lambda (i)
+       (if (string-matches (item.name i) ".*b$")
+	   (set! a (item.name i))))
+     (item.relation.daughters syl 'IntonationSyllable))
+    a))
+
+(define (mt_ssyl_out s)
+  (cond
+   ((null s) 0)
+   ((not (string-equal 
+	  "0" (item.feat s "R:WordStructure.root.lisp_word_mt_break")))
+    0)
+   ((string-equal "s" (item.feat s "MetricalValue"))
+    (+ 1 (mt_ssyl_out (item.relation.next s 'Syllable))))
+   (t
+    (mt_ssyl_out (item.relation.next s 'Syllable)))))
+
+(define (mt_num_s s)
+  "(mt_num_s s)
+The number of s MetricalValues from here to a w or top."
+  (cond
+   ((null s) 0)
+   ((string-equal "w" (item.feat s "MetricalValue"))
+    0)
+   (t
+    (+ 1 (mt_num_s (item.parent s))))))
+
+(define (mt_num_w s)
+  "(mt_num_w s)
+The number of w MetricalValues from here to a s or top."
+  (cond
+   ((null s) 0)
+   ((string-equal "s" (item.feat s "MetricalValue"))
+    0)
+   (t
+    (+ 1 (mt_num_w (item.parent s))))))
+
+(define (mt_strong s)
+  "(mt_strong s)
+1 if all MetricalValues a s to a word, 0 otherwise."
+  (cond
+   ((string-equal "w" (item.feat s "MetricalValue"))
+    "0")
+   ((member_string 'Word (item.relations s)) "1")
+   (t
+    (mt_strong (item.relation.parent s 'MetricalTree)))))
+
+(define (mt_lssp s)
+  "(mt_lssp s)
+1 if last stressed syllable in phrase, 0 otherwise."
+  (if (and (string-equal "s" (item.feat s "MetricalValue"))
+	   (equal? 0 (mt_ssyl_out s)))
+      "1"
+      "0"))
+
+(define (mt_fssw s)
+  "(mt_fssw s)
+1 if first stressed syllable in word, 0 otherwise."
+  (if (and (string-equal "s" (item.feat s "MetricalValue"))
+	   (mt_no_stress_before (item.relation.prev s 'Syllable)))
+      "1"
+      "0"))
+
+(define (mt_nfssw s)
+  "(nfssw s)
+1 if second or later stressed syllable in word, 0 otherwise."
+  (if (and (string-equal "s" (item.feat s "MetricalValue"))
+	   (null (mt_no_stress_before (item.relation.prev s 'Syllable))))
+      "1"
+      "0"))
+
+(define (mt_no_stress_before ss)
+  (cond
+   ((null ss) t)
+   ((not (string-equal 
+	  (item.feat ss "R:WordStructure.root.addr")
+	  (item.feat (item.next ss) "R:WordStructure.root.addr")))
+    t)
+   ((string-equal "s" (item.feat ss "MetricalValue"))
+    nil)
+   (t
+    (mt_no_stress_before (item.prev ss)))))
+
+(define (word_mt_break w)
+  (cond
+   ((string-equal "1" (item.feat w "sentence_end"))
+    "BB")
+   ((string-equal "1" (item.feat w "phrase_end"))
+    "B")
+   (t
+    "0")))
+  
+(provide 'tilt)

pretrained_models/CosyVoice-ttsfrd/resource/festival/tobi.scm

@@ -0,0 +1,338 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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 CART tree for predicting ToBI accents (learned from f2b)
+;;;   punctuation and minimal pos
+;;;
+
+;         NON    !H*  L+H    L*+  
+;     NONE10265  583   66   40    0    0 10954      [10265/10954]      93.710
+;        H* 650 1805   61   57    0    0 2573      [1805/2573]      70.152
+;       !H* 317  241  125   42    0    0  725      [125/725]      17.241
+;      L+H* 457  486   76   80    0    0 1099      [80/1099]       7.279
+;        L*  45  113   14    4    0    0  176      [0/176]       0.000
+;      L*+H   6    6    0    1    0    0   13      [0/13]       0.000
+;          11740 3234  342  224    0    0 
+;total 15540 correct 12275.000 78.990%
+
+(set! f2b_int_accent_cart_tree
+'
+;; these first few lines are hand written to deal with emphasis (from ssml)
+((R:SylStructure.parent.R:Token.parent.EMPH is 1)
+ (((NONE 0.0) (H* 1) (!H* 0.0) (L+H* 0) (L* 0) (L*+H 0) H*))
+ ((n.R:SylStructure.parent.R:Token.parent.EMPH is 1)
+  (((NONE 1.0) (H* 0) (!H* 0.0) (L+H* 0) (L* 0) (L*+H 0) NONE))
+  ((p.R:SylStructure.parent.R:Token.parent.EMPH is 1)
+   (((NONE 1.0) (H* 0) (!H* 0.0) (L+H* 0) (L* 0) (L*+H 0) NONE))
+
+((ssyl_in is 10)
+ (((NONE 0.99726) (H* 0) (!H* 0.00273973) (L+H* 0) (L* 0) (L*+H 0) NONE))
+ ((R:SylStructure.parent.gpos is to)
+  (((NONE 0.995984) (H* 0.00401606) (!H* 0) (L+H* 0) (L* 0) (L*+H 0) NONE))
+  ((R:SylStructure.parent.gpos is cc)
+   (((NONE 0.987768) (H* 0.00611621) (!H* 0) (L+H* 0.00611621) (L* 0) (L*+H 0) NONE))
+   ((ssyl_out is 10)
+    (((NONE 0.927273) (H* 0.0545455) (!H* 0) (L+H* 0.0181818) (L* 0) (L*+H 0) NONE))
+    ((R:SylStructure.parent.gpos is in)
+     (((NONE 0.938322) (H* 0.0353618) (!H* 0.00493421) (L+H* 0.0197368) (L* 0.00164474) (L*+H 0) NONE))
+     ((R:SylStructure.parent.gpos is wp)
+      (((NONE 0.895238) (H* 0.0857143) (!H* 0) (L+H* 0.0190476) (L* 0) (L*+H 0) NONE))
+      ((R:SylStructure.parent.gpos is aux)
+       (((NONE 0.912281) (H* 0.0380117) (!H* 0.00584795) (L+H* 0.0350877) (L* 0.00584795) (L*+H 0.00292398) NONE))
+       ((R:SylStructure.parent.gpos is det)
+        (((NONE 0.898004) (H* 0.0643016) (!H* 0.00332594) (L+H* 0.0332594) (L* 0) (L*+H 0.00110865) NONE))
+        ((stress is 0)
+         (((NONE 0.978415) (H* 0.0144999) (!H* 0.00164772) (L+H* 0.00510793) (L* 0.000329544) (L*+H 0) NONE))
+         ((R:SylStructure.parent.R:Word.p.gpos is 0)
+          (((NONE 0.209877) (H* 0.716049) (!H* 0) (L+H* 0.0617284) (L* 0.0123457) (L*+H 0) H*))
+          ((R:SylStructure.parent.gpos is md)
+           (((NONE 0.693548) (H* 0.177419) (!H* 0.0322581) (L+H* 0.0967742) (L* 0) (L*+H 0) NONE))
+           ((p.syl_break is 3)
+            ((syl_break is 1)
+             (((NONE 0.4375) (H* 0.416667) (!H* 0) (L+H* 0.135417) (L* 0.0104167) (L*+H 0) NONE))
+             (((NONE 0.171171) (H* 0.666667) (!H* 0) (L+H* 0.144144) (L* 0.018018) (L*+H 0) H*)))
+            ((pp.syl_break is 4)
+             ((R:SylStructure.parent.R:Word.pp.gpos is in)
+              (((NONE 0.0980392) (H* 0.803922) (!H* 0) (L+H* 0.0784314) (L* 0.0196078) (L*+H 0) H*))
+              ((syl_out is 0)
+               (((NONE 0.0185185) (H* 0.796296) (!H* 0.037037) (L+H* 0.0925926) (L* 0.0555556) (L*+H 0) H*))
+               ((R:SylStructure.parent.R:Word.n.gpos is in)
+                (((NONE 0.132353) (H* 0.676471) (!H* 0) (L+H* 0.161765) (L* 0.0294118) (L*+H 0) H*))
+                ((syl_break is 0)
+                 (((NONE 0.125) (H* 0.633929) (!H* 0.0133929) (L+H* 0.183036) (L* 0.0401786) (L*+H 0.00446429) H*))
+                 ((n.stress is 0)
+                  (((NONE 0.364865) (H* 0.567568) (!H* 0) (L+H* 0.0540541) (L* 0.0135135) (L*+H 0) H*))
+                  ((p.syl_break is 0)
+                   (((NONE 0.612903) (H* 0.290323) (!H* 0) (L+H* 0.0967742) (L* 0) (L*+H 0) NONE))
+                   (((NONE 0.32) (H* 0.44) (!H* 0.02) (L+H* 0.22) (L* 0) (L*+H 0) H*))))))))
+             ((ssyl_in is 0)
+              (((NONE 0.167769) (H* 0.628926) (!H* 0.0214876) (L+H* 0.142975) (L* 0.0363636) (L*+H 0.00247934) H*))
+              ((ssyl_out is 4)
+               (((NONE 0.490385) (H* 0.240385) (!H* 0.0961538) (L+H* 0.163462) (L* 0.00961538) (L*+H 0) NONE))
+               ((pp.syl_break is 3)
+                ((R:SylStructure.parent.R:Word.p.gpos is content)
+                 (((NONE 0.346154) (H* 0.346154) (!H* 0.0769231) (L+H* 0.192308) (L* 0.0384615) (L*+H 0) NONE))
+                 (((NONE 0.160714) (H* 0.571429) (!H* 0.0178571) (L+H* 0.178571) (L* 0.0714286) (L*+H 0) H*)))
+                ((syl_in is 2)
+                 ((n.stress is 0)
+                  ((R:SylStructure.parent.R:Word.p.gpos is in)
+                   (((NONE 0.218182) (H* 0.618182) (!H* 0.0363636) (L+H* 0.0909091) (L* 0.0181818) (L*+H 0.0181818) H*))
+                   ((syl_out is 2)
+                    (((NONE 0.0961538) (H* 0.634615) (!H* 0.0961538) (L+H* 0.134615) (L* 0.0384615) (L*+H 0) H*))
+                    ((R:SylStructure.parent.R:Word.p.gpos is content)
+                     ((syl_out is 4)
+                      (((NONE 0.56) (H* 0.12) (!H* 0.08) (L+H* 0.24) (L* 0) (L*+H 0) NONE))
+                      (((NONE 0.262821) (H* 0.378205) (!H* 0.121795) (L+H* 0.192308) (L* 0.0448718) (L*+H 0) H*)))
+                     (((NONE 0.161905) (H* 0.590476) (!H* 0.0285714) (L+H* 0.171429) (L* 0.047619) (L*+H 0) H*)))))
+                  ((n.syl_break is 0)
+                   (((NONE 0.551724) (H* 0.293103) (!H* 0) (L+H* 0.155172) (L* 0) (L*+H 0) NONE))
+                   (((NONE 0.408451) (H* 0.422535) (!H* 0.056338) (L+H* 0.112676) (L* 0) (L*+H 0) H*))))
+                 ((R:SylStructure.parent.R:Word.n.gpos is 0)
+                  ((syl_break is 0)
+                   (((NONE 0.105263) (H* 0.315789) (!H* 0.157895) (L+H* 0.421053) (L* 0) (L*+H 0) L+H*))
+                   (((NONE 0.641509) (H* 0.132075) (!H* 0.132075) (L+H* 0.0943396) (L* 0) (L*+H 0) NONE)))
+                  ((syl_break is 1)
+                   ((ssyl_in is 3)
+                    (((NONE 0.638889) (H* 0.152778) (!H* 0.125) (L+H* 0.0833333) (L* 0) (L*+H 0) NONE))
+                    ((p.syl_break is 0)
+                     (((NONE 0.551402) (H* 0.186916) (!H* 0.158879) (L+H* 0.0841122) (L* 0.0186916) (L*+H 0) NONE))
+                     ((n.stress is 0)
+                      ((pp.syl_break is 0)
+                       (((NONE 0.413043) (H* 0.184783) (!H* 0.152174) (L+H* 0.23913) (L* 0.0108696) (L*+H 0) NONE))
+                       (((NONE 0.2125) (H* 0.3375) (!H* 0.1875) (L+H* 0.2125) (L* 0.05) (L*+H 0) H*)))
+                      (((NONE 0.449153) (H* 0.245763) (!H* 0.101695) (L+H* 0.20339) (L* 0) (L*+H 0) NONE)))))
+                   ((syl_out is 4)
+                    ((nn.syl_break is 0)
+                     ((pp.syl_break is 0)
+                      (((NONE 0.45614) (H* 0.210526) (!H* 0.192982) (L+H* 0.140351) (L* 0) (L*+H 0) NONE))
+                      (((NONE 0.288462) (H* 0.25) (!H* 0.0961538) (L+H* 0.346154) (L* 0) (L*+H 0.0192308) L+H*)))
+                     (((NONE 0.163934) (H* 0.459016) (!H* 0.131148) (L+H* 0.245902) (L* 0) (L*+H 0) H*)))
+                    ((syl_out is 5)
+                     ((R:SylStructure.parent.R:Word.p.gpos is content)
+                      (((NONE 0.372881) (H* 0.20339) (!H* 0.169492) (L+H* 0.220339) (L* 0.0338983) (L*+H 0) NONE))
+                      (((NONE 0.0961538) (H* 0.673077) (!H* 0.115385) (L+H* 0.0961538) (L* 0.0192308) (L*+H 0) H*)))
+                     ((R:SylStructure.parent.R:Word.pp.gpos is in)
+                      ((syl_in is 4)
+                       (((NONE 0.352113) (H* 0.422535) (!H* 0.15493) (L+H* 0.0704225) (L* 0) (L*+H 0) H*))
+                       ((syl_in is 3)
+                        (((NONE 0.290323) (H* 0.467742) (!H* 0.0806452) (L+H* 0.145161) (L* 0.016129) (L*+H 0) H*))
+                        ((pp.syl_break is 0)
+                         (((NONE 0.465517) (H* 0.293103) (!H* 0.172414) (L+H* 0.0689655) (L* 0) (L*+H 0) NONE))
+                         ((R:SylStructure.parent.R:Word.p.gpos is content)
+                          (((NONE 0.18) (H* 0.36) (!H* 0.28) (L+H* 0.14) (L* 0.04) (L*+H 0) H*))
+                          (((NONE 0.0877193) (H* 0.22807) (!H* 0.368421) (L+H* 0.298246) (L* 0.0175439) (L*+H 0) !H*))))))
+                      ((ssyl_out is 2)
+                       ((p.syl_break is 0)
+                        (((NONE 0.634921) (H* 0.174603) (!H* 0.0793651) (L+H* 0.111111) (L* 0) (L*+H 0) NONE))
+                        ((pp.syl_break is 0)
+                         (((NONE 0.388889) (H* 0.148148) (!H* 0.148148) (L+H* 0.259259) (L* 0.0185185) (L*+H 0.037037) NONE))
+                         (((NONE 0.294118) (H* 0.137255) (!H* 0.215686) (L+H* 0.333333) (L* 0.0196078) (L*+H 0) L+H*))))
+                       ((R:SylStructure.parent.R:Word.pp.gpos is to)
+                        (((NONE 0.0877193) (H* 0.350877) (!H* 0.210526) (L+H* 0.315789) (L* 0.0350877) (L*+H 0) H*))
+                        ((syl_break is 3)
+                         ((pp.syl_break is 0)
+                          (((NONE 0.478261) (H* 0.141304) (!H* 0.195652) (L+H* 0.184783) (L* 0) (L*+H 0) NONE))
+                          (((NONE 0.217822) (H* 0.366337) (!H* 0.257426) (L+H* 0.128713) (L* 0.029703) (L*+H 0) H*)))
+                         ((syl_in is 7)
+                          ((n.stress is 0)
+                           ((R:SylStructure.parent.R:Word.n.gpos is content)
+                            (((NONE 0.117647) (H* 0.220588) (!H* 0.441176) (L+H* 0.176471) (L* 0.0441176) (L*+H 0) !H*))
+                            (((NONE 0.415385) (H* 0.0461538) (!H* 0.2) (L+H* 0.246154) (L* 0.0923077) (L*+H 0) NONE)))
+                           (((NONE 0.716981) (H* 0.113208) (!H* 0.0943396) (L+H* 0.0754717) (L* 0) (L*+H 0) NONE)))
+                          ((R:SylStructure.parent.R:Word.n.gpos is cc)
+                           (((NONE 0.292308) (H* 0.184615) (!H* 0.276923) (L+H* 0.246154) (L* 0) (L*+H 0) NONE))
+                           ((nn.syl_break is 3)
+                            (((NONE 0.2) (H* 0.333333) (!H* 0.283333) (L+H* 0.15) (L* 0.0333333) (L*+H 0) H*))
+                            ((ssyl_in is 4)
+                             (((NONE 0.383838) (H* 0.151515) (!H* 0.212121) (L+H* 0.20202) (L* 0.050505) (L*+H 0) NONE))
+                             ((p.syl_break is 0)
+                              ((n.syl_break is 1)
+                               (((NONE 0.526316) (H* 0.210526) (!H* 0.0921053) (L+H* 0.171053) (L* 0) (L*+H 0) NONE))
+                               ((ssyl_in is 3)
+                                (((NONE 0.509804) (H* 0.0980392) (!H* 0.215686) (L+H* 0.156863) (L* 0.0196078) (L*+H 0) NONE))
+                                ((pp.syl_break is 0)
+                                 (((NONE 0.506667) (H* 0.173333) (!H* 0.106667) (L+H* 0.2) (L* 0.0133333) (L*+H 0) NONE))
+                                 ((ssyl_in is 1)
+                                  (((NONE 0.1) (H* 0.4) (!H* 0.266667) (L+H* 0.188889) (L* 0.0444444) (L*+H 0) H*))
+                                  (((NONE 0.326316) (H* 0.210526) (!H* 0.221053) (L+H* 0.189474) (L* 0.0526316) (L*+H 0) NONE))))))
+                              ((R:SylStructure.parent.R:Word.p.gpos is in)
+                               (((NONE 0.0625) (H* 0.296875) (!H* 0.265625) (L+H* 0.328125) (L* 0.046875) (L*+H 0) L+H*))
+                               ((syl_in is 6)
+                                (((NONE 0.271739) (H* 0.152174) (!H* 0.358696) (L+H* 0.184783) (L* 0.0326087) (L*+H 0) !H*))
+                                ((syl_out is 2)
+                                 (((NONE 0.111111) (H* 0.361111) (!H* 0.319444) (L+H* 0.138889) (L* 0.0555556) (L*+H 0.0138889) H*))
+                                 ((syl_in is 4)
+                                  (((NONE 0.224) (H* 0.152) (!H* 0.328) (L+H* 0.24) (L* 0.056) (L*+H 0) !H*))
+                                  ((n.stress is 0)
+                                   ((syl_in is 3)
+                                    (((NONE 0.0833333) (H* 0.333333) (!H* 0.233333) (L+H* 0.216667) (L* 0.133333) (L*+H 0) H*))
+                                    (((NONE 0.283465) (H* 0.188976) (!H* 0.23622) (L+H* 0.204724) (L* 0.0708661) (L*+H 0.015748) NONE)))
+                                   (((NONE 0.305263) (H* 0.284211) (!H* 0.210526) (L+H* 0.178947) (L* 0.0210526) (L*+H 0) NONE))))))))))))))))))))))))))))))))))))))))
+)
+
+;          NON             L-L  L-H  H-L  
+;    NONE13017    0    0    0    0    0 13017      [13017/13017]     100.000
+;       H- 339   81    0    1    1    0  422      [81/422]      19.194
+;       L- 223   52    0    5    0    0  280      [0/280]       0.000
+;     L-L%  17    0    0 1057   96    0 1170      [1057/1170]      90.342
+;     L-H%  16    0    0  457  139    0  612      [139/612]      22.712
+;     H-L%   5    0    0   30    4    0   39      [0/39]       0.000
+;        13617  133    0 1550  240    0 
+;total 15540 correct 14294.000 91.982%
+(set! f2b_int_tone_cart_tree
+'((lisp_syl_yn_question is 1)
+  (((H-H% 1.0) H-H%))
+((R:SylStructure.parent.gpos is cc)
+ (((NONE 0.996942) (H- 0.0030581) (L- 0) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+ ((ssyl_in is 10)
+  (((NONE 0.989041) (H- 0.00273973) (L- 0) (L-L% 0.00273973) (L-H% 0.00547945) (H-L% 0) NONE))
+  ((R:SylStructure.parent.gpos is md)
+   (((NONE 0.986014) (H- 0) (L- 0) (L-L% 0.00699301) (L-H% 0.00699301) (H-L% 0) NONE))
+   ((p.old_syl_break is 4)
+    (((NONE 0.99462) (H- 0.00239091) (L- 0.00119546) (L-L% 0) (L-H% 0.00119546) (H-L% 0.000597729) NONE))
+    ((R:SylStructure.parent.gpos is det)
+     (((NONE 0.984635) (H- 0.00512164) (L- 0.00384123) (L-L% 0.00384123) (L-H% 0.00256082) (H-L% 0) NONE))
+     ((n.old_syl_break is 3)
+      (((NONE 0.981848) (H- 0.00495049) (L- 0.00330033) (L-L% 0.00660066) (L-H% 0.00330033) (H-L% 0) NONE))
+      ((n.old_syl_break is 4)
+       (((NONE 0.986982) (H- 0.000591716) (L- 0.0100592) (L-L% 0.00118343) (L-H% 0.00118343) (H-L% 0) NONE))
+       ((R:SylStructure.parent.gpos is in)
+        (((NONE 0.977865) (H- 0.00390625) (L- 0.00390625) (L-L% 0.0078125) (L-H% 0.00651042) (H-L% 0) NONE))
+        ((old_syl_break is 4)
+         ((R:SylStructure.parent.R:Word.n.gpos is 0)
+          (((NONE 0) (H- 0.00892857) (L- 0) (L-L% 0.982143) (L-H% 0.00892857) (H-L% 0) L-L%))
+          ((R:SylStructure.parent.R:Word.p.gpos is aux)
+           (((NONE 0) (H- 0) (L- 0) (L-L% 0.761905) (L-H% 0.238095) (H-L% 0) L-L%))
+           ((R:SylStructure.parent.R:Word.n.gpos is det)
+            (((NONE 0) (H- 0) (L- 0) (L-L% 0.652542) (L-H% 0.347458) (H-L% 0) L-L%))
+            ((ssyl_in is 4)
+             (((NONE 0) (H- 0) (L- 0) (L-L% 0.682243) (L-H% 0.313084) (H-L% 0.0046729) L-L%))
+             ((syl_in is 6)
+              (((NONE 0) (H- 0) (L- 0.00649351) (L-L% 0.688312) (L-H% 0.298701) (H-L% 0.00649351) L-L%))
+              ((R:SylStructure.parent.R:Word.n.gpos is aux)
+               (((NONE 0) (H- 0) (L- 0) (L-L% 0.464286) (L-H% 0.535714) (H-L% 0) L-H%))
+               ((syl_in is 5)
+                (((NONE 0) (H- 0) (L- 0) (L-L% 0.666667) (L-H% 0.322034) (H-L% 0.0112994) L-L%))
+                ((sub_phrases is 2)
+                 (((NONE 0) (H- 0) (L- 0) (L-L% 0.696429) (L-H% 0.267857) (H-L% 0.0357143) L-L%))
+                 ((R:SylStructure.parent.R:Word.p.gpos is det)
+                  (((NONE 0) (H- 0) (L- 0) (L-L% 0.628866) (L-H% 0.350515) (H-L% 0.0206186) L-L%))
+                  ((sub_phrases is 0)
+                   ((R:SylStructure.parent.R:Word.n.gpos is in)
+                    ((n.old_syl_break is 0)
+                     (((NONE 0) (H- 0) (L- 0) (L-L% 0.68254) (L-H% 0.31746) (H-L% 0) L-L%))
+                     (((NONE 0) (H- 0.0147059) (L- 0) (L-L% 0.338235) (L-H% 0.632353) (H-L% 0.0147059) L-H%)))
+                    ((n.stress is 0)
+                     (((NONE 0) (H- 0) (L- 0.0108303) (L-L% 0.599278) (L-H% 0.32491) (H-L% 0.064982) L-L%))
+                     (((NONE 0) (H- 0) (L- 0) (L-L% 0.386364) (L-H% 0.579545) (H-L% 0.0340909) L-H%))))
+                   (((NONE 0) (H- 0) (L- 0.00456621) (L-L% 0.652968) (L-H% 0.324201) (H-L% 0.0182648) L-L%))))))))))))
+         ((R:SylStructure.parent.gpos is pps)
+          (((NONE 0.988764) (H- 0.011236) (L- 0) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+          ((syl_in is 0)
+           (((NONE 0.984848) (H- 0.0126263) (L- 0.00252525) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+           ((R:SylStructure.parent.gpos is content)
+            ((R:SylStructure.parent.R:Word.nn.gpos is 0)
+             (((NONE 0.967914) (H- 0.0106952) (L- 0.0213904) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+             ((pp.old_syl_break is 4)
+              (((NONE 0.972315) (H- 0.0232558) (L- 0.00442968) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+              ((syl_in is 1)
+               (((NONE 0.951163) (H- 0.0372093) (L- 0.0116279) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+               ((nn.old_syl_break is 4)
+                (((NONE 0.956244) (H- 0.0127621) (L- 0.0291705) (L-L% 0) (L-H% 0) (H-L% 0.00182315) NONE))
+                ((R:SylStructure.parent.R:Word.nn.gpos is in)
+                 (((NONE 0.941919) (H- 0.0378788) (L- 0.020202) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                 ((R:SylStructure.parent.R:Word.p.gpos is cc)
+                  (((NONE 0.919643) (H- 0.0714286) (L- 0.00892857) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                  ((nn.old_syl_break is 3)
+                   (((NONE 0.927273) (H- 0.0472727) (L- 0.0254545) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                   ((R:SylStructure.parent.R:Word.nn.gpos is cc)
+                    (((NONE 0.921569) (H- 0.0588235) (L- 0.0196078) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                    ((ssyl_in is 0)
+                     (((NONE 0.911591) (H- 0.0825147) (L- 0.00589391) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                     ((R:SylStructure.parent.R:Word.nn.gpos is to)
+                      (((NONE 0.912281) (H- 0.0350877) (L- 0.0526316) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                      ((R:SylStructure.parent.R:Word.pp.gpos is to)
+                       (((NONE 0.894737) (H- 0.0526316) (L- 0.0526316) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                       ((R:SylStructure.parent.R:Word.p.gpos is in)
+                        (((NONE 0.888554) (H- 0.0662651) (L- 0.0451807) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                        ((R:SylStructure.parent.R:Word.pp.gpos is in)
+                         (((NONE 0.875817) (H- 0.0718954) (L- 0.0522876) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                         ((syl_in is 2)
+                          (((NONE 0.869942) (H- 0.0867052) (L- 0.0433526) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                          ((R:SylStructure.parent.R:Word.nn.gpos is aux)
+                           (((NONE 0.854839) (H- 0.0967742) (L- 0.0483871) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                           ((sub_phrases is 1)
+                            (((NONE 0.836538) (H- 0.0721154) (L- 0.0913462) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                            ((R:SylStructure.parent.R:Word.pp.gpos is det)
+                             (((NONE 0.832402) (H- 0.0949721) (L- 0.0726257) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                             ((ssyl_in is 4)
+                              (((NONE 0.793103) (H- 0.103448) (L- 0.103448) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                              ((n.old_syl_break is 0)
+                               (((NONE 0.850816) (H- 0.0839161) (L- 0.0652681) (L-L% 0) (L-H% 0) (H-L% 0) NONE))
+                               ((R:SylStructure.parent.R:Word.n.gpos is content)
+                                (((NONE 0.889447) (H- 0.0753769) (L- 0.0251256) (L-L% 0) (L-H% 0) (H-L% 0.0100503) NONE))
+                                ((old_syl_break is 3)
+                                 (((NONE 0) (H- 0.609023) (L- 0.390977) (L-L% 0) (L-H% 0) (H-L% 0) H-))
+                                 (((NONE 1) (H- 0) (L- 0) (L-L% 0) (L-H% 0) (H-L% 0) NONE)))))))))))))))))))))))
+            (((NONE 0.978947) (H- 0.0131579) (L- 0.00789474) (L-L% 0) (L-H% 0) (H-L% 0) NONE)))))))))))))))
+
+)
+
+(defvar tobi_support_yn_questions t
+  "tobi_support_yn_questions
+If set a crude final rise will be added at utterance that are judged
+to be yesy/no questions.  Namely ending in a ? and not starting with
+a wh-for word.")
+
+(define (first_word syl)
+  (let ((w (item.relation.parent syl 'SylStructure)))
+    (item.relation.first w 'Word)))
+
+(define (syl_yn_question syl)
+"(syl_yn_question utt syl)
+Return 1 if this is the last syllable in a yes-no question.  Basically
+if it ends in question mark and doesn't start with a wh-woerd.  This
+isn't right but it depends on how much you want rising intonation."
+  (if (and 
+       tobi_support_yn_questions
+       (member_string (item.feat syl "syl_break") '("4" "3"))
+       (not (member_string 
+	     (downcase (item.name (first_word syl)))
+	     '("how" "why" "which" "who" "what" "where" "when")))
+       (string-matches 
+	(item.feat syl "R:SylStructure.parent.R:Token.parent.punc")
+		       ".*\\?.*"))
+      "1"
+      "0"))
+
+(provide 'tobi)

pretrained_models/CosyVoice-ttsfrd/resource/festival/tobi_rules.scm

@@ -0,0 +1,1002 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                Authors: Robert A. J. Clark and Alan W Black
+;;;                Modifications and Checking: 
+;;;                         Gregor Moehler (moehler@ims.uni-stuttgart.de)
+;;;                         Matthew Stone (mdstone@cs.rutgers.edu)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Generate F0 points from tobi labels using rules given in:
+;;; Jilka, Moehler & Dogil (forthcomming in Speech Communications)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  *** Converted to new Relation architecture -- but not checked yet -- awb
+;;;      -> crude (beta) checking: gm in Dec. 98
+;;;
+;;;      -> fixed TAKEOVER bug that used time value 
+;;;         as pitch target (!) - MDS 1/02
+;;;      -> hacked around bunches of target overlap problems - MDS 1/02
+;;;      -> added primitive pitch range controls
+;;;      
+;;;  Known problems and bugs:
+;;;      Can't currently use voicing intervals which cross syllable boundaries,
+;;;      so pre/post-nuclear tones are currently places 0.2s before/after the 
+;;;      nuclear tone even if no voicing occurs. Failing this they default a
+;;;      percentage of the voicing for that syllable. 
+;;; 
+;;;      Don't know about target points ahead of the current syllable.
+;;;      (As you need to know what comes before them to calculate them)
+;;;      So: post accent tones are placed 0.2 ahead if following syllable exists
+;;;          ends before 0.2 from starred target and is not accented
+;;;      The H-target of the H+!H* is 0.2 sec instead of 0.15 sec before 
+;;;      starred tone.
+;;;      
+;;;      Multi-utterance input has not been tested. 
+;;;      
+;;;      !H- does not generate any targets
+;;;      
+;;;      Unfortunaltely some other modules may decide to put pauses in the 
+;;;      middle of a phrase
+;;;      
+;;;      valleys are not tested yet
+;;;      
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  To use this in a voice 
+;;;     (require 'tobi_rules)
+;;;  And in the voice call
+;;;     (setup_tobi_f0_method)
+;;;  Set the following for your speaker's F0 range
+;;;  (Parameter.set 'Default_Topline 146)
+;;;  (Parameter.set 'Default_Start_Baseline 61)
+;;;  (Parameter.set 'Valley_Dip 75)
+
+;; level of debug printout
+(set! printdebug 0)
+
+(define (setup_tobi_f0_method)
+  "(setup_tobi_f0_method)
+Set up parameters for current voice to use the implementaion
+of ToBI labels to F0 targets by rule."
+  (Parameter.set 'Int_Method Intonation_Tree)
+  (Parameter.set 'Int_Target_Method Int_Targets_General)
+  (set! int_accent_cart_tree no_int_cart_tree) ; NONE always
+  (set! int_tone_cart_tree   no_int_cart_tree) ; NONE always
+  (set! int_general_params
+	(list 
+	 (list 'targ_func tobi_f0_targets)))   ; we will return a list of f0 targets here
+
+  (Parameter.set 'Phrase_Method 'cart_tree)
+  (set! phrase_cart_tree tobi_label_phrase_cart_tree) ; redefines the phrasebreak tree
+  t)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;
+;;;;;; Define and set the new f0 rules
+;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;; Set global parameters
+;;; You may want to reset these for different speakers
+
+(Parameter.set 'Default_Topline 146) ;146
+(Parameter.set 'Default_Start_Baseline 61) ;61
+(Parameter.set 'Current_Topline        (Parameter.get 'Default_Topline))
+(Parameter.set 'Current_Start_Baseline (Parameter.get 'Default_Start_Baseline))
+(Parameter.set 'Current_End_Baseline   (Parameter.get 'Current_Start_Baseline))
+(Parameter.set 'Downstep_Factor 0.70)
+(Parameter.set 'Valley_Dip 75)
+;;; function to add target points on a given syllable and fill in 
+;;; targets where necessary
+
+(define (tobi_f0_targets utt syl)
+  "(tobi_f0_targets UTT ITEM)
+   Returns a list of targets for the given syllable."
+  (if (and (>= printdebug  1)
+	   (not(equal? 0 (item.feat syl "R:Intonation.daughter1.name"))))
+      (format t "### %l (%.2f %.2f) %l ptarg: %l ###\n" (item.name syl)
+	      (item.feat syl "syllable_start")(item.feat syl "syllable_end")
+	      (item.feat syl "R:Intonation.daughter1.name") (ttt_last_target_time syl)))
+  
+  ;; only continue if there is a Word related to this syllable
+  ;; I know there always should be, but there might be a bug elsewhere
+  (cond 
+   ((not(equal? 0 (item.feat syl "R:SylStructure.parent.name")))
+
+    ; get current label. This assumes that there is only one accent and
+    ; one endtone on a syllable. Although there can be one of each.
+    (let ((voicing  (ttt_get_voice_times syl))                ; voicing interval
+	  (pvoicing (ttt_get_voice_times                      ; previous voicing
+		     (item.relation.prev syl 'Syllable)))
+	  (nvoicing (ttt_get_voice_times                      ; next voicing
+		     (item.relation.next syl 'Syllable))))
+
+    ; if first syl of phrase set Phrase_Start and Phrase_End parameters
+    ; and reset downstep (currently does so on big and little breaks.)
+    ; only assignes Default values at this stage 
+    ; maybe trained from CART later - first steps now - MDS
+    ; following Moehler and Mayer, SSW 2001 
+    (if   (eq 0 (item.feat syl 'syl_in)) ;; GM maybe something better needed here?
+	(progn
+	 (Parameter.set 'Phrase_Start (item.feat syl 'R:SylStructure.parent.R:Phrase.last.word_start))
+	 (Parameter.set 'Phrase_End (item.feat syl 'R:SylStructure.parent.R:Phrase.last.word_end))
+	 (Parameter.set 'Current_Topline 
+			(/ (* (wagon syl ttt_topline_tree) 
+			      (Parameter.get 'Default_Topline)) 100))
+	 (Parameter.set 'Current_Start_Baseline
+			(/ (* (wagon syl ttt_baseline_tree)
+			      (Parameter.get 'Default_Start_Baseline)) 100))
+	 (Parameter.set 'Current_End_Baseline 
+			(Parameter.get 'Current_Start_Baseline))
+	 (if (>= printdebug  3)
+	     (begin 
+	       (print (format nil "new range: %f %f %f" 
+			      (Parameter.get 'Current_Topline) 
+			      (Parameter.get 'Current_Start_Baseline)
+			      (Parameter.get 'Current_End_Baseline) ))))  ))
+
+    ; do stuff (should go only if there is an accent/boundary?)
+    (let ((new_targets 
+	   (ttt_to_targets syl (wagon syl ttt_starttone_tree)
+			   voicing
+			   pvoicing
+			   nvoicing
+			   'Starttones)))
+
+    (set! new_targets (append new_targets 
+	   (ttt_to_targets syl (wagon syl ttt_accent_tree)
+			   voicing 
+			   pvoicing 
+			   nvoicing 
+			   'Accents)))
+
+    (set! new_targets (append new_targets 
+	   (ttt_to_targets syl (wagon syl ttt_endtone_tree)
+			   voicing
+			   pvoicing
+			   nvoicing
+			   'Endtones)))
+
+    (if (and(not(equal? new_targets nil))
+	    (>= printdebug  2))
+	(begin
+	  (format t ">> Targets: %l\n" new_targets)
+	  (format t ">> LastTarget: %l\n" (last new_targets))
+	  ))
+
+      new_targets)))))
+
+
+;;; CART tree to specify no accents
+
+(set! no_int_cart_tree
+'
+((NONE)))
+
+;;;
+;;; Relate phrasing to boundary tones.
+;;;   Added downstepped tones - MDS
+
+(set! tobi_label_phrase_cart_tree
+'
+((tone in ("L-" "H-" "!H-"))
+ ((B))
+ ((tone in ("H-H%" "H-L%" "!H-L%" "L-L%" "L-H%"))
+  ((BB))
+  ((NB)))))
+
+;;;
+;;;  The other functions
+;;;
+
+;;; process a list of relative targets and convert to actual targets
+
+(define (ttt_to_targets syl rlist voicing pvoicing nvoicing type)
+  "Takes a list of target sets and returns a list of targets."
+  (if (or (and (>= printdebug  2)
+	       rlist (atom (caar rlist)) 
+	       (not (equal? 'NONE (caar rlist))) (not (equal? '(NONE) (caar rlist))))
+	  (>= printdebug  3)) 
+       (begin (print "Entering ttt_to_targets with:")
+	(print (format nil "rlist: %l vc: %l pvc: %l nvc: %l type: %s" rlist voicing pvoicing nvoicing type))))
+(cond 
+ ;; nowt
+ ((eq (length rlist) 0) ())
+ ;; a single target set
+ ((atom (car (car rlist)))
+  (cond
+   ((eq type 'Accents)
+    (ttt_accent_set_to_targets syl rlist voicing pvoicing nvoicing))
+   ((eq type 'Starttones)
+    (ttt_bound_set_to_targets syl rlist voicing pvoicing))
+   ((eq type 'Endtones)
+    (ttt_bound_set_to_targets syl rlist voicing pvoicing))
+   (t (error "unknown target set encountered in ttt_to_targets"))))
+ ;; list of target sets
+ ((atom (car (car (car rlist))))
+  (append (ttt_to_targets syl (cdr rlist) voicing pvoicing nvoicing type)
+	  (ttt_to_targets syl (car rlist) voicing pvoicing nvoicing type)))
+ ;; error
+ (t (error "something strange has happened in ttt_to_targets"))))
+
+
+;; process a starttone/endtone target set.
+
+(define (ttt_bound_set_to_targets syl tset voicing pvoicing)
+  "takes a start/endtone target set and returns a list of target points."
+  (if (>= printdebug  3) (begin
+      (print "Entering ttt_bound_set_to_targets with:")
+      (pprintf (format nil "tset: %l vc: %l pvc: %l" tset voicing pvoicing))))
+  (cond
+   ;; usually target given is NONE. (also ignore unknown!)
+   ((or (eq (car (car tset)) 'NONE)
+	(eq (car (car tset)) 'UNKNOWN))
+    nil)
+   ;; a pair of target pairs
+   ((eq (length tset) 2)
+    (list (ttt_get_target (car tset) voicing) 
+	  (ttt_get_target (car (cdr tset)) voicing)))
+   ;; single target pair
+   ((eq (length tset) 1)
+    (cond
+     ;; an actual target pair
+     ((not (null (cdr (car tset))))
+      (list (ttt_get_target (car tset) voicing)))
+     ;; a TAKEOVER marker
+     ((eq (car (car tset)) 'TAKEOVER)
+      (list (list (ttt_interval_percent voicing 0) 
+		  (ttt_last_target_value syl))))
+     (t (error "unknown target pair in ttt_bound_set_to_targets"))))
+   (t (error "unknown target set type in ttt_bound_set_to_targets"))))
+
+
+;; process an accent target set.
+
+(define (ttt_accent_set_to_targets syl tset voicing pvoicing nvoicing)
+  "takes a accent target set and returns a list of target points."
+  (if (>= printdebug  3) (begin
+      (print "Entering ttt_accent_set_to_targets with:")
+      (pprintf (format nil "tset: %l vc: %l pvc: %l nvc: %l" tset voicing pvoicing nvoicing))))
+  (cond
+   ;; single target in set
+   ((null (cdr tset)) 
+    (cond
+     ; target given is NONE.
+     ((or (eq (car (car tset)) 'NONE)
+	  (eq (car (car tset)) 'UNKNOWN)) nil) 
+     ; V1 marker
+     ((eq (car (car tset)) 'V1)
+      (let ((target_time (+ (/ (- (next_accent_start syl)
+				  (ttt_last_target_time syl))
+			       2.0)
+			    (ttt_last_target_time syl))))
+	(list (list target_time (ttt_accent_pitch (Parameter.get 'Valley_Dip) target_time)))))
+     ; V2 marker
+     ((eq (car (car tset)) 'V2)
+      (let ((target_time (+ (ttt_last_target_time syl) 0.25)))
+	(list (list target_time (ttt_accent_pitch (Parameter.get 'Valley_Dip) target_time)))))
+     ; V3 marker
+     ((eq (car (car tset)) 'V3)
+      (let ((target_time (- (next_accent_start syl) 0.25)))
+	(list (list target_time (ttt_accent_pitch (Parameter.get 'Valley_Dip) target_time)))))     
+     ; single target pair
+     (t (list (ttt_get_target (car tset) voicing)))))
+   ;; a pair of targets
+   ((length tset 2)
+    (cond
+     ;; a *ed tone with PRE type tone (as in L+H*)
+     ((eq (car (car tset)) 'PRE)
+      (let ((star_target (ttt_get_target (car (cdr tset)) voicing))
+	    (last_target (parse-number(ttt_last_target_time syl))))
+	(cond
+	 ; normal 0.2s case (currently doesn't check for voicing)
+	 ((and (eqv? 0 (ip_initial syl))
+	       (> (- (car star_target) 0.2) last_target))
+	  (list  (list (- (car star_target) 0.2)
+	   	       (ttt_accent_pitch (car (cdr (car tset)))
+					 (- (car star_target) 0.2))) ; the time
+	   	 star_target))
+
+	 ; 90% prev voiced if not before last target - Added back in MDS,
+	 ; with parse-number added and new check for ip_initial
+	 ((and (eqv? 0 (ip_initial syl))
+	       (> (parse-number (ttt_interval_percent pvoicing 90))
+		  (parse-number (ttt_last_target_time syl))))
+	  (list (list (ttt_interval_percent pvoicing 90)
+		      (ttt_accent_pitch (car (cdr (car tset)))
+					(ttt_interval_percent pvoicing 90)))
+		star_target))
+
+	 ;  otherwise (UNTESTED) [NOTE: Voicing for this syllable only]
+	 (t 
+	  (list (list (ttt_interval_percent voicing 20)
+	 		(ttt_accent_pitch (car (cdr (car tset)))
+	 				  (ttt_interval_percent voicing 20)))
+	 	  star_target)))))
+     ; a *ed tone with POST type tone (as L*+H)
+     ((eq (car(car(cdr tset))) 'POST)
+      (let ((star_target (ttt_get_target (car tset) voicing))
+	    (next_target nil ) ; interesting problem
+	    (next_syl (item.next syl)))
+
+	(cond
+	 ; normal 0.2s case (UNTESTED)
+	 ((and (not (equal? next_syl nil))
+	       (eq 0 (item.feat next_syl "accented")))
+	  (cond
+	   ((< (+ (car star_target) 0.2) (item.feat next_syl "syllable_end"))
+	    (list star_target 
+		  (list (+ (car star_target) 0.2) 
+			(ttt_accent_pitch (car (cdr (car (cdr tset))))
+					  (+ (car star_target) 0.2) ))))
+	   (t 
+	    
+	    (list star_target
+		    (list (ttt_interval_percent nvoicing 90)
+			  (ttt_accent_pitch (car (cdr (car (cdr tset))))
+					    (ttt_interval_percent nvoicing 90) ))))))
+
+	 ; 20% next voiced (BUG: Can't do this as the next target hasn't been
+	 ;                                                     calculated yet!)
+	 (nil nil)
+	 ;otherwise (UNTESTED)
+	 (t (list star_target
+		  (list (ttt_interval_percent voicing 90)
+			(ttt_accent_pitch (car (cdr (car (cdr tset))))
+					  (ttt_interval_percent voicing 90) )))))))
+     
+     (t 
+      ;; This case didn't use to happen, but now must 
+      ;; to avoid +H's clobbering endtones - MDS's hack.
+      (list (ttt_get_target (car tset) voicing)
+	    (ttt_get_target (cadr tset) voicing)))))
+
+   
+   ;; something else...
+   (t (error (format nil "unknown accent set in ttt_accent_set_to_targets: %l" tset)))))
+
+
+
+(define (ttt_get_target pair voicing)
+  "Returns actual target pair, usually for a stared tone."
+  (if (>= printdebug  4) (begin
+      (print "Entering ttt_get_target with:")
+      (pprintf pair) (pprintf voicing)))
+  (list (ttt_interval_percent voicing (car pair))
+	(ttt_accent_pitch (car (cdr pair))
+			  (ttt_interval_percent voicing (car pair)))))
+
+(define (ttt_accent_pitch value time)
+  "Converts a accent pitch entry to a pitch value."
+  (if (>= printdebug  4) (begin
+      (print "Entering ttt_accent_pitch with:")
+      (pprintf value)))
+  (cond
+   ;; a real value
+   ((number? value) 
+    (ttt_interval_percent (list (ttt_get_current_baseline time)
+				(Parameter.get 'Current_Topline))
+			  value))
+   ;; Downstep then Topline
+   ((eq value 'DHIGH)
+    (progn
+     (Parameter.set 'Current_Topline (+ (ttt_get_current_baseline time)
+					(* (Parameter.get 'Downstep_Factor)
+					   (- (Parameter.get 'Current_Topline)
+					      (ttt_get_current_baseline time)))))
+     (ttt_interval_percent (list (ttt_get_current_baseline time)
+				 (Parameter.get 'Current_Topline))
+			   100)))
+     
+   ;; Unknown
+   (t  (error "Unknown accent pitch value encountered"))))
+
+
+(define (ttt_get_current_baseline v)
+  "Returns the current declined baseline at time v."
+  (if (>= printdebug  4) (begin
+      (print "Entering  ttt_get_current_baseline with:")
+      (pprintf v)))
+  (let ((h (Parameter.get 'Current_Start_Baseline))
+	(l (Parameter.get 'Current_End_Baseline))
+	(e (Parameter.get 'Phrase_End))
+	(s (Parameter.get 'Phrase_Start)))
+    (- h (* (/ (- h l) (- e s)) (- v s)))))
+
+;;; find the time n% through an inteval
+
+(define (ttt_interval_percent pair percent)
+  "Returns the time that is percent percent thought the pair."
+  (if (>= printdebug  4) (begin
+      (print "Entering ttt_interval_percent with:")
+      (pprintf (format nil "%l, %l" pair percent))))
+  (cond
+   ; no pair given: just return nil
+   ((null pair) nil)
+   ; otherwise do the calculation
+   (t (let ((start (car pair))
+	    (end (car(cdr pair))))
+	(+ start (* (- end start) (/ percent 100)))))))
+
+
+;;;  Getting start and end voicing times in a syllable
+
+(define (ttt_get_voice_times syl_item)
+  "Returns a pair of start time of first voiced phone in syllable and
+end of last voiced phone in syllable, or nil if syllable is nil"
+  (cond
+   ((null syl_item) nil)
+   (t (let ((segs (item.relation.daughters syl_item "SylStructure")))
+	(list
+	 (item.feat (ttt_first_voiced segs) "segment_start")
+	 (item.feat (ttt_first_voiced (reverse segs)) "end"))))))
+
+(define (ttt_first_voiced segs)
+  "Returns first segment that is voiced (vowel or voiced consonant)
+returns last segment if all are unvoiced."
+  (cond
+   ((null (cdr segs))
+    (car segs))  ;; last possibility
+   ((equal? "+" (item.feat (car segs) "ph_vc"))
+    (car segs))
+   ((equal? "+" (item.feat (car segs) "ph_cvox"))
+    (car segs))
+   (t
+    (ttt_first_voiced (cdr segs)))))
+
+;;; ttt_last_target has bifurcated into
+;;;   ttt_last_target_time and
+;;;   ttt_last_target_value 
+;;; to fix a place where f0 was set to last target time!
+;;;   - MDS
+
+(define (ttt_last_target_time syl)
+  "Returns the end of the most recent previous target 
+in the utterance or nil if there is not one present
+"
+  (if (>= printdebug  3)
+      (begin (print "Entering  ttt_last_target_time")
+	     (print syl))
+      )
+  (let ((target (ttt_last_target syl)))
+    (if (null? target)
+	nil
+	(item.feat target "R:Target.daughter1.pos"))))
+
+(define (ttt_last_target_value syl)
+  "Returns the pitch of the most recent previous target 
+in the utterance or nil if there is not one present
+"
+  (if (>= printdebug  3)
+      (begin (print "Entering  ttt_last_target_time")
+	     (print syl))
+      )
+  (let ((target (ttt_last_target syl)))
+    (if (null? target)
+	nil
+	(item.feat target "R:Target.daughter1.f0"))))
+
+;; Changed to scan through segments in the segment relation,
+;; to catch (notional) targets on pauses.  - MDS
+;;
+;;; associated segments are:
+;;; - the segments in the word
+;;; - subsequent segments not in the syllable structure
+;;; and on the first word, preceding segments
+;;; not in the syllable structure 
+
+(define (ttt_collect_following seg accum)
+  (if (or (null? seg)
+	  (not (null? (item.relation seg 'SylStructure))))
+      accum
+      (ttt_collect_following (item.next seg) 
+			     (cons seg accum))))
+
+
+(define (ttt_last_target syl)
+  "Returns the most recent previous target 
+in the utterance or nil if there is not one present
+"
+(if (>= printdebug  3)
+    (begin (print "Entering  ttt_last_target")
+    (print syl))
+    )
+  (let ((prev_syl (item.relation.prev syl 'Syllable)))
+    (cond
+;     ((symbol-bound? 'new_targets) (last (caar new_targets)))
+     ((null prev_syl) nil)
+     ((ttt_last_target_segs 
+       (ttt_collect_following 
+	(item.relation.next 
+	 (item.relation.daughtern prev_syl "SylStructure")
+	 "Segment")
+	(reverse (item.relation.daughters prev_syl "SylStructure")))))
+					;list of segments of prev. syllable
+					;in reverse order, with pauses
+					;prepended.
+     (t (ttt_last_target prev_syl)))))
+
+(define (ttt_last_target_segs segs)
+  "Returns the first target no earlier than seg
+or nil if there is not one
+"
+(if (>= printdebug  4)
+    (begin (print "Entering  ttt_last_target_segs with:")
+	   (pprintf (format nil "%l" segs))
+))
+  (cond
+   ((null segs) nil)
+   ((and  (> (parse-number 
+	      (item.feat  (car segs) "R:Target.daughter1.f0")) 0)
+	  (eq 0 (item.feat (car segs) "R:SylStructure.parent.lisp_lh_condition"))
+	  (eq 0 (item.feat (car segs) "R:SylStructure.parent.lisp_hl_condition"))
+	  (eq 0 (item.feat (car segs) "R:SylStructure.parent.lisp_valley_condition")))
+    (car segs))
+   
+   (t (ttt_last_target_segs (cdr segs)))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;
+;;;;;; CART TREES                           (ttt - tobi to target)
+;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;;;
+;;; Return a list of target lists. A target list comprises of a list
+;;; of related targets (ie for the L and H in L+H*), just to confuse
+;;; matters each target is also a list! (pos pitch)
+;;;
+
+
+(set! ttt_endtone_tree  ; BUG: does it check the current syl for last accent?
+      '
+      ((tobi_endtone is NONE)        ; ususally none
+       ((((NONE))))
+       ((tobi_endtone is "H-H%")     ; H-H%
+	((((100 120))))
+	((tobi_endtone is "L-L%")    ; L-L%
+	 ((((100 -20))))
+	 ((tobi_endtone is "L-H%")   ; L-H%
+	  ((lisp_last_accent > 2)
+	   ((lisp_last_accent_type is "L*") 
+	    ((((0 25) (100 40))))    ; paper says 80 but AWB had 40
+	    ((((0 0) (100 40)))))
+	   ((lisp_last_accent_type is "L*")
+	    ((((100 40))))
+	    ((((50 0) (100 40))))))
+	  ((tobi_endtone is "H-L%")  ; H-L%
+	   ((lisp_last_accent_type is "L*")
+	    ((tobi_accent is"L*")
+	     ((((50 100) (100 100))))
+	     ((((0 100) (100 100)))))
+	    ((((100 100)))))
+	  ((tobi_endtone is "!H-L%")  ; !H-L%
+	   ((lisp_last_accent_type is "L*")
+	    ((tobi_accent is"L*")
+	     ((((50 DHIGH) (100 100))))
+	     ((((0 DHIGH) (100 100)))))
+	    ((((100 DHIGH)))))
+	   ((tobi_endtone is "H-")
+	    ((((100 100))))
+	    ((tobi_endtone is "!H-")
+	     ((((100 DHIGH))))
+	     ((tobi_endtone is "L-")
+	      ((((100 0))))
+	      ((((UNKNOWN))))))))))))))
+
+(set! ttt_starttone_tree
+      '
+      ((lisp_ip_initial = 1)
+       ((tobi_endtone is "%H")
+	((((0 100))))
+	((p.tobi_endtone in ("H-" "!H-" "L-"))
+	 ((((TAKEOVER))))       ; takeover case
+	 ((tobi_accent is NONE)  
+	  ((lisp_next_accent > 2) ; default cases  (dep. on whether next target is low)
+	   ((lisp_next_accent_type in ("L*" "L*+H" "L*+!H" "L+H*" "L+!H*" "L-" "L-H%" "L-L%"))
+	    ((((0 50)(100 25))))
+	    ((((0 50)(100 75)))))
+	   ((lisp_next_accent_type in ("L*" "L*+H" "L*+!H" "L+H*" "L+!H*" "L-" "L-H%" "L-L%"))
+	    ((((0 30))))
+	    ((((0 70))))))
+	  ((tobi_accent in ("L*" "L*+H" "L*+!H" "L+H*" "L+!H*" "L-" "L-H%" "L-L%"))
+	    ((((0 30))))
+	    ((((0 70))))))))
+       ((((NONE))))))     ; otherwise (and usually) nothing.  
+
+;; Redone after Jilka, Moehler and Dogil
+;; - But treating one-syllable-ip's like
+;; last-syllable-of-ip's in cases of 
+;; two tone switches per syllable (e.g. H* L-H%). 
+;; - And (hack) a 70% target for the initial 
+;; H*'s of phrases when the next accent is L+H*
+;; - MDS
+
+(set! ttt_accent_tree
+      '
+      ((tobi_accent is "H*" )    ; H*
+       ((lisp_ip_final = 1)
+	((lisp_ip_one_syllable_case = 1)
+	 ((((50 100))))
+	 ((((25 100)))))
+	((lisp_hstar_weak_target = 1)
+	 ((((60 70))))
+	 ((lisp_ip_initial = 1) 
+	  ((((85 100))))
+	  ((((60 100)))))))
+
+      ((tobi_accent is "!H*" )    ; !H*
+       ((lisp_ip_final = 1)
+	((lisp_ip_one_syllable_case = 1)
+	 ((((50 DHIGH))))
+	 ((((25 DHIGH)))))
+       ((lisp_ip_initial = 1) 
+	((((85 DHIGH))))
+	((((60 DHIGH))))))
+
+	((tobi_accent is "L*" )    ; L*
+	 ((lisp_ip_final = 1)
+	  ((lisp_ip_one_syllable_case = 1)
+	   ((((50 0))))
+	   ((((25 0)))))
+	  ((lisp_ip_initial = 1) 
+	   ((((85 0))))
+	   ((((60 0))))))
+
+	((tobi_accent is "L+H*")   ; L+H*
+	 ((lisp_ip_final = 1)
+	  ((lisp_ip_one_syllable_case = 1)
+	   ((((PRE 20) (50 100))))  ; JMD estimated 70
+	   ((((PRE 20) (25 100)))))
+	  ((lisp_ip_initial = 1) 
+	   ((((PRE 20) (90 100))))
+	   ((((PRE 20) (75 100))))))
+
+	 ((tobi_accent is "L+!H*")   ; L+!H*
+	 ((lisp_ip_final = 1)
+	  ((lisp_ip_one_syllable_case = 1)
+	   ((((PRE 20) (70 DHIGH))))
+	   ((((PRE 20) (25 DHIGH)))))
+	  ((lisp_ip_initial = 1) 
+	   ((((PRE 20) (90 DHIGH))))
+	   ((((PRE 20) (75 DHIGH))))))
+
+	  ((tobi_accent is "L*+H")   ; L*+H
+	   ((lisp_ip_final = 1)
+	    ((lisp_ip_one_syllable_case = 1)
+	     ((((35 0) (80 100))))     ; POST would clobber endtones
+	     ((((15 0) (40 100)))))    ; POST would clobber endtones - MDS
+	    ((lisp_ip_initial = 1) 
+	     ((((55 0) (POST 100))))
+	     ((((40 0) (POST 100))))))
+
+	  ((tobi_accent is "L*+!H")   ; L*+!H
+	   ((lisp_ip_final = 1)
+	    ((lisp_ip_one_syllable_case = 1)
+	     ((((35 0) (80 DHIGH))))    ; POST would clobber endtones - MDS
+	     ((((15 0) (40 DHIGH)))))   ; POST would clobber endtones - MDS
+	    ((lisp_ip_initial = 1) 
+	     ((((55 0) (POST DHIGH))))
+	     ((((40 0) (POST DHIGH))))))
+
+	   ((tobi_accent is "H+!H*")    ; H+!H* 
+	    ((lisp_ip_final = 1)
+	     ((lisp_ip_one_syllable_case = 1)
+	      ((((PRE 143) (60 DHIGH)))) ; the 143 is a hack to level out the downstep
+	      ((((PRE 143) (20 DHIGH)))))
+	     ((lisp_ip_initial = 1) 
+	      ((((PRE 143) (90 DHIGH))))
+	      ((((PRE 143) (60 DHIGH))))))
+
+	    ((lisp_lh_condition = 1) 
+	     ((((100 75))))
+	     ((lisp_lh_condition = 2)
+	      ((((0 90))))    
+	      ((lisp_hl_condition = 1)
+	       ((((100 25))))
+	       ((lisp_valley_condition = 1)
+		((((V1 85))))
+		((lisp_valley_condition = 2)
+		 ((((V2 70))))
+		 ((lisp_valley_condition = 3)
+		  ((((V3 70))))
+		  ((tobi_accent is NONE)   ; usually we find no accent
+		   ((((NONE))))
+		   ((((UNKNOWN))))))))))))))))))))     ; UNKNOWN TARGET FOUND
+
+;;; Cart tree to "predict" pitch range
+;;; Right now just accesses a feature
+;;; "register" following Moehler & Mayer 2001.
+;;; Register must be one of
+;;;   H    - primary high register (default): 133% lowest, 92% highest
+;;;   H-H  - expanded high register: 134% lowest, 100% highest
+;;;   H-L  - lowered high register: 128% lowest, 87% highest
+;;;   L    - primary low register: 100% lowest, 73% highest
+;;;   L-L  and HL-L - low compressed: 100% lowest, 66% highest
+;;;   HL   - expanded register:   100% lowest, 84% highest
+;;;   HL-H - complete register:   100% lowest, 96% highest
+;;; For their speaker, ,BASELINE was 42% of PEAK
+
+(set! ttt_topline_tree 
+      '
+      ((R:SylStructure.parent.register is "H")
+       (92)
+       ((R:SylStructure.parent.register is "H-H")
+	(100)
+	((R:SylStructure.parent.register is "H-L")
+	 (87)
+	 ((R:SylStructure.parent.register is "L")
+	  (73)
+	  ((R:SylStructure.parent.register is "L-L")
+	   (66)
+	   ((R:SylStructure.parent.register is "HL")
+	    (84)
+	    ((R:SylStructure.parent.register is "HL-H")
+	     (96)
+	     (92)))))))))
+
+(set! ttt_baseline_tree 
+      '
+      ((R:SylStructure.parent.register is "H")
+       (133)
+       ((R:SylStructure.parent.register is "H-H")
+	(134)
+	((R:SylStructure.parent.register is "H-L")
+	 (128)
+	 ((R:SylStructure.parent.register is "L")
+	  (100)
+	  ((R:SylStructure.parent.register is "L-L")
+	   (100)
+	   ((R:SylStructure.parent.register is "HL")
+	    (100)
+	    ((R:SylStructure.parent.register is "HL-H")
+	     (100)
+	     (133)))))))))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;;;;
+;;;;;;   Lisp Feature functions.
+;;;;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (valley_condition syl)
+"(valley_condition syl)
+Function to determine if a lowered target between two high target points
+is needed in this syllable.
+Returns:  0 - no target required
+          1 - the single target case
+          2 - the first of the two target case
+          3 - the second of the two target case
+"
+(if (>= printdebug  4)
+    (begin (print "Entering valley_condition")))
+(cond
+ ((and (eq 0 (item.feat syl 'accented))
+       (string-matches (next_accent_type syl)
+		       "\\(H\\*\\|H\\-\\|H\\-L\\%\\|H\\-H\\%\\|\\!H\\*\\|\\!H\\-\\|\\!H\\-L\\%\\|\\!H\\-H\\%\\)")
+       (string-matches (last_accent_type syl)
+		       "\\(H\\*\\|L\\+H\\*\\|L\\*\\+H\\\\|\\!H\\*\\|L\\+\\!H\\*\\|L\\*\\+\\!H\\)")) 
+                       ;GM: excluded %H (returns nil for last target)
+  (let ((nas (next_accent_start syl))
+	(syls (item.feat syl 'syllable_start))
+	(syle (item.feat syl 'syllable_end))
+	(las (ttt_last_target_time syl)))
+    (if (>= printdebug  3)
+	(begin (print (format nil "nas: %l syls: %l syle %l las %l" nas syls syle las))))
+    (cond
+     ((and (< (- nas las) 0.5)
+	   (> (- nas las) 0.25)
+	   (< syls (+ (/ (- nas las) 2.0) (ttt_last_target_time syl)))
+	   (> syle (+ (/ (- nas las) 2.0) (ttt_last_target_time syl)))) 1)
+     ((and (> (- nas las) 0.5)
+	   (< syls (+ (ttt_last_target_time syl) 0.25))
+	   (> syle (+ (ttt_last_target_time syl) 0.25))) 2)
+     ((and (> (- nas las) 0.5)
+	   (< syls (- nas 0.25))
+	   (> syle (- nas 0.25))) 3)
+     (t 0))))
+ (t 0))) 
+   
+       
+
+(define (lh_condition syl)
+"(lh_condition syl)
+Function to determine the need for extra target points between an L and an H
+Returns: 1 - first extra target required
+         2 - second extra target required
+         0 - no target required.
+"
+(if (>= printdebug  4)
+    (begin (print "Entering LH_condition")))
+(cond
+ ((and (eq 0 (item.feat syl 'accented))
+       (string-matches (last_accent_type syl) "\\(L\\*\\)")
+       (string-matches (next_accent_type syl)
+		       "\\(H\\*\\|H\\-\\|H\\-L\\%\\|H\\-H\\%\\)"))
+  (cond
+   ((and (eq 1 (last_accent syl))
+	 (< 2 (next_accent syl))) 1)
+   ((and (< 2 (last_accent syl))
+	 (eq 1 (next_accent syl))) 2)
+   (t 0)))
+ (t 0)))
+
+(define (hl_condition syl)
+"(lh_condition syl)
+Function to determine the need for extra target points between an H and an L
+Returns: 1 - extra target required
+         0 - no target required.
+"
+(if (>= printdebug  4) 
+    (begin (print "Entering HL_condition")))
+(cond
+ ((and (eq 0 (item.feat syl 'accented))
+       (string-matches (next_accent_type syl)
+           "\\(L\\*\\|L\\+H\\*\\|L\\+\\!H\\*\\|L\\*\\+H\\|L\\*\\+!H\\|L\\-\\|L\\-L\\%\\|L-H\\%\\)")
+       (string-matches (last_accent_type syl)
+		       "\\(H\\*\\|L\\+H\\*\\|L\\*\\+H\\\\|\\!H\\*\\|L\\+\\!H\\*\\|L\\*\\+\\!H\\|\\%H\\)")
+                       ;MDS: added !H's
+       (eq 1 (last_accent syl))
+
+       ;; fall faster! -MDS
+       (<= 2 (next_accent syl))) 1)
+ (t 0)))
+
+(define (next_accent syl)
+"(next_accent syl)
+Wrapper for c++ func ff_next_accent.
+Returns the number of the syllables to the next accent in the following format.
+0 - no next accent
+1 - next syllable
+2 - next next syllable
+etc..."
+(if (>= printdebug  4) 
+    (begin (print "Entering next_accent")))
+(cond
+ ((eq 0 (next_accent_type syl)) 0)
+ (t (+ (item.feat syl 'next_accent) 1))))
+
+;; Fixed bug that crashed complex phrase tones. - MDS
+;; Not sure how else to get a big number...
+(define infinity (/ 1 0))
+
+;; Modified to include current accent as well -MDS
+
+(define (last_accent syl)
+"(last_accent syl)
+Wrapper for c++ func ff_last_accent.
+Returns the number of the syllables to the previous accent in the following format.
+0 - accent on current syllable
+1 - prev syllable
+2 - prev to prev syllable
+etc...
+infinity - no previous syllable"
+(if (>= printdebug  4) 
+    (begin (print "Entering last_accent")))
+(cond
+ ((not (equal? "NONE" (item.feat syl 'tobi_accent))) 0)
+ ((equal? 0 (last_accent_type syl)) infinity)
+ (t (+  (item.feat syl 'last_accent) 1))))
+
+(define (next_accent_type syl)
+"(next_accent_type syl)
+Returns the type of the next accent."
+(cond 
+ ((not (eq 0 (item.feat syl "n.R:Intonation.daughter1.name")))
+  (item.feat syl "n.R:Intonation.daughter1.name"))
+ ((eq 0 (item.feat syl 'syl_out)) 0)  ;;GM real ip_final would be better
+ (t (next_accent_type (item.relation.next syl 'Syllable)))))
+
+(define (last_accent_type syl)
+"(last_accent_type syl)
+Returns the type of the last (previous)  accent."
+(if (>= printdebug  4) 
+    (begin (print "Entering last_accent_type")))
+(cond
+  ((not (equal? "NONE"  (item.feat syl 'p.tobi_endtone)))
+   (item.feat syl 'R:Syllable.p.tobi_endtone))
+  ((not (equal? "NONE"  (item.feat syl 'p.tobi_accent)))
+   (item.feat syl 'R:Syllable.p.tobi_accent))
+  ((eq 0 (item.feat syl 'syl_in)) 0)  ;;GM real ip_initial would be better
+  (t (last_accent_type (item.prev syl 'Syllable)))))
+
+(define (next_accent_start syl)
+"(next_accent_start syl)
+Returns the start time  of the vowel of next accented syllable"
+(if (>= printdebug 4) 
+    (begin (print "Entering next_accent_start")))
+(cond 
+ ((not (eq 0 (item.feat syl "n.R:Intonation.daughter1.name")))
+  (item.feat syl "R:Syllable.n.syllable_start")) ;;GM vowel start would be better
+ ((eq 0 (item.feat syl 'syl_out)) 0)
+ (t (next_accent_start (item.relation.next syl 'Syllable)))))
+
+; new features (not used yet)
+
+(define (ip_final syl)
+  "(ip_final SYL)
+  returns 1 if the syllable is the final syllable of an 
+  ip (intermediate phrase)"
+  (cond  
+   ((or (equal? 0 (item.feat syl "syl_out"))
+       (equal? "L-" (item.feat syl "tobi_endtone"))
+       (equal? "H-" (item.feat syl "tobi_endtone"))
+       (equal? "!H-" (item.feat syl "tobi_endtone"))) 1)
+   (t 0)))
+
+(define (ip_initial syl)
+  "(ip_initial SYL)
+  returns 1 if the syllable is the initial syllable of an 
+  ip (intermediate phrase)"
+  (cond
+   ((equal? 0 (item.feat syl "syl_in"))
+    1)
+   ((equal? 1 (ip_final (item.relation.prev syl 'Syllable)))
+    1)
+   (t 0)))
+
+;; NEXT TWO FUNCTIONS ARE NEW - MDS
+(define (ip_one_syllable_case syl)
+  "(ip_one_syllable_case SYL)
+  returns true if the syllable is the initial syllable of an 
+  ip (intermediate phrase) and doesn't itself contain a complex
+  tone that starts opposite this syllable's accent"
+  (if (eqv? 0 (ip_initial syl))
+      0
+      (let ((accent (item.feat syl "tobi_accent"))
+	    (tone (item.feat syl "tobi_endtone")))
+	(cond
+	  ((and (equal? tone "L-H%")
+		(or (equal? accent "H*")
+		    (equal? accent "!H*")
+		    (equal? accent "L+H*")
+		    (equal? accent "L+!H*")
+		    (equal? accent "L*+H")
+		    (equal? accent "L*+!H*")
+		    (equal? accent "H+!H*")))
+	   0)
+	  ((and (or (equal? tone "H-L%")
+		    (equal? tone "!H-L%"))
+		(equal? accent "L*"))
+	   0)
+	  (t
+	   1)))))
+
+(define (hstar_weak_target syl)
+  (if (and (equal? 0 (item.feat syl 'asyl_in))
+	   (member (next_accent_type syl)
+		   (list "L*" "L*+H" "L*+!H" "L+H*" "L+!H*")))
+      1
+      0))
+       
+(provide 'tobi_rules)

pretrained_models/CosyVoice-ttsfrd/resource/festival/token.scm

@@ -0,0 +1,815 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Various tokenizing functions and customization 
+
+(define (Token utt)
+  "(Token UTT)
+Build a Word stream from the Token stream, analyzing compound words
+numbers etc as tokens into words. Respects the Parameter Language
+to choose the appropriate token to word module."
+  (let ((rval (apply_method 'Token_Method utt)) ;; might be defined
+	(language (Parameter.get 'Language)))
+    (cond
+     (rval rval)  ;; newer style
+     ((or (string-equal "britishenglish" language)
+	  (string-equal "english" language)
+	  (string-equal "americanenglish" language))
+      (Token_English utt))
+     ((string-equal "welsh" language)
+      (Token_Welsh utt))
+     (t
+      (Token_Any utt)))))
+
+(define (remove_leadtrail_underscores name)
+  "(remove_leadtrail_underscores name)
+Get rid of leading and trailing underscores that may be used for emphasis,
+not this is called when there are underscores at the beginning and end but
+there may not be an equal number of them."
+  (let ((se (symbolexplode name)))
+    (while (string-equal "_" (car se))
+      (set! se (cdr se)))
+    (set! se (reverse se))
+    (while (string-equal "_" (car se))
+      (set! se (cdr se)))
+    (apply string-append (reverse se))))
+
+(define (english_token_to_words token name)
+"(english_token_to_words TOKEN NAME)
+Returns a list of words for NAME from TOKEN.  This allows the
+user to customize various non-local, multi-word, context dependent
+translations of tokens into words.  If this function is unset only
+the builtin translation rules are used, if this is set the builtin
+rules are not used unless explicitly called. [see Token to word rules]"
+ (cond
+  ((string-equal (downcase name) "al'ar")
+   (list "Allar"))
+  ((string-equal name "POA")
+   (list "P" "O" (list '(name "A") (list 'pos token.letter_pos))))
+  ((string-equal name "US")
+   (list "U" "S"))
+  ((string-equal name "IT")
+   (list (list '(name "I") (list 'pos token.letter_pos)) "T"))
+  ((string-equal name "AI")
+   (list (list '(name "A") (list 'pos token.letter_pos)) "I"))
+  ((string-equal (downcase name) "openai")
+   (list "Open" (list '(name "A") (list 'pos token.letter_pos)) "I"))
+  ((string-equal name "EB")
+   (list "E" "B"))
+  ((string-equal (downcase name) "ios")
+   (list "I" "O" "S"))
+  ((string-equal (downcase name) "content")
+   (if (and (string-equal (downcase (item.feat token "n.name")) "with")
+            (string-matches (downcase (item.feat token "p.name")) "be\\|been\\|being\\|is\\(n'?t\\)?\\|are\\(n'?t\\)?\\|was\\(n'?t\\)\\|were\\(n'?t\\)\\|not\\|will\\|won'?t\\|may\\|would\\(n'?t\\)?\\|can\\(not\\)?\\|could\\(n'?t\\)?\\|should\\(n'?t\\)?\\|must\\(n'?t\\)?\\|might"))
+       (list (list (list 'name name)(list 'pos 'jj)))
+       (list (list (list 'name name)(list 'pos 'nn)))))
+  ((string-equal name "/") (list ""))
+  ((and (string-equal (downcase name) "refuse")
+        (string-equal (downcase (item.feat token "n.name")) "to"))
+       (list (list (list 'name name)(list 'pos 'vb))))
+  ((string-equal (downcase name) "live")
+   (cond
+    ((or (string-matches (downcase (item.feat token "n.name")) "nation\\|tv\\|news\\|broadcasts?\\|streams?\\|stream\\(ing\\)?\\|shows?\\|events?\\|games?\\|match\\(es\\)?\\|scores?")
+           (string-matches (downcase (item.feat token "nn.name")) "games?\\|match\\(es\\)?\\|scores?"))
+     (list (list (list 'name name)(list 'pos 'jj))))
+    ((string-equal (item.feat token "p.name") "I")
+       (list (list (list 'name name)(list 'pos 'vb))))
+    ((not (string-equal (item.feat token "punc") 0))
+      (if (string-matches (downcase (item.feat token "p.name")) "to\\|I\\|we\\|you\\|they\\|he\\|she\\|will\\|may\\|would\\|can\\|could\\|should\\|must\\|might")
+		    (list (list (list 'name name)(list 'pos 'vb)))
+		    (list (list (list 'name name)(list 'pos 'jj)))))
+    (t
+     (builtin_english_token_to_words token name))))
+  ((string-equal name "#") (list "pound"))
+  ((string-equal name "$") (list "dollar"))
+  ((string-matches name "[A-Z]*[\\$#][0-9,]+\\(\\.[0-9]+\\)?")
+   ;; Some form of money (pounds or type of dollars)
+   (let (amount type currency)
+     (cond
+      ((string-matches name ".*\\$.*")
+       (set! amount (string-after name "$"))
+       (set! type (string-before name "$"))
+       (set! currency "dollar"))
+      ((string-matches name ".*#.*")
+       (set! amount (string-after name "#"))
+       (set! type (string-before name "#"))
+       (set! currency "pound"))
+      (t
+       ;; who knows
+       (set! amount (string-after name "$"))
+       (set! type (string-before name "$"))
+       (set! currency "dollar")))
+     (cond
+      ((string-matches (item.feat token "n.name")
+		       ".*illion.?")
+       (append   ;; "billions and billions" - Sagan
+	(builtin_english_token_to_words token amount)
+	(list (item.feat token "n.name")) ;; illion
+	(token_money_expand type)
+	(list (string-append currency "s"))))
+      ((string-matches amount ".*\\...$")
+       (cond
+        ((string-equal amount "0.00")
+         (append
+          (list "zero")
+          (list (string-append currency "s"))))
+        ((string-equal amount "0.01")
+         (append
+          (list "one")
+          (if (string-equal currency "dollar")
+           (list "cent")
+           (list "penny"))))
+        ((string-matches amount "0\\.[0-9][0-9]")
+         (append
+          (builtin_english_token_to_words
+           token (remove_leading_zeros (string-after amount ".")))
+          (if (string-equal currency "dollar")
+           (list "cents")
+           (list "pence"))))
+        (t
+         (append
+	  (builtin_english_token_to_words token (string-before amount "."))
+	  (token_money_expand type)
+	  (if (string-matches amount "1\\..*")
+	   (list currency)
+	   (list (string-append currency "s")))
+          (cond
+           ((string-matches name ".*\\.00$")
+            nil)
+           ((string-matches name ".*\\.01$")
+            (append
+             (list "and" "one")
+             (if (string-equal currency "dollar")
+              (list "cent")
+              (list "penny"))))
+           (t
+            (append
+             (list "and")
+             (builtin_english_token_to_words
+              token (remove_leading_zeros (string-after amount ".")))
+             (if (string-equal currency "dollar")
+              (list "cents")
+              (list "pence")))))))))
+      (t
+       (append   ;; nothing after point or lots after point
+	(builtin_english_token_to_words token amount)
+	(token_money_expand type)
+	(if (or (string-matches amount "1")
+		(string-equal currency "yuan"))
+	    (list currency)
+	    (list (string-append currency "s"))))))))
+  ((and (string-matches name ".*illion.?")
+	(string-matches (item.feat token "p.name")
+			"[A-Z]*[\\$#][0-9,]+\\(\\.[0-9]+\\)?"))
+   nil ;; dealt with on the previous symbol
+   )
+  ((string-matches name "[1-9][0-9]*/[1-9][0-9]*")
+   (let ((numerator (string-before name "/"))
+	 (denominator (string-after name "/"))
+	 )
+     (cond
+      ((string-matches name "1/2")
+       (list "half"))
+      ((string-matches denominator "4")
+       (append
+	(builtin_english_token_to_words token numerator)
+	(list "quarter")
+	(if (string-equal numerator "1")
+	    (list '((name "'s")(pos nnp)))
+	    nil)))
+      (t
+       (append
+	(builtin_english_token_to_words token numerator)
+	(begin
+	  (item.set_feat token "token_pos" "ordinal")
+	  (builtin_english_token_to_words token denominator))
+	(if (string-equal numerator "1")
+	    nil
+	    (list '((name "'s")(pos nnp)))))))))
+  ((and (string-matches name "No")
+	(item.next token)
+        (string-matches (item.feat token "n.name")
+			"[0-9]+"))
+   (list
+    "number"))
+  ((string-matches name ".*%$")
+   (append
+    (token_to_words token (string-before name "%"))
+    (list "percent")))
+  ((string-matches name "[0-9]+s")  ;; e.g. 1950s
+   (item.set_feat token "token_pos" "year")  ;; reasonable guess
+   (append
+    (builtin_english_token_to_words token (string-before name "s"))
+    (list '((name "'s")(pos nnp))) ;; will get assimilated by postlexical rules
+   ))
+  ((string-matches name "[0-9]+'s")  ;; e.g. 1950's
+   (item.set_feat token "token_pos" "year")  ;; reasonable guess
+   (append
+    (builtin_english_token_to_words token (string-before name "'s"))
+    (list '((name "'s")(pos nnp))) ;; will get assimilated by postlexical rules
+   ))
+  ((and (string-matches name ".*s$")
+	(string-equal (item.feat token "punc") "'"))
+   ;; potential possessive or may be end of a quote
+   (if (token_no_starting_quote token)
+       (item.set_feat token "punc" ""))
+   (builtin_english_token_to_words token name))
+  ((and (string-equal name "A")  ;; letter or determiner
+	(or (and (string-matches (item.feat token "p.name") "[A-Za-z].*")
+                 (string-equal (item.feat token "p.punc") 0))
+			 ;; (or (string-equal (item.feat token "p.punc") 0)
+				 ;; (not string-matches (item.feat token "p.punc") ".*[?!:\\.;].*")))
+	    (string-matches (item.feat token "n.name") "[A-Z].*")))
+   (list (list '(name "a")(list 'pos token.letter_pos))))
+  ((and (or (string-equal name "A") (string-equal name "a")) ;; letter or determiner
+	(and (string-equal (item.feat token "p.name") 0)
+	    (string-equal (item.feat token "n.name") 0)))
+   (list (list '(name "a")(list 'pos token.letter_pos))))
+  ((member_string name english_homographs)
+   (list (list (list 'name name)
+	       (list 'hg_pos (item.feat token "token_pos")))))
+  ((string-matches name "__*[^_][^_]*_*_") ;; _emphasis_
+   (english_token_to_words
+    token
+    (remove_leadtrail_underscores name)
+   ))
+  ((string-matches name "\\(EW\\|NS\\|NE\\|CC\\|DT\\|TE\\|JS\\|JW\\|JE\\|CR\\|CP\\)[1-4][0-9]")  ;; Singapore MRT station IDs
+   (let (lname num)
+     (cond
+      ((string-matches name "EW.*")
+       (set! lname "EW"))
+      ((string-matches name "NS.*")
+       (set! lname "NS"))
+      ((string-matches name "NE.*")
+       (set! lname "NE"))
+      ((string-matches name "CC.*")
+       (set! lname "CC"))
+      ((string-matches name "DT.*")
+       (set! lname "DT"))
+      ((string-matches name "TE.*")
+       (set! lname "TE"))
+      ((string-matches name "JS.*")
+       (set! lname "JS"))
+      ((string-matches name "JW.*")
+       (set! lname "JW"))
+      ((string-matches name "JE.*")
+       (set! lname "JE"))
+      ((string-matches name "CR.*")
+       (set! lname "CR"))
+      (t
+        (set! lname "CP")))
+     (set! num (string-after name lname))
+     (append
+      (symbolexplode lname)
+      (builtin_english_token_to_words token num))))
+  ((string-matches name "\\([1-9]\\|10\\|11\\|12\\)[AaPp][Mm]")  ;; time
+   (let (hour apm (atime (downcase name)))
+     (if (string-matches atime ".*am")
+         (set! apm "am")
+         (set! apm "pm"))
+     (set! hour (string-before atime apm))
+     (append
+      (builtin_english_token_to_words token hour)
+      (if (string-equal apm "am")
+          (builtin_english_token_to_words token "A.M")
+          (builtin_english_token_to_words token "P.M")))))
+  ((string-matches name "[0-9]?[0-9][:\\.][0-9][0-9][AaPp][Mm]")  ;; time
+   ;;  must be am/pm present for . to be acceptable separator
+   (let (hours mins half sep (ttime (downcase name)))
+     (if (string-matches ttime ".*:.*")
+	 (set! sep ":")
+	 (set! sep "."))
+     (set! hours (string-before ttime sep))
+     (set! mins (string-after ttime sep))
+     (if (string-matches ttime ".*am")
+	 (set! sep "am")
+	 (set! sep "pm"))
+     (set! mins (string-before mins sep))
+     (append
+      (builtin_english_token_to_words token hours)
+      (cond
+       ((string-equal mins "00")
+	nil)
+       ((string-matches mins "0.")
+	(cons
+	 "oh"
+	 (builtin_english_token_to_words token (string-after mins "0"))))
+       (t
+	(builtin_english_token_to_words token mins)))
+      (if (string-equal sep "am")
+	  (builtin_english_token_to_words token "A.M")
+	  (builtin_english_token_to_words token "P.M")))))
+  ((string-matches name "[0-9]?[0-9]:[0-9][0-9]")  ;; time
+   (append
+     (builtin_english_token_to_words 
+      token (remove_leading_zeros (string-before name ":")))
+     (cond
+      ((string-equal "00" (string-after name ":"))
+	 nil)
+      ((string-matches (string-after name ":") "0.")
+	(cons
+	 "oh"
+	 (builtin_english_token_to_words 
+	  token 
+	  (remove_leading_zeros (string-after name ":")))))
+      (t
+	 (builtin_english_token_to_words 
+	  token 
+	  (string-after name ":"))))))
+  ((string-matches name "[0-9][0-9]:[0-9][0-9]:[0-9][0-9]")  ;; exact time
+   (append
+    (builtin_english_token_to_words 
+     token (remove_leading_zeros (string-before name ":")))
+    (list "hours")
+    (builtin_english_token_to_words 
+      token (remove_leading_zeros 
+		 (string-before (string-after name ":") ":")))
+    (list "minutes" "and")
+    (builtin_english_token_to_words 
+      token (remove_leading_zeros
+		 (string-after (string-after name ":") ":")))
+    (list "seconds")))
+  ((string-matches name "[12][0-9][0-9][0-9]/\\(1[012]\\|0[1-9]\\)/\\(0[1-9]\\|[12][0-9]\\|3[01]\\)")
+   (let ((year (string-before name "/"))
+         (num1 (string-before (string-after name "/") "/"))
+         (num2 (string-after (string-after name "/") "/"))
+         month day)
+     (cond
+      ((string-equal num1 "01")
+       (set! month "january"))
+      ((string-equal num1 "02")
+       (set! month "february"))
+      ((string-equal num1 "03")
+       (set! month "march"))
+      ((string-equal num1 "04")
+       (set! month "april"))
+      ((string-equal num1 "05")
+       (set! month "may"))
+      ((string-equal num1 "06")
+       (set! month "june"))
+      ((string-equal num1 "07")
+       (set! month "july"))
+      ((string-equal num1 "08")
+       (set! month "august"))
+      ((string-equal num1 "09")
+       (set! month "september"))
+      ((string-equal num1 "10")
+       (set! month "october"))
+      ((string-equal num1 "11")
+       (set! month "november"))
+      ((string-equal num1 "12")
+       (set! month "december"))
+      (t
+       (set! month (tok_string_as_letters num1))))
+     (item.set_feat token "token_pos" "ordinal")
+     (set! day (builtin_english_token_to_words token num2))
+     (item.set_feat token "token_pos" "year")
+     (append
+      (list month)
+      (list "the")
+      day
+      (builtin_english_token_to_words token year))))
+  ((string-matches name "[0-9][0-9]?/[0-9][0-9]?/[0-9][0-9]\\([0-9][0-9]\\)?")
+   ;; date, say it as numbers to avoid American/British problem
+   (let ((num1 (string-before name "/"))
+	 (num2 (string-before (string-after name "/") "/"))
+	 (year (string-after (string-after name "/") "/"))
+	 day month)
+     (item.set_feat token "token_pos" "cardinal")
+     (set! day (builtin_english_token_to_words token num1))
+     (set! month (builtin_english_token_to_words token num2))
+     (item.set_feat token "token_pos" "year")
+     (append
+      day
+      month
+      (list '((name ",")(pbreak_scale 0.9)))
+      (builtin_english_token_to_words token year))))
+  ((string-matches name "[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]")
+   (item.set_feat token "token_pos" "digits")  ;; canonical phone number
+   (append
+    (builtin_english_token_to_words token (string-before name "-"))
+    (list '((name ",")(pbreak_scale 1.0)))
+    (builtin_english_token_to_words token (string-after name "-"))))
+  ((string-matches name "[0-9]+-[0-9]+-[-0-9]+")
+   ;; long distance number 
+   (let ((r '(dummy)) (remainder name))
+     (item.set_feat token "token_pos" "digits")
+     (while (> (length remainder) 0)
+       (if (string-matches remainder "[0-9]+")
+	   (set! r (append r 
+		       (builtin_english_token_to_words 
+			token remainder)))
+	   (set! r (append r 
+			   (builtin_english_token_to_words 
+			    token (string-before remainder "-")))))
+       (set! remainder (string-after remainder "-"))
+       (if (> (length remainder) 0)
+	   (set! r (append r (list '((name ",")(pbreak_scale 1.0)))))))
+     (cdr r))
+   )
+  ((and (string-matches name "[0-9][0-9][0-9]")
+	(string-matches (item.feat token "n.name")
+			"[0-9][0-9][0-9]-[0-9][0-9][0-9][0-9]"))
+     (item.set_feat token "token_pos" "digits")
+     (builtin_english_token_to_words token name))
+  ((string-matches name "[0-9]+-[0-9]+")
+   (let ((tokpos))
+     (item.set_name token (string-before name "-"))
+     (set! tokpos (wagon token 
+			 (car (cdr (assoc "[0-9]+" token_pos_cart_trees)))))
+     (item.set_feat token "token_pos" (car tokpos))
+     (append
+      (builtin_english_token_to_words token (string-before name "-"))
+      (list "to")
+      (builtin_english_token_to_words token (string-after name "-")))))
+  ((string-matches name "\\(iii?\\|II?I?\\|IV\\|VI?I?I?\\|IX\\|X[VIX]*\\)")
+   ;; Roman numerals
+   (let ((tp (item.feat token "token_pos")))
+     (cond
+      ((string-matches tp "century");; always believe this
+       (item.set_feat token "token_pos" "ordinal")
+       (if (or (string-equal "1" (tok_rex token))
+	       (item.feat token "p.lisp_tok_rex_names"))
+	   (append
+	    (list "the")
+	    (builtin_english_token_to_words 
+	     token (tok_roman_to_numstring name)))
+	   (builtin_english_token_to_words 
+	    token (tok_roman_to_numstring name))))
+      ((string-matches name "[IVX]");; be *very* wary of this one
+       (if (and (string-equal 
+		 "1" (item.feat token "p.lisp_tok_section_name"))
+		(string-matches tp "number")
+                (string-equal (item.feat token "p.punc") 0))
+	   (builtin_english_token_to_words 
+	    token (tok_roman_to_numstring name))
+	   (tok_string_as_letters name)))
+      ((or (string-matches tp "number")
+           (string-matches name "iii?\\|III?"))
+       (item.set_feat token "token_pos" "cardinal")
+       (builtin_english_token_to_words 
+	token (tok_roman_to_numstring name)))
+      (t;; else its a letter
+       (tok_string_as_letters name)))))
+  ((and (string-matches name "pp")
+	(string-matches (item.feat token "n.name")
+			"[0-9]+-[0-9]+"))
+   (list "pages"))
+  ((and (string-matches name "ss")
+	(string-matches (item.feat token "n.name")
+			"[0-9]+-[0-9]+"))
+   (list "sections"))
+  ((string-matches name "_____+")
+   (list "line" "of" "underscores"))
+  ((string-matches name "=====+")
+   (list "line" "of" "equals"))
+  ((string-matches name "-----+")
+   (list "line" "of" "hyphens"))
+  ((string-matches name "\\*\\*\\*\\*\\*+")
+   (list "line" "of" "asterisks"))
+  ((string-matches name "--+")
+   (list '((name ",")(pbreak_scale 1.0))))
+  ((string-matches name ".*--+.*")
+   (append
+    (builtin_english_token_to_words token (string-before name "--"))
+    (list '((name ",")(pbreak_scale 1.0)))
+    (builtin_english_token_to_words token (string-after name "--"))))
+  ((string-matches name "[A-Z][A-Z]?&[A-Z][A-Z]?")
+   (append
+    (tok_string_as_letters (string-before name "&"))
+    (list "and")
+    (tok_string_as_letters (string-after name "&"))))
+  ((and (string-equal name "Ms")
+        (string-matches (item.feat token "n.name") "[A-Z][^A-Z]*"))
+   (list "mizz"))
+  ((string-matches name "[A-Z]+'s")
+   (append
+    (builtin_english_token_to_words token (string-before name "'s"))
+    (list '((name "'s")(pos nnp))) ;; will get assimilated by postlexical rules
+    ))
+  ((or (string-matches name "[A-Z][A-Z]+s")
+       (string-matches name "[BCDEFGHJKLMNOPQRSTVWXYZ]+s"))
+   (append
+    (builtin_english_token_to_words token (string-before name "s"))
+    (list '((name "'s")(pos nnp))) ;; will get assimilated by postlexical rules
+    ))
+  ((string-matches name "<.*@.*>")  ;; quoted e-mail
+   (append 
+    (builtin_english_token_to_words
+     token (string-after (string-before name "@") "<"))
+    (list "at")
+    (builtin_english_token_to_words
+     token (string-before (string-after name "@") ">"))))
+  ((string-matches name "\\(Dr\\|St\\)")
+   (if (string-equal (item.feat token "token_pos") "street")
+       (if (string-matches name "Dr")
+	   (list "drive")
+	   (list "street"))
+       (if (string-matches name "Dr")  ;; default on title side
+	   (list "doctor")
+	   (list "saint"))))
+  ((string-matches name "[Cc]alif")  ;; hopelessly specific ...
+   (list 
+    "california"))
+  (t
+   (builtin_english_token_to_words token name))))
+
+;;; This is set as the default
+(defvar token_to_words english_token_to_words)
+
+(defvar token.punctuation "\"'`.,:;!?(){}[]"
+  "token.punctuation
+A string of characters which are to be treated as punctuation when
+tokenizing text.  Punctuation symbols will be removed from the text
+of the token and made available through the \"punctuation\" feature.
+[see Tokenizing]")
+(defvar token.prepunctuation "\"'`({["
+  "token.prepunctuation
+A string of characters which are to be treated as preceding punctuation
+when tokenizing text.  Prepunctuation symbols will be removed from the text
+of the token and made available through the \"prepunctuation\" feature.
+[see Tokenizing]")
+(defvar token.whitespace " \t\n\r "
+  "token.whitespace
+A string of characters which are to be treated as whitespace when
+tokenizing text.  Whitespace is treated as a separator and removed
+from the text of a token and made available through the \"whitespace\"
+feature.  [see Tokenizing]")
+(defvar token.singlecharsymbols ""
+  "token.singlecharsymbols
+Characters which have always to be split as tokens.  This would be
+usual is standard text, but is useful in parsing some types of
+file. [see Tokenizing]")
+
+(defvar token.letter_pos 'nn
+  "token.letter_pos
+The part of speech tag (valid for your part of speech tagger) for
+individual letters.  When the tokenizer decide to pronounce a token
+as a list of letters this tag is added to each letter in the list.  
+Note this should be from the part of speech set used in your tagger 
+which may not be the same one that appears in the actual lexical 
+entry (if you map them afterwards).  This specifically allows \"a\"
+to come out as ae rather than @.")
+
+(defvar token.unknown_word_name "unknown"
+  "token.unknown_word_name
+When all else fails and a pronunciation for a word or character can't
+be found this word will be said instead.  If you make this \"\" them
+the unknown word will simple be omitted.  This will only
+really be called when there is a bug in the lexicon and characters
+are missing from the lexicon.  Note this word should be in the lexicon.")
+
+(def_feature_docstring
+  'Token.punc
+  "Token.punc
+Succeeding punctuation symbol found after token in original 
+string/file.")
+(def_feature_docstring
+  'Token.whitespace
+  "Token.whitespace
+Whitespace found before token in original string/file.")
+(def_feature_docstring
+  'Token.prepunctuation
+  "Token.prepunctuation
+Preceeding puctuation symbol found before token in original string/file.")
+
+(require 'tokenpos)
+;;;
+;;;  Token pos are gross level part of speech tags which help decide
+;;;  pronunciation of tokens (particular expansion of Tokens into words)
+;;;  The most obvious example is identifying number types (ordinals,
+;;;  years, digits or numbers).
+;;;
+(defvar english_token_pos_cart_trees
+  '(
+    ;;  Format is (Regex Tree)
+    ("[0-9]+" 
+     ((lisp_num_digits < 3.8)
+      ((p.lisp_token_pos_guess is month)
+       ((lisp_month_range is 0) ((cardinal)) ((ordinal)))
+       ((n.lisp_token_pos_guess is month)
+	((lisp_month_range is 0) ((cardinal)) ((ordinal)))
+	((n.lisp_token_pos_guess is numeric)
+	 ((lisp_num_digits < 2)
+	  ((p.lisp_token_pos_guess is numeric)
+	   ((pp.lisp_token_pos_guess is sym) ((digits)) ((cardinal)))
+	   ((cardinal)))
+	  ((nn.lisp_token_pos_guess is sym) ((cardinal)) ((digits))))
+	 ((lisp_num_digits < 2)
+	  ((nn.lisp_token_pos_guess is numeric)
+	   ((n.lisp_token_pos_guess is sym)
+	    ((lisp_month_range is 0) ((digits)) ((cardinal)))
+	    ((cardinal)))
+	   ((cardinal)))
+	  ((name < 302.3)
+	   ((p.lisp_token_pos_guess is flight)
+	    ((digits))
+	    ((n.lisp_token_pos_guess is sym)
+	     ((p.lisp_token_pos_guess is sym) ((digits)) ((cardinal)))
+	     ((cardinal))))
+	   ((p.lisp_token_pos_guess is a)
+	    ((digits))
+	    ((n.lisp_token_pos_guess is sym)
+	     ((nn.lisp_token_pos_guess is sym)
+	      ((name < 669.2) ((digits)) ((cardinal)))
+	      ((cardinal)))
+	     ((name < 373.2)
+	      ((cardinal))
+	      ((name < 436.2)
+	       ((name < 392.6) ((digits)) ((cardinal)))
+	       ((name < 716.5)
+		((cardinal))
+		((name < 773.6)
+		 ((p.lisp_token_pos_guess is _other_) ((digits)) ((cardinal)))
+		 ((cardinal)))))))))))))
+      ((p.lisp_token_pos_guess is numeric)
+       ((pp.lisp_token_pos_guess is month)
+	((year))
+	((nn.lisp_token_pos_guess is numeric) 
+	((cardinal)) 
+	((p.lisp_token_pos_precise_val is year)
+	((cardinal))
+	((p.lisp_token_pos_precise_val is ordinal)
+	((cardinal))
+	((digits))))))
+       ((nn.lisp_token_pos_guess is numeric)
+	((n.lisp_token_pos_guess is month)
+	 ((cardinal))
+	 ((n.lisp_token_pos_guess is numeric)
+	  ((digits))
+	  ((p.lisp_token_pos_guess is _other_) ((cardinal)) ((year)))))
+	((p.lisp_token_pos_guess is _other_)
+	 ((lisp_num_digits < 4.4)
+	  ((name < 2959.6)
+	   ((name < 1773.4) ((cardinal)) ((year)))
+	   ((cardinal)))
+	  ((pp.lisp_token_pos_guess is _other_) ((digits)) ((cardinal))))
+	 ((n.lisp_token_pos_guess is to)
+	  ((year))
+	  ((p.lisp_token_pos_guess is sym)
+	   ((pp.lisp_token_pos_guess is sym)
+	    ((cardinal))
+	    ((lisp_num_digits < 4.6) ((year)) ((digits))))
+	   ((lisp_num_digits < 4.8)
+	    ((name < 2880)
+	     ((name < 1633.2)
+	      ((name < 1306.4) ((cardinal)) ((year)))
+	      ((year)))
+	     ((cardinal)))
+	    ((cardinal)))))))))
+     )
+    ("\\(II?I?\\|IV\\|VI?I?I?\\|IX\\|X[VIX]*\\)";; Roman numerals
+     ((p.lisp_tok_rex_names is 0)
+      ((lisp_num_digits is 5)
+       ((number))
+       ((lisp_num_digits is 4)
+	((number))
+	((nn.lisp_num_digits is 13)
+	 ((number))
+	 ((p.lisp_num_digits is 7)
+	  ((number))
+	  ((p.lisp_tok_section_name is 0)
+	   ((lisp_tok_rex is 0)
+	    ((lisp_num_digits is 3)
+	     ((p.lisp_num_digits is 4)
+	      ((number))
+	      ((nn.lisp_num_digits is 4)
+	       ((number))
+	       ((n.lisp_num_digits is 4)
+		((number))
+		((pp.lisp_num_digits is 3)
+		 ((number))
+		 ((p.lisp_num_digits is 2)
+		  ((letter))
+		  ((nn.lisp_num_digits is 2)
+		   ((letter))
+		   ((n.cap is 0) ((letter)) ((number)))))))))
+	     ((nn.lisp_num_digits is 11)
+	      ((letter))
+	      ((lisp_num_digits is 1)
+	       ((pp.lisp_num_digits is 9)
+		((letter))
+		((p.lisp_num_digits is 9)
+		 ((letter))
+		 ((n.lisp_num_digits is 6)
+		  ((letter))
+		  ((pp.lisp_num_digits is 6)
+		   ((letter))
+		   ((pp.cap is 0)
+		    ((n.cap is 0)
+		     ((p.lisp_num_digits is 1)
+		      ((letter))
+		      ((n.lisp_num_digits is 4) ((letter)) ((letter))))
+		     ((letter)))
+		    ((letter)))))))
+	       ((p.lisp_num_digits is 10)
+		((number))
+		((n.lisp_num_digits is 8)
+		 ((number))
+		 ((pp.lisp_num_digits is 9)
+		  ((number))
+		  ((nn.lisp_num_digits is 5)
+		   ((number))
+		   ((n.lisp_num_digits is 4) ((number)) ((letter))))))))))
+	    ((letter)))
+	   ((number)))))))
+      ((century))))
+    ("\\(Dr\\|St\\)"
+     ((n.name is 0)
+      ((p.cap is 1)
+       ((street))
+       ((p.name matches "[0-9]*\\(1[sS][tT]\\|2[nN][dD]\\|3[rR][dD]\\|[0-9][tT][hH]\\)")
+	((street))
+	((title))))
+      ((punc matches ".*,.*")
+       ((street))
+       ((p.punc matches ".*,.*")
+	((title))
+	((n.cap is 0)
+	 ((street))
+	 ((p.cap is 0)
+	  ((p.name matches "[0-9]*\\(1[sS][tT]\\|2[nN][dD]\\|3[rR][dD]\\|[0-9][tT][hH]\\)")
+	   ((street))
+	   ((title)))
+	  ((pp.name matches "[1-9][0-9]+")
+	   ((street))
+	   ((title)))))))))
+    ("lead"
+     ((p.name in (was were have had been having has is are))
+      ((led))
+      ((liid))))
+    ("read"
+     ((p.name in ("was" "wasn't" "were" "weren't" "have" "haven't" "had" "hadn't" "been" "having" "has" "hasn't" "is" "isn't" "are" "aren't" "He" "She"))
+       ((red))
+       ((riid))))
+    ;("read"
+    ; ((p.name matches "[Pp]lease\\|PLEASE\\|[Ll]et'?s\\|LET'?S\\|[Tt][Oo]\\|[Ww]ill\\|WILL\\|[Ww]on'?t\\|WON'?T\\|[Mm]ay\\|MAY\\|[Cc]an\\(not\\|'?t\\)?\\|CAN\\(NOT\\|'?T\\)?\\|[Mm]ight\\|MIGHT\\|\\([Ww]ould\\|[Cc]ould\\|[Ss]hould\\|[Mm]ust\\)\\(n'?t\\)?\\|\\(WOULD\\|COULD\\|SHOULD\\|MUST\\)\\(N'?T\\)?")
+    ;  ((riid))
+    ;  ((p.name is 0)
+    ;   ((riid))
+    ;   ((red)))))
+    ("and"
+     ((n.name is 0)
+      ((aend))
+      ((punc is 0)
+       ((ahnd))
+       ((aend)))))
+    ("for"
+     ((n.name is 0)
+      ((faor))
+      ((punc is 0)
+       ((fer))
+       ((faor)))))
+    ("to"
+     ((n.name is 0)
+      ((tuu))
+      ((punc is 0)
+       ((to))
+       ((tuu)))))
+    ))
+
+(defvar english_homographs
+  '("lead" "read" "and" "for" "to")
+  "english_homographs
+A list of tokens that are dealt with by a homograph disambiguation tree
+in english_token_pos_cart_trees.")
+
+(defvar token_pos_cart_trees
+  english_token_pos_cart_trees
+  "token_pos_cart_trees
+This is a list of pairs or regex plus CART tree.  Tokens that match
+the regex will have the CART tree aplied, setting the result as
+the token_pos feature on the token.  The list is checked in order
+and only the first match will be applied.")
+
+(provide 'token)

pretrained_models/CosyVoice-ttsfrd/resource/festival/tokenpos.scm

@@ -0,0 +1,286 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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 used in identifying token types.
+;;;
+
+(defvar token_most_common
+'(
+sym numeric month to day in the of on and writes a years from
+for jst at million by is was gmt page he that than more since as when
+with but after about or his i has it date no died number bst who miles
+university some people an only w year have ago were are pages up days
+months hours minutes through out had which least hi last now ft this
+all one its there between cents until over will before past they
+nearly times tim message so lbs just if age we during she billion then
+other be time new her first states not you members under would many
+says degrees two next fax week while bush been around including back
+campaign american within publisher flight points even early later
+world countries every edt can president most could their what them
+former began women killed another also received long americans pounds
+do dear said km made into did dead war tel still old x took total men
+like f am less c well late down weeks end chapter among place house
+away him election death almost students state soviet where version
+summer man s nation because washington top though m id est these spent
+seats gnu estimated those lost ian high each copies children acres
+tons son per my found won off seconds power nations federal born
+presidential much city begin p name different whose three home hello
+million-euro)
+
+"token_most_common
+A list of (English) words which were found to be most common in 
+an text database and are used as discriminators in token analysis.")
+
+(define (token_pos_precise_val sc)
+"(tok_pos sc)
+Returns a general pos for sc's name. 
+  numeric   All digits
+  number    float or comma'd numeric
+  sym       Contains at least one non alphanumeric
+  month     has month name (or abbrev)
+  day       has day name (or abbrev)
+  rootname  else downcased alphabetic.
+Note this can be used to find token_pos but isn't used directly as
+its not disciminatory enough."
+  (let ((name (downcase (item.feat sc "token_pos"))))
+    (cond
+     ((string-equal name "year")
+      'year)
+     ((string-equal name "ordinal")
+      'ordinal)
+     (t
+      '_other_))))
+	  
+(define (token_pos_guess sc)
+"(tok_pos sc)
+Returns a general pos for sc's name. 
+  numeric   All digits
+  number    float or comma'd numeric
+  sym       Contains at least one non alphanumeric
+  month     has month name (or abbrev)
+  day       has day name (or abbrev)
+  rootname  else downcased alphabetic.
+Note this can be used to find token_pos but isn't used directly as
+its not disciminatory enough."
+  (let ((name (downcase (item.name sc))))
+    (cond
+     ((string-matches name "[0-9]+")
+      'numeric)
+     ((or (string-matches name "[0-9]+\\.[0-9]+")
+	  (string-matches name 
+	     "[0-9][0-9]?[0-9]?,\\([0-9][0-9][0-9],\\)*[0-9][0-9][0-9]"))
+      'number)
+     ((member_string name token_most_common)
+      name)
+     ((string-matches name ".*[^A-Za-z0-9].*")
+      'sym)
+     ((member_string name '(jan january feb february mar march 
+   			    apr april may jun june
+			    jul july aug august sep sept september
+			    oct october nov november dec december))
+      'month)
+     ((member_string name '(sun sunday mon monday tue tues tuesday 
+			    wed wednesday thu thurs thursday 
+			    fri friday sat saturday))
+      'day)
+     (t
+      '_other_))))
+
+(define (token_no_starting_quote token)
+  "(token_no_starting_quote TOKEN)
+Check to see if a single quote (or backquote) appears as prepunctuation
+in this token or any previous one in this utterance.  This is used to
+disambiguate ending single quote as possessive or end quote."
+  (cond
+   ((null token)
+    t)
+   ((string-matches (item.feat token "prepunctuation") "[`']")
+    nil)
+   (t
+    (token_no_starting_quote (item.relation.prev token "Token")))))
+
+(define (token_zerostart sc)
+"(zerostart sc)
+Returns, 1 if first char of sc's name is 0, 0 otherwise."
+  (if (string-matches (item.name sc) "^0.*")
+      "1"
+      "0"))
+
+(define (tok_roman_to_numstring roman)
+  "(tok_roman_to_numstring ROMAN)
+Takes a string of roman numerals and converts it to a number and
+then returns the printed string of that.  Only deals with numbers up to 50."
+  (let ((val 0) (chars (symbolexplode (upcase roman))))
+    (while chars
+     (cond
+      ((equal? (car chars) 'X)
+       (set! val (+ 10 val)))
+      ((equal? (car chars) 'V)
+       (set! val (+ 5 val)))
+      ((equal? (car chars) 'I)
+       (cond
+	((equal? (car (cdr chars)) 'V)
+	 (set! val (+ 4 val))
+	 (set! chars (cdr chars)))
+	((equal? (car (cdr chars)) 'X)
+	 (set! val (+ 9 val))
+	 (set! chars (cdr chars)))
+	(t
+	 (set! val (+ 1 val))))))
+     (set! chars (cdr chars)))
+    (format nil "%d" val)))
+
+(define (num_digits sc)
+"(num_digits SC)
+Returns number of digits (actually chars) is SC's name."
+  (string-length (format nil "%s" (item.name sc))))
+
+(define (month_range sc)
+"(month_range SC)
+1 if SC's name is > 0 and < 32, 0 otherwise."
+  (let ((val (parse-number (item.name sc))))
+    (if (and (> val 0) (< val 32))
+	"1"
+	"0")))
+
+(define (remove_leading_zeros name)
+  "(remove_leading_zeros name)
+Remove leading zeros from given string."
+  (let ((nname name))
+    (while (string-matches nname "^0..*")
+	   (set! nname (string-after nname "0")))
+    nname))
+
+(define (token_money_expand type)
+"(token_money_expand type)
+Convert shortened form of money identifier to words if of a known type."
+  (cond
+   ((string-equal type "HK")
+    (list "Hong" "Kong"))
+   ((string-equal type "C")
+    (list "Canadian"))
+   ((string-equal type "A")
+    (list "Australian"))
+   ((< (length type) 4)
+    (mapcar
+     (lambda (letter)
+       (list (list 'name letter)
+	     (list 'pos token.letter_pos)))
+     (symbolexplode type)))
+   (t
+    (list type))))
+
+(define (find_month_from_number token string-number)
+  "(find_month_from_number token string-number)
+Find the textual representation of the month from the given string number"
+  (let ((nnum (parse-number string-number)))
+    (cond
+     ((equal? 1 nnum) (list "January"))
+     ((equal? 2 nnum) (list "February"))
+     ((equal? 3 nnum) (list "March"))
+     ((equal? 4 nnum) (list "April"))
+     ((equal? 5 nnum) (list "May"))
+     ((equal? 6 nnum) (list "June"))
+     ((equal? 7 nnum) (list "July"))
+     ((equal? 8 nnum) (list "August"))
+     ((equal? 9 nnum) (list "September"))
+     ((equal? 10 nnum) (list "October"))
+     ((equal? 11 nnum) (list "November"))
+     ((equal? 12 nnum) (list "December"))
+     (t
+      (cons "month"
+	    (builtin_english_token_to_words token string-number))))))
+      
+(define (tok_allcaps sc)
+  "(tok_allcaps sc)
+Returns 1 if sc's name is all capitals, 0 otherwise"
+  (if (string-matches (item.name sc) "[A-Z]+")
+      "1"
+      "0"))
+
+(define (tok_section_name sc)
+  "(tok_section_name sc)
+Returns 1 if sc's name is in list of things that are section/chapter
+like."
+  (if (member_string
+       (downcase (item.name sc))
+       '(chapter section part article phrase verse scene act book 
+		 volume chap sect art vol war fortran saturn
+		 trek))
+      "1"
+      "0"))
+
+(define (tok_string_as_letters name)
+  "(tok_string_as_letters NAME)
+Return list of letters marked as letter part of speech made
+by exploding NAME."
+  (mapcar
+   (lambda (letter)
+     (list (list 'name letter)
+	   (list 'pos token.letter_pos)))
+   (symbolexplode name)))
+
+(define (tok_rex sc)
+  "(tok_rex sc)
+Returns 1 if King like title is within 3 tokens before or 2 after."
+  (let ((kings '(king queen pope duke tsar emperor shah ceasar
+		      duchess tsarina empress baron baroness
+		      count countess)))
+    (if (or (member_string 
+	     (downcase (item.feat sc "R:Token.pp.name"))
+	     kings)
+	    (member_string 
+	     (downcase (item.feat sc "R:Token.pp.p.name"))
+	     kings)
+	    (member_string 
+	     (downcase (item.feat sc "R:Token.n.name"))
+	     kings))
+	"1"
+	"0")))
+
+(define (tok_rex_names sc)
+  "(tok_rex sc)
+Returns 1 if this is a King-like name."
+  (if (and
+       (member_string
+        (downcase (item.name sc))
+        '(louis henry charles philip george edward pius william richard
+                ptolemy john paul peter nicholas
+                alexander frederick james alfonso ivan napolean leo 
+                gregory catherine alexandria pierre elizabeth mary))
+       (or (string-equal "" (item.feat sc "punc"))
+           (string-equal "0" (item.feat sc "punc"))))
+      "1"
+      "0"))
+
+(provide 'tokenpos)

pretrained_models/CosyVoice-ttsfrd/resource/festival/tts.scm

@@ -0,0 +1,304 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Various tts functions and hooks
+
+;;;  Once the utterance is built these functions synth and play it
+(defvar tts_hooks (list utt.synth utt.play)
+  "tts_hooks
+Function or list of functions to be called during text to speech.
+The function tts_file, chunks data into Utterances of type Token and
+applies this hook to the utterance.  This typically contains the utt.synth
+function and utt.play. [see TTS]")
+
+;;;  This is used to define utterance breaks in tts on files
+(defvar eou_tree 
+  '((lisp_max_num_tokens > 200)
+    ((1))
+    ((n.whitespace matches ".*\n.*\n\\(.\\|\n\\)*");; significant break (2 nls)
+     ((1))
+     ((name matches "--+")
+     ((1))
+     ((punc matches ".*[\\?:!;].*")
+      ((1))
+      ((punc matches ".*\\..*")
+       ((punc matches "..+");; longer punctuation string
+	((punc matches "\\..*,")  ;; for U.S.S.R., like tokens
+	 ((0))
+	 ((1)))
+	;; 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)))))))
+  "eou_tree
+End of utterance tree.  A decision tree used to determine if the given
+token marks the end of an utterance.  It may look one token ahead to
+do this. [see Utterance chunking]")
+
+(define (max_num_tokens x)
+  "(num_tokens x)
+This is probably controversial, but its good to have a maximum number
+of tokens in an utterance.  You really dont want to wait on very long
+utterances, some utts can be thousands of words long, these maybe
+shouldn't be spoken, but we do have to deal with them."
+  (let ((c 1) (y x))
+    (while y
+     (set! c (+ 1 c))
+     (set! y (item.prev y)))
+    c))
+
+;;;  The program used to parse stml files
+;;;  Needs version 1.0 to allow -D option to work
+(defvar sgml_parse_progname "nsgmls-1.0"
+  "sgml_parse_progname
+The name of the program to use to parse SGML files.  Typically this is
+nsgml-1.0 from the sp SGML package. [see XML/SGML requirements]")
+
+;;;  When PHRASE elements are specified in an utterance in STML
+;;;  no other method for phrase prediction is to be used, so we
+;;;  use the following tree
+(set! stml_phrase_cart_tree
+'((R:Token.parent.pbreak is B)
+  ((B))
+  ((n.name is 0)
+   ((B))
+   ((NB)))))
+
+(define (xxml_synth utt)
+"(xxml_synth UTT)
+This applies the xxml_hooks (mode specific) and tts_hooks to the
+given utterance.  This function should be called from xxml element
+definitions that signal an utterance boundary."
+   (cond
+    ((or (not utt)
+	 (not (utt.relation utt 'Token)))  ;; no tokens
+     nil)
+    (t
+     (apply_hooks xxml_hooks utt)
+     (apply_hooks tts_hooks utt)
+     (set! utt nil) ;; not enough ... 
+     (gc)
+     utt))
+)
+
+(define (xxml_attval ATTNAME ATTLIST)
+"(xxml_attval ATTNAME ATTLIST)
+Returns attribute value of ATTNAME in ATTLIST or nil if it doesn't
+exists."
+  (cond
+   ((not ATTLIST)
+    nil)
+   ((string-equal ATTNAME (car (car ATTLIST)))
+    (car (cdr (car ATTLIST))))
+   (t
+    (xxml_attval ATTNAME (cdr ATTLIST)))))
+
+(defvar xxml_word_features nil
+  "xxml_word_features
+An assoc list of features to be added to the current word when
+in xxml parse mode.")
+
+(defvar xxml_token_hooks nil
+  "xxml_token_hooks
+Functions to apply to each token.")
+
+(defvar xxml_hooks nil
+  "xxml_hooks
+  Function or list of functions to be applied to an utterance when
+  parsed with xxML, before tts_hooks.")
+
+(defvar xxml_elements nil
+  "xxml_elements
+List of Scheme actions to perform on finding xxML tags.")
+
+(defvar xml_dtd_dir libdir
+  "xml_dtd_dir
+The directory holding standard DTD form the xml parser.")
+
+(set! tts_fnum 1)
+(define (save_tts_output utt)
+  (let ((fname (string-append "tts_file_" tts_fnum ".wav")))
+    (format stderr "festival: saving waveform in %s\n" fname)
+    (utt.save.wave utt fname)
+    (set! tts_fnum (+ 1 tts_fnum))
+    utt))
+
+(define (save_waves_during_tts)
+  "(save_waves_during_tts)
+Save each waveform in the current directory in files \"tts_file_XXX.wav\".
+use (save_waves_during_tts_STOP) to stop saving waveforms"
+  (if (not (member save_tts_output tts_hooks))
+      (set! tts_hooks (append tts_hooks (list save_tts_output))))
+  t)
+
+(define (save_waves_during_tts_STOP)
+  "(save_waves_during_tts_STOP)
+Stop saving waveforms when doing tts."
+  (if (member save_tts_output tts_hooks)
+      (set! tts_hooks (delq save_tts_output tts_hooks)))
+  t)
+
+(define (tts file mode)
+  "(tts FILE MODE)
+  Convert FILE to speech.  MODE identifies any special treatment
+  necessary for FILE.  This is simply a front end to tts_file but 
+  puts the system in async audio mode first. [see TTS]"
+  (audio_mode 'async)
+  (if mode
+      (tts_file file mode)
+      (tts_file file (tts_find_text_mode file auto-text-mode-alist)))
+;;  (audio_mode 'sync) ;; Hmm this is probably bad
+)
+
+(define (tts_text string mode)
+  "(tts_text STRING mode)
+Apply tts on given string.  That is, segment it into utterances and
+apply tts_hooks to each utterance.  This is naively done by saving the
+string to a file and calling tts_file on that file.  This differs from
+SayText which constructs a single utterance for the whole given text."
+  (let ((tmpfile (make_tmp_filename))
+	(fd))
+    (set! fd (fopen tmpfile "wb"))
+    (format fd "%s" string)
+    (fclose fd)
+    (audio_mode 'async)
+    (tts_file tmpfile mode)
+    (delete-file tmpfile)))
+
+(define (save_record_wave utt)
+"Saves the waveform and records its so it can be joined into a 
+a single waveform at the end."
+  (let ((fn (make_tmp_filename)))
+    (utt.save.wave utt fn)
+    (set! wavefiles (cons fn wavefiles))
+    utt))
+
+(define (combine_waves)
+  "(combine_waves)
+Join all the waves together into the desired output file
+and delete the intermediate ones."
+  (let ((wholeutt (Utterance Text "")))
+    (mapcar
+     (lambda (d) 
+       (utt.import.wave wholeutt d t)
+       (delete-file d))
+     (reverse wavefiles))
+    wholeutt))
+
+(define (tts_textall string mode)
+  "(tts_textall STRING MODE)
+Apply tts to STRING.  This function is specifically designed for
+use in server mode so a single function call may synthesize the string.
+This function name maybe added to the server safe functions."
+  (if (not (string-equal mode "nil"))
+      (begin
+ 	  ;; a mode has been specified so do something different
+	  (let ((tmpfile (make_tmp_filename))
+		(fd))
+	    (set! fd (fopen tmpfile "wb"))
+	    (format fd "%s" string)
+	    (fclose fd)
+	    (set! tts_hooks (list utt.synth save_record_wave))
+	    (set! wavefiles nil)
+	    (tts_file tmpfile mode)
+	    (delete-file tmpfile)
+	    (utt.send.wave.client (combine_waves))
+	))
+      ;; Simple fundamental mode
+      (utt.send.wave.client 
+       (utt.synth
+	(eval (list 'Utterance 'Text string))))))
+
+;; Function to interface with app_festival for asterisk
+;; See http://www.asterisk.org
+(define (tts_textasterisk string mode)
+  "(tts_textasterisk STRING MODE)
+Apply tts to STRING.  This function is specifically designed for
+use in server mode so a single function call may synthesize the string.
+This function name may be added to the server safe functions."
+  (utt.send.wave.asterisk
+   (utt.synth
+    (eval (list 'Utterance 'Text string)))))
+
+
+
+(define (tts_return_to_client)
+  "(tts_return_to_client)
+This function is called by clients who wish to return waveforms of
+their text samples asynchronously.  This replaces utt.play in tts_hooks
+with utt.send.wave.client."
+  (if (not (member utt.send.wave.client tts_hooks))
+      (set! tts_hooks
+	    (append (delq utt.play tts_hooks)
+		    (list utt.send.wave.client)))))
+
+(defvar tts_text_modes nil
+"tts_text_modes
+An a-list of text modes data for file type specific tts functions.
+See the manual for an example.  [see Text modes]")
+
+(define (tts_find_text_mode file alist)
+  "(find_text_mode FILE ALIST)
+Search through ALIST for one that matches FILE.  Returns nil if
+nothing macthes."
+  (cond
+   ((null alist) nil)  ;; can't find a match
+   ((string-matches file (string-append ".*" (car (car alist)) ".*"))
+    (cdr (car alist)))
+   (t
+    (tts_find_text_mode file (cdr alist)))))
+
+(defvar auto-text-mode-alist
+  (list
+   (cons "\\.sable$" 'sable)
+   (cons "\\.ogi" 'ogimarkup)
+   (cons "\\.email" 'email)
+   (cons "" 'fundamental)
+   )
+  "auto-text-mode-alist
+Following Emacs' auto-mode-alist thios provides a mechanism for auto
+selecting a TTS text mode based on the filename being analyzed.  Its
+format is exactly the same as Emacs in that it consists of an alist of
+dotted pairs of regular expression and text mode name.")
+
+(provide 'tts)

pretrained_models/CosyVoice-ttsfrd/resource/festival/unilex_phones.scm

@@ -0,0 +1,189 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                Centre for Speech Technology Research                  ;;
+;;;                     University of Edinburgh, UK                       ;;
+;;;                       Copyright (c) 2003, 2004                        ;;
+;;;                        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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; unilex phoneset
+;;;
+
+
+(defPhoneSet
+  unilex
+  ;;;  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 affricative nasal liquid approximant
+   (ctype s f a n l t 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)
+   )
+  (
+   (SIL  - 0 0 0 0 0 0 -)  ;; slience ... 
+   (#  - 0 0 0 0 0 0 -)  ;; slience ... 
+   (B_10  - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_20 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_30 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_40 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_50 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_100 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_150 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_200 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_250 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_300 - 0 0 0 0 0 0 -)  ;; Pauses
+   (B_400 - 0 0 0 0 0 0 -)  ;; Pauses
+   (IGNORE - 0 0 0 0 0 0 -)  ;; Pauses
+
+
+   ;; insert the phones here, see examples in 
+   ;; festival/lib/*_phones.scm
+
+   ;(name vc vling vheight vfront vrnd ctype cplace cvox)
+
+   ;;; Rob guesed these values for Edinburgh English
+   ;;; Not to be taken too seriously.
+
+   (p    -   0   0   0   0   s   l   -)
+   (t    -   0   0   0   0   s   a   -)
+   (?    -   0   0   0   0   s   g   +) ;;; ???
+   (t^   -   0   0   0   0   t   a   +) ;;; ???
+   (k    -   0   0   0   0   s   v   -)
+   (x    -   0   0   0   0   f   v   -)
+   (b    -   0   0   0   0   s   l   +)
+   (d    -   0   0   0   0   s   a   +)
+   (g    -   0   0   0   0   s   v   +)
+   (ch   -   0   0   0   0   a   p   -)
+   (jh   -   0   0   0   0   a   p   +)
+   (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   +)
+   (h    -   0   0   0   0   f   0   -) ;;; ???
+   (m    -   0   0   0   0   n   l   +)
+   (m!   -   0   0   0   0   n   l   +)
+   (n    -   0   0   0   0   n   a   +)
+   (n!   -   0   0   0   0   n   a   +)
+   (ng   -   0   0   0   0   n   v   +)
+   (l    -   0   0   0   0   r   a   +)
+   (ll   -   0   0   0   0   r   a   +)
+   (lw   -   0   0   0   0   r   a   +)
+   (l!   -   0   0   0   0   r   a   +)
+   (r    -   0   0   0   0   r   a   +)
+   (y    -   0   0   0   0   l   p   +)
+   (w    -   0   0   0   0   l   l   +)
+   (hw   -   0   0   0   0   l   l   +)
+   (e    +   s   2   1   -   0   0   0)
+   (ao   +   s   3   1   -   0   0   0)
+   (a    +   s   3   1   -   0   0   0)
+   (ah   +   s   3   1   -   0   0   0)
+   (oa   +   s   3   1   -   0   0   0)
+   (aa   +   s   3   1   -   0   0   0)
+   (ar   +   s   3   1   -   0   0   0)
+   (eh   +   s   3   1   -   0   0   0)   ;;; ?
+   (oul  +   d   2   3   +   0   0   0)   ;;; ?
+   (ou   +   d   2   3   +   0   0   0)
+   (ouw  +   d   2   3   +   0   0   0)
+   (oou  +   l   3   3   +   0   0   0)
+   (o    +   l   3   3   +   0   0   0)
+   (au   +   l   3   3   +   0   0   0)
+   (oo   +   l   3   3   +   0   0   0)
+   (or   +   l   3   3   +   0   0   0)
+   (our  +   d   2   3   +   0   0   0)
+   (ii   +   l   1   1   -   0   0   0)
+   (ihr  +   s   1   1   -   0   0   0)
+   (iy   +   l   1   1   -   0   0   0)
+   (i    +   s   1   1   -   0   0   0)
+   (ie   +   l   1   1   -   0   0   0)   ;;; ?
+   (iii  +   s   1   1   -   0   0   0)   ;;; was ii;
+   (@r   +   a   2   2   -   r   a   +)
+   (@    +   a   2   2   -   0   0   0)
+   (uh   +   s   2   2   -   0   0   0) 
+   (uhr  +   s   2   2   -   0   0   0)
+   (u    +   l   1   3   +   0   0   0)
+   (uu   +   l   1   3   +   0   0   0)
+   (iu   +   l   1   3   +   0   0   0)
+   (uuu  +   l   1   3   +   0   0   0)   ;;; was uu;
+   (uw   +   l   1   3   +   0   0   0)   ;;; ???
+   (uul  +   l   1   3   +   0   0   0)   ;;; ???
+   (ei   +   d   2   1   -   0   0   0)
+   (ee   +   d   2   1   -   0   0   0)
+   (ai   +   d   3   2   -   0   0   0)    ;;; ???
+   (ae   +   d   3   2   -   0   0   0)    ;;; ???
+   (aer  +   d   3   2   -   0   0   0)    ;;; ???
+   (aai  +   d   3   2   -   0   0   0)    ;;; ???
+   (oi   +   d   2   3   +   0   0   0)    ;;; ???
+   (oir  +   d   2   3   +   0   0   0)    ;;; ???
+   (ow   +   d   3   2   -   0   0   0)
+   (owr  +   d   3   2   -   0   0   0)    ;;; ???
+   (oow  +   d   3   2   -   0   0   0)    ;;; ???
+   (i@   +   l   1   1   -   0   0   0)    ;;; iy + @ ?
+   (ir   +   s   1   1   -   0   0   0)
+   (irr  +   s   1   1   -   0   0   0)    ;;; was ir;
+   (iir  +   s   1   1   -   0   0   0)
+   (@@r  +   a   2   2   -   0   0   0)
+   (er   +   s   2   1   -   0   0   0)
+   (eir  +   s   2   1   -   0   0   0)    ;;; ???
+   (ur   +   s   1   3   +   0   0   0)    ;;; ???
+   (urr  +   s   1   3   +   0   0   0)    ;;; ???
+   (iur  +   s   1   3   +   0   0   0)    ;;; ???
+  )
+)
+
+(PhoneSet.silences '( # SIL))
+
+(define (unilex::select_phoneset)
+  "(unilex::select_phoneset)
+Set up phone set for unilex"
+  (Parameter.set 'PhoneSet 'unilex)
+  (PhoneSet.select 'unilex)
+)
+
+(define (unilex::reset_phoneset)
+  "(unilex::reset_phoneset)
+Reset phone set for unilex."
+  t
+)
+
+(provide 'unilex_phones)

pretrained_models/CosyVoice-ttsfrd/resource/festival/voices.scm

@@ -0,0 +1,361 @@
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;                                                                       ;;
+;;;                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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; Preapre to access voices. Searches down a path of places.
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define current-voice nil
+  "current-voice
+   The name of the current voice.")
+
+;; The path to search for voices is created from the load-path with
+;; an extra list of directories appended.
+
+(defvar system-voice-path '( )
+  "system-voice-path
+   Additional directory not near the load path where voices can be
+   found, this can be redefined in lib/sitevars.scm if desired.")
+
+(defvar system-voice-path-multisyn '( )
+  "system-voice-path-multisyn
+   Additional directory not near the load path where multisyn voices can be
+   found, this can be redefined in lib/sitevars.scm if desired.")
+
+(defvar voice-path 
+  (remove-duplicates
+   (append (mapcar (lambda (d) (path-append d "voices/")) load-path)
+	   (mapcar (lambda (d) (path-as-directory d)) system-voice-path)
+	   ))
+
+  "voice-path
+   List of places to look for voices. If not set it is initialised from
+   load-path by appending \"voices/\" to each directory with 
+   system-voice-path appended.")
+
+(defvar voice-path-multisyn 
+  (remove-duplicates
+   (append (mapcar (lambda (d) (path-append d "voices-multisyn/")) load-path)
+	   (mapcar (lambda (d) (path-as-directory d)) system-voice-path-multisyn)
+	   ))
+
+  "voice-path-multisyn
+   List of places to look for multisyn voices. If not set it is initialised from
+   load-path by appending \"voices-multisyn/\" to each directory with 
+   system-voice-path-multisyn appended.")
+
+
+;; Declaration of voices. When we declare a voice we record the
+;; directory and set up an autoload for the vocie-selecting function
+
+(defvar voice-locations ()
+  "voice-locations
+   Association list recording where voices were found.")
+
+(defvar voice-location-trace nil
+  "voice-location-trace
+   Set t to print voice locations as they are found")
+
+(define (voice-location name dir doc)
+  "(voice-location NAME DIR DOCSTRING)
+   Record the location of a voice. Called for each voice found on voice-path.
+   Can be called in site-init or .festivalrc for additional voices which
+   exist elsewhere."
+  (let ((func_name (intern (string-append "voice_" name)))
+	)
+
+    (set! name (intern name))
+    (set! voice-locations (cons (cons name dir) voice-locations))
+    (eval (list 'autoload func_name (path-append dir "festvox/" name) doc))
+    (if voice-location-trace
+	(format t "Voice: %s %s\n" name dir)
+	)
+    )
+  )
+
+(define (voice-location-multisyn name rootname dir doc)
+  "(voice-location NAME ROOTNAME DIR DOCSTRING)
+   Record the location of a voice. Called for each voice found on voice-path.
+   Can be called in site-init or .festivalrc for additional voices which
+   exist elsewhere."
+  (let ((func_name (intern (string-append "voice_" name)))
+	)
+
+    (set! name (intern name))
+    (set! voice-locations (cons (cons name dir) voice-locations))
+    (eval (list 'autoload func_name (path-append dir "festvox/" rootname) doc))
+    (if voice-location-trace
+	(format t "Voice: %s %s\n" name dir)
+	)
+    )
+  )
+
+
+
+(define (current_voice_reset)
+"(current_voice_reset)
+This function is called at the start of defining any new voice.
+It is design to allow the previous voice to reset any global
+values it has messed with.  If this variable value is nil then
+the function wont be called.")
+
+(define (voice_reset)
+"(voice_reset)
+This resets all variables back to acceptable values that may affect
+voice generation.  This function should always be called at the
+start of any function defining a voice.  In addition to reseting
+standard variables the function current_voice_reset will be called.
+This should always be set by the voice definition function (even
+if it does nothing).  This allows voice specific changes to be reset
+when a new voice is selection.  Unfortunately I can't force this
+to be used."
+   (Parameter.set 'Duration_Stretch 1.0)
+   (set! after_synth_hooks default_after_synth_hooks)
+
+   ;; The follow are reset to allow existing voices to continue
+   ;; to work, new voices should be setting these explicitly
+   (Parameter.set 'Token_Method 'Token_English)
+   (Parameter.set 'POS_Method Classic_POS)
+   (Parameter.set 'Phrasify_Method Classic_Phrasify)
+   (Parameter.set 'Word_Method Classic_Word)
+   (Parameter.set 'Pause_Method Classic_Pauses)
+   (Parameter.set 'PostLex_Method Classic_PostLex)
+
+   (set! diphone_module_hooks nil)
+   (set! UniSyn_module_hooks nil)
+
+   (if current_voice_reset
+       (current_voice_reset))
+   (set! current_voice_reset nil)
+)
+
+
+(defvar Voice_descriptions nil
+  "Internal variable containing list of voice descriptions as
+decribed by proclaim_voice.")
+
+(define (proclaim_voice name description)
+"(proclaim_voice NAME DESCRIPTION)
+Describe a voice to the systen.  NAME should be atomic name, that
+conventionally will have voice_ prepended to name the basic selection
+function.  OPTIONS is an assoc list of feature and value and must
+have at least features for language, gender, dialect and 
+description.  The first there of these are atomic, while the description
+is a text string describing the voice."
+  (let ((voxdesc (assoc name Voice_descriptions)))
+    (if voxdesc
+	(set-car! (cdr voxdesc) description)
+	(set! Voice_descriptions 
+	      (cons (list name description) Voice_descriptions))))
+)
+
+(define (voice.description name)
+"(voice.description NAME)
+Output description of named voice.  If the named voice is not yet loaded
+it is loaded."
+  (let ((voxdesc (assoc name Voice_descriptions))
+	(cv current-voice))
+    (if (null voxdesc)
+	(unwind-protect
+	 (begin 
+	   (voice.select name)
+	   (voice.select cv) ;; switch back to current voice
+	   (set! voxdesc (assoc name Voice_descriptions)))))
+    (if voxdesc
+       voxdesc
+       (begin
+	 (format t "SIOD: unknown voice %s\n" name)
+	 nil))))
+
+(define (voice.select name)
+"(voice.select NAME)
+Call function to set up voice NAME.  This is normally done by 
+prepending voice_ to NAME and call it as a function."
+  (eval (list (intern (string-append "voice_" name)))))
+
+(define (voice.describe name)
+"(voice.describe NAME)
+Describe voice NAME by saying its description.  Unfortunately although
+it would be nice to say that voice's description in the voice itself
+its not going to work cross language.  So this just uses the current
+voice.  So here we assume voices describe themselves in English 
+which is pretty anglo-centric, shitsurei shimasu."
+  (let ((voxdesc (voice.description name)))
+    (let ((desc (car (cdr (assoc 'description (car (cdr voxdesc)))))))
+      (cond
+       (desc (tts_text desc nil))
+       (voxdesc 
+	(SayText 
+	 (format nil "A voice called %s exist but it has no description"
+		 name)))
+       (t
+	(SayText 
+	 (format nil "There is no voice called %s defined" name)))))))
+
+(define (voice.list)
+"(voice.list)
+List of all (potential) voices in the system.  This checks the voice-location
+list of potential voices found be scanning the voice-path at start up time.
+These names can be used as arguments to voice.description and
+voice.describe."
+   (mapcar car voice-locations))
+
+;; Voices are found on the voice-path if they are in directories of the form
+;;		DIR/LANGUAGE/NAME
+
+(define (search-for-voices)
+  "(search-for-voices)
+   Search down voice-path to locate voices."
+
+  (let ((dirs voice-path)
+	(dir nil)
+	languages language
+	voices voicedir voice
+	)
+    (while dirs
+     (set! dir (car dirs))
+     (setq languages (directory-entries dir t))
+     (while languages
+       (set! language (car languages))
+       (set! voices (directory-entries (path-append dir language) t))
+       (while voices
+	 (set! voicedir (car voices))
+	 (set! voice (path-basename voicedir))
+	 (if (string-matches voicedir ".*\\..*")
+	     nil
+	     (voice-location 
+	      voice 
+	      (path-as-directory (path-append dir language voicedir))
+	      "voice found on path")
+	     )
+	 (set! voices (cdr voices))
+	 )
+       (set! languages (cdr languages))
+       )
+     (set! dirs (cdr dirs))
+     )
+    )
+  )
+
+;; A single file is allowed to define multiple multisyn voices, so this has
+;; been adapted for this. Rob thinks this is just evil, but couldn't think
+;; of a better way.
+(define (search-for-voices-multisyn)
+  "(search-for-voices-multisyn)
+   Search down multisyn voice-path to locate multisyn voices."
+  (let ((dirs voice-path-multisyn)
+	(dir nil)
+	languages language
+	voices voicedir voice voice-list
+	)
+    (while dirs
+     (set! dir (car dirs))
+     (set! languages (directory-entries dir t))
+     (while languages
+       (set! language (car languages))
+       (set! voices (directory-entries (path-append dir language) t))
+       (while voices
+	 (set! voicedir (car voices))
+	 (set! voice (path-basename voicedir))
+	 (if (string-matches voicedir ".*\\..*")
+	     nil
+	     (begin
+	       ;; load the voice definition file, but don't evaluate it!
+	       (set! voice-def-file (load (path-append dir language voicedir "festvox" 
+						       (string-append voicedir ".scm")) t))
+	       ;; now find the "proclaim_voice" lines and register these voices.
+	       (mapcar
+		(lambda (line)
+		  (if (string-matches (car line) "proclaim_voice")
+		      (voice-location-multisyn (intern (cadr (cadr line)))  voicedir (path-append dir language voicedir) "registerd multisyn voice")))
+		voice-def-file)
+	     ))
+	 (set! voices (cdr voices)))
+       (set! languages (cdr languages)))
+     (set! dirs (cdr dirs)))))
+
+(search-for-voices)
+(search-for-voices-multisyn)
+
+;; We select the default voice from a list of possibilities. One of these
+;; had better exist in every installation.
+
+(define (no_voice_error)
+  (format t "\nWARNING\n")
+  (format t "No default voice found in %l\n" voice-path)
+  (format t "either no voices unpacked or voice-path is wrong\n")
+  (format t "Scheme interpreter will work, but there is no voice to speak with.\n")
+  (format t "WARNING\n\n"))
+
+(defvar voice_default 'no_voice_error
+ "voice_default
+A variable whose value is a function name that is called on start up to
+the default voice. [see Site initialization]")
+
+(defvar default-voice-priority-list 
+  '(kal_diphone
+    cmu_us_slt_cg
+    cmu_us_rms_cg
+    cmu_us_bdl_cg
+    cmu_us_jmk_cg
+    cmu_us_awb_cg
+;    cstr_rpx_nina_multisyn       ; restricted license (lexicon)
+;    cstr_rpx_jon_multisyn       ; restricted license (lexicon)
+;    cstr_edi_awb_arctic_multisyn ; restricted license (lexicon)
+;    cstr_us_awb_arctic_multisyn
+    ked_diphone
+    don_diphone
+    rab_diphone
+    en1_mbrola
+    us1_mbrola
+    us2_mbrola
+    us3_mbrola
+    gsw_diphone  ;; not publically distributed
+    el_diphone
+    )
+  "default-voice-priority-list
+   List of voice names. The first of them available becomes the default voice.")
+
+(let ((voices default-voice-priority-list)
+      voice)
+  (while (and voices (eq voice_default 'no_voice_error))
+	 (set! voice (car voices))
+	 (if (assoc voice voice-locations)
+	     (set! voice_default (intern (string-append "voice_" voice)))
+	     )
+	 (set! voices (cdr voices))
+	 )
+  )
+
+
+(provide 'voices)

pretrained_models/CosyVoice-ttsfrd/resource/festival/web.scm

@@ -0,0 +1,103 @@
+
+
+
+
+ ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+ ;;; DO NOT EDIT THIS FILE ON PAIN OF MORE PAIN.
+ ;;; 
+ ;;; The master copy of this file is in ../../speech_tools/lib/siod/web.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.                                                       ;;
+;;;                                                                       ;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;;  Some things for dealing with the web.
+;;;
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(define (get_url url filename)
+  "(get_url URL OUTFILE)
+  Get URL and put contents in OUTFILE. Currently only http, and file
+  type URLs are supported."
+
+  (let ((infile (fopen (parse_url url) "rb")))
+    (if infile
+	(let ((outfile (fopen filename "wb")))
+	  (if outfile
+	      (let ((buffer "                                                                                                                               ") n)
+		(while (set! n (fread buffer infile))
+		       (if ( < n (length buffer))
+			   (setq buffer (substring buffer 0 n)))
+		       (fwrite buffer outfile))
+		(fclose infile)
+		(fclose outfile)
+		)
+	      "can't open out"
+	      )
+	  )
+	"can't open in"
+	)
+    )
+  )
+
+(define (socket_open host port how)
+  "(socket_open HOST PORT HOW)
+   Open a file descriptor to the BSD socket on HOST at PORT.  HOW may
+   be \"r\" or \"w\" for a read only or write only filedescriptor.  If
+   HOW is unspecified or NIL, \"w\" is assumed.  If HOW is \"rw\" then
+   a list of two file descriptors is returned, the first for reading
+   the second for writing.  Take care when using the bidiectional socket
+   that deadlock doesn't occur."
+
+  (let ((file (fopen (list "tcp" host port "") how)))
+    (if (or (equal? how "rw") (equal how "r+"))
+	(list file file)
+	file)
+    )
+  )
+  
+    
+(provide 'web)
+	

pretrained_models/CosyVoice-ttsfrd/resource/jprsc/COPYING

@@ -0,0 +1,100 @@
+Copyright (c) 2009, Nara Institute of Science and Technology, Japan.
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+Neither the name of the Nara Institute of Science and Technology
+(NAIST) nor the names of its contributors may be used to endorse or
+promote products derived from this software without specific prior
+written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Copyright (c) 2011-2017, The UniDic Consortium
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the
+   distribution.
+
+ * Neither the name of the UniDic Consortium nor the names of its
+   contributors may be used to endorse or promote products derived
+   from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/* ----------------------------------------------------------------- */
+/*           The Japanese TTS System "Open JTalk"                    */
+/*           developed by HTS Working Group                          */
+/*           http://open-jtalk.sourceforge.net/                      */
+/* ----------------------------------------------------------------- */
+/*                                                                   */
+/*  Copyright (c) 2008-2016  Nagoya Institute of Technology          */
+/*                           Department of Computer Science          */
+/*                                                                   */
+/* All rights reserved.                                              */
+/*                                                                   */
+/* Redistribution and use in source and binary forms, with or        */
+/* without modification, are permitted provided that the following   */
+/* conditions are met:                                               */
+/*                                                                   */
+/* - Redistributions of source code must retain the above copyright  */
+/*   notice, this list of conditions and the following disclaimer.   */
+/* - Redistributions in binary form must reproduce the above         */
+/*   copyright notice, this list of conditions and the following     */
+/*   disclaimer in the documentation and/or other materials provided */
+/*   with the distribution.                                          */
+/* - Neither the name of the HTS working group nor the names of its  */
+/*   contributors may be used to endorse or promote products derived */
+/*   from this software without specific prior written permission.   */
+/*                                                                   */
+/* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND            */
+/* CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,       */
+/* INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF          */
+/* MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE          */
+/* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS */
+/* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,          */
+/* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED   */
+/* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,     */
+/* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON */
+/* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,   */
+/* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY    */
+/* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE           */
+/* POSSIBILITY OF SUCH DAMAGE.                                       */
+/* ----------------------------------------------------------------- */