migrating to miniblack

rigel/tcp.py

@@ -85,7 +85,7 @@ def synth(config):
                     break
 
                 wav = synthesizer.tts(message, speaker_idx, "None", None)
-                # synthesizer.save_wav(wav, "/tmp/blah.wav")
+                synthesizer.save_wav(wav, "/tmp/blah.wav")
                 play(wav)
 
                 writer.write(b"Ok")

telegram_bot/pkg/core/#converter.go#

@@ -0,0 +1,185 @@
+/*
+ Orion --- Speech to text bot
+
+   Copyright (c) 2022  Sameer Rahmani <lxsameer@gnu.org>
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 2 of the License.
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package core
+
+import (
+	"os/exec"
+)
+
+func ConvertOggtoWav(inputFile *string, outputFile *string) error {
+	cmd := exec.Command("ffmpeg", "-i", *inputFile, "-ar", "16000", *outputFile)
+	if err := cmd.Run(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// =============================
+// Since sox doesn't support Opus and telegram uses opus format, i've
+// tried to convert opus to wav but it didn't go well and since it's
+// a personal project and I don't want to spend much time on it, I've
+// decided to use ffmpeg but I'm keeping my effort here. Maybe in the
+// future I spend more time on it.
+
+// func ConvertOpusToWav(inputFile *string, outputFile *string) error {
+// 	channels := 1
+
+// 	f, err := os.Open(*inputFile)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	defer f.Close()
+
+// 	wavOut, err := os.Create(*outputFile)
+
+// 	if err != nil {
+// 		return err
+// 	}
+// 	defer wavOut.Close()
+
+// 	out := wav.File{
+// 		Channels:        1,
+// 		SampleRate:      rate,
+// 		SignificantBits: bits,
+// 	}
+// 	writer, err := out.NewWriter(wavOut)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	defer writer.Close()
+
+// 	s, err := opus.NewStream(f)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	defer s.Close()
+
+// 	pcmbuf := make([]int16, )
+// 	for {
+// 		n, err := s.Read(pcmbuf)
+// 		if err == io.EOF {
+// 			break
+// 		} else if err != nil {
+// 			return err
+// 		}
+
+// 		pcm := pcmbuf[:n*channels]
+// 		buf := new(bytes.Buffer)
+// 		err = binary.Write(buf, binary.LittleEndian, pcm)
+// 		if err != nil {
+// 			return err
+// 		}
+
+// 		writer.WriteSample(buf.Bytes())
+// 		// send pcm to audio device here, or write to a .wav file
+// 	}
+// 	return nil
+// 	// sampleRate := 16000
+// 	// frameSizeMs  := 60
+// 	// frameSize := channels * frameSizeMs * sampleRate / 1000
+
+// 	// dec, err := opus.NewDecoder(sampleRate, channels)
+
+// 	// if err != nil {
+// 	// 	return nil, err
+// 	// }
+
+// 	// in, err := os.Open(*inputFile)
+// 	// if err != nil {
+// 	// 	return nil, err
+// 	// }
+// 	// defer in.Close()
+// 	// data, err := ioutil.ReadFile(*inputFile)
+
+// 	// if err != nil {
+// 	// 	return nil, err
+// 	// }
+
+// 	// pcm := make([]int16, int(frameSize))
+// 	// n, err := dec.Decode(data, pcm)
+// 	// if err != nil {
+// 	// 	return nil, err
+// 	// }
+
+// 	// // To get all samples (interleaved if multiple channels):
+// 	// pcm = pcm[:n*channels] // only necessary if you didn't know the right frame size
+// 	// return pcm, nil
+// 	// // buf := new(bytes.Buffer)
+// 	// // err = binary.Write(buf, binary.LittleEndian, pcm)
+// 	// // if(err != nil) {
+// 	// // 	return nil, err
+// 	// // }
+// 	// // return buf.Bytes(), nil
+// }
+
+// func ConvertToWav(inputFile *string, outputFile *string) error {
+// 	if !sox.Init() {
+// 		return fmt.Errorf("failed to initialize SoX")
+// 	}
+// 	defer sox.Quit()
+
+// 	// Open the input file (with default parameters)
+// 	in := sox.OpenRead(*inputFile)
+// 	if in == nil {
+// 		return fmt.Errorf("failed to open input ogg file")
+// 	}
+// 	// Close the file before exiting
+// 	defer in.Release()
+
+// 	out := sox.OpenWrite(*outputFile, in.Signal(), nil, "alsa")
+// 	if out == nil {
+// 		out = sox.OpenWrite("default", in.Signal(), nil, "pulseaudio")
+// 		if out == nil {
+// 			return fmt.Errorf("failed to open output device")
+// 		}
+// 	}
+// 	// Close the output device before exiting
+// 	defer out.Release()
+
+// 	// Create an effects chain: Some effects need to know about the
+// 	// input or output encoding so we provide that information here.
+// 	chain := sox.CreateEffectsChain(in.Encoding(), out.Encoding())
+// 	// Make sure to clean up!
+// 	defer chain.Release()
+
+// 	// The first effect in the effect chain must be something that can
+// 	// source samples; in this case, we use the built-in handler that
+// 	// inputs data from an audio file.
+// 	e := sox.CreateEffect(sox.FindEffect("input"))
+// 	e.Options(in)
+// 	// This becomes the first "effect" in the chain
+// 	chain.Add(e, in.Signal(), in.Signal())
+// 	e.Release()
+
+// 	// Create the `rate' effect, to set the samplerate
+// 	e = sox.CreateEffect(sox.FindEffect("rate"))
+// 	e.Options(16000)
+// 	chain.Add(e, in.Signal(), in.Signal())
+// 	e.Release()
+
+// 	// The last effect in the effect chain must be something that only consumes
+// 	// samples; in this case, we use the built-in handler that outputs data.
+// 	e = sox.CreateEffect(sox.FindEffect("output"))
+// 	e.Options(out)
+// 	chain.Add(e, in.Signal(), in.Signal())
+// 	e.Release()
+
+// 	// Flow samples through the effects processing chain until EOF is reached.
+// 	chain.Flow()
+
+// 	return nil
+// }				//