Add tts-cpp/ subtree (Chatterbox Turbo + Multilingual + Supertonic TTS) + integration fixes

README.md

@@ -55,6 +55,24 @@ On Apple Silicon, the inference runs fully on the GPU via Metal:
 
 https://github.com/ggml-org/whisper.cpp/assets/1991296/c82e8f86-60dc-49f2-b048-d2fdbd6b5225
 
+## QVAC speech-stack ports
+
+This fork carries two in-tree subtrees alongside the upstream whisper.cpp
+sources:
+
+- [`tts-cpp/`](tts-cpp/) — text-to-speech via Resemble Chatterbox (Turbo +
+  Multilingual) and Supertonic. In-tree subtree of
+  [github.com/gianni-cor/chatterbox.cpp](https://github.com/gianni-cor/chatterbox.cpp);
+  consumes ggml from the [`qvac-ext-ggml/speech`](https://github.com/tetherto/qvac-ext-ggml/tree/speech)
+  branch via the `ggml-speech` vcpkg port.
+- [`parakeet-cpp/`](parakeet-cpp/) — automatic speech recognition (NVIDIA
+  Parakeet FastConformer family — CTC, TDT, EOU, Sortformer) and
+  speaker diarization. In-tree subtree of the standalone parakeet.cpp
+  repo; same `ggml-speech` consumption pattern.
+
+Each subtree has its own README / build flow / public C++ API.  The
+upstream whisper.cpp build below is unaffected by either.
+
 ## Quick start
 
 First clone the repository:

parakeet-cpp/include/parakeet/streaming.h

@@ -94,6 +94,21 @@ struct StreamingSegment {
     int  chunk_index = 0;
     bool is_final    = true;
 
+    // True when this segment's first token is a SentencePiece word-start
+    // (the piece begins with the `▁` U+2581 marker), false when it is a
+    // wordpiece continuation of the previous segment's last token.
+    //
+    // Streaming consumers building a running transcript should insert a
+    // separator (e.g. " ") between successive segments only when the
+    // *new* segment has `starts_word == true`. Concatenating verbatim
+    // when `starts_word == false` joins the splits like
+    // ["pun", "ctuation"] back into "punctuation"; inserting a space
+    // there would yield "pun ctuation" instead.
+    //
+    // Always true on the very first segment of a session and on any
+    // segment whose token list is empty (defensive default).
+    bool   starts_word = true;
+
     // EOU-only: true when this segment ends on `<EOU>`. For CTC/TDT use StreamEvent
     // EndOfTurn via `on_event` instead; those engines leave this flag false here.
     bool   is_eou_boundary = false;

parakeet-cpp/src/parakeet_engine.cpp

@@ -473,6 +473,9 @@ EngineResult Engine::transcribe_samples_stream(const float * samples,
             seg.end_s       = seg_end_s;
             seg.chunk_index = chunk_index;
             seg.is_final    = true;
+            seg.starts_word = win_tokens.empty()
+                ? true
+                : token_is_word_start(pimpl_->model.vocab, win_tokens.front());
             seg.is_eou_boundary = eou_boundaries_in_chunk > 0;
             seg.encoder_ms  = first_segment ? encoder_ms : 0.0;
             seg.decode_ms   = win_decode_ms;
@@ -863,6 +866,9 @@ void StreamSession::Impl::process_window(const float * window_samples, int windo
         seg.end_s       = chunk_end_s;
         seg.chunk_index = chunk_index;
         seg.is_final    = true;
+        seg.starts_word = win_tokens.empty()
+            ? true
+            : token_is_word_start(engine_impl->model.vocab, win_tokens.front());
         seg.is_eou_boundary = eou_boundaries_in_chunk > 0;
         seg.encoder_ms  = encoder_ms;
         seg.decode_ms   = decode_ms;

parakeet-cpp/src/sentencepiece_bpe.cpp

@@ -36,4 +36,16 @@ std::string detokenize(const BpeVocab & vocab,
     return out;
 }
 
+bool token_is_word_start(const BpeVocab & vocab, int32_t token_id) {
+    if (token_id < 0 || token_id >= static_cast<int32_t>(vocab.pieces.size())) return false;
+    if (token_id == vocab.blank_id || token_id == vocab.bos_id ||
+        token_id == vocab.eos_id   || token_id == vocab.pad_id) return false;
+    const std::string & piece = vocab.pieces[token_id];
+    if (piece.size() < 3) return false;
+    const unsigned char c0 = static_cast<unsigned char>(piece[0]);
+    const unsigned char c1 = static_cast<unsigned char>(piece[1]);
+    const unsigned char c2 = static_cast<unsigned char>(piece[2]);
+    return c0 == 0xE2 && c1 == 0x96 && c2 == 0x81;
+}
+
 }

parakeet-cpp/src/sentencepiece_bpe.h

@@ -25,4 +25,18 @@ struct BpeVocab {
 std::string detokenize(const BpeVocab & vocab,
                        const std::vector<int32_t> & token_ids);
 
+// True when the token's piece (in `vocab.pieces`) begins with the
+// SentencePiece word-boundary marker `▁` (U+2581, encoded as the 3-byte
+// sequence 0xE2 0x96 0x81 in UTF-8). Used by the streaming sessions to
+// stamp `StreamingSegment::starts_word` so consumers can distinguish a
+// chunk-boundary wordpiece continuation ("ctuation" after "pun") from
+// a fresh word ("if" after "see") without re-implementing the BPE
+// detokenizer rules.
+//
+// Returns false for out-of-range, blank/bos/eos/pad ids, and pieces
+// whose first byte does not start the U+2581 marker (e.g. punctuation
+// pieces like ",", "." that should still be glued onto the previous
+// word without an inserted space).
+bool token_is_word_start(const BpeVocab & vocab, int32_t token_id);
+
 }

tts-cpp/.gitignore

@@ -0,0 +1,40 @@
+# Vendored ggml (cloned separately at setup time; see README)
+ggml/
+
+# Build artifacts
+build/
+build-*/
+build_tts_cli/
+*.o
+*.obj
+
+# Python
+__pycache__/
+*.pyc
+.venv/
+venv/
+
+# Model files (too big for git)
+models/
+*.gguf
+
+# Reference dumps
+artifacts/
+
+# Local tokenizer files (downloaded from HF cache)
+tokenizer/
+
+# Voice-clone profiles (generated per reference audio)
+voices/
+
+# Generated audio
+*.wav
+
+# Editor files
+.vscode/
+.idea/
+*.swp
+.DS_Store
+._*
+.cache/
+compile_commands.json