1. Full Pipeline Overview

Dictionary word
   ↓
Orthographic normalization
   ↓
BPM to IPA conversion
   ↓
Phoneme tokenization
   ↓
Diphone generation
   ↓
Safe filename mapping
   ↓
Audio file lookup
   ↓
Browser playback
  

Each stage depends on the previous one being stable. If one layer changes unexpectedly, later stages may fail even if their own code is correct.

2. System Goal

The goal of the TTS system is to turn a Bishnupriya Manipuri word into playable speech by combining:

• dictionary data
• rule-based pronunciation logic
• phoneme sequencing
• diphone audio files
• browser-side playback

3. Layer 1: Dictionary Input

The pipeline begins with a dictionary word record. The dictionary is the lexical foundation of the system and supplies the source form that needs pronunciation and speech output.

4. Layer 2: Orthographic Normalization

Before pronunciation logic runs, the input should be normalized. This reduces errors caused by inconsistent encoding or unexpected character forms.

Raw text
   ↓
Unicode normalization
   ↓
clean internal form
  

This step is especially important for Eastern Nagari text processing.

5. Layer 3: BPM to IPA Conversion

The rule-based converter transforms the written word into an IPA representation. This stage is one of the most important in the whole architecture.

The converter must handle:

• basic consonant and vowel mapping
• cluster-sensitive pronunciation
• schwa behavior
• learned or exceptional forms

6. Layer 4: Phoneme Tokenization

Once IPA is generated, the next step is to split it into phoneme units.

This stage must use the same phoneme rules everywhere. If tokenization differs across pages, the diphone sequence will also differ.

7. Layer 5: Diphone Generation

The phoneme sequence is transformed into diphone transitions. These are the units that connect the linguistic layer to the audio layer.

Phonemes: d i ʃ a
Diphones:
#-d
d-i
i-ʃ
ʃ-a
a-#
  

Boundary diphones are included so the word has a natural entry and exit in playback.

8. Layer 6: Safe Filename Mapping

Diphone strings are then converted into filesystem-safe names. This lets the audio library use predictable WAV filenames instead of raw IPA symbols.

9. Layer 7: Audio File Lookup

Once safe filenames are produced, the system checks whether the expected WAV files exist.

sil-d.wav
d-i.wav
i-sh.wav
sh-a.wav
a-sil.wav
  

If one or more expected files are missing, playback becomes partial or fails. This is where validator tools become essential.

10. Layer 8: Browser Playback

On the client side, JavaScript or browser audio logic loads the diphone files and plays them in sequence.

load filenames
   ↓
request WAV files
   ↓
play in order
   ↓
heard as one synthesized word
  

This stage is the user-facing end of the TTS pipeline, but it depends entirely on the earlier linguistic and file-generation stages being correct.

11. Architecture Diagram by System Layer

12. Validation Layer Across the Whole System

Validation is not a separate afterthought. It cuts across the whole architecture.

Dictionary word
   ↓
IPA check
   ↓
Phoneme check
   ↓
Diphone check
   ↓
Filename check
   ↓
Audio file existence check
   ↓
Playback check
  

A good validator can show exactly where the pipeline breaks.

13. Common Failure Points

14. Recommended Architectural Rule

This reduces mismatch and makes the system much easier to maintain.

15. Practical End-to-End Example

Input word: দিশা

IPA:
diʃa

Phonemes:
d i ʃ a

Diphones:
#-d
d-i
i-ʃ
ʃ-a
a-#

Safe filenames:
sil-d.wav
d-i.wav
i-sh.wav
sh-a.wav
a-sil.wav

Playback:
load and play these 5 files in sequence
  

16. Related Archive Pages