first commit

examples/example_babble.c

@@ -0,0 +1,107 @@
+/*
+ * EXAMPLE: Pure Random Motor Babbling
+ *
+ * This example bypasses all linguistic rules, phoneme definitions, and attractor states.
+ * It sends completely random vectors to the articulatory physics engine.
+ *
+ * That is the sound of raw, uncoordinated motor commands! Without a 'brain' 
+ * (linguistic rules) to smooth things out and coordinate the glottis with the tongue, 
+ * you essentially get the acoustic equivalent of a seizure or extreme distress.
+ *
+ * It proves that human speech is less about having a mouth and more about the 
+ * incredibly precise, learned choreography of closing it.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include "articulator.h"
+#include "transcriber.h"
+
+extern char RAW_OUTPUT_BUFFER[];
+extern const ortho_rule_t ORTHO_IPA[];
+extern const ortho_rule_t ORTHO_POLISH[];
+extern const ortho_rule_t ORTHO_HUNGARIAN[];
+extern const ortho_rule_t ORTHO_GERMAN[];
+extern const ortho_rule_t ORTHO_CYRILLIC[];
+extern const ortho_rule_t ORTHO_ORCISH[];
+
+float randf(float min, float max) { return min + ((float)rand() / (float)RAND_MAX) * (max - min); }
+
+// PURE RANDOM GENERATOR
+// No concept of vowels, consonants, or linguistic structure.
+// Just random points in the 6-dimensional muscle space.
+f6_t generate_random_target(void) {
+  f6_t t;
+
+  // 1. Randomize Articulators (0.0 - 1.0)
+  t.tx = randf(0.0, 1.0);  // Tongue Place (Front <-> Back)
+  t.ty = randf(0.0, 1.0);  // Tongue Height (Roof <-> Open)
+  t.la = randf(0.0, 1.0);  // Lips (Closed <-> Wide)
+  t.lr = randf(0.0, 1.0);  // Rounding (Spread <-> Round)
+  
+  // Velum (Oral vs Nasal)
+  // We use discrete values (0.0 or 1.0) because continuous random values (e.g. 0.5)
+  // create physically ambiguous targets that result in constant air leakage.
+  t.nz = (rand() % 5 == 0) ? 1.0f : 0.0f; // 20% chance of nasal
+
+  // 2. Randomize Glottis (Voicing)
+  // We bias slightly towards voicing (0.5-1.0) to ensure audible output.
+  // Using pure 0.0-1.0 would result in ~40% silent breathing.
+  if (rand() % 10 < 2) {
+      t.gt = randf(0.0, 0.4); // Breath/Silence
+  } else {
+      t.gt = randf(0.5, 0.9); // Voicing/Creak
+  }
+
+  return t;
+}
+
+void motor_babble(int count) {
+  printf("\n=== Random Motor Babble (%d gestures) ===\n", count);
+
+  // Allocate memory for the stream (1 chunk per gesture)
+  f6_t* stream = malloc(sizeof(f6_t) * count);
+
+  for (int i = 0; i < count; i++) {
+    stream[i] = generate_random_target();
+  }
+
+  // Run the physics simulation
+  simulate_motor_stream(stream, count);
+
+  char word[256];
+
+  printf("RAW: \"%s\"\n", RAW_OUTPUT_BUFFER);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_IPA);
+  printf("IPA: \"%s\"\n", word);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_POLISH);
+  printf(" PL: \"%s\"\n", word);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_HUNGARIAN);
+  printf(" HU: \"%s\"\n", word);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_GERMAN);
+  printf(" DE: \"%s\"\n", word);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_CYRILLIC);
+  printf(" RU: \"%s\"\n", word);
+  
+  transcribe(RAW_OUTPUT_BUFFER, word, ORTHO_ORCISH);
+  printf("ORC: \"%s\"\n", word);
+
+  free(stream);
+}
+
+int main(void) {
+  srand(time(NULL));
+
+  // Generate 5 random sequences of varying length
+  for (int i = 0; i < 5; i++) {
+    motor_babble(8 + rand() % 8);
+  }
+
+  return 0;
+}