|
|
@@ -0,0 +1,5703 @@
|
|
|
+
|
|
|
+#include "stm32_sam.h"
|
|
|
+///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// All
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+char input[256 + 1] = {0}; //tab39445
|
|
|
+//standard sam sound
|
|
|
+
|
|
|
+unsigned char wait1 = 7;
|
|
|
+unsigned char wait2 = 6;
|
|
|
+
|
|
|
+unsigned char A, X, Y;
|
|
|
+unsigned char mem44;
|
|
|
+unsigned char mem47;
|
|
|
+unsigned char mem49;
|
|
|
+unsigned char mem39;
|
|
|
+unsigned char mem50;
|
|
|
+unsigned char mem51;
|
|
|
+unsigned char mem53;
|
|
|
+unsigned char mem56;
|
|
|
+unsigned char mem59 = 0;
|
|
|
+
|
|
|
+unsigned char phonemeIndexOutput[60]; //tab47296
|
|
|
+unsigned char stressOutput[60]; //tab47365
|
|
|
+unsigned char phonemeLengthOutput[60]; //tab47416
|
|
|
+
|
|
|
+// contains the soundbuffer position
|
|
|
+int bufferpos;
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Sam Tabs
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+//tab40672
|
|
|
+const unsigned char stressInputTable[] = {'*', '1', '2', '3', '4', '5', '6', '7', '8'};
|
|
|
+
|
|
|
+//tab40682
|
|
|
+const unsigned char signInputTable1[] = {
|
|
|
+ ' ', '.', '?', ',', '-', 'I', 'I', 'E', 'A', 'A', 'A', 'A', 'U', 'A', 'I', 'E', 'U',
|
|
|
+ 'O', 'R', 'L', 'W', 'Y', 'W', 'R', 'L', 'W', 'Y', 'M', 'N', 'N', 'D', 'Q', 'S', 'S',
|
|
|
+ 'F', 'T', '/', '/', 'Z', 'Z', 'V', 'D', 'C', '*', 'J', '*', '*', '*', 'E', 'A', 'O',
|
|
|
+ 'A', 'O', 'U', 'B', '*', '*', 'D', '*', '*', 'G', '*', '*', 'G', '*', '*', 'P', '*',
|
|
|
+ '*', 'T', '*', '*', 'K', '*', '*', 'K', '*', '*', 'U', 'U', 'U'};
|
|
|
+
|
|
|
+//tab40763
|
|
|
+const unsigned char signInputTable2[] = {
|
|
|
+ '*', '*', '*', '*', '*', 'Y', 'H', 'H', 'E', 'A', 'H', 'O', 'H', 'X', 'X', 'R', 'X',
|
|
|
+ 'H', 'X', 'X', 'X', 'X', 'H', '*', '*', '*', '*', '*', '*', 'X', 'X', '*', '*', 'H',
|
|
|
+ '*', 'H', 'H', 'X', '*', 'H', '*', 'H', 'H', '*', '*', '*', '*', '*', 'Y', 'Y', 'Y',
|
|
|
+ 'W', 'W', 'W', '*', '*', '*', '*', '*', '*', '*', '*', '*', 'X', '*', '*', '*', '*',
|
|
|
+ '*', '*', '*', '*', '*', '*', '*', 'X', '*', '*', 'L', 'M', 'N'};
|
|
|
+
|
|
|
+//loc_9F8C
|
|
|
+const unsigned char flags[] = {
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0xA4, 0x84, 0x84, 0xA4,
|
|
|
+ 0xA4, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x44, 0x44, 0x44, 0x44, 0x44, 0x4C,
|
|
|
+ 0x4C, 0x4C, 0x48, 0x4C, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x44, 0x44, 0x44, 0x44,
|
|
|
+ 0x48, 0x40, 0x4C, 0x44, 0x00, 0x00, 0xB4, 0xB4, 0xB4, 0x94, 0x94, 0x94, 0x4E, 0x4E,
|
|
|
+ 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4E, 0x4B, 0x4B, 0x4B, 0x4B,
|
|
|
+ 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x4B, 0x80, 0xC1, 0xC1
|
|
|
+
|
|
|
+};
|
|
|
+
|
|
|
+//??? flags overlap flags2
|
|
|
+//loc_9FDA
|
|
|
+const unsigned char flags2[] = {
|
|
|
+ 0x80, 0xC1, 0xC1, 0xC1, 0xC1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x10, 0x10, 0x10, 0x08, 0x0C, 0x08, 0x04, 0x40,
|
|
|
+ 0x24, 0x20, 0x20, 0x24, 0x00, 0x00, 0x24, 0x20, 0x20, 0x24, 0x20, 0x20, 0x00, 0x20, 0x00, 0x00,
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00,
|
|
|
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
|
|
+
|
|
|
+//tab45616???
|
|
|
+const unsigned char phonemeStressedLengthTable[] = {
|
|
|
+ 0x00, 0x12, 0x12, 0x12, 8, 0xB, 9, 0xB, 0xE, 0xF, 0xB, 0x10, 0xC, 6, 6, 0xE,
|
|
|
+ 0xC, 0xE, 0xC, 0xB, 8, 8, 0xB, 0xA, 9, 8, 8, 8, 8, 8, 3, 5,
|
|
|
+ 2, 2, 2, 2, 2, 2, 6, 6, 8, 6, 6, 2, 9, 4, 2, 1,
|
|
|
+ 0xE, 0xF, 0xF, 0xF, 0xE, 0xE, 8, 2, 2, 7, 2, 1, 7, 2, 2, 7,
|
|
|
+ 2, 2, 8, 2, 2, 6, 2, 2, 7, 2, 4, 7, 1, 4, 5, 5};
|
|
|
+
|
|
|
+//tab45536???
|
|
|
+const unsigned char phonemeLengthTable[] = {
|
|
|
+ 0, 0x12, 0x12, 0x12, 8, 8, 8, 8, 8, 0xB, 6, 0xC, 0xA, 5, 5, 0xB, 0xA, 0xA, 0xA, 9,
|
|
|
+ 8, 7, 9, 7, 6, 8, 6, 7, 7, 7, 2, 5, 2, 2, 2, 2, 2, 2, 6, 6,
|
|
|
+ 7, 6, 6, 2, 8, 3, 1, 0x1E, 0xD, 0xC, 0xC, 0xC, 0xE, 9, 6, 1, 2, 5, 1, 1,
|
|
|
+ 6, 1, 2, 6, 1, 2, 8, 2, 2, 4, 2, 2, 6, 1, 4, 6, 1, 4, 0xC7, 0xFF};
|
|
|
+
|
|
|
+/*
|
|
|
+
|
|
|
+ Ind | phoneme | flags |
|
|
|
+ -----|---------|----------|
|
|
|
+ 0 | * | 00000000 |
|
|
|
+ 1 | .* | 00000000 |
|
|
|
+ 2 | ?* | 00000000 |
|
|
|
+ 3 | ,* | 00000000 |
|
|
|
+ 4 | -* | 00000000 |
|
|
|
+
|
|
|
+ VOWELS
|
|
|
+ 5 | IY | 10100100 |
|
|
|
+ 6 | IH | 10100100 |
|
|
|
+ 7 | EH | 10100100 |
|
|
|
+ 8 | AE | 10100100 |
|
|
|
+ 9 | AA | 10100100 |
|
|
|
+ 10 | AH | 10100100 |
|
|
|
+ 11 | AO | 10000100 |
|
|
|
+ 17 | OH | 10000100 |
|
|
|
+ 12 | UH | 10000100 |
|
|
|
+ 16 | UX | 10000100 |
|
|
|
+ 15 | ER | 10000100 |
|
|
|
+ 13 | AX | 10100100 |
|
|
|
+ 14 | IX | 10100100 |
|
|
|
+
|
|
|
+ DIPHTONGS
|
|
|
+ 48 | EY | 10110100 |
|
|
|
+ 49 | AY | 10110100 |
|
|
|
+ 50 | OY | 10110100 |
|
|
|
+ 51 | AW | 10010100 |
|
|
|
+ 52 | OW | 10010100 |
|
|
|
+ 53 | UW | 10010100 |
|
|
|
+
|
|
|
+
|
|
|
+ 21 | YX | 10000100 |
|
|
|
+ 20 | WX | 10000100 |
|
|
|
+ 18 | RX | 10000100 |
|
|
|
+ 19 | LX | 10000100 |
|
|
|
+ 37 | /X | 01000000 |
|
|
|
+ 30 | DX | 01001000 |
|
|
|
+
|
|
|
+
|
|
|
+ 22 | WH | 01000100 |
|
|
|
+
|
|
|
+
|
|
|
+ VOICED CONSONANTS
|
|
|
+ 23 | R* | 01000100 |
|
|
|
+ 24 | L* | 01000100 |
|
|
|
+ 25 | W* | 01000100 |
|
|
|
+ 26 | Y* | 01000100 |
|
|
|
+ 27 | M* | 01001100 |
|
|
|
+ 28 | N* | 01001100 |
|
|
|
+ 29 | NX | 01001100 |
|
|
|
+ 54 | B* | 01001110 |
|
|
|
+ 57 | D* | 01001110 |
|
|
|
+ 60 | G* | 01001110 |
|
|
|
+ 44 | J* | 01001100 |
|
|
|
+ 38 | Z* | 01000100 |
|
|
|
+ 39 | ZH | 01000100 |
|
|
|
+ 40 | V* | 01000100 |
|
|
|
+ 41 | DH | 01000100 |
|
|
|
+
|
|
|
+ unvoiced CONSONANTS
|
|
|
+ 32 | S* | 01000000 |
|
|
|
+ 33 | SH | 01000000 |
|
|
|
+ 34 | F* | 01000000 |
|
|
|
+ 35 | TH | 01000000 |
|
|
|
+ 66 | P* | 01001011 |
|
|
|
+ 69 | T* | 01001011 |
|
|
|
+ 72 | K* | 01001011 |
|
|
|
+ 42 | CH | 01001000 |
|
|
|
+ 36 | /H | 01000000 |
|
|
|
+
|
|
|
+ 43 | ** | 01000000 |
|
|
|
+ 45 | ** | 01000100 |
|
|
|
+ 46 | ** | 00000000 |
|
|
|
+ 47 | ** | 00000000 |
|
|
|
+
|
|
|
+
|
|
|
+ 55 | ** | 01001110 |
|
|
|
+ 56 | ** | 01001110 |
|
|
|
+ 58 | ** | 01001110 |
|
|
|
+ 59 | ** | 01001110 |
|
|
|
+ 61 | ** | 01001110 |
|
|
|
+ 62 | ** | 01001110 |
|
|
|
+ 63 | GX | 01001110 |
|
|
|
+ 64 | ** | 01001110 |
|
|
|
+ 65 | ** | 01001110 |
|
|
|
+ 67 | ** | 01001011 |
|
|
|
+ 68 | ** | 01001011 |
|
|
|
+ 70 | ** | 01001011 |
|
|
|
+ 71 | ** | 01001011 |
|
|
|
+ 73 | ** | 01001011 |
|
|
|
+ 74 | ** | 01001011 |
|
|
|
+ 75 | KX | 01001011 |
|
|
|
+ 76 | ** | 01001011 |
|
|
|
+ 77 | ** | 01001011 |
|
|
|
+
|
|
|
+
|
|
|
+ SPECIAL
|
|
|
+ 78 | UL | 10000000 |
|
|
|
+ 79 | UM | 11000001 |
|
|
|
+ 80 | UN | 11000001 |
|
|
|
+ 31 | Q* | 01001100 |
|
|
|
+
|
|
|
+*/
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// RenderTabs
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+const unsigned char tab48426[5] = {0x18, 0x1A, 0x17, 0x17, 0x17};
|
|
|
+
|
|
|
+const unsigned char tab47492[] = {0, 0, 0xE0, 0xE6, 0xEC, 0xF3, 0xF9, 0, 6, 0xC, 6};
|
|
|
+
|
|
|
+const unsigned char amplitudeRescale[] = {
|
|
|
+ 0,
|
|
|
+ 1,
|
|
|
+ 2,
|
|
|
+ 2,
|
|
|
+ 2,
|
|
|
+ 3,
|
|
|
+ 3,
|
|
|
+ 4,
|
|
|
+ 4,
|
|
|
+ 5,
|
|
|
+ 6,
|
|
|
+ 8,
|
|
|
+ 9,
|
|
|
+ 0xB,
|
|
|
+ 0xD,
|
|
|
+ 0xF,
|
|
|
+ 0 //17 elements?
|
|
|
+};
|
|
|
+
|
|
|
+// Used to decide which phoneme's blend lengths. The candidate with the lower score is selected.
|
|
|
+// tab45856
|
|
|
+const unsigned char blendRank[] = {0, 0x1F, 0x1F, 0x1F, 0x1F, 2, 2, 2, 2, 2,
|
|
|
+ 2, 2, 2, 2, 5, 5, 2, 0xA, 2, 8,
|
|
|
+ 5, 5, 0xB, 0xA, 9, 8, 8, 0xA0, 8, 8,
|
|
|
+ 0x17, 0x1F, 0x12, 0x12, 0x12, 0x12, 0x1E, 0x1E, 0x14, 0x14,
|
|
|
+ 0x14, 0x14, 0x17, 0x17, 0x1A, 0x1A, 0x1D, 0x1D, 2, 2,
|
|
|
+ 2, 2, 2, 2, 0x1A, 0x1D, 0x1B, 0x1A, 0x1D, 0x1B,
|
|
|
+ 0x1A, 0x1D, 0x1B, 0x1A, 0x1D, 0x1B, 0x17, 0x1D, 0x17, 0x17,
|
|
|
+ 0x1D, 0x17, 0x17, 0x1D, 0x17, 0x17, 0x1D, 0x17, 0x17, 0x17};
|
|
|
+
|
|
|
+// Number of frames at the end of a phoneme devoted to interpolating to next phoneme's final value
|
|
|
+//tab45696
|
|
|
+const unsigned char outBlendLength[] = {0, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
|
+ 4, 4, 3, 2, 4, 4, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1,
|
|
|
+ 1, 1, 1, 1, 1, 1, 2, 2, 2, 1, 0, 1, 0, 1, 0, 5,
|
|
|
+ 5, 5, 5, 5, 4, 4, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2,
|
|
|
+ 0, 1, 2, 0, 2, 2, 0, 1, 3, 0, 2, 3, 0, 2, 0xA0, 0xA0};
|
|
|
+
|
|
|
+// Number of frames at beginning of a phoneme devoted to interpolating to phoneme's final value
|
|
|
+// tab45776
|
|
|
+const unsigned char inBlendLength[] = {0, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
|
|
|
+ 4, 4, 3, 3, 4, 4, 3, 3, 3, 3, 3, 1, 2, 3, 2, 1,
|
|
|
+ 3, 3, 3, 3, 1, 1, 3, 3, 3, 2, 2, 3, 2, 3, 0, 0,
|
|
|
+ 5, 5, 5, 5, 4, 4, 2, 0, 2, 2, 0, 3, 2, 0, 4, 2,
|
|
|
+ 0, 3, 2, 0, 2, 2, 0, 2, 3, 0, 3, 3, 0, 3, 0xB0, 0xA0};
|
|
|
+
|
|
|
+// Looks like it's used as bit flags
|
|
|
+// High bits masked by 248 (11111000)
|
|
|
+//
|
|
|
+// 32: S* 241 11110001
|
|
|
+// 33: SH 226 11100010
|
|
|
+// 34: F* 211 11010011
|
|
|
+// 35: TH 187 10111011
|
|
|
+// 36: /H 124 01111100
|
|
|
+// 37: /X 149 10010101
|
|
|
+// 38: Z* 1 00000001
|
|
|
+// 39: ZH 2 00000010
|
|
|
+// 40: V* 3 00000011
|
|
|
+// 41: DH 3 00000011
|
|
|
+// 43: ** 114 01110010
|
|
|
+// 45: ** 2 00000010
|
|
|
+// 67: ** 27 00011011
|
|
|
+// 70: ** 25 00011001
|
|
|
+// tab45936
|
|
|
+const unsigned char sampledConsonantFlags[] = {
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xF1, 0xE2, 0xD3, 0xBB, 0x7C, 0x95, 1, 2,
|
|
|
+ 3, 3, 0, 0x72, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0x1B, 0, 0, 0x19, 0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
+
|
|
|
+//tab45056
|
|
|
+unsigned char freq1data[] = {
|
|
|
+ 0x00, 0x13, 0x13, 0x13, 0x13, 0xA, 0xE, 0x12, 0x18, 0x1A, 0x16, 0x14, 0x10, 0x14, 0xE, 0x12,
|
|
|
+ 0xE, 0x12, 0x12, 0x10, 0xC, 0xE, 0xA, 0x12, 0xE, 0xA, 8, 6, 6, 6, 6, 0x11,
|
|
|
+ 6, 6, 6, 6, 0xE, 0x10, 9, 0xA, 8, 0xA, 6, 6, 6, 5, 6, 0,
|
|
|
+ 0x12, 0x1A, 0x14, 0x1A, 0x12, 0xC, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
|
|
|
+ 6, 6, 6, 6, 6, 6, 6, 6, 6, 0xA, 0xA, 6, 6, 6, 0x2C, 0x13};
|
|
|
+
|
|
|
+//tab451356
|
|
|
+unsigned char freq2data[] = {0x00, 0x43, 0x43, 0x43, 0x43, 0x54, 0x48, 0x42, 0x3E, 0x28,
|
|
|
+ 0x2C, 0x1E, 0x24, 0x2C, 0x48, 0x30, 0x24, 0x1E, 0x32, 0x24,
|
|
|
+ 0x1C, 0x44, 0x18, 0x32, 0x1E, 0x18, 0x52, 0x2E, 0x36, 0x56,
|
|
|
+ 0x36, 0x43, 0x49, 0x4F, 0x1A, 0x42, 0x49, 0x25, 0x33, 0x42,
|
|
|
+ 0x28, 0x2F, 0x4F, 0x4F, 0x42, 0x4F, 0x6E, 0x00, 0x48, 0x26,
|
|
|
+ 0x1E, 0x2A, 0x1E, 0x22, 0x1A, 0x1A, 0x1A, 0x42, 0x42, 0x42,
|
|
|
+ 0x6E, 0x6E, 0x6E, 0x54, 0x54, 0x54, 0x1A, 0x1A, 0x1A, 0x42,
|
|
|
+ 0x42, 0x42, 0x6D, 0x56, 0x6D, 0x54, 0x54, 0x54, 0x7F, 0x7F};
|
|
|
+//tab45216
|
|
|
+unsigned char freq3data[] = {0x00, 0x5B, 0x5B, 0x5B, 0x5B, 0x6E, 0x5D, 0x5B, 0x58, 0x59,
|
|
|
+ 0x57, 0x58, 0x52, 0x59, 0x5D, 0x3E, 0x52, 0x58, 0x3E, 0x6E,
|
|
|
+ 0x50, 0x5D, 0x5A, 0x3C, 0x6E, 0x5A, 0x6E, 0x51, 0x79, 0x65,
|
|
|
+ 0x79, 0x5B, 0x63, 0x6A, 0x51, 0x79, 0x5D, 0x52, 0x5D, 0x67,
|
|
|
+ 0x4C, 0x5D, 0x65, 0x65, 0x79, 0x65, 0x79, 0x00, 0x5A, 0x58,
|
|
|
+ 0x58, 0x58, 0x58, 0x52, 0x51, 0x51, 0x51, 0x79, 0x79, 0x79,
|
|
|
+ 0x70, 0x6E, 0x6E, 0x5E, 0x5E, 0x5E, 0x51, 0x51, 0x51, 0x79,
|
|
|
+ 0x79, 0x79, 0x65, 0x65, 0x70, 0x5E, 0x5E, 0x5E, 0x08, 0x01};
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Reciter
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+unsigned char inputtemp[256]; // secure copy of input tab36096
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Render
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+//timetable for more accurate c64 simulation
|
|
|
+int timetable[5][5] = {
|
|
|
+ {162, 167, 167, 127, 128},
|
|
|
+ {226, 60, 60, 0, 0},
|
|
|
+ {225, 60, 59, 0, 0},
|
|
|
+ {200, 0, 0, 54, 55},
|
|
|
+ {199, 0, 0, 54, 54}};
|
|
|
+
|
|
|
+unsigned oldtimetableindex;
|
|
|
+
|
|
|
+const unsigned char ampl1data[] = {0, 0, 0, 0, 0, 0xD, 0xD, 0xE, 0xF, 0xF, 0xF, 0xF,
|
|
|
+ 0xF, 0xC, 0xD, 0xC, 0xF, 0xF, 0xD, 0xD, 0xD, 0xE, 0xD, 0xC,
|
|
|
+ 0xD, 0xD, 0xD, 0xC, 9, 9, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 0, 0xB, 0xB, 0xB, 0xB, 0, 0, 1, 0xB, 0, 2,
|
|
|
+ 0xE, 0xF, 0xF, 0xF, 0xF, 0xD, 2, 4, 0, 2, 4, 0,
|
|
|
+ 1, 4, 0, 1, 4, 0, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 0xC, 0, 0, 0, 0, 0xF, 0xF};
|
|
|
+
|
|
|
+const unsigned char ampl2data[] = {
|
|
|
+ 0, 0, 0, 0, 0, 0xA, 0xB, 0xD, 0xE, 0xD, 0xC, 0xC, 0xB, 9, 0xB, 0xB, 0xC, 0xC, 0xC, 8,
|
|
|
+ 8, 0xC, 8, 0xA, 8, 8, 0xA, 3, 9, 6, 0, 0, 0, 0, 0, 0, 0, 0, 3, 5,
|
|
|
+ 3, 4, 0, 0, 0, 5, 0xA, 2, 0xE, 0xD, 0xC, 0xD, 0xC, 8, 0, 1, 0, 0, 1, 0,
|
|
|
+ 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0xA, 0, 0, 0xA, 0, 0, 0};
|
|
|
+
|
|
|
+const unsigned char ampl3data[] = {0, 0, 0, 0, 0, 8, 7, 8, 8, 1, 1, 0, 1, 0, 7, 5,
|
|
|
+ 1, 0, 6, 1, 0, 7, 0, 5, 1, 0, 8, 0, 0, 3, 0, 0,
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0xE, 1,
|
|
|
+ 9, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 5, 0, 0x13, 0x10};
|
|
|
+
|
|
|
+//tab42240
|
|
|
+const signed char sinus[256] = {
|
|
|
+ 0, 3, 6, 9, 12, 16, 19, 22, 25, 28, 31, 34, 37, 40, 43, 46,
|
|
|
+ 49, 51, 54, 57, 60, 63, 65, 68, 71, 73, 76, 78, 81, 83, 85, 88,
|
|
|
+ 90, 92, 94, 96, 98, 100, 102, 104, 106, 107, 109, 111, 112, 113, 115, 116,
|
|
|
+ 117, 118, 120, 121, 122, 122, 123, 124, 125, 125, 126, 126, 126, 127, 127, 127,
|
|
|
+ 127, 127, 127, 127, 126, 126, 126, 125, 125, 124, 123, 122, 122, 121, 120, 118,
|
|
|
+ 117, 116, 115, 113, 112, 111, 109, 107, 106, 104, 102, 100, 98, 96, 94, 92,
|
|
|
+ 90, 88, 85, 83, 81, 78, 76, 73, 71, 68, 65, 63, 60, 57, 54, 51,
|
|
|
+ 49, 46, 43, 40, 37, 34, 31, 28, 25, 22, 19, 16, 12, 9, 6, 3,
|
|
|
+ 0, -3, -6, -9, -12, -16, -19, -22, -25, -28, -31, -34, -37, -40, -43, -46,
|
|
|
+ -49, -51, -54, -57, -60, -63, -65, -68, -71, -73, -76, -78, -81, -83, -85, -88,
|
|
|
+ -90, -92, -94, -96, -98, -100, -102, -104, -106, -107, -109, -111, -112, -113, -115, -116,
|
|
|
+ -117, -118, -120, -121, -122, -122, -123, -124, -125, -125, -126, -126, -126, -127, -127, -127,
|
|
|
+ -127, -127, -127, -127, -126, -126, -126, -125, -125, -124, -123, -122, -122, -121, -120, -118,
|
|
|
+ -117, -116, -115, -113, -112, -111, -109, -107, -106, -104, -102, -100, -98, -96, -94, -92,
|
|
|
+ -90, -88, -85, -83, -81, -78, -76, -73, -71, -68, -65, -63, -60, -57, -54, -51,
|
|
|
+ -49, -46, -43, -40, -37, -34, -31, -28, -25, -22, -19, -16, -12, -9, -6, -3};
|
|
|
+
|
|
|
+//tab42496
|
|
|
+const unsigned char rectangle[] = {
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90,
|
|
|
+ 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x90, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70, 0x70,
|
|
|
+ 0x70};
|
|
|
+
|
|
|
+//random data ?
|
|
|
+const unsigned char sampleTable[0x500] = {
|
|
|
+ //00
|
|
|
+
|
|
|
+ 0x38,
|
|
|
+ 0x84,
|
|
|
+ 0x6B,
|
|
|
+ 0x19,
|
|
|
+ 0xC6,
|
|
|
+ 0x63,
|
|
|
+ 0x18,
|
|
|
+ 0x86,
|
|
|
+ 0x73,
|
|
|
+ 0x98,
|
|
|
+ 0xC6,
|
|
|
+ 0xB1,
|
|
|
+ 0x1C,
|
|
|
+ 0xCA,
|
|
|
+ 0x31,
|
|
|
+ 0x8C,
|
|
|
+ 0xC7,
|
|
|
+ 0x31,
|
|
|
+ 0x88,
|
|
|
+ 0xC2,
|
|
|
+ 0x30,
|
|
|
+ 0x98,
|
|
|
+ 0x46,
|
|
|
+ 0x31,
|
|
|
+ 0x18,
|
|
|
+ 0xC6,
|
|
|
+ 0x35,
|
|
|
+ 0xC,
|
|
|
+ 0xCA,
|
|
|
+ 0x31,
|
|
|
+ 0xC,
|
|
|
+ 0xC6
|
|
|
+ //20
|
|
|
+ ,
|
|
|
+ 0x21,
|
|
|
+ 0x10,
|
|
|
+ 0x24,
|
|
|
+ 0x69,
|
|
|
+ 0x12,
|
|
|
+ 0xC2,
|
|
|
+ 0x31,
|
|
|
+ 0x14,
|
|
|
+ 0xC4,
|
|
|
+ 0x71,
|
|
|
+ 8,
|
|
|
+ 0x4A,
|
|
|
+ 0x22,
|
|
|
+ 0x49,
|
|
|
+ 0xAB,
|
|
|
+ 0x6A,
|
|
|
+ 0xA8,
|
|
|
+ 0xAC,
|
|
|
+ 0x49,
|
|
|
+ 0x51,
|
|
|
+ 0x32,
|
|
|
+ 0xD5,
|
|
|
+ 0x52,
|
|
|
+ 0x88,
|
|
|
+ 0x93,
|
|
|
+ 0x6C,
|
|
|
+ 0x94,
|
|
|
+ 0x22,
|
|
|
+ 0x15,
|
|
|
+ 0x54,
|
|
|
+ 0xD2,
|
|
|
+ 0x25
|
|
|
+ //40
|
|
|
+ ,
|
|
|
+ 0x96,
|
|
|
+ 0xD4,
|
|
|
+ 0x50,
|
|
|
+ 0xA5,
|
|
|
+ 0x46,
|
|
|
+ 0x21,
|
|
|
+ 8,
|
|
|
+ 0x85,
|
|
|
+ 0x6B,
|
|
|
+ 0x18,
|
|
|
+ 0xC4,
|
|
|
+ 0x63,
|
|
|
+ 0x10,
|
|
|
+ 0xCE,
|
|
|
+ 0x6B,
|
|
|
+ 0x18,
|
|
|
+ 0x8C,
|
|
|
+ 0x71,
|
|
|
+ 0x19,
|
|
|
+ 0x8C,
|
|
|
+ 0x63,
|
|
|
+ 0x35,
|
|
|
+ 0xC,
|
|
|
+ 0xC6,
|
|
|
+ 0x33,
|
|
|
+ 0x99,
|
|
|
+ 0xCC,
|
|
|
+ 0x6C,
|
|
|
+ 0xB5,
|
|
|
+ 0x4E,
|
|
|
+ 0xA2,
|
|
|
+ 0x99
|
|
|
+ //60
|
|
|
+ ,
|
|
|
+ 0x46,
|
|
|
+ 0x21,
|
|
|
+ 0x28,
|
|
|
+ 0x82,
|
|
|
+ 0x95,
|
|
|
+ 0x2E,
|
|
|
+ 0xE3,
|
|
|
+ 0x30,
|
|
|
+ 0x9C,
|
|
|
+ 0xC5,
|
|
|
+ 0x30,
|
|
|
+ 0x9C,
|
|
|
+ 0xA2,
|
|
|
+ 0xB1,
|
|
|
+ 0x9C,
|
|
|
+ 0x67,
|
|
|
+ 0x31,
|
|
|
+ 0x88,
|
|
|
+ 0x66,
|
|
|
+ 0x59,
|
|
|
+ 0x2C,
|
|
|
+ 0x53,
|
|
|
+ 0x18,
|
|
|
+ 0x84,
|
|
|
+ 0x67,
|
|
|
+ 0x50,
|
|
|
+ 0xCA,
|
|
|
+ 0xE3,
|
|
|
+ 0xA,
|
|
|
+ 0xAC,
|
|
|
+ 0xAB,
|
|
|
+ 0x30
|
|
|
+ //80
|
|
|
+ ,
|
|
|
+ 0xAC,
|
|
|
+ 0x62,
|
|
|
+ 0x30,
|
|
|
+ 0x8C,
|
|
|
+ 0x63,
|
|
|
+ 0x10,
|
|
|
+ 0x94,
|
|
|
+ 0x62,
|
|
|
+ 0xB1,
|
|
|
+ 0x8C,
|
|
|
+ 0x82,
|
|
|
+ 0x28,
|
|
|
+ 0x96,
|
|
|
+ 0x33,
|
|
|
+ 0x98,
|
|
|
+ 0xD6,
|
|
|
+ 0xB5,
|
|
|
+ 0x4C,
|
|
|
+ 0x62,
|
|
|
+ 0x29,
|
|
|
+ 0xA5,
|
|
|
+ 0x4A,
|
|
|
+ 0xB5,
|
|
|
+ 0x9C,
|
|
|
+ 0xC6,
|
|
|
+ 0x31,
|
|
|
+ 0x14,
|
|
|
+ 0xD6,
|
|
|
+ 0x38,
|
|
|
+ 0x9C,
|
|
|
+ 0x4B,
|
|
|
+ 0xB4
|
|
|
+ //A0
|
|
|
+ ,
|
|
|
+ 0x86,
|
|
|
+ 0x65,
|
|
|
+ 0x18,
|
|
|
+ 0xAE,
|
|
|
+ 0x67,
|
|
|
+ 0x1C,
|
|
|
+ 0xA6,
|
|
|
+ 0x63,
|
|
|
+ 0x19,
|
|
|
+ 0x96,
|
|
|
+ 0x23,
|
|
|
+ 0x19,
|
|
|
+ 0x84,
|
|
|
+ 0x13,
|
|
|
+ 8,
|
|
|
+ 0xA6,
|
|
|
+ 0x52,
|
|
|
+ 0xAC,
|
|
|
+ 0xCA,
|
|
|
+ 0x22,
|
|
|
+ 0x89,
|
|
|
+ 0x6E,
|
|
|
+ 0xAB,
|
|
|
+ 0x19,
|
|
|
+ 0x8C,
|
|
|
+ 0x62,
|
|
|
+ 0x34,
|
|
|
+ 0xC4,
|
|
|
+ 0x62,
|
|
|
+ 0x19,
|
|
|
+ 0x86,
|
|
|
+ 0x63
|
|
|
+ //C0
|
|
|
+ ,
|
|
|
+ 0x18,
|
|
|
+ 0xC4,
|
|
|
+ 0x23,
|
|
|
+ 0x58,
|
|
|
+ 0xD6,
|
|
|
+ 0xA3,
|
|
|
+ 0x50,
|
|
|
+ 0x42,
|
|
|
+ 0x54,
|
|
|
+ 0x4A,
|
|
|
+ 0xAD,
|
|
|
+ 0x4A,
|
|
|
+ 0x25,
|
|
|
+ 0x11,
|
|
|
+ 0x6B,
|
|
|
+ 0x64,
|
|
|
+ 0x89,
|
|
|
+ 0x4A,
|
|
|
+ 0x63,
|
|
|
+ 0x39,
|
|
|
+ 0x8A,
|
|
|
+ 0x23,
|
|
|
+ 0x31,
|
|
|
+ 0x2A,
|
|
|
+ 0xEA,
|
|
|
+ 0xA2,
|
|
|
+ 0xA9,
|
|
|
+ 0x44,
|
|
|
+ 0xC5,
|
|
|
+ 0x12,
|
|
|
+ 0xCD,
|
|
|
+ 0x42
|
|
|
+ //E0
|
|
|
+ ,
|
|
|
+ 0x34,
|
|
|
+ 0x8C,
|
|
|
+ 0x62,
|
|
|
+ 0x18,
|
|
|
+ 0x8C,
|
|
|
+ 0x63,
|
|
|
+ 0x11,
|
|
|
+ 0x48,
|
|
|
+ 0x66,
|
|
|
+ 0x31,
|
|
|
+ 0x9D,
|
|
|
+ 0x44,
|
|
|
+ 0x33,
|
|
|
+ 0x1D,
|
|
|
+ 0x46,
|
|
|
+ 0x31,
|
|
|
+ 0x9C,
|
|
|
+ 0xC6,
|
|
|
+ 0xB1,
|
|
|
+ 0xC,
|
|
|
+ 0xCD,
|
|
|
+ 0x32,
|
|
|
+ 0x88,
|
|
|
+ 0xC4,
|
|
|
+ 0x73,
|
|
|
+ 0x18,
|
|
|
+ 0x86,
|
|
|
+ 0x73,
|
|
|
+ 8,
|
|
|
+ 0xD6,
|
|
|
+ 0x63,
|
|
|
+ 0x58
|
|
|
+ //100
|
|
|
+ ,
|
|
|
+ 7,
|
|
|
+ 0x81,
|
|
|
+ 0xE0,
|
|
|
+ 0xF0,
|
|
|
+ 0x3C,
|
|
|
+ 7,
|
|
|
+ 0x87,
|
|
|
+ 0x90,
|
|
|
+ 0x3C,
|
|
|
+ 0x7C,
|
|
|
+ 0xF,
|
|
|
+ 0xC7,
|
|
|
+ 0xC0,
|
|
|
+ 0xC0,
|
|
|
+ 0xF0,
|
|
|
+ 0x7C,
|
|
|
+ 0x1E,
|
|
|
+ 7,
|
|
|
+ 0x80,
|
|
|
+ 0x80,
|
|
|
+ 0,
|
|
|
+ 0x1C,
|
|
|
+ 0x78,
|
|
|
+ 0x70,
|
|
|
+ 0xF1,
|
|
|
+ 0xC7,
|
|
|
+ 0x1F,
|
|
|
+ 0xC0,
|
|
|
+ 0xC,
|
|
|
+ 0xFE,
|
|
|
+ 0x1C,
|
|
|
+ 0x1F
|
|
|
+ //120
|
|
|
+ ,
|
|
|
+ 0x1F,
|
|
|
+ 0xE,
|
|
|
+ 0xA,
|
|
|
+ 0x7A,
|
|
|
+ 0xC0,
|
|
|
+ 0x71,
|
|
|
+ 0xF2,
|
|
|
+ 0x83,
|
|
|
+ 0x8F,
|
|
|
+ 3,
|
|
|
+ 0xF,
|
|
|
+ 0xF,
|
|
|
+ 0xC,
|
|
|
+ 0,
|
|
|
+ 0x79,
|
|
|
+ 0xF8,
|
|
|
+ 0x61,
|
|
|
+ 0xE0,
|
|
|
+ 0x43,
|
|
|
+ 0xF,
|
|
|
+ 0x83,
|
|
|
+ 0xE7,
|
|
|
+ 0x18,
|
|
|
+ 0xF9,
|
|
|
+ 0xC1,
|
|
|
+ 0x13,
|
|
|
+ 0xDA,
|
|
|
+ 0xE9,
|
|
|
+ 0x63,
|
|
|
+ 0x8F,
|
|
|
+ 0xF,
|
|
|
+ 0x83
|
|
|
+ //140
|
|
|
+ ,
|
|
|
+ 0x83,
|
|
|
+ 0x87,
|
|
|
+ 0xC3,
|
|
|
+ 0x1F,
|
|
|
+ 0x3C,
|
|
|
+ 0x70,
|
|
|
+ 0xF0,
|
|
|
+ 0xE1,
|
|
|
+ 0xE1,
|
|
|
+ 0xE3,
|
|
|
+ 0x87,
|
|
|
+ 0xB8,
|
|
|
+ 0x71,
|
|
|
+ 0xE,
|
|
|
+ 0x20,
|
|
|
+ 0xE3,
|
|
|
+ 0x8D,
|
|
|
+ 0x48,
|
|
|
+ 0x78,
|
|
|
+ 0x1C,
|
|
|
+ 0x93,
|
|
|
+ 0x87,
|
|
|
+ 0x30,
|
|
|
+ 0xE1,
|
|
|
+ 0xC1,
|
|
|
+ 0xC1,
|
|
|
+ 0xE4,
|
|
|
+ 0x78,
|
|
|
+ 0x21,
|
|
|
+ 0x83,
|
|
|
+ 0x83,
|
|
|
+ 0xC3
|
|
|
+ //160
|
|
|
+ ,
|
|
|
+ 0x87,
|
|
|
+ 6,
|
|
|
+ 0x39,
|
|
|
+ 0xE5,
|
|
|
+ 0xC3,
|
|
|
+ 0x87,
|
|
|
+ 7,
|
|
|
+ 0xE,
|
|
|
+ 0x1C,
|
|
|
+ 0x1C,
|
|
|
+ 0x70,
|
|
|
+ 0xF4,
|
|
|
+ 0x71,
|
|
|
+ 0x9C,
|
|
|
+ 0x60,
|
|
|
+ 0x36,
|
|
|
+ 0x32,
|
|
|
+ 0xC3,
|
|
|
+ 0x1E,
|
|
|
+ 0x3C,
|
|
|
+ 0xF3,
|
|
|
+ 0x8F,
|
|
|
+ 0xE,
|
|
|
+ 0x3C,
|
|
|
+ 0x70,
|
|
|
+ 0xE3,
|
|
|
+ 0xC7,
|
|
|
+ 0x8F,
|
|
|
+ 0xF,
|
|
|
+ 0xF,
|
|
|
+ 0xE,
|
|
|
+ 0x3C
|
|
|
+ //180
|
|
|
+ ,
|
|
|
+ 0x78,
|
|
|
+ 0xF0,
|
|
|
+ 0xE3,
|
|
|
+ 0x87,
|
|
|
+ 6,
|
|
|
+ 0xF0,
|
|
|
+ 0xE3,
|
|
|
+ 7,
|
|
|
+ 0xC1,
|
|
|
+ 0x99,
|
|
|
+ 0x87,
|
|
|
+ 0xF,
|
|
|
+ 0x18,
|
|
|
+ 0x78,
|
|
|
+ 0x70,
|
|
|
+ 0x70,
|
|
|
+ 0xFC,
|
|
|
+ 0xF3,
|
|
|
+ 0x10,
|
|
|
+ 0xB1,
|
|
|
+ 0x8C,
|
|
|
+ 0x8C,
|
|
|
+ 0x31,
|
|
|
+ 0x7C,
|
|
|
+ 0x70,
|
|
|
+ 0xE1,
|
|
|
+ 0x86,
|
|
|
+ 0x3C,
|
|
|
+ 0x64,
|
|
|
+ 0x6C,
|
|
|
+ 0xB0,
|
|
|
+ 0xE1
|
|
|
+ //1A0
|
|
|
+ ,
|
|
|
+ 0xE3,
|
|
|
+ 0xF,
|
|
|
+ 0x23,
|
|
|
+ 0x8F,
|
|
|
+ 0xF,
|
|
|
+ 0x1E,
|
|
|
+ 0x3E,
|
|
|
+ 0x38,
|
|
|
+ 0x3C,
|
|
|
+ 0x38,
|
|
|
+ 0x7B,
|
|
|
+ 0x8F,
|
|
|
+ 7,
|
|
|
+ 0xE,
|
|
|
+ 0x3C,
|
|
|
+ 0xF4,
|
|
|
+ 0x17,
|
|
|
+ 0x1E,
|
|
|
+ 0x3C,
|
|
|
+ 0x78,
|
|
|
+ 0xF2,
|
|
|
+ 0x9E,
|
|
|
+ 0x72,
|
|
|
+ 0x49,
|
|
|
+ 0xE3,
|
|
|
+ 0x25,
|
|
|
+ 0x36,
|
|
|
+ 0x38,
|
|
|
+ 0x58,
|
|
|
+ 0x39,
|
|
|
+ 0xE2,
|
|
|
+ 0xDE
|
|
|
+ //1C0
|
|
|
+ ,
|
|
|
+ 0x3C,
|
|
|
+ 0x78,
|
|
|
+ 0x78,
|
|
|
+ 0xE1,
|
|
|
+ 0xC7,
|
|
|
+ 0x61,
|
|
|
+ 0xE1,
|
|
|
+ 0xE1,
|
|
|
+ 0xB0,
|
|
|
+ 0xF0,
|
|
|
+ 0xF0,
|
|
|
+ 0xC3,
|
|
|
+ 0xC7,
|
|
|
+ 0xE,
|
|
|
+ 0x38,
|
|
|
+ 0xC0,
|
|
|
+ 0xF0,
|
|
|
+ 0xCE,
|
|
|
+ 0x73,
|
|
|
+ 0x73,
|
|
|
+ 0x18,
|
|
|
+ 0x34,
|
|
|
+ 0xB0,
|
|
|
+ 0xE1,
|
|
|
+ 0xC7,
|
|
|
+ 0x8E,
|
|
|
+ 0x1C,
|
|
|
+ 0x3C,
|
|
|
+ 0xF8,
|
|
|
+ 0x38,
|
|
|
+ 0xF0,
|
|
|
+ 0xE1
|
|
|
+ //1E0
|
|
|
+ ,
|
|
|
+ 0xC1,
|
|
|
+ 0x8B,
|
|
|
+ 0x86,
|
|
|
+ 0x8F,
|
|
|
+ 0x1C,
|
|
|
+ 0x78,
|
|
|
+ 0x70,
|
|
|
+ 0xF0,
|
|
|
+ 0x78,
|
|
|
+ 0xAC,
|
|
|
+ 0xB1,
|
|
|
+ 0x8F,
|
|
|
+ 0x39,
|
|
|
+ 0x31,
|
|
|
+ 0xDB,
|
|
|
+ 0x38,
|
|
|
+ 0x61,
|
|
|
+ 0xC3,
|
|
|
+ 0xE,
|
|
|
+ 0xE,
|
|
|
+ 0x38,
|
|
|
+ 0x78,
|
|
|
+ 0x73,
|
|
|
+ 0x17,
|
|
|
+ 0x1E,
|
|
|
+ 0x39,
|
|
|
+ 0x1E,
|
|
|
+ 0x38,
|
|
|
+ 0x64,
|
|
|
+ 0xE1,
|
|
|
+ 0xF1,
|
|
|
+ 0xC1
|
|
|
+ //200
|
|
|
+ ,
|
|
|
+ 0x4E,
|
|
|
+ 0xF,
|
|
|
+ 0x40,
|
|
|
+ 0xA2,
|
|
|
+ 2,
|
|
|
+ 0xC5,
|
|
|
+ 0x8F,
|
|
|
+ 0x81,
|
|
|
+ 0xA1,
|
|
|
+ 0xFC,
|
|
|
+ 0x12,
|
|
|
+ 8,
|
|
|
+ 0x64,
|
|
|
+ 0xE0,
|
|
|
+ 0x3C,
|
|
|
+ 0x22,
|
|
|
+ 0xE0,
|
|
|
+ 0x45,
|
|
|
+ 7,
|
|
|
+ 0x8E,
|
|
|
+ 0xC,
|
|
|
+ 0x32,
|
|
|
+ 0x90,
|
|
|
+ 0xF0,
|
|
|
+ 0x1F,
|
|
|
+ 0x20,
|
|
|
+ 0x49,
|
|
|
+ 0xE0,
|
|
|
+ 0xF8,
|
|
|
+ 0xC,
|
|
|
+ 0x60,
|
|
|
+ 0xF0
|
|
|
+ //220
|
|
|
+ ,
|
|
|
+ 0x17,
|
|
|
+ 0x1A,
|
|
|
+ 0x41,
|
|
|
+ 0xAA,
|
|
|
+ 0xA4,
|
|
|
+ 0xD0,
|
|
|
+ 0x8D,
|
|
|
+ 0x12,
|
|
|
+ 0x82,
|
|
|
+ 0x1E,
|
|
|
+ 0x1E,
|
|
|
+ 3,
|
|
|
+ 0xF8,
|
|
|
+ 0x3E,
|
|
|
+ 3,
|
|
|
+ 0xC,
|
|
|
+ 0x73,
|
|
|
+ 0x80,
|
|
|
+ 0x70,
|
|
|
+ 0x44,
|
|
|
+ 0x26,
|
|
|
+ 3,
|
|
|
+ 0x24,
|
|
|
+ 0xE1,
|
|
|
+ 0x3E,
|
|
|
+ 4,
|
|
|
+ 0x4E,
|
|
|
+ 4,
|
|
|
+ 0x1C,
|
|
|
+ 0xC1,
|
|
|
+ 9,
|
|
|
+ 0xCC
|
|
|
+ //240
|
|
|
+ ,
|
|
|
+ 0x9E,
|
|
|
+ 0x90,
|
|
|
+ 0x21,
|
|
|
+ 7,
|
|
|
+ 0x90,
|
|
|
+ 0x43,
|
|
|
+ 0x64,
|
|
|
+ 0xC0,
|
|
|
+ 0xF,
|
|
|
+ 0xC6,
|
|
|
+ 0x90,
|
|
|
+ 0x9C,
|
|
|
+ 0xC1,
|
|
|
+ 0x5B,
|
|
|
+ 3,
|
|
|
+ 0xE2,
|
|
|
+ 0x1D,
|
|
|
+ 0x81,
|
|
|
+ 0xE0,
|
|
|
+ 0x5E,
|
|
|
+ 0x1D,
|
|
|
+ 3,
|
|
|
+ 0x84,
|
|
|
+ 0xB8,
|
|
|
+ 0x2C,
|
|
|
+ 0xF,
|
|
|
+ 0x80,
|
|
|
+ 0xB1,
|
|
|
+ 0x83,
|
|
|
+ 0xE0,
|
|
|
+ 0x30,
|
|
|
+ 0x41
|
|
|
+ //260
|
|
|
+ ,
|
|
|
+ 0x1E,
|
|
|
+ 0x43,
|
|
|
+ 0x89,
|
|
|
+ 0x83,
|
|
|
+ 0x50,
|
|
|
+ 0xFC,
|
|
|
+ 0x24,
|
|
|
+ 0x2E,
|
|
|
+ 0x13,
|
|
|
+ 0x83,
|
|
|
+ 0xF1,
|
|
|
+ 0x7C,
|
|
|
+ 0x4C,
|
|
|
+ 0x2C,
|
|
|
+ 0xC9,
|
|
|
+ 0xD,
|
|
|
+ 0x83,
|
|
|
+ 0xB0,
|
|
|
+ 0xB5,
|
|
|
+ 0x82,
|
|
|
+ 0xE4,
|
|
|
+ 0xE8,
|
|
|
+ 6,
|
|
|
+ 0x9C,
|
|
|
+ 7,
|
|
|
+ 0xA0,
|
|
|
+ 0x99,
|
|
|
+ 0x1D,
|
|
|
+ 7,
|
|
|
+ 0x3E,
|
|
|
+ 0x82,
|
|
|
+ 0x8F
|
|
|
+ //280
|
|
|
+ ,
|
|
|
+ 0x70,
|
|
|
+ 0x30,
|
|
|
+ 0x74,
|
|
|
+ 0x40,
|
|
|
+ 0xCA,
|
|
|
+ 0x10,
|
|
|
+ 0xE4,
|
|
|
+ 0xE8,
|
|
|
+ 0xF,
|
|
|
+ 0x92,
|
|
|
+ 0x14,
|
|
|
+ 0x3F,
|
|
|
+ 6,
|
|
|
+ 0xF8,
|
|
|
+ 0x84,
|
|
|
+ 0x88,
|
|
|
+ 0x43,
|
|
|
+ 0x81,
|
|
|
+ 0xA,
|
|
|
+ 0x34,
|
|
|
+ 0x39,
|
|
|
+ 0x41,
|
|
|
+ 0xC6,
|
|
|
+ 0xE3,
|
|
|
+ 0x1C,
|
|
|
+ 0x47,
|
|
|
+ 3,
|
|
|
+ 0xB0,
|
|
|
+ 0xB8,
|
|
|
+ 0x13,
|
|
|
+ 0xA,
|
|
|
+ 0xC2
|
|
|
+ //2A0
|
|
|
+ ,
|
|
|
+ 0x64,
|
|
|
+ 0xF8,
|
|
|
+ 0x18,
|
|
|
+ 0xF9,
|
|
|
+ 0x60,
|
|
|
+ 0xB3,
|
|
|
+ 0xC0,
|
|
|
+ 0x65,
|
|
|
+ 0x20,
|
|
|
+ 0x60,
|
|
|
+ 0xA6,
|
|
|
+ 0x8C,
|
|
|
+ 0xC3,
|
|
|
+ 0x81,
|
|
|
+ 0x20,
|
|
|
+ 0x30,
|
|
|
+ 0x26,
|
|
|
+ 0x1E,
|
|
|
+ 0x1C,
|
|
|
+ 0x38,
|
|
|
+ 0xD3,
|
|
|
+ 1,
|
|
|
+ 0xB0,
|
|
|
+ 0x26,
|
|
|
+ 0x40,
|
|
|
+ 0xF4,
|
|
|
+ 0xB,
|
|
|
+ 0xC3,
|
|
|
+ 0x42,
|
|
|
+ 0x1F,
|
|
|
+ 0x85,
|
|
|
+ 0x32
|
|
|
+ //2C0
|
|
|
+ ,
|
|
|
+ 0x26,
|
|
|
+ 0x60,
|
|
|
+ 0x40,
|
|
|
+ 0xC9,
|
|
|
+ 0xCB,
|
|
|
+ 1,
|
|
|
+ 0xEC,
|
|
|
+ 0x11,
|
|
|
+ 0x28,
|
|
|
+ 0x40,
|
|
|
+ 0xFA,
|
|
|
+ 4,
|
|
|
+ 0x34,
|
|
|
+ 0xE0,
|
|
|
+ 0x70,
|
|
|
+ 0x4C,
|
|
|
+ 0x8C,
|
|
|
+ 0x1D,
|
|
|
+ 7,
|
|
|
+ 0x69,
|
|
|
+ 3,
|
|
|
+ 0x16,
|
|
|
+ 0xC8,
|
|
|
+ 4,
|
|
|
+ 0x23,
|
|
|
+ 0xE8,
|
|
|
+ 0xC6,
|
|
|
+ 0x9A,
|
|
|
+ 0xB,
|
|
|
+ 0x1A,
|
|
|
+ 3,
|
|
|
+ 0xE0
|
|
|
+ //2E0
|
|
|
+ ,
|
|
|
+ 0x76,
|
|
|
+ 6,
|
|
|
+ 5,
|
|
|
+ 0xCF,
|
|
|
+ 0x1E,
|
|
|
+ 0xBC,
|
|
|
+ 0x58,
|
|
|
+ 0x31,
|
|
|
+ 0x71,
|
|
|
+ 0x66,
|
|
|
+ 0,
|
|
|
+ 0xF8,
|
|
|
+ 0x3F,
|
|
|
+ 4,
|
|
|
+ 0xFC,
|
|
|
+ 0xC,
|
|
|
+ 0x74,
|
|
|
+ 0x27,
|
|
|
+ 0x8A,
|
|
|
+ 0x80,
|
|
|
+ 0x71,
|
|
|
+ 0xC2,
|
|
|
+ 0x3A,
|
|
|
+ 0x26,
|
|
|
+ 6,
|
|
|
+ 0xC0,
|
|
|
+ 0x1F,
|
|
|
+ 5,
|
|
|
+ 0xF,
|
|
|
+ 0x98,
|
|
|
+ 0x40,
|
|
|
+ 0xAE
|
|
|
+ //300
|
|
|
+ ,
|
|
|
+ 1,
|
|
|
+ 0x7F,
|
|
|
+ 0xC0,
|
|
|
+ 7,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0xE,
|
|
|
+ 0xFE,
|
|
|
+ 0,
|
|
|
+ 3,
|
|
|
+ 0xDF,
|
|
|
+ 0x80,
|
|
|
+ 3,
|
|
|
+ 0xEF,
|
|
|
+ 0x80,
|
|
|
+ 0x1B,
|
|
|
+ 0xF1,
|
|
|
+ 0xC2,
|
|
|
+ 0,
|
|
|
+ 0xE7,
|
|
|
+ 0xE0,
|
|
|
+ 0x18,
|
|
|
+ 0xFC,
|
|
|
+ 0xE0,
|
|
|
+ 0x21,
|
|
|
+ 0xFC,
|
|
|
+ 0x80,
|
|
|
+ 0x3C,
|
|
|
+ 0xFC,
|
|
|
+ 0x40,
|
|
|
+ 0xE,
|
|
|
+ 0x7E
|
|
|
+ //320
|
|
|
+ ,
|
|
|
+ 0,
|
|
|
+ 0x3F,
|
|
|
+ 0x3E,
|
|
|
+ 0,
|
|
|
+ 0xF,
|
|
|
+ 0xFE,
|
|
|
+ 0,
|
|
|
+ 0x1F,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0x3E,
|
|
|
+ 0xF0,
|
|
|
+ 7,
|
|
|
+ 0xFC,
|
|
|
+ 0,
|
|
|
+ 0x7E,
|
|
|
+ 0x10,
|
|
|
+ 0x3F,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0x3F,
|
|
|
+ 0x38,
|
|
|
+ 0xE,
|
|
|
+ 0x7C,
|
|
|
+ 1,
|
|
|
+ 0x87,
|
|
|
+ 0xC,
|
|
|
+ 0xFC,
|
|
|
+ 0xC7,
|
|
|
+ 0,
|
|
|
+ 0x3E,
|
|
|
+ 4
|
|
|
+ //340
|
|
|
+ ,
|
|
|
+ 0xF,
|
|
|
+ 0x3E,
|
|
|
+ 0x1F,
|
|
|
+ 0xF,
|
|
|
+ 0xF,
|
|
|
+ 0x1F,
|
|
|
+ 0xF,
|
|
|
+ 2,
|
|
|
+ 0x83,
|
|
|
+ 0x87,
|
|
|
+ 0xCF,
|
|
|
+ 3,
|
|
|
+ 0x87,
|
|
|
+ 0xF,
|
|
|
+ 0x3F,
|
|
|
+ 0xC0,
|
|
|
+ 7,
|
|
|
+ 0x9E,
|
|
|
+ 0x60,
|
|
|
+ 0x3F,
|
|
|
+ 0xC0,
|
|
|
+ 3,
|
|
|
+ 0xFE,
|
|
|
+ 0,
|
|
|
+ 0x3F,
|
|
|
+ 0xE0,
|
|
|
+ 0x77,
|
|
|
+ 0xE1,
|
|
|
+ 0xC0,
|
|
|
+ 0xFE,
|
|
|
+ 0xE0,
|
|
|
+ 0xC3
|
|
|
+ //360
|
|
|
+ ,
|
|
|
+ 0xE0,
|
|
|
+ 1,
|
|
|
+ 0xDF,
|
|
|
+ 0xF8,
|
|
|
+ 3,
|
|
|
+ 7,
|
|
|
+ 0,
|
|
|
+ 0x7E,
|
|
|
+ 0x70,
|
|
|
+ 0,
|
|
|
+ 0x7C,
|
|
|
+ 0x38,
|
|
|
+ 0x18,
|
|
|
+ 0xFE,
|
|
|
+ 0xC,
|
|
|
+ 0x1E,
|
|
|
+ 0x78,
|
|
|
+ 0x1C,
|
|
|
+ 0x7C,
|
|
|
+ 0x3E,
|
|
|
+ 0xE,
|
|
|
+ 0x1F,
|
|
|
+ 0x1E,
|
|
|
+ 0x1E,
|
|
|
+ 0x3E,
|
|
|
+ 0,
|
|
|
+ 0x7F,
|
|
|
+ 0x83,
|
|
|
+ 7,
|
|
|
+ 0xDB,
|
|
|
+ 0x87,
|
|
|
+ 0x83
|
|
|
+ //380
|
|
|
+ ,
|
|
|
+ 7,
|
|
|
+ 0xC7,
|
|
|
+ 7,
|
|
|
+ 0x10,
|
|
|
+ 0x71,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0x3F,
|
|
|
+ 0xE2,
|
|
|
+ 1,
|
|
|
+ 0xE0,
|
|
|
+ 0xC1,
|
|
|
+ 0xC3,
|
|
|
+ 0xE1,
|
|
|
+ 0,
|
|
|
+ 0x7F,
|
|
|
+ 0xC0,
|
|
|
+ 5,
|
|
|
+ 0xF0,
|
|
|
+ 0x20,
|
|
|
+ 0xF8,
|
|
|
+ 0xF0,
|
|
|
+ 0x70,
|
|
|
+ 0xFE,
|
|
|
+ 0x78,
|
|
|
+ 0x79,
|
|
|
+ 0xF8,
|
|
|
+ 2,
|
|
|
+ 0x3F,
|
|
|
+ 0xC,
|
|
|
+ 0x8F,
|
|
|
+ 3
|
|
|
+ //3a0
|
|
|
+ ,
|
|
|
+ 0xF,
|
|
|
+ 0x9F,
|
|
|
+ 0xE0,
|
|
|
+ 0xC1,
|
|
|
+ 0xC7,
|
|
|
+ 0x87,
|
|
|
+ 3,
|
|
|
+ 0xC3,
|
|
|
+ 0xC3,
|
|
|
+ 0xB0,
|
|
|
+ 0xE1,
|
|
|
+ 0xE1,
|
|
|
+ 0xC1,
|
|
|
+ 0xE3,
|
|
|
+ 0xE0,
|
|
|
+ 0x71,
|
|
|
+ 0xF0,
|
|
|
+ 0,
|
|
|
+ 0xFC,
|
|
|
+ 0x70,
|
|
|
+ 0x7C,
|
|
|
+ 0xC,
|
|
|
+ 0x3E,
|
|
|
+ 0x38,
|
|
|
+ 0xE,
|
|
|
+ 0x1C,
|
|
|
+ 0x70,
|
|
|
+ 0xC3,
|
|
|
+ 0xC7,
|
|
|
+ 3,
|
|
|
+ 0x81,
|
|
|
+ 0xC1
|
|
|
+ //3c0
|
|
|
+ ,
|
|
|
+ 0xC7,
|
|
|
+ 0xE7,
|
|
|
+ 0,
|
|
|
+ 0xF,
|
|
|
+ 0xC7,
|
|
|
+ 0x87,
|
|
|
+ 0x19,
|
|
|
+ 9,
|
|
|
+ 0xEF,
|
|
|
+ 0xC4,
|
|
|
+ 0x33,
|
|
|
+ 0xE0,
|
|
|
+ 0xC1,
|
|
|
+ 0xFC,
|
|
|
+ 0xF8,
|
|
|
+ 0x70,
|
|
|
+ 0xF0,
|
|
|
+ 0x78,
|
|
|
+ 0xF8,
|
|
|
+ 0xF0,
|
|
|
+ 0x61,
|
|
|
+ 0xC7,
|
|
|
+ 0,
|
|
|
+ 0x1F,
|
|
|
+ 0xF8,
|
|
|
+ 1,
|
|
|
+ 0x7C,
|
|
|
+ 0xF8,
|
|
|
+ 0xF0,
|
|
|
+ 0x78,
|
|
|
+ 0x70,
|
|
|
+ 0x3C
|
|
|
+ //3e0
|
|
|
+ ,
|
|
|
+ 0x7C,
|
|
|
+ 0xCE,
|
|
|
+ 0xE,
|
|
|
+ 0x21,
|
|
|
+ 0x83,
|
|
|
+ 0xCF,
|
|
|
+ 8,
|
|
|
+ 7,
|
|
|
+ 0x8F,
|
|
|
+ 8,
|
|
|
+ 0xC1,
|
|
|
+ 0x87,
|
|
|
+ 0x8F,
|
|
|
+ 0x80,
|
|
|
+ 0xC7,
|
|
|
+ 0xE3,
|
|
|
+ 0,
|
|
|
+ 7,
|
|
|
+ 0xF8,
|
|
|
+ 0xE0,
|
|
|
+ 0xEF,
|
|
|
+ 0,
|
|
|
+ 0x39,
|
|
|
+ 0xF7,
|
|
|
+ 0x80,
|
|
|
+ 0xE,
|
|
|
+ 0xF8,
|
|
|
+ 0xE1,
|
|
|
+ 0xE3,
|
|
|
+ 0xF8,
|
|
|
+ 0x21,
|
|
|
+ 0x9F
|
|
|
+ //400
|
|
|
+ ,
|
|
|
+ 0xC0,
|
|
|
+ 0xFF,
|
|
|
+ 3,
|
|
|
+ 0xF8,
|
|
|
+ 7,
|
|
|
+ 0xC0,
|
|
|
+ 0x1F,
|
|
|
+ 0xF8,
|
|
|
+ 0xC4,
|
|
|
+ 4,
|
|
|
+ 0xFC,
|
|
|
+ 0xC4,
|
|
|
+ 0xC1,
|
|
|
+ 0xBC,
|
|
|
+ 0x87,
|
|
|
+ 0xF0,
|
|
|
+ 0xF,
|
|
|
+ 0xC0,
|
|
|
+ 0x7F,
|
|
|
+ 5,
|
|
|
+ 0xE0,
|
|
|
+ 0x25,
|
|
|
+ 0xEC,
|
|
|
+ 0xC0,
|
|
|
+ 0x3E,
|
|
|
+ 0x84,
|
|
|
+ 0x47,
|
|
|
+ 0xF0,
|
|
|
+ 0x8E,
|
|
|
+ 3,
|
|
|
+ 0xF8,
|
|
|
+ 3
|
|
|
+ //420
|
|
|
+ ,
|
|
|
+ 0xFB,
|
|
|
+ 0xC0,
|
|
|
+ 0x19,
|
|
|
+ 0xF8,
|
|
|
+ 7,
|
|
|
+ 0x9C,
|
|
|
+ 0xC,
|
|
|
+ 0x17,
|
|
|
+ 0xF8,
|
|
|
+ 7,
|
|
|
+ 0xE0,
|
|
|
+ 0x1F,
|
|
|
+ 0xA1,
|
|
|
+ 0xFC,
|
|
|
+ 0xF,
|
|
|
+ 0xFC,
|
|
|
+ 1,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F,
|
|
|
+ 0,
|
|
|
+ 0xFE,
|
|
|
+ 3,
|
|
|
+ 0xF0,
|
|
|
+ 0x1F,
|
|
|
+ 0,
|
|
|
+ 0xFD,
|
|
|
+ 0,
|
|
|
+ 0xFF,
|
|
|
+ 0x88,
|
|
|
+ 0xD,
|
|
|
+ 0xF9,
|
|
|
+ 1
|
|
|
+ //440
|
|
|
+ ,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0x70,
|
|
|
+ 7,
|
|
|
+ 0xC0,
|
|
|
+ 0x3E,
|
|
|
+ 0x42,
|
|
|
+ 0xF3,
|
|
|
+ 0xD,
|
|
|
+ 0xC4,
|
|
|
+ 0x7F,
|
|
|
+ 0x80,
|
|
|
+ 0xFC,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 0x5E,
|
|
|
+ 0xC0,
|
|
|
+ 0x3F,
|
|
|
+ 0,
|
|
|
+ 0x78,
|
|
|
+ 0x3F,
|
|
|
+ 0x81,
|
|
|
+ 0xFF,
|
|
|
+ 1,
|
|
|
+ 0xF8,
|
|
|
+ 1,
|
|
|
+ 0xC3,
|
|
|
+ 0xE8,
|
|
|
+ 0xC,
|
|
|
+ 0xE4,
|
|
|
+ 0x64,
|
|
|
+ 0x8F
|
|
|
+ ////460
|
|
|
+ ,
|
|
|
+ 0xE4,
|
|
|
+ 0xF,
|
|
|
+ 0xF0,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 0xC2,
|
|
|
+ 0x1F,
|
|
|
+ 0,
|
|
|
+ 0x7F,
|
|
|
+ 0xC0,
|
|
|
+ 0x6F,
|
|
|
+ 0x80,
|
|
|
+ 0x7E,
|
|
|
+ 3,
|
|
|
+ 0xF8,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 0x3F,
|
|
|
+ 0xC0,
|
|
|
+ 0x78,
|
|
|
+ 0xF,
|
|
|
+ 0x82,
|
|
|
+ 7,
|
|
|
+ 0xFE,
|
|
|
+ 0x22,
|
|
|
+ 0x77,
|
|
|
+ 0x70,
|
|
|
+ 2,
|
|
|
+ 0x76,
|
|
|
+ 3,
|
|
|
+ 0xFE,
|
|
|
+ 0
|
|
|
+ //480
|
|
|
+ ,
|
|
|
+ 0xFE,
|
|
|
+ 0x67,
|
|
|
+ 0,
|
|
|
+ 0x7C,
|
|
|
+ 0xC7,
|
|
|
+ 0xF1,
|
|
|
+ 0x8E,
|
|
|
+ 0xC6,
|
|
|
+ 0x3B,
|
|
|
+ 0xE0,
|
|
|
+ 0x3F,
|
|
|
+ 0x84,
|
|
|
+ 0xF3,
|
|
|
+ 0x19,
|
|
|
+ 0xD8,
|
|
|
+ 3,
|
|
|
+ 0x99,
|
|
|
+ 0xFC,
|
|
|
+ 9,
|
|
|
+ 0xB8,
|
|
|
+ 0xF,
|
|
|
+ 0xF8,
|
|
|
+ 0,
|
|
|
+ 0x9D,
|
|
|
+ 0x24,
|
|
|
+ 0x61,
|
|
|
+ 0xF9,
|
|
|
+ 0xD,
|
|
|
+ 0,
|
|
|
+ 0xFD,
|
|
|
+ 3,
|
|
|
+ 0xF0
|
|
|
+ //4a0
|
|
|
+ ,
|
|
|
+ 0x1F,
|
|
|
+ 0x90,
|
|
|
+ 0x3F,
|
|
|
+ 1,
|
|
|
+ 0xF8,
|
|
|
+ 0x1F,
|
|
|
+ 0xD0,
|
|
|
+ 0xF,
|
|
|
+ 0xF8,
|
|
|
+ 0x37,
|
|
|
+ 1,
|
|
|
+ 0xF8,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 0xF,
|
|
|
+ 0xC0,
|
|
|
+ 0x3F,
|
|
|
+ 0,
|
|
|
+ 0xFE,
|
|
|
+ 3,
|
|
|
+ 0xF8,
|
|
|
+ 0xF,
|
|
|
+ 0xC0,
|
|
|
+ 0x3F,
|
|
|
+ 0,
|
|
|
+ 0xFA,
|
|
|
+ 3,
|
|
|
+ 0xF0,
|
|
|
+ 0xF,
|
|
|
+ 0x80,
|
|
|
+ 0xFF,
|
|
|
+ 1
|
|
|
+ //4c0
|
|
|
+ ,
|
|
|
+ 0xB8,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 1,
|
|
|
+ 0xFC,
|
|
|
+ 1,
|
|
|
+ 0xBC,
|
|
|
+ 0x80,
|
|
|
+ 0x13,
|
|
|
+ 0x1E,
|
|
|
+ 0,
|
|
|
+ 0x7F,
|
|
|
+ 0xE1,
|
|
|
+ 0x40,
|
|
|
+ 0x7F,
|
|
|
+ 0xA0,
|
|
|
+ 0x7F,
|
|
|
+ 0xB0,
|
|
|
+ 0,
|
|
|
+ 0x3F,
|
|
|
+ 0xC0,
|
|
|
+ 0x1F,
|
|
|
+ 0xC0,
|
|
|
+ 0x38,
|
|
|
+ 0xF,
|
|
|
+ 0xF0,
|
|
|
+ 0x1F,
|
|
|
+ 0x80,
|
|
|
+ 0xFF,
|
|
|
+ 1,
|
|
|
+ 0xFC,
|
|
|
+ 3
|
|
|
+ //4e0
|
|
|
+ ,
|
|
|
+ 0xF1,
|
|
|
+ 0x7E,
|
|
|
+ 1,
|
|
|
+ 0xFE,
|
|
|
+ 1,
|
|
|
+ 0xF0,
|
|
|
+ 0xFF,
|
|
|
+ 0,
|
|
|
+ 0x7F,
|
|
|
+ 0xC0,
|
|
|
+ 0x1D,
|
|
|
+ 7,
|
|
|
+ 0xF0,
|
|
|
+ 0xF,
|
|
|
+ 0xC0,
|
|
|
+ 0x7E,
|
|
|
+ 6,
|
|
|
+ 0xE0,
|
|
|
+ 7,
|
|
|
+ 0xE0,
|
|
|
+ 0xF,
|
|
|
+ 0xF8,
|
|
|
+ 6,
|
|
|
+ 0xC1,
|
|
|
+ 0xFE,
|
|
|
+ 1,
|
|
|
+ 0xFC,
|
|
|
+ 3,
|
|
|
+ 0xE0,
|
|
|
+ 0xF,
|
|
|
+ 0,
|
|
|
+ 0xFC};
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Render
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+unsigned char pitches[256]; // tab43008
|
|
|
+
|
|
|
+unsigned char frequency1[256];
|
|
|
+unsigned char frequency2[256];
|
|
|
+unsigned char frequency3[256];
|
|
|
+
|
|
|
+unsigned char amplitude1[256];
|
|
|
+unsigned char amplitude2[256];
|
|
|
+unsigned char amplitude3[256];
|
|
|
+
|
|
|
+unsigned char sampledConsonantFlag[256]; // tab44800
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Sam
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+unsigned char stress[256]; //numbers from 0 to 8
|
|
|
+unsigned char phonemeLength[256]; //tab40160
|
|
|
+unsigned char phonemeindex[256];
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// ReciterTabs
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+//some flags
|
|
|
+const unsigned char tab36376[] = {
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, // 0-7
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, // 8-15
|
|
|
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
|
|
|
+ 0, 2, 2, 2, 2, 2, 2, 130, // ' ', '!'
|
|
|
+ 0, 0, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3,
|
|
|
+ 3, 3, 2, 2, 2, 2, 2, 2, 2, 192, 168, 176, 172, 192, 160, 184, // '@', 'A'
|
|
|
+ 160, 192, 188, 160, 172, 168, 172, 192, 160, 160, 172, 180, 164, 192, 168, 168,
|
|
|
+ 176, 192, 188, 0, 0, 0, 2, 0, // 'X', 'Y', 'Z', '[',
|
|
|
+ 32, 32, 155, 32, 192, 185, 32, 205, 163, 76, 138, 142};
|
|
|
+
|
|
|
+const unsigned char rules[] = {
|
|
|
+ ']', 'A' | 0x80, ' ', '(', 'A', '.', ')', '=',
|
|
|
+ 'E', 'H', '4', 'Y', '.', ' ' | 0x80, '(', 'A',
|
|
|
+ ')', ' ', '=', 'A', 'H' | 0x80, ' ', '(', 'A',
|
|
|
+ 'R', 'E', ')', ' ', '=', 'A', 'A', 'R' | 0x80,
|
|
|
+ ' ', '(', 'A', 'R', ')', 'O', '=', 'A',
|
|
|
+ 'X', 'R' | 0x80, '(', 'A', 'R', ')', '#', '=',
|
|
|
+ 'E', 'H', '4', 'R' | 0x80, ' ', '^', '(', 'A',
|
|
|
+ 'S', ')', '#', '=', 'E', 'Y', '4', 'S' | 0x80,
|
|
|
+ '(', 'A', ')', 'W', 'A', '=', 'A', 'X' | 0x80,
|
|
|
+ '(', 'A', 'W', ')', '=', 'A', 'O', '5' | 0x80,
|
|
|
+ ' ', ':', '(', 'A', 'N', 'Y', ')', '=',
|
|
|
+ 'E', 'H', '4', 'N', 'I', 'Y' | 0x80, '(', 'A',
|
|
|
+ ')', '^', '+', '#', '=', 'E', 'Y', '5' | 0x80,
|
|
|
+ '#', ':', '(', 'A', 'L', 'L', 'Y', ')',
|
|
|
+ '=', 'U', 'L', 'I', 'Y' | 0x80, ' ', '(', 'A',
|
|
|
+ 'L', ')', '#', '=', 'U', 'L' | 0x80, '(', 'A',
|
|
|
+ 'G', 'A', 'I', 'N', ')', '=', 'A', 'X',
|
|
|
+ 'G', 'E', 'H', '4', 'N' | 0x80, '#', ':', '(',
|
|
|
+ 'A', 'G', ')', 'E', '=', 'I', 'H', 'J' | 0x80,
|
|
|
+ '(', 'A', ')', '^', '%', '=', 'E', 'Y' | 0x80,
|
|
|
+ '(', 'A', ')', '^', '+', ':', '#', '=',
|
|
|
+ 'A', 'E' | 0x80, ' ', ':', '(', 'A', ')', '^',
|
|
|
+ '+', ' ', '=', 'E', 'Y', '4' | 0x80, ' ', '(',
|
|
|
+ 'A', 'R', 'R', ')', '=', 'A', 'X', 'R' | 0x80,
|
|
|
+ '(', 'A', 'R', 'R', ')', '=', 'A', 'E',
|
|
|
+ '4', 'R' | 0x80, ' ', '^', '(', 'A', 'R', ')',
|
|
|
+ ' ', '=', 'A', 'A', '5', 'R' | 0x80, '(', 'A',
|
|
|
+ 'R', ')', '=', 'A', 'A', '5', 'R' | 0x80, '(',
|
|
|
+ 'A', 'I', 'R', ')', '=', 'E', 'H', '4',
|
|
|
+ 'R' | 0x80, '(', 'A', 'I', ')', '=', 'E', 'Y',
|
|
|
+ '4' | 0x80, '(', 'A', 'Y', ')', '=', 'E', 'Y',
|
|
|
+ '5' | 0x80, '(', 'A', 'U', ')', '=', 'A', 'O',
|
|
|
+ '4' | 0x80, '#', ':', '(', 'A', 'L', ')', ' ',
|
|
|
+ '=', 'U', 'L' | 0x80, '#', ':', '(', 'A', 'L',
|
|
|
+ 'S', ')', ' ', '=', 'U', 'L', 'Z' | 0x80, '(',
|
|
|
+ 'A', 'L', 'K', ')', '=', 'A', 'O', '4',
|
|
|
+ 'K' | 0x80, '(', 'A', 'L', ')', '^', '=', 'A',
|
|
|
+ 'O', 'L' | 0x80, ' ', ':', '(', 'A', 'B', 'L',
|
|
|
+ 'E', ')', '=', 'E', 'Y', '4', 'B', 'U',
|
|
|
+ 'L' | 0x80, '(', 'A', 'B', 'L', 'E', ')', '=',
|
|
|
+ 'A', 'X', 'B', 'U', 'L' | 0x80, '(', 'A', ')',
|
|
|
+ 'V', 'O', '=', 'E', 'Y', '4' | 0x80, '(', 'A',
|
|
|
+ 'N', 'G', ')', '+', '=', 'E', 'Y', '4',
|
|
|
+ 'N', 'J' | 0x80, '(', 'A', 'T', 'A', 'R', 'I',
|
|
|
+ ')', '=', 'A', 'H', 'T', 'A', 'A', '4',
|
|
|
+ 'R', 'I', 'Y' | 0x80, '(', 'A', ')', 'T', 'O',
|
|
|
+ 'M', '=', 'A', 'E' | 0x80, '(', 'A', ')', 'T',
|
|
|
+ 'T', 'I', '=', 'A', 'E' | 0x80, ' ', '(', 'A',
|
|
|
+ 'T', ')', ' ', '=', 'A', 'E', 'T' | 0x80, ' ',
|
|
|
+ '(', 'A', ')', 'T', '=', 'A', 'H' | 0x80, '(',
|
|
|
+ 'A', ')', '=', 'A', 'E' | 0x80,
|
|
|
+
|
|
|
+ ']', 'B' | 0x80, ' ', '(', 'B', ')', ' ', '=',
|
|
|
+ 'B', 'I', 'Y', '4' | 0x80, ' ', '(', 'B', 'E',
|
|
|
+ ')', '^', '#', '=', 'B', 'I', 'H' | 0x80, '(',
|
|
|
+ 'B', 'E', 'I', 'N', 'G', ')', '=', 'B',
|
|
|
+ 'I', 'Y', '4', 'I', 'H', 'N', 'X' | 0x80, ' ',
|
|
|
+ '(', 'B', 'O', 'T', 'H', ')', ' ', '=',
|
|
|
+ 'B', 'O', 'W', '4', 'T', 'H' | 0x80, ' ', '(',
|
|
|
+ 'B', 'U', 'S', ')', '#', '=', 'B', 'I',
|
|
|
+ 'H', '4', 'Z' | 0x80, '(', 'B', 'R', 'E', 'A',
|
|
|
+ 'K', ')', '=', 'B', 'R', 'E', 'Y', '5',
|
|
|
+ 'K' | 0x80, '(', 'B', 'U', 'I', 'L', ')', '=',
|
|
|
+ 'B', 'I', 'H', '4', 'L' | 0x80, '(', 'B', ')',
|
|
|
+ '=', 'B' | 0x80,
|
|
|
+
|
|
|
+ ']', 'C' | 0x80, ' ', '(', 'C', ')', ' ', '=',
|
|
|
+ 'S', 'I', 'Y', '4' | 0x80, ' ', '(', 'C', 'H',
|
|
|
+ ')', '^', '=', 'K' | 0x80, '^', 'E', '(', 'C',
|
|
|
+ 'H', ')', '=', 'K' | 0x80, '(', 'C', 'H', 'A',
|
|
|
+ ')', 'R', '#', '=', 'K', 'E', 'H', '5' | 0x80,
|
|
|
+ '(', 'C', 'H', ')', '=', 'C', 'H' | 0x80, ' ',
|
|
|
+ 'S', '(', 'C', 'I', ')', '#', '=', 'S',
|
|
|
+ 'A', 'Y', '4' | 0x80, '(', 'C', 'I', ')', 'A',
|
|
|
+ '=', 'S', 'H' | 0x80, '(', 'C', 'I', ')', 'O',
|
|
|
+ '=', 'S', 'H' | 0x80, '(', 'C', 'I', ')', 'E',
|
|
|
+ 'N', '=', 'S', 'H' | 0x80, '(', 'C', 'I', 'T',
|
|
|
+ 'Y', ')', '=', 'S', 'I', 'H', 'T', 'I',
|
|
|
+ 'Y' | 0x80, '(', 'C', ')', '+', '=', 'S' | 0x80, '(',
|
|
|
+ 'C', 'K', ')', '=', 'K' | 0x80, '(', 'C', 'O',
|
|
|
+ 'M', 'M', 'O', 'D', 'O', 'R', 'E', ')',
|
|
|
+ '=', 'K', 'A', 'A', '4', 'M', 'A', 'H',
|
|
|
+ 'D', 'O', 'H', 'R' | 0x80, '(', 'C', 'O', 'M',
|
|
|
+ ')', '=', 'K', 'A', 'H', 'M' | 0x80, '(', 'C',
|
|
|
+ 'U', 'I', 'T', ')', '=', 'K', 'I', 'H',
|
|
|
+ 'T' | 0x80, '(', 'C', 'R', 'E', 'A', ')', '=',
|
|
|
+ 'K', 'R', 'I', 'Y', 'E', 'Y' | 0x80, '(', 'C',
|
|
|
+ ')', '=', 'K' | 0x80,
|
|
|
+
|
|
|
+ ']', 'D' | 0x80, ' ', '(', 'D', ')', ' ', '=',
|
|
|
+ 'D', 'I', 'Y', '4' | 0x80, ' ', '(', 'D', 'R',
|
|
|
+ '.', ')', ' ', '=', 'D', 'A', 'A', '4',
|
|
|
+ 'K', 'T', 'E', 'R' | 0x80, '#', ':', '(', 'D',
|
|
|
+ 'E', 'D', ')', ' ', '=', 'D', 'I', 'H',
|
|
|
+ 'D' | 0x80, '.', 'E', '(', 'D', ')', ' ', '=',
|
|
|
+ 'D' | 0x80, '#', ':', '^', 'E', '(', 'D', ')',
|
|
|
+ ' ', '=', 'T' | 0x80, ' ', '(', 'D', 'E', ')',
|
|
|
+ '^', '#', '=', 'D', 'I', 'H' | 0x80, ' ', '(',
|
|
|
+ 'D', 'O', ')', ' ', '=', 'D', 'U', 'W' | 0x80,
|
|
|
+ ' ', '(', 'D', 'O', 'E', 'S', ')', '=',
|
|
|
+ 'D', 'A', 'H', 'Z' | 0x80, '(', 'D', 'O', 'N',
|
|
|
+ 'E', ')', ' ', '=', 'D', 'A', 'H', '5',
|
|
|
+ 'N' | 0x80, '(', 'D', 'O', 'I', 'N', 'G', ')',
|
|
|
+ '=', 'D', 'U', 'W', '4', 'I', 'H', 'N',
|
|
|
+ 'X' | 0x80, ' ', '(', 'D', 'O', 'W', ')', '=',
|
|
|
+ 'D', 'A', 'W' | 0x80, '#', '(', 'D', 'U', ')',
|
|
|
+ 'A', '=', 'J', 'U', 'W' | 0x80, '#', '(', 'D',
|
|
|
+ 'U', ')', '^', '#', '=', 'J', 'A', 'X' | 0x80,
|
|
|
+ '(', 'D', ')', '=', 'D' | 0x80,
|
|
|
+
|
|
|
+ ']', 'E' | 0x80, ' ', '(', 'E', ')', ' ', '=',
|
|
|
+ 'I', 'Y', 'I', 'Y', '4' | 0x80, '#', ':', '(',
|
|
|
+ 'E', ')', ' ', '=' | 0x80, '\'', ':', '^', '(',
|
|
|
+ 'E', ')', ' ', '=' | 0x80, ' ', ':', '(', 'E',
|
|
|
+ ')', ' ', '=', 'I', 'Y' | 0x80, '#', '(', 'E',
|
|
|
+ 'D', ')', ' ', '=', 'D' | 0x80, '#', ':', '(',
|
|
|
+ 'E', ')', 'D', ' ', '=' | 0x80, '(', 'E', 'V',
|
|
|
+ ')', 'E', 'R', '=', 'E', 'H', '4', 'V' | 0x80,
|
|
|
+ '(', 'E', ')', '^', '%', '=', 'I', 'Y',
|
|
|
+ '4' | 0x80, '(', 'E', 'R', 'I', ')', '#', '=',
|
|
|
+ 'I', 'Y', '4', 'R', 'I', 'Y' | 0x80, '(', 'E',
|
|
|
+ 'R', 'I', ')', '=', 'E', 'H', '4', 'R',
|
|
|
+ 'I', 'H' | 0x80, '#', ':', '(', 'E', 'R', ')',
|
|
|
+ '#', '=', 'E', 'R' | 0x80, '(', 'E', 'R', 'R',
|
|
|
+ 'O', 'R', ')', '=', 'E', 'H', '4', 'R',
|
|
|
+ 'O', 'H', 'R' | 0x80, '(', 'E', 'R', 'A', 'S',
|
|
|
+ 'E', ')', '=', 'I', 'H', 'R', 'E', 'Y',
|
|
|
+ '5', 'S' | 0x80, '(', 'E', 'R', ')', '#', '=',
|
|
|
+ 'E', 'H', 'R' | 0x80, '(', 'E', 'R', ')', '=',
|
|
|
+ 'E', 'R' | 0x80, ' ', '(', 'E', 'V', 'E', 'N',
|
|
|
+ ')', '=', 'I', 'Y', 'V', 'E', 'H', 'N' | 0x80,
|
|
|
+ '#', ':', '(', 'E', ')', 'W', '=' | 0x80, '@',
|
|
|
+ '(', 'E', 'W', ')', '=', 'U', 'W' | 0x80, '(',
|
|
|
+ 'E', 'W', ')', '=', 'Y', 'U', 'W' | 0x80, '(',
|
|
|
+ 'E', ')', 'O', '=', 'I', 'Y' | 0x80, '#', ':',
|
|
|
+ '&', '(', 'E', 'S', ')', ' ', '=', 'I',
|
|
|
+ 'H', 'Z' | 0x80, '#', ':', '(', 'E', ')', 'S',
|
|
|
+ ' ', '=' | 0x80, '#', ':', '(', 'E', 'L', 'Y',
|
|
|
+ ')', ' ', '=', 'L', 'I', 'Y' | 0x80, '#', ':',
|
|
|
+ '(', 'E', 'M', 'E', 'N', 'T', ')', '=',
|
|
|
+ 'M', 'E', 'H', 'N', 'T' | 0x80, '(', 'E', 'F',
|
|
|
+ 'U', 'L', ')', '=', 'F', 'U', 'H', 'L' | 0x80,
|
|
|
+ '(', 'E', 'E', ')', '=', 'I', 'Y', '4' | 0x80,
|
|
|
+ '(', 'E', 'A', 'R', 'N', ')', '=', 'E',
|
|
|
+ 'R', '5', 'N' | 0x80, ' ', '(', 'E', 'A', 'R',
|
|
|
+ ')', '^', '=', 'E', 'R', '5' | 0x80, '(', 'E',
|
|
|
+ 'A', 'D', ')', '=', 'E', 'H', 'D' | 0x80, '#',
|
|
|
+ ':', '(', 'E', 'A', ')', ' ', '=', 'I',
|
|
|
+ 'Y', 'A', 'X' | 0x80, '(', 'E', 'A', ')', 'S',
|
|
|
+ 'U', '=', 'E', 'H', '5' | 0x80, '(', 'E', 'A',
|
|
|
+ ')', '=', 'I', 'Y', '5' | 0x80, '(', 'E', 'I',
|
|
|
+ 'G', 'H', ')', '=', 'E', 'Y', '4' | 0x80, '(',
|
|
|
+ 'E', 'I', ')', '=', 'I', 'Y', '4' | 0x80, ' ',
|
|
|
+ '(', 'E', 'Y', 'E', ')', '=', 'A', 'Y',
|
|
|
+ '4' | 0x80, '(', 'E', 'Y', ')', '=', 'I', 'Y' | 0x80,
|
|
|
+ '(', 'E', 'U', ')', '=', 'Y', 'U', 'W',
|
|
|
+ '5' | 0x80, '(', 'E', 'Q', 'U', 'A', 'L', ')',
|
|
|
+ '=', 'I', 'Y', '4', 'K', 'W', 'U', 'L' | 0x80,
|
|
|
+ '(', 'E', ')', '=', 'E', 'H' | 0x80,
|
|
|
+
|
|
|
+ ']', 'F' | 0x80, ' ', '(', 'F', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'F' | 0x80, '(', 'F', 'U', 'L',
|
|
|
+ ')', '=', 'F', 'U', 'H', 'L' | 0x80, '(', 'F',
|
|
|
+ 'R', 'I', 'E', 'N', 'D', ')', '=', 'F',
|
|
|
+ 'R', 'E', 'H', '5', 'N', 'D' | 0x80, '(', 'F',
|
|
|
+ 'A', 'T', 'H', 'E', 'R', ')', '=', 'F',
|
|
|
+ 'A', 'A', '4', 'D', 'H', 'E', 'R' | 0x80, '(',
|
|
|
+ 'F', ')', 'F', '=' | 0x80, '(', 'F', ')', '=',
|
|
|
+ 'F' | 0x80,
|
|
|
+
|
|
|
+ ']', 'G' | 0x80, ' ', '(', 'G', ')', ' ', '=',
|
|
|
+ 'J', 'I', 'Y', '4' | 0x80, '(', 'G', 'I', 'V',
|
|
|
+ ')', '=', 'G', 'I', 'H', '5', 'V' | 0x80, ' ',
|
|
|
+ '(', 'G', ')', 'I', '^', '=', 'G' | 0x80, '(',
|
|
|
+ 'G', 'E', ')', 'T', '=', 'G', 'E', 'H',
|
|
|
+ '5' | 0x80, 'S', 'U', '(', 'G', 'G', 'E', 'S',
|
|
|
+ ')', '=', 'G', 'J', 'E', 'H', '4', 'S' | 0x80,
|
|
|
+ '(', 'G', 'G', ')', '=', 'G' | 0x80, ' ', 'B',
|
|
|
+ '#', '(', 'G', ')', '=', 'G' | 0x80, '(', 'G',
|
|
|
+ ')', '+', '=', 'J' | 0x80, '(', 'G', 'R', 'E',
|
|
|
+ 'A', 'T', ')', '=', 'G', 'R', 'E', 'Y',
|
|
|
+ '4', 'T' | 0x80, '(', 'G', 'O', 'N', ')', 'E',
|
|
|
+ '=', 'G', 'A', 'O', '5', 'N' | 0x80, '#', '(',
|
|
|
+ 'G', 'H', ')', '=' | 0x80, ' ', '(', 'G', 'N',
|
|
|
+ ')', '=', 'N' | 0x80, '(', 'G', ')', '=', 'G' | 0x80,
|
|
|
+
|
|
|
+ ']', 'H' | 0x80, ' ', '(', 'H', ')', ' ', '=',
|
|
|
+ 'E', 'Y', '4', 'C', 'H' | 0x80, ' ', '(', 'H',
|
|
|
+ 'A', 'V', ')', '=', '/', 'H', 'A', 'E',
|
|
|
+ '6', 'V' | 0x80, ' ', '(', 'H', 'E', 'R', 'E',
|
|
|
+ ')', '=', '/', 'H', 'I', 'Y', 'R' | 0x80, ' ',
|
|
|
+ '(', 'H', 'O', 'U', 'R', ')', '=', 'A',
|
|
|
+ 'W', '5', 'E', 'R' | 0x80, '(', 'H', 'O', 'W',
|
|
|
+ ')', '=', '/', 'H', 'A', 'W' | 0x80, '(', 'H',
|
|
|
+ ')', '#', '=', '/', 'H' | 0x80, '(', 'H', ')',
|
|
|
+ '=' | 0x80,
|
|
|
+
|
|
|
+ ']', 'I' | 0x80, ' ', '(', 'I', 'N', ')', '=',
|
|
|
+ 'I', 'H', 'N' | 0x80, ' ', '(', 'I', ')', ' ',
|
|
|
+ '=', 'A', 'Y', '4' | 0x80, '(', 'I', ')', ' ',
|
|
|
+ '=', 'A', 'Y' | 0x80, '(', 'I', 'N', ')', 'D',
|
|
|
+ '=', 'A', 'Y', '5', 'N' | 0x80, 'S', 'E', 'M',
|
|
|
+ '(', 'I', ')', '=', 'I', 'Y' | 0x80, ' ', 'A',
|
|
|
+ 'N', 'T', '(', 'I', ')', '=', 'A', 'Y' | 0x80,
|
|
|
+ '(', 'I', 'E', 'R', ')', '=', 'I', 'Y',
|
|
|
+ 'E', 'R' | 0x80, '#', ':', 'R', '(', 'I', 'E',
|
|
|
+ 'D', ')', ' ', '=', 'I', 'Y', 'D' | 0x80, '(',
|
|
|
+ 'I', 'E', 'D', ')', ' ', '=', 'A', 'Y',
|
|
|
+ '5', 'D' | 0x80, '(', 'I', 'E', 'N', ')', '=',
|
|
|
+ 'I', 'Y', 'E', 'H', 'N' | 0x80, '(', 'I', 'E',
|
|
|
+ ')', 'T', '=', 'A', 'Y', '4', 'E', 'H' | 0x80,
|
|
|
+ '(', 'I', '\'', ')', '=', 'A', 'Y', '5' | 0x80,
|
|
|
+ ' ', ':', '(', 'I', ')', '^', '%', '=',
|
|
|
+ 'A', 'Y', '5' | 0x80, ' ', ':', '(', 'I', 'E',
|
|
|
+ ')', ' ', '=', 'A', 'Y', '4' | 0x80, '(', 'I',
|
|
|
+ ')', '%', '=', 'I', 'Y' | 0x80, '(', 'I', 'E',
|
|
|
+ ')', '=', 'I', 'Y', '4' | 0x80, ' ', '(', 'I',
|
|
|
+ 'D', 'E', 'A', ')', '=', 'A', 'Y', 'D',
|
|
|
+ 'I', 'Y', '5', 'A', 'H' | 0x80, '(', 'I', ')',
|
|
|
+ '^', '+', ':', '#', '=', 'I', 'H' | 0x80, '(',
|
|
|
+ 'I', 'R', ')', '#', '=', 'A', 'Y', 'R' | 0x80,
|
|
|
+ '(', 'I', 'Z', ')', '%', '=', 'A', 'Y',
|
|
|
+ 'Z' | 0x80, '(', 'I', 'S', ')', '%', '=', 'A',
|
|
|
+ 'Y', 'Z' | 0x80, 'I', '^', '(', 'I', ')', '^',
|
|
|
+ '#', '=', 'I', 'H' | 0x80, '+', '^', '(', 'I',
|
|
|
+ ')', '^', '+', '=', 'A', 'Y' | 0x80, '#', ':',
|
|
|
+ '^', '(', 'I', ')', '^', '+', '=', 'I',
|
|
|
+ 'H' | 0x80, '(', 'I', ')', '^', '+', '=', 'A',
|
|
|
+ 'Y' | 0x80, '(', 'I', 'R', ')', '=', 'E', 'R' | 0x80,
|
|
|
+ '(', 'I', 'G', 'H', ')', '=', 'A', 'Y',
|
|
|
+ '4' | 0x80, '(', 'I', 'L', 'D', ')', '=', 'A',
|
|
|
+ 'Y', '5', 'L', 'D' | 0x80, ' ', '(', 'I', 'G',
|
|
|
+ 'N', ')', '=', 'I', 'H', 'G', 'N' | 0x80, '(',
|
|
|
+ 'I', 'G', 'N', ')', ' ', '=', 'A', 'Y',
|
|
|
+ '4', 'N' | 0x80, '(', 'I', 'G', 'N', ')', '^',
|
|
|
+ '=', 'A', 'Y', '4', 'N' | 0x80, '(', 'I', 'G',
|
|
|
+ 'N', ')', '%', '=', 'A', 'Y', '4', 'N' | 0x80,
|
|
|
+ '(', 'I', 'C', 'R', 'O', ')', '=', 'A',
|
|
|
+ 'Y', '4', 'K', 'R', 'O', 'H' | 0x80, '(', 'I',
|
|
|
+ 'Q', 'U', 'E', ')', '=', 'I', 'Y', '4',
|
|
|
+ 'K' | 0x80, '(', 'I', ')', '=', 'I', 'H' | 0x80,
|
|
|
+
|
|
|
+ ']', 'J' | 0x80, ' ', '(', 'J', ')', ' ', '=',
|
|
|
+ 'J', 'E', 'Y', '4' | 0x80, '(', 'J', ')', '=',
|
|
|
+ 'J' | 0x80,
|
|
|
+
|
|
|
+ ']', 'K' | 0x80, ' ', '(', 'K', ')', ' ', '=',
|
|
|
+ 'K', 'E', 'Y', '4' | 0x80, ' ', '(', 'K', ')',
|
|
|
+ 'N', '=' | 0x80, '(', 'K', ')', '=', 'K' | 0x80,
|
|
|
+
|
|
|
+ ']', 'L' | 0x80, ' ', '(', 'L', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'L' | 0x80, '(', 'L', 'O', ')',
|
|
|
+ 'C', '#', '=', 'L', 'O', 'W' | 0x80, 'L', '(',
|
|
|
+ 'L', ')', '=' | 0x80, '#', ':', '^', '(', 'L',
|
|
|
+ ')', '%', '=', 'U', 'L' | 0x80, '(', 'L', 'E',
|
|
|
+ 'A', 'D', ')', '=', 'L', 'I', 'Y', 'D' | 0x80,
|
|
|
+ ' ', '(', 'L', 'A', 'U', 'G', 'H', ')',
|
|
|
+ '=', 'L', 'A', 'E', '4', 'F' | 0x80, '(', 'L',
|
|
|
+ ')', '=', 'L' | 0x80,
|
|
|
+
|
|
|
+ ']', 'M' | 0x80, ' ', '(', 'M', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'M' | 0x80, ' ', '(', 'M', 'R',
|
|
|
+ '.', ')', ' ', '=', 'M', 'I', 'H', '4',
|
|
|
+ 'S', 'T', 'E', 'R' | 0x80, ' ', '(', 'M', 'S',
|
|
|
+ '.', ')', '=', 'M', 'I', 'H', '5', 'Z' | 0x80,
|
|
|
+ ' ', '(', 'M', 'R', 'S', '.', ')', ' ',
|
|
|
+ '=', 'M', 'I', 'H', '4', 'S', 'I', 'X',
|
|
|
+ 'Z' | 0x80, '(', 'M', 'O', 'V', ')', '=', 'M',
|
|
|
+ 'U', 'W', '4', 'V' | 0x80, '(', 'M', 'A', 'C',
|
|
|
+ 'H', 'I', 'N', ')', '=', 'M', 'A', 'H',
|
|
|
+ 'S', 'H', 'I', 'Y', '5', 'N' | 0x80, 'M', '(',
|
|
|
+ 'M', ')', '=' | 0x80, '(', 'M', ')', '=', 'M' | 0x80,
|
|
|
+
|
|
|
+ ']', 'N' | 0x80, ' ', '(', 'N', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'N' | 0x80, 'E', '(', 'N', 'G',
|
|
|
+ ')', '+', '=', 'N', 'J' | 0x80, '(', 'N', 'G',
|
|
|
+ ')', 'R', '=', 'N', 'X', 'G' | 0x80, '(', 'N',
|
|
|
+ 'G', ')', '#', '=', 'N', 'X', 'G' | 0x80, '(',
|
|
|
+ 'N', 'G', 'L', ')', '%', '=', 'N', 'X',
|
|
|
+ 'G', 'U', 'L' | 0x80, '(', 'N', 'G', ')', '=',
|
|
|
+ 'N', 'X' | 0x80, '(', 'N', 'K', ')', '=', 'N',
|
|
|
+ 'X', 'K' | 0x80, ' ', '(', 'N', 'O', 'W', ')',
|
|
|
+ ' ', '=', 'N', 'A', 'W', '4' | 0x80, 'N', '(',
|
|
|
+ 'N', ')', '=' | 0x80, '(', 'N', 'O', 'N', ')',
|
|
|
+ 'E', '=', 'N', 'A', 'H', '4', 'N' | 0x80, '(',
|
|
|
+ 'N', ')', '=', 'N' | 0x80,
|
|
|
+
|
|
|
+ ']', 'O' | 0x80, ' ', '(', 'O', ')', ' ', '=',
|
|
|
+ 'O', 'H', '4', 'W' | 0x80, '(', 'O', 'F', ')',
|
|
|
+ ' ', '=', 'A', 'H', 'V' | 0x80, ' ', '(', 'O',
|
|
|
+ 'H', ')', ' ', '=', 'O', 'W', '5' | 0x80, '(',
|
|
|
+ 'O', 'R', 'O', 'U', 'G', 'H', ')', '=',
|
|
|
+ 'E', 'R', '4', 'O', 'W' | 0x80, '#', ':', '(',
|
|
|
+ 'O', 'R', ')', ' ', '=', 'E', 'R' | 0x80, '#',
|
|
|
+ ':', '(', 'O', 'R', 'S', ')', ' ', '=',
|
|
|
+ 'E', 'R', 'Z' | 0x80, '(', 'O', 'R', ')', '=',
|
|
|
+ 'A', 'O', 'R' | 0x80, ' ', '(', 'O', 'N', 'E',
|
|
|
+ ')', '=', 'W', 'A', 'H', 'N' | 0x80, '#', '(',
|
|
|
+ 'O', 'N', 'E', ')', ' ', '=', 'W', 'A',
|
|
|
+ 'H', 'N' | 0x80, '(', 'O', 'W', ')', '=', 'O',
|
|
|
+ 'W' | 0x80, ' ', '(', 'O', 'V', 'E', 'R', ')',
|
|
|
+ '=', 'O', 'W', '5', 'V', 'E', 'R' | 0x80, 'P',
|
|
|
+ 'R', '(', 'O', ')', 'V', '=', 'U', 'W',
|
|
|
+ '4' | 0x80, '(', 'O', 'V', ')', '=', 'A', 'H',
|
|
|
+ '4', 'V' | 0x80, '(', 'O', ')', '^', '%', '=',
|
|
|
+ 'O', 'W', '5' | 0x80, '(', 'O', ')', '^', 'E',
|
|
|
+ 'N', '=', 'O', 'W' | 0x80, '(', 'O', ')', '^',
|
|
|
+ 'I', '#', '=', 'O', 'W', '5' | 0x80, '(', 'O',
|
|
|
+ 'L', ')', 'D', '=', 'O', 'W', '4', 'L' | 0x80,
|
|
|
+ '(', 'O', 'U', 'G', 'H', 'T', ')', '=',
|
|
|
+ 'A', 'O', '5', 'T' | 0x80, '(', 'O', 'U', 'G',
|
|
|
+ 'H', ')', '=', 'A', 'H', '5', 'F' | 0x80, ' ',
|
|
|
+ '(', 'O', 'U', ')', '=', 'A', 'W' | 0x80, 'H',
|
|
|
+ '(', 'O', 'U', ')', 'S', '#', '=', 'A',
|
|
|
+ 'W', '4' | 0x80, '(', 'O', 'U', 'S', ')', '=',
|
|
|
+ 'A', 'X', 'S' | 0x80, '(', 'O', 'U', 'R', ')',
|
|
|
+ '=', 'O', 'H', 'R' | 0x80, '(', 'O', 'U', 'L',
|
|
|
+ 'D', ')', '=', 'U', 'H', '5', 'D' | 0x80, '(',
|
|
|
+ 'O', 'U', ')', '^', 'L', '=', 'A', 'H',
|
|
|
+ '5' | 0x80, '(', 'O', 'U', 'P', ')', '=', 'U',
|
|
|
+ 'W', '5', 'P' | 0x80, '(', 'O', 'U', ')', '=',
|
|
|
+ 'A', 'W' | 0x80, '(', 'O', 'Y', ')', '=', 'O',
|
|
|
+ 'Y' | 0x80, '(', 'O', 'I', 'N', 'G', ')', '=',
|
|
|
+ 'O', 'W', '4', 'I', 'H', 'N', 'X' | 0x80, '(',
|
|
|
+ 'O', 'I', ')', '=', 'O', 'Y', '5' | 0x80, '(',
|
|
|
+ 'O', 'O', 'R', ')', '=', 'O', 'H', '5',
|
|
|
+ 'R' | 0x80, '(', 'O', 'O', 'K', ')', '=', 'U',
|
|
|
+ 'H', '5', 'K' | 0x80, 'F', '(', 'O', 'O', 'D',
|
|
|
+ ')', '=', 'U', 'W', '5', 'D' | 0x80, 'L', '(',
|
|
|
+ 'O', 'O', 'D', ')', '=', 'A', 'H', '5',
|
|
|
+ 'D' | 0x80, 'M', '(', 'O', 'O', 'D', ')', '=',
|
|
|
+ 'U', 'W', '5', 'D' | 0x80, '(', 'O', 'O', 'D',
|
|
|
+ ')', '=', 'U', 'H', '5', 'D' | 0x80, 'F', '(',
|
|
|
+ 'O', 'O', 'T', ')', '=', 'U', 'H', '5',
|
|
|
+ 'T' | 0x80, '(', 'O', 'O', ')', '=', 'U', 'W',
|
|
|
+ '5' | 0x80, '(', 'O', '\'', ')', '=', 'O', 'H' | 0x80,
|
|
|
+ '(', 'O', ')', 'E', '=', 'O', 'W' | 0x80, '(',
|
|
|
+ 'O', ')', ' ', '=', 'O', 'W' | 0x80, '(', 'O',
|
|
|
+ 'A', ')', '=', 'O', 'W', '4' | 0x80, ' ', '(',
|
|
|
+ 'O', 'N', 'L', 'Y', ')', '=', 'O', 'W',
|
|
|
+ '4', 'N', 'L', 'I', 'Y' | 0x80, ' ', '(', 'O',
|
|
|
+ 'N', 'C', 'E', ')', '=', 'W', 'A', 'H',
|
|
|
+ '4', 'N', 'S' | 0x80, '(', 'O', 'N', '\'', 'T',
|
|
|
+ ')', '=', 'O', 'W', '4', 'N', 'T' | 0x80, 'C',
|
|
|
+ '(', 'O', ')', 'N', '=', 'A', 'A' | 0x80, '(',
|
|
|
+ 'O', ')', 'N', 'G', '=', 'A', 'O' | 0x80, ' ',
|
|
|
+ ':', '^', '(', 'O', ')', 'N', '=', 'A',
|
|
|
+ 'H' | 0x80, 'I', '(', 'O', 'N', ')', '=', 'U',
|
|
|
+ 'N' | 0x80, '#', ':', '(', 'O', 'N', ')', '=',
|
|
|
+ 'U', 'N' | 0x80, '#', '^', '(', 'O', 'N', ')',
|
|
|
+ '=', 'U', 'N' | 0x80, '(', 'O', ')', 'S', 'T',
|
|
|
+ '=', 'O', 'W' | 0x80, '(', 'O', 'F', ')', '^',
|
|
|
+ '=', 'A', 'O', '4', 'F' | 0x80, '(', 'O', 'T',
|
|
|
+ 'H', 'E', 'R', ')', '=', 'A', 'H', '5',
|
|
|
+ 'D', 'H', 'E', 'R' | 0x80, 'R', '(', 'O', ')',
|
|
|
+ 'B', '=', 'R', 'A', 'A' | 0x80, '^', 'R', '(',
|
|
|
+ 'O', ')', ':', '#', '=', 'O', 'W', '5' | 0x80,
|
|
|
+ '(', 'O', 'S', 'S', ')', ' ', '=', 'A',
|
|
|
+ 'O', '5', 'S' | 0x80, '#', ':', '^', '(', 'O',
|
|
|
+ 'M', ')', '=', 'A', 'H', 'M' | 0x80, '(', 'O',
|
|
|
+ ')', '=', 'A', 'A' | 0x80,
|
|
|
+
|
|
|
+ ']', 'P' | 0x80, ' ', '(', 'P', ')', ' ', '=',
|
|
|
+ 'P', 'I', 'Y', '4' | 0x80, '(', 'P', 'H', ')',
|
|
|
+ '=', 'F' | 0x80, '(', 'P', 'E', 'O', 'P', 'L',
|
|
|
+ ')', '=', 'P', 'I', 'Y', '5', 'P', 'U',
|
|
|
+ 'L' | 0x80, '(', 'P', 'O', 'W', ')', '=', 'P',
|
|
|
+ 'A', 'W', '4' | 0x80, '(', 'P', 'U', 'T', ')',
|
|
|
+ ' ', '=', 'P', 'U', 'H', 'T' | 0x80, '(', 'P',
|
|
|
+ ')', 'P', '=' | 0x80, '(', 'P', ')', 'S', '=' | 0x80,
|
|
|
+ '(', 'P', ')', 'N', '=' | 0x80, '(', 'P', 'R',
|
|
|
+ 'O', 'F', '.', ')', '=', 'P', 'R', 'O',
|
|
|
+ 'H', 'F', 'E', 'H', '4', 'S', 'E', 'R' | 0x80,
|
|
|
+ '(', 'P', ')', '=', 'P' | 0x80,
|
|
|
+
|
|
|
+ ']', 'Q' | 0x80, ' ', '(', 'Q', ')', ' ', '=',
|
|
|
+ 'K', 'Y', 'U', 'W', '4' | 0x80, '(', 'Q', 'U',
|
|
|
+ 'A', 'R', ')', '=', 'K', 'W', 'O', 'H',
|
|
|
+ '5', 'R' | 0x80, '(', 'Q', 'U', ')', '=', 'K',
|
|
|
+ 'W' | 0x80, '(', 'Q', ')', '=', 'K' | 0x80, ']', 'R' | 0x80,
|
|
|
+ ' ', '(', 'R', ')', ' ', '=', 'A', 'A',
|
|
|
+ '5', 'R' | 0x80, ' ', '(', 'R', 'E', ')', '^',
|
|
|
+ '#', '=', 'R', 'I', 'Y' | 0x80, '(', 'R', ')',
|
|
|
+ 'R', '=' | 0x80, '(', 'R', ')', '=', 'R' | 0x80,
|
|
|
+
|
|
|
+ ']', 'S' | 0x80, ' ', '(', 'S', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'S' | 0x80, '(', 'S', 'H', ')',
|
|
|
+ '=', 'S', 'H' | 0x80, '#', '(', 'S', 'I', 'O',
|
|
|
+ 'N', ')', '=', 'Z', 'H', 'U', 'N' | 0x80, '(',
|
|
|
+ 'S', 'O', 'M', 'E', ')', '=', 'S', 'A',
|
|
|
+ 'H', 'M' | 0x80, '#', '(', 'S', 'U', 'R', ')',
|
|
|
+ '#', '=', 'Z', 'H', 'E', 'R' | 0x80, '(', 'S',
|
|
|
+ 'U', 'R', ')', '#', '=', 'S', 'H', 'E',
|
|
|
+ 'R' | 0x80, '#', '(', 'S', 'U', ')', '#', '=',
|
|
|
+ 'Z', 'H', 'U', 'W' | 0x80, '#', '(', 'S', 'S',
|
|
|
+ 'U', ')', '#', '=', 'S', 'H', 'U', 'W' | 0x80,
|
|
|
+ '#', '(', 'S', 'E', 'D', ')', '=', 'Z',
|
|
|
+ 'D' | 0x80, '#', '(', 'S', ')', '#', '=', 'Z' | 0x80,
|
|
|
+ '(', 'S', 'A', 'I', 'D', ')', '=', 'S',
|
|
|
+ 'E', 'H', 'D' | 0x80, '^', '(', 'S', 'I', 'O',
|
|
|
+ 'N', ')', '=', 'S', 'H', 'U', 'N' | 0x80, '(',
|
|
|
+ 'S', ')', 'S', '=' | 0x80, '.', '(', 'S', ')',
|
|
|
+ ' ', '=', 'Z' | 0x80, '#', ':', '.', 'E', '(',
|
|
|
+ 'S', ')', ' ', '=', 'Z' | 0x80, '#', ':', '^',
|
|
|
+ '#', '(', 'S', ')', ' ', '=', 'S' | 0x80, 'U',
|
|
|
+ '(', 'S', ')', ' ', '=', 'S' | 0x80, ' ', ':',
|
|
|
+ '#', '(', 'S', ')', ' ', '=', 'Z' | 0x80, '#',
|
|
|
+ '#', '(', 'S', ')', ' ', '=', 'Z' | 0x80, ' ',
|
|
|
+ '(', 'S', 'C', 'H', ')', '=', 'S', 'K' | 0x80,
|
|
|
+ '(', 'S', ')', 'C', '+', '=' | 0x80, '#', '(',
|
|
|
+ 'S', 'M', ')', '=', 'Z', 'U', 'M' | 0x80, '#',
|
|
|
+ '(', 'S', 'N', ')', '\'', '=', 'Z', 'U',
|
|
|
+ 'M' | 0x80, '(', 'S', 'T', 'L', 'E', ')', '=',
|
|
|
+ 'S', 'U', 'L' | 0x80, '(', 'S', ')', '=', 'S' | 0x80,
|
|
|
+
|
|
|
+ ']', 'T' | 0x80, ' ', '(', 'T', ')', ' ', '=',
|
|
|
+ 'T', 'I', 'Y', '4' | 0x80, ' ', '(', 'T', 'H',
|
|
|
+ 'E', ')', ' ', '#', '=', 'D', 'H', 'I',
|
|
|
+ 'Y' | 0x80, ' ', '(', 'T', 'H', 'E', ')', ' ',
|
|
|
+ '=', 'D', 'H', 'A', 'X' | 0x80, '(', 'T', 'O',
|
|
|
+ ')', ' ', '=', 'T', 'U', 'X' | 0x80, ' ', '(',
|
|
|
+ 'T', 'H', 'A', 'T', ')', '=', 'D', 'H',
|
|
|
+ 'A', 'E', 'T' | 0x80, ' ', '(', 'T', 'H', 'I',
|
|
|
+ 'S', ')', ' ', '=', 'D', 'H', 'I', 'H',
|
|
|
+ 'S' | 0x80, ' ', '(', 'T', 'H', 'E', 'Y', ')',
|
|
|
+ '=', 'D', 'H', 'E', 'Y' | 0x80, ' ', '(', 'T',
|
|
|
+ 'H', 'E', 'R', 'E', ')', '=', 'D', 'H',
|
|
|
+ 'E', 'H', 'R' | 0x80, '(', 'T', 'H', 'E', 'R',
|
|
|
+ ')', '=', 'D', 'H', 'E', 'R' | 0x80, '(', 'T',
|
|
|
+ 'H', 'E', 'I', 'R', ')', '=', 'D', 'H',
|
|
|
+ 'E', 'H', 'R' | 0x80, ' ', '(', 'T', 'H', 'A',
|
|
|
+ 'N', ')', ' ', '=', 'D', 'H', 'A', 'E',
|
|
|
+ 'N' | 0x80, ' ', '(', 'T', 'H', 'E', 'M', ')',
|
|
|
+ ' ', '=', 'D', 'H', 'A', 'E', 'N' | 0x80, '(',
|
|
|
+ 'T', 'H', 'E', 'S', 'E', ')', ' ', '=',
|
|
|
+ 'D', 'H', 'I', 'Y', 'Z' | 0x80, ' ', '(', 'T',
|
|
|
+ 'H', 'E', 'N', ')', '=', 'D', 'H', 'E',
|
|
|
+ 'H', 'N' | 0x80, '(', 'T', 'H', 'R', 'O', 'U',
|
|
|
+ 'G', 'H', ')', '=', 'T', 'H', 'R', 'U',
|
|
|
+ 'W', '4' | 0x80, '(', 'T', 'H', 'O', 'S', 'E',
|
|
|
+ ')', '=', 'D', 'H', 'O', 'H', 'Z' | 0x80, '(',
|
|
|
+ 'T', 'H', 'O', 'U', 'G', 'H', ')', ' ',
|
|
|
+ '=', 'D', 'H', 'O', 'W' | 0x80, '(', 'T', 'O',
|
|
|
+ 'D', 'A', 'Y', ')', '=', 'T', 'U', 'X',
|
|
|
+ 'D', 'E', 'Y' | 0x80, '(', 'T', 'O', 'M', 'O',
|
|
|
+ ')', 'R', 'R', 'O', 'W', '=', 'T', 'U',
|
|
|
+ 'M', 'A', 'A', '5' | 0x80, '(', 'T', 'O', ')',
|
|
|
+ 'T', 'A', 'L', '=', 'T', 'O', 'W', '5' | 0x80,
|
|
|
+ ' ', '(', 'T', 'H', 'U', 'S', ')', '=',
|
|
|
+ 'D', 'H', 'A', 'H', '4', 'S' | 0x80, '(', 'T',
|
|
|
+ 'H', ')', '=', 'T', 'H' | 0x80, '#', ':', '(',
|
|
|
+ 'T', 'E', 'D', ')', '=', 'T', 'I', 'X',
|
|
|
+ 'D' | 0x80, 'S', '(', 'T', 'I', ')', '#', 'N',
|
|
|
+ '=', 'C', 'H' | 0x80, '(', 'T', 'I', ')', 'O',
|
|
|
+ '=', 'S', 'H' | 0x80, '(', 'T', 'I', ')', 'A',
|
|
|
+ '=', 'S', 'H' | 0x80, '(', 'T', 'I', 'E', 'N',
|
|
|
+ ')', '=', 'S', 'H', 'U', 'N' | 0x80, '(', 'T',
|
|
|
+ 'U', 'R', ')', '#', '=', 'C', 'H', 'E',
|
|
|
+ 'R' | 0x80, '(', 'T', 'U', ')', 'A', '=', 'C',
|
|
|
+ 'H', 'U', 'W' | 0x80, ' ', '(', 'T', 'W', 'O',
|
|
|
+ ')', '=', 'T', 'U', 'W' | 0x80, '&', '(', 'T',
|
|
|
+ ')', 'E', 'N', ' ', '=' | 0x80, '(', 'T', ')',
|
|
|
+ '=', 'T' | 0x80,
|
|
|
+
|
|
|
+ ']', 'U' | 0x80, ' ', '(', 'U', ')', ' ', '=',
|
|
|
+ 'Y', 'U', 'W', '4' | 0x80, ' ', '(', 'U', 'N',
|
|
|
+ ')', 'I', '=', 'Y', 'U', 'W', 'N' | 0x80, ' ',
|
|
|
+ '(', 'U', 'N', ')', '=', 'A', 'H', 'N' | 0x80,
|
|
|
+ ' ', '(', 'U', 'P', 'O', 'N', ')', '=',
|
|
|
+ 'A', 'X', 'P', 'A', 'O', 'N' | 0x80, '@', '(',
|
|
|
+ 'U', 'R', ')', '#', '=', 'U', 'H', '4',
|
|
|
+ 'R' | 0x80, '(', 'U', 'R', ')', '#', '=', 'Y',
|
|
|
+ 'U', 'H', '4', 'R' | 0x80, '(', 'U', 'R', ')',
|
|
|
+ '=', 'E', 'R' | 0x80, '(', 'U', ')', '^', ' ',
|
|
|
+ '=', 'A', 'H' | 0x80, '(', 'U', ')', '^', '^',
|
|
|
+ '=', 'A', 'H', '5' | 0x80, '(', 'U', 'Y', ')',
|
|
|
+ '=', 'A', 'Y', '5' | 0x80, ' ', 'G', '(', 'U',
|
|
|
+ ')', '#', '=' | 0x80, 'G', '(', 'U', ')', '%',
|
|
|
+ '=' | 0x80, 'G', '(', 'U', ')', '#', '=', 'W' | 0x80,
|
|
|
+ '#', 'N', '(', 'U', ')', '=', 'Y', 'U',
|
|
|
+ 'W' | 0x80, '@', '(', 'U', ')', '=', 'U', 'W' | 0x80,
|
|
|
+ '(', 'U', ')', '=', 'Y', 'U', 'W' | 0x80,
|
|
|
+
|
|
|
+ ']', 'V' | 0x80, ' ', '(', 'V', ')', ' ', '=',
|
|
|
+ 'V', 'I', 'Y', '4' | 0x80, '(', 'V', 'I', 'E',
|
|
|
+ 'W', ')', '=', 'V', 'Y', 'U', 'W', '5' | 0x80,
|
|
|
+ '(', 'V', ')', '=', 'V' | 0x80,
|
|
|
+
|
|
|
+ ']', 'W' | 0x80, ' ', '(', 'W', ')', ' ', '=',
|
|
|
+ 'D', 'A', 'H', '4', 'B', 'U', 'L', 'Y',
|
|
|
+ 'U', 'W' | 0x80, ' ', '(', 'W', 'E', 'R', 'E',
|
|
|
+ ')', '=', 'W', 'E', 'R' | 0x80, '(', 'W', 'A',
|
|
|
+ ')', 'S', 'H', '=', 'W', 'A', 'A' | 0x80, '(',
|
|
|
+ 'W', 'A', ')', 'S', 'T', '=', 'W', 'E',
|
|
|
+ 'Y' | 0x80, '(', 'W', 'A', ')', 'S', '=', 'W',
|
|
|
+ 'A', 'H' | 0x80, '(', 'W', 'A', ')', 'T', '=',
|
|
|
+ 'W', 'A', 'A' | 0x80, '(', 'W', 'H', 'E', 'R',
|
|
|
+ 'E', ')', '=', 'W', 'H', 'E', 'H', 'R' | 0x80,
|
|
|
+ '(', 'W', 'H', 'A', 'T', ')', '=', 'W',
|
|
|
+ 'H', 'A', 'H', 'T' | 0x80, '(', 'W', 'H', 'O',
|
|
|
+ 'L', ')', '=', '/', 'H', 'O', 'W', 'L' | 0x80,
|
|
|
+ '(', 'W', 'H', 'O', ')', '=', '/', 'H',
|
|
|
+ 'U', 'W' | 0x80, '(', 'W', 'H', ')', '=', 'W',
|
|
|
+ 'H' | 0x80, '(', 'W', 'A', 'R', ')', '#', '=',
|
|
|
+ 'W', 'E', 'H', 'R' | 0x80, '(', 'W', 'A', 'R',
|
|
|
+ ')', '=', 'W', 'A', 'O', 'R' | 0x80, '(', 'W',
|
|
|
+ 'O', 'R', ')', '^', '=', 'W', 'E', 'R' | 0x80,
|
|
|
+ '(', 'W', 'R', ')', '=', 'R' | 0x80, '(', 'W',
|
|
|
+ 'O', 'M', ')', 'A', '=', 'W', 'U', 'H',
|
|
|
+ 'M' | 0x80, '(', 'W', 'O', 'M', ')', 'E', '=',
|
|
|
+ 'W', 'I', 'H', 'M' | 0x80, '(', 'W', 'E', 'A',
|
|
|
+ ')', 'R', '=', 'W', 'E', 'H' | 0x80, '(', 'W',
|
|
|
+ 'A', 'N', 'T', ')', '=', 'W', 'A', 'A',
|
|
|
+ '5', 'N', 'T' | 0x80, 'A', 'N', 'S', '(', 'W',
|
|
|
+ 'E', 'R', ')', '=', 'E', 'R' | 0x80, '(', 'W',
|
|
|
+ ')', '=', 'W' | 0x80,
|
|
|
+
|
|
|
+ ']', 'X' | 0x80, ' ', '(', 'X', ')', ' ', '=',
|
|
|
+ 'E', 'H', '4', 'K', 'R' | 0x80, ' ', '(', 'X',
|
|
|
+ ')', '=', 'Z' | 0x80, '(', 'X', ')', '=', 'K',
|
|
|
+ 'S' | 0x80,
|
|
|
+
|
|
|
+ ']', 'Y' | 0x80, ' ', '(', 'Y', ')', ' ', '=',
|
|
|
+ 'W', 'A', 'Y', '4' | 0x80, '(', 'Y', 'O', 'U',
|
|
|
+ 'N', 'G', ')', '=', 'Y', 'A', 'H', 'N',
|
|
|
+ 'X' | 0x80, ' ', '(', 'Y', 'O', 'U', 'R', ')',
|
|
|
+ '=', 'Y', 'O', 'H', 'R' | 0x80, ' ', '(', 'Y',
|
|
|
+ 'O', 'U', ')', '=', 'Y', 'U', 'W' | 0x80, ' ',
|
|
|
+ '(', 'Y', 'E', 'S', ')', '=', 'Y', 'E',
|
|
|
+ 'H', 'S' | 0x80, ' ', '(', 'Y', ')', '=', 'Y' | 0x80,
|
|
|
+ 'F', '(', 'Y', ')', '=', 'A', 'Y' | 0x80, 'P',
|
|
|
+ 'S', '(', 'Y', 'C', 'H', ')', '=', 'A',
|
|
|
+ 'Y', 'K' | 0x80, '#', ':', '^', '(', 'Y', ')',
|
|
|
+ '=', 'I', 'Y' | 0x80, '#', ':', '^', '(', 'Y',
|
|
|
+ ')', 'I', '=', 'I', 'Y' | 0x80, ' ', ':', '(',
|
|
|
+ 'Y', ')', ' ', '=', 'A', 'Y' | 0x80, ' ', ':',
|
|
|
+ '(', 'Y', ')', '#', '=', 'A', 'Y' | 0x80, ' ',
|
|
|
+ ':', '(', 'Y', ')', '^', '+', ':', '#',
|
|
|
+ '=', 'I', 'H' | 0x80, ' ', ':', '(', 'Y', ')',
|
|
|
+ '^', '#', '=', 'A', 'Y' | 0x80, '(', 'Y', ')',
|
|
|
+ '=', 'I', 'H' | 0x80,
|
|
|
+
|
|
|
+ ']', 'Z' | 0x80, ' ', '(', 'Z', ')', ' ', '=',
|
|
|
+ 'Z', 'I', 'Y', '4' | 0x80, '(', 'Z', ')', '=',
|
|
|
+ 'Z' | 0x80, 'j' | 0x80};
|
|
|
+
|
|
|
+const unsigned char rules2[] = {
|
|
|
+ '(', 'A', ')', '=' | 0x80, '(', '!', ')', '=',
|
|
|
+ '.' | 0x80, '(', '"', ')', ' ', '=', '-', 'A',
|
|
|
+ 'H', '5', 'N', 'K', 'W', 'O', 'W', 'T',
|
|
|
+ '-' | 0x80, '(', '"', ')', '=', 'K', 'W', 'O',
|
|
|
+ 'W', '4', 'T', '-' | 0x80, '(', '#', ')', '=',
|
|
|
+ ' ', 'N', 'A', 'H', '4', 'M', 'B', 'E',
|
|
|
+ 'R' | 0x80, '(', '$', ')', '=', ' ', 'D', 'A',
|
|
|
+ 'A', '4', 'L', 'E', 'R' | 0x80, '(', '%', ')',
|
|
|
+ '=', ' ', 'P', 'E', 'R', 'S', 'E', 'H',
|
|
|
+ '4', 'N', 'T' | 0x80, '(', '&', ')', '=', ' ',
|
|
|
+ 'A', 'E', 'N', 'D' | 0x80, '(', '\'', ')', '=' | 0x80,
|
|
|
+ '(', '*', ')', '=', ' ', 'A', 'E', '4',
|
|
|
+ 'S', 'T', 'E', 'R', 'I', 'H', 'S', 'K' | 0x80,
|
|
|
+ '(', '+', ')', '=', ' ', 'P', 'L', 'A',
|
|
|
+ 'H', '4', 'S' | 0x80, '(', ',', ')', '=', ',' | 0x80,
|
|
|
+ ' ', '(', '-', ')', ' ', '=', '-' | 0x80, '(',
|
|
|
+ '-', ')', '=' | 0x80, '(', '.', ')', '=', ' ',
|
|
|
+ 'P', 'O', 'Y', 'N', 'T' | 0x80, '(', '/', ')',
|
|
|
+ '=', ' ', 'S', 'L', 'A', 'E', '4', 'S',
|
|
|
+ 'H' | 0x80, '(', '0', ')', '=', ' ', 'Z', 'I',
|
|
|
+ 'Y', '4', 'R', 'O', 'W' | 0x80, ' ', '(', '1',
|
|
|
+ 'S', 'T', ')', '=', 'F', 'E', 'R', '4',
|
|
|
+ 'S', 'T' | 0x80, ' ', '(', '1', '0', 'T', 'H',
|
|
|
+ ')', '=', 'T', 'E', 'H', '4', 'N', 'T',
|
|
|
+ 'H' | 0x80, '(', '1', ')', '=', ' ', 'W', 'A',
|
|
|
+ 'H', '4', 'N' | 0x80, ' ', '(', '2', 'N', 'D',
|
|
|
+ ')', '=', 'S', 'E', 'H', '4', 'K', 'U',
|
|
|
+ 'N', 'D' | 0x80, '(', '2', ')', '=', ' ', 'T',
|
|
|
+ 'U', 'W', '4' | 0x80, ' ', '(', '3', 'R', 'D',
|
|
|
+ ')', '=', 'T', 'H', 'E', 'R', '4', 'D' | 0x80,
|
|
|
+ '(', '3', ')', '=', ' ', 'T', 'H', 'R',
|
|
|
+ 'I', 'Y', '4' | 0x80, '(', '4', ')', '=', ' ',
|
|
|
+ 'F', 'O', 'H', '4', 'R' | 0x80, ' ', '(', '5',
|
|
|
+ 'T', 'H', ')', '=', 'F', 'I', 'H', '4',
|
|
|
+ 'F', 'T', 'H' | 0x80, '(', '5', ')', '=', ' ',
|
|
|
+ 'F', 'A', 'Y', '4', 'V' | 0x80, ' ', '(', '6',
|
|
|
+ '4', ')', ' ', '=', 'S', 'I', 'H', '4',
|
|
|
+ 'K', 'S', 'T', 'I', 'Y', ' ', 'F', 'O',
|
|
|
+ 'H', 'R' | 0x80, '(', '6', ')', '=', ' ', 'S',
|
|
|
+ 'I', 'H', '4', 'K', 'S' | 0x80, '(', '7', ')',
|
|
|
+ '=', ' ', 'S', 'E', 'H', '4', 'V', 'U',
|
|
|
+ 'N' | 0x80, ' ', '(', '8', 'T', 'H', ')', '=',
|
|
|
+ 'E', 'Y', '4', 'T', 'H' | 0x80, '(', '8', ')',
|
|
|
+ '=', ' ', 'E', 'Y', '4', 'T' | 0x80, '(', '9',
|
|
|
+ ')', '=', ' ', 'N', 'A', 'Y', '4', 'N' | 0x80,
|
|
|
+ '(', ':', ')', '=', '.' | 0x80, '(', ';', ')',
|
|
|
+ '=', '.' | 0x80, '(', '<', ')', '=', ' ', 'L',
|
|
|
+ 'E', 'H', '4', 'S', ' ', 'D', 'H', 'A',
|
|
|
+ 'E', 'N' | 0x80, '(', '=', ')', '=', ' ', 'I',
|
|
|
+ 'Y', '4', 'K', 'W', 'U', 'L', 'Z' | 0x80, '(',
|
|
|
+ '>', ')', '=', ' ', 'G', 'R', 'E', 'Y',
|
|
|
+ '4', 'T', 'E', 'R', ' ', 'D', 'H', 'A',
|
|
|
+ 'E', 'N' | 0x80, '(', '?', ')', '=', '?' | 0x80, '(',
|
|
|
+ '@', ')', '=', ' ', 'A', 'E', '6', 'T' | 0x80,
|
|
|
+ '(', '^', ')', '=', ' ', 'K', 'A', 'E',
|
|
|
+ '4', 'R', 'I', 'X', 'T' | 0x80, ']', 'A' | 0x80};
|
|
|
+
|
|
|
+//26 items. From 'A' to 'Z'
|
|
|
+// positions for mem62 and mem63 for each character
|
|
|
+const unsigned char tab37489[] = {0, 149, 247, 162, 57, 197, 6, 126, 199, 38, 55, 78, 145,
|
|
|
+ 241, 85, 161, 254, 36, 69, 45, 167, 54, 83, 46, 71, 218};
|
|
|
+
|
|
|
+const unsigned char tab37515[] = {125, 126, 126, 127, 128, 129, 130, 130, 130, 132, 132, 132, 132,
|
|
|
+ 132, 133, 135, 135, 136, 136, 137, 138, 139, 139, 140, 140, 140};
|
|
|
+
|
|
|
+void STM32SAM::Output8BitAry(int index, unsigned char ary[5]) {
|
|
|
+ int k;
|
|
|
+
|
|
|
+ uint32_t bufferposOld = bufferpos;
|
|
|
+
|
|
|
+ bufferpos += timetable[oldtimetableindex][index];
|
|
|
+ oldtimetableindex = index;
|
|
|
+
|
|
|
+ int sample_uS = bufferpos - bufferposOld;
|
|
|
+
|
|
|
+ uint32_t f = 0;
|
|
|
+
|
|
|
+ // write a little bit in advance
|
|
|
+ for(k = 0; k < 5; k++) {
|
|
|
+ // buffer[bufferpos / 50 + k] = ary[k];
|
|
|
+
|
|
|
+ // f = micros() + sample_uS / (_STM32SAM_SPEED + 1);
|
|
|
+ // while(micros() < f) {
|
|
|
+ // };
|
|
|
+ f = sample_uS / (_STM32SAM_SPEED + 1);
|
|
|
+ furi_delay_us(f);
|
|
|
+ SetAUDIO(ary[k]);
|
|
|
+ // delayMicroseconds(sample_uS / 5 );
|
|
|
+ }
|
|
|
+
|
|
|
+ // SetAUDIO(ary[0]);
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::Output8Bit(int index, unsigned char A) {
|
|
|
+ unsigned char ary[5] = {A, A, A, A, A};
|
|
|
+ Output8BitAry(index, ary);
|
|
|
+}
|
|
|
+
|
|
|
+//written by me because of different table positions.
|
|
|
+// mem[47] = ...
|
|
|
+// 168=pitches
|
|
|
+// 169=frequency1
|
|
|
+// 170=frequency2
|
|
|
+// 171=frequency3
|
|
|
+// 172=amplitude1
|
|
|
+// 173=amplitude2
|
|
|
+// 174=amplitude3
|
|
|
+unsigned char STM32SAM::Read(unsigned char p, unsigned char Y) {
|
|
|
+ switch(p) {
|
|
|
+ case 168:
|
|
|
+ return pitches[Y];
|
|
|
+ case 169:
|
|
|
+ return frequency1[Y];
|
|
|
+ case 170:
|
|
|
+ return frequency2[Y];
|
|
|
+ case 171:
|
|
|
+ return frequency3[Y];
|
|
|
+ case 172:
|
|
|
+ return amplitude1[Y];
|
|
|
+ case 173:
|
|
|
+ return amplitude2[Y];
|
|
|
+ case 174:
|
|
|
+ return amplitude3[Y];
|
|
|
+ }
|
|
|
+ // Serial1.println("Error reading to tables");
|
|
|
+ return 0;
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::Write(unsigned char p, unsigned char Y, unsigned char value) {
|
|
|
+ switch(p) {
|
|
|
+ case 168:
|
|
|
+ pitches[Y] = value;
|
|
|
+ return;
|
|
|
+ case 169:
|
|
|
+ frequency1[Y] = value;
|
|
|
+ return;
|
|
|
+ case 170:
|
|
|
+ frequency2[Y] = value;
|
|
|
+ return;
|
|
|
+ case 171:
|
|
|
+ frequency3[Y] = value;
|
|
|
+ return;
|
|
|
+ case 172:
|
|
|
+ amplitude1[Y] = value;
|
|
|
+ return;
|
|
|
+ case 173:
|
|
|
+ amplitude2[Y] = value;
|
|
|
+ return;
|
|
|
+ case 174:
|
|
|
+ amplitude3[Y] = value;
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ //Serial1.println("Error writing to tables\n");
|
|
|
+}
|
|
|
+
|
|
|
+// -------------------------------------------------------------------------
|
|
|
+//Code48227
|
|
|
+// Render a sampled sound from the sampleTable.
|
|
|
+//
|
|
|
+// Phoneme Sample Start Sample End
|
|
|
+// 32: S* 15 255
|
|
|
+// 33: SH 257 511
|
|
|
+// 34: F* 559 767
|
|
|
+// 35: TH 583 767
|
|
|
+// 36: /H 903 1023
|
|
|
+// 37: /X 1135 1279
|
|
|
+// 38: Z* 84 119
|
|
|
+// 39: ZH 340 375
|
|
|
+// 40: V* 596 639
|
|
|
+// 41: DH 596 631
|
|
|
+//
|
|
|
+// 42: CH
|
|
|
+// 43: ** 399 511
|
|
|
+//
|
|
|
+// 44: J*
|
|
|
+// 45: ** 257 276
|
|
|
+// 46: **
|
|
|
+//
|
|
|
+// 66: P*
|
|
|
+// 67: ** 743 767
|
|
|
+// 68: **
|
|
|
+//
|
|
|
+// 69: T*
|
|
|
+// 70: ** 231 255
|
|
|
+// 71: **
|
|
|
+//
|
|
|
+// The SampledPhonemesTable[] holds flags indicating if a phoneme is
|
|
|
+// voiced or not. If the upper 5 bits are zero, the sample is voiced.
|
|
|
+//
|
|
|
+// Samples in the sampleTable are compressed, with bits being converted to
|
|
|
+// bytes from high bit to low, as follows:
|
|
|
+//
|
|
|
+// unvoiced 0 bit -> X
|
|
|
+// unvoiced 1 bit -> 5
|
|
|
+//
|
|
|
+// voiced 0 bit -> 6
|
|
|
+// voiced 1 bit -> 24
|
|
|
+//
|
|
|
+// Where X is a value from the table:
|
|
|
+//
|
|
|
+// { 0x18, 0x1A, 0x17, 0x17, 0x17 };
|
|
|
+//
|
|
|
+// The index into this table is determined by masking off the lower
|
|
|
+// 3 bits from the SampledPhonemesTable:
|
|
|
+//
|
|
|
+// index = (SampledPhonemesTable[i] & 7) - 1;
|
|
|
+//
|
|
|
+// For voices samples, samples are interleaved between voiced output.
|
|
|
+
|
|
|
+// Code48227()
|
|
|
+void STM32SAM::RenderSample(unsigned char* mem66) {
|
|
|
+ int tempA;
|
|
|
+ // current phoneme's index
|
|
|
+ mem49 = Y;
|
|
|
+
|
|
|
+ // mask low three bits and subtract 1 get value to
|
|
|
+ // convert 0 bits on unvoiced samples.
|
|
|
+ A = mem39 & 7;
|
|
|
+ X = A - 1;
|
|
|
+
|
|
|
+ // store the result
|
|
|
+ mem56 = X;
|
|
|
+
|
|
|
+ // determine which offset to use from table { 0x18, 0x1A, 0x17, 0x17, 0x17 }
|
|
|
+ // T, S, Z 0 0x18
|
|
|
+ // CH, J, SH, ZH 1 0x1A
|
|
|
+ // P, F*, V, TH, DH 2 0x17
|
|
|
+ // /H 3 0x17
|
|
|
+ // /X 4 0x17
|
|
|
+
|
|
|
+ // get value from the table
|
|
|
+ mem53 = tab48426[X];
|
|
|
+ mem47 = X; //46016+mem[56]*256
|
|
|
+
|
|
|
+ // voiced sample?
|
|
|
+ A = mem39 & 248;
|
|
|
+ if(A == 0) {
|
|
|
+ // voiced phoneme: Z*, ZH, V*, DH
|
|
|
+ Y = mem49;
|
|
|
+ A = pitches[mem49] >> 4;
|
|
|
+
|
|
|
+ // jump to voiced portion
|
|
|
+ goto pos48315;
|
|
|
+ }
|
|
|
+
|
|
|
+ Y = A ^ 255;
|
|
|
+pos48274:
|
|
|
+
|
|
|
+ // step through the 8 bits in the sample
|
|
|
+ mem56 = 8;
|
|
|
+
|
|
|
+ // get the next sample from the table
|
|
|
+ // mem47*256 = offset to start of samples
|
|
|
+ A = sampleTable[mem47 * 256 + Y];
|
|
|
+pos48280:
|
|
|
+
|
|
|
+ // left shift to get the high bit
|
|
|
+ tempA = A;
|
|
|
+ A = A << 1;
|
|
|
+ //48281: BCC 48290
|
|
|
+
|
|
|
+ // bit not set?
|
|
|
+ if((tempA & 128) == 0) {
|
|
|
+ // convert the bit to value from table
|
|
|
+ X = mem53;
|
|
|
+ //mem[54296] = X;
|
|
|
+ // output the byte
|
|
|
+ Output8Bit(1, (X & 0x0f) * 16);
|
|
|
+ // if X != 0, exit loop
|
|
|
+ if(X != 0) goto pos48296;
|
|
|
+ }
|
|
|
+
|
|
|
+ // output a 5 for the on bit
|
|
|
+ Output8Bit(2, 5 * 16);
|
|
|
+
|
|
|
+ //48295: NOP
|
|
|
+pos48296:
|
|
|
+
|
|
|
+ X = 0;
|
|
|
+
|
|
|
+ // decrement counter
|
|
|
+ mem56--;
|
|
|
+
|
|
|
+ // if not done, jump to top of loop
|
|
|
+ if(mem56 != 0) goto pos48280;
|
|
|
+
|
|
|
+ // increment position
|
|
|
+ Y++;
|
|
|
+ if(Y != 0) goto pos48274;
|
|
|
+
|
|
|
+ // restore values and return
|
|
|
+ mem44 = 1;
|
|
|
+ Y = mem49;
|
|
|
+ return;
|
|
|
+
|
|
|
+ unsigned char phase1;
|
|
|
+
|
|
|
+pos48315:
|
|
|
+ // handle voiced samples here
|
|
|
+
|
|
|
+ // number of samples?
|
|
|
+ phase1 = A ^ 255;
|
|
|
+
|
|
|
+ Y = *mem66;
|
|
|
+ do {
|
|
|
+ //pos48321:
|
|
|
+
|
|
|
+ // shift through all 8 bits
|
|
|
+ mem56 = 8;
|
|
|
+ //A = Read(mem47, Y);
|
|
|
+
|
|
|
+ // fetch value from table
|
|
|
+ A = sampleTable[mem47 * 256 + Y];
|
|
|
+
|
|
|
+ // loop 8 times
|
|
|
+ //pos48327:
|
|
|
+ do {
|
|
|
+ //48327: ASL A
|
|
|
+ //48328: BCC 48337
|
|
|
+
|
|
|
+ // left shift and check high bit
|
|
|
+ tempA = A;
|
|
|
+ A = A << 1;
|
|
|
+ if((tempA & 128) != 0) {
|
|
|
+ // if bit set, output 26
|
|
|
+ X = 26;
|
|
|
+ Output8Bit(3, (X & 0xf) * 16);
|
|
|
+ } else {
|
|
|
+ //timetable 4
|
|
|
+ // bit is not set, output a 6
|
|
|
+ X = 6;
|
|
|
+ Output8Bit(4, (X & 0xf) * 16);
|
|
|
+ }
|
|
|
+
|
|
|
+ mem56--;
|
|
|
+ } while(mem56 != 0);
|
|
|
+
|
|
|
+ // move ahead in the table
|
|
|
+ Y++;
|
|
|
+
|
|
|
+ // continue until counter done
|
|
|
+ phase1++;
|
|
|
+
|
|
|
+ } while(phase1 != 0);
|
|
|
+ // if (phase1 != 0) goto pos48321;
|
|
|
+
|
|
|
+ // restore values and return
|
|
|
+ A = 1;
|
|
|
+ mem44 = 1;
|
|
|
+ *mem66 = Y;
|
|
|
+ Y = mem49;
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+// RENDER THE PHONEMES IN THE LIST
|
|
|
+//
|
|
|
+// The phoneme list is converted into sound through the steps:
|
|
|
+//
|
|
|
+// 1. Copy each phoneme <length> number of times into the frames list,
|
|
|
+// where each frame represents 10 milliseconds of sound.
|
|
|
+//
|
|
|
+// 2. Determine the transitions lengths between phonemes, and linearly
|
|
|
+// interpolate the values across the frames.
|
|
|
+//
|
|
|
+// 3. Offset the pitches by the fundamental frequency.
|
|
|
+//
|
|
|
+// 4. Render the each frame.
|
|
|
+
|
|
|
+//void Code47574()
|
|
|
+void STM32SAM::Render() {
|
|
|
+ unsigned char phase1 = 0; //mem43
|
|
|
+ unsigned char phase2 = 0;
|
|
|
+ unsigned char phase3 = 0;
|
|
|
+ unsigned char mem66 = 0;
|
|
|
+ unsigned char mem38 = 0;
|
|
|
+ unsigned char mem40 = 0;
|
|
|
+ unsigned char speedcounter = 0; //mem45
|
|
|
+ unsigned char mem48 = 0;
|
|
|
+ int i;
|
|
|
+ if(phonemeIndexOutput[0] == 255) return; //exit if no data
|
|
|
+
|
|
|
+ A = 0;
|
|
|
+ X = 0;
|
|
|
+ mem44 = 0;
|
|
|
+
|
|
|
+ // CREATE FRAMES
|
|
|
+ //
|
|
|
+ // The length parameter in the list corresponds to the number of frames
|
|
|
+ // to expand the phoneme to. Each frame represents 10 milliseconds of time.
|
|
|
+ // So a phoneme with a length of 7 = 7 frames = 70 milliseconds duration.
|
|
|
+ //
|
|
|
+ // The parameters are copied from the phoneme to the frame verbatim.
|
|
|
+
|
|
|
+ // pos47587:
|
|
|
+ do {
|
|
|
+ // get the index
|
|
|
+ Y = mem44;
|
|
|
+ // get the phoneme at the index
|
|
|
+ A = phonemeIndexOutput[mem44];
|
|
|
+ mem56 = A;
|
|
|
+
|
|
|
+ // if terminal phoneme, exit the loop
|
|
|
+ if(A == 255) break;
|
|
|
+
|
|
|
+ // period phoneme *.
|
|
|
+ if(A == 1) {
|
|
|
+ // add rising inflection
|
|
|
+ A = 1;
|
|
|
+ mem48 = 1;
|
|
|
+ //goto pos48376;
|
|
|
+ AddInflection(mem48, phase1);
|
|
|
+ }
|
|
|
+ /*
|
|
|
+ if (A == 2) goto pos48372;
|
|
|
+ */
|
|
|
+
|
|
|
+ // question mark phoneme?
|
|
|
+ if(A == 2) {
|
|
|
+ // create falling inflection
|
|
|
+ mem48 = 255;
|
|
|
+ AddInflection(mem48, phase1);
|
|
|
+ }
|
|
|
+ // pos47615:
|
|
|
+
|
|
|
+ // get the stress amount (more stress = higher pitch)
|
|
|
+ phase1 = tab47492[stressOutput[Y] + 1];
|
|
|
+
|
|
|
+ // get number of frames to write
|
|
|
+ phase2 = phonemeLengthOutput[Y];
|
|
|
+ Y = mem56;
|
|
|
+
|
|
|
+ // copy from the source to the frames list
|
|
|
+ do {
|
|
|
+ frequency1[X] = freq1data[Y]; // F1 frequency
|
|
|
+ frequency2[X] = freq2data[Y]; // F2 frequency
|
|
|
+ frequency3[X] = freq3data[Y]; // F3 frequency
|
|
|
+ amplitude1[X] = ampl1data[Y]; // F1 amplitude
|
|
|
+ amplitude2[X] = ampl2data[Y]; // F2 amplitude
|
|
|
+ amplitude3[X] = ampl3data[Y]; // F3 amplitude
|
|
|
+ sampledConsonantFlag[X] =
|
|
|
+ sampledConsonantFlags[Y]; // phoneme data for sampled consonants
|
|
|
+ pitches[X] = pitch + phase1; // pitch
|
|
|
+ X++;
|
|
|
+ phase2--;
|
|
|
+ } while(phase2 != 0);
|
|
|
+ mem44++;
|
|
|
+ } while(mem44 != 0);
|
|
|
+ // -------------------
|
|
|
+ //pos47694:
|
|
|
+
|
|
|
+ // CREATE TRANSITIONS
|
|
|
+ //
|
|
|
+ // Linear transitions are now created to smoothly connect the
|
|
|
+ // end of one sustained portion of a phoneme to the following
|
|
|
+ // phoneme.
|
|
|
+ //
|
|
|
+ // To do this, three tables are used:
|
|
|
+ //
|
|
|
+ // Table Purpose
|
|
|
+ // ========= ==================================================
|
|
|
+ // blendRank Determines which phoneme's blend values are used.
|
|
|
+ //
|
|
|
+ // blendOut The number of frames at the end of the phoneme that
|
|
|
+ // will be used to transition to the following phoneme.
|
|
|
+ //
|
|
|
+ // blendIn The number of frames of the following phoneme that
|
|
|
+ // will be used to transition into that phoneme.
|
|
|
+ //
|
|
|
+ // In creating a transition between two phonemes, the phoneme
|
|
|
+ // with the HIGHEST rank is used. Phonemes are ranked on how much
|
|
|
+ // their identity is based on their transitions. For example,
|
|
|
+ // vowels are and diphthongs are identified by their sustained portion,
|
|
|
+ // rather than the transitions, so they are given low values. In contrast,
|
|
|
+ // stop consonants (P, B, T, K) and glides (Y, L) are almost entirely
|
|
|
+ // defined by their transitions, and are given high rank values.
|
|
|
+ //
|
|
|
+ // Here are the rankings used by SAM:
|
|
|
+ //
|
|
|
+ // Rank Type Phonemes
|
|
|
+ // 2 All vowels IY, IH, etc.
|
|
|
+ // 5 Diphthong endings YX, WX, ER
|
|
|
+ // 8 Terminal liquid consonants LX, WX, YX, N, NX
|
|
|
+ // 9 Liquid consonants L, RX, W
|
|
|
+ // 10 Glide R, OH
|
|
|
+ // 11 Glide WH
|
|
|
+ // 18 Voiceless fricatives S, SH, F, TH
|
|
|
+ // 20 Voiced fricatives Z, ZH, V, DH
|
|
|
+ // 23 Plosives, stop consonants P, T, K, KX, DX, CH
|
|
|
+ // 26 Stop consonants J, GX, B, D, G
|
|
|
+ // 27-29 Stop consonants (internal) **
|
|
|
+ // 30 Unvoiced consonants /H, /X and Q*
|
|
|
+ // 160 Nasal M
|
|
|
+ //
|
|
|
+ // To determine how many frames to use, the two phonemes are
|
|
|
+ // compared using the blendRank[] table. The phoneme with the
|
|
|
+ // higher rank is selected. In case of a tie, a blend of each is used:
|
|
|
+ //
|
|
|
+ // if blendRank[phoneme1] == blendRank[phomneme2]
|
|
|
+ // // use lengths from each phoneme
|
|
|
+ // outBlendFrames = outBlend[phoneme1]
|
|
|
+ // inBlendFrames = outBlend[phoneme2]
|
|
|
+ // else if blendRank[phoneme1] > blendRank[phoneme2]
|
|
|
+ // // use lengths from first phoneme
|
|
|
+ // outBlendFrames = outBlendLength[phoneme1]
|
|
|
+ // inBlendFrames = inBlendLength[phoneme1]
|
|
|
+ // else
|
|
|
+ // // use lengths from the second phoneme
|
|
|
+ // // note that in and out are SWAPPED!
|
|
|
+ // outBlendFrames = inBlendLength[phoneme2]
|
|
|
+ // inBlendFrames = outBlendLength[phoneme2]
|
|
|
+ //
|
|
|
+ // Blend lengths can't be less than zero.
|
|
|
+ //
|
|
|
+ // Transitions are assumed to be symetrical, so if the transition
|
|
|
+ // values for the second phoneme are used, the inBlendLength and
|
|
|
+ // outBlendLength values are SWAPPED.
|
|
|
+ //
|
|
|
+ // For most of the parameters, SAM interpolates over the range of the last
|
|
|
+ // outBlendFrames-1 and the first inBlendFrames.
|
|
|
+ //
|
|
|
+ // The exception to this is the Pitch[] parameter, which is interpolates the
|
|
|
+ // pitch from the CENTER of the current phoneme to the CENTER of the next
|
|
|
+ // phoneme.
|
|
|
+ //
|
|
|
+ // Here are two examples. First, For example, consider the word "SUN" (S AH N)
|
|
|
+ //
|
|
|
+ // Phoneme Duration BlendWeight OutBlendFrames InBlendFrames
|
|
|
+ // S 2 18 1 3
|
|
|
+ // AH 8 2 4 4
|
|
|
+ // N 7 8 1 2
|
|
|
+ //
|
|
|
+ // The formant transitions for the output frames are calculated as follows:
|
|
|
+ //
|
|
|
+ // flags ampl1 freq1 ampl2 freq2 ampl3 freq3 pitch
|
|
|
+ // ------------------------------------------------
|
|
|
+ // S
|
|
|
+ // 241 0 6 0 73 0 99 61 Use S (weight 18) for transition instead of AH (weight 2)
|
|
|
+ // 241 0 6 0 73 0 99 61 <-- (OutBlendFrames-1) = (1-1) = 0 frames
|
|
|
+ // AH
|
|
|
+ // 0 2 10 2 66 0 96 59 * <-- InBlendFrames = 3 frames
|
|
|
+ // 0 4 14 3 59 0 93 57 *
|
|
|
+ // 0 8 18 5 52 0 90 55 *
|
|
|
+ // 0 15 22 9 44 1 87 53
|
|
|
+ // 0 15 22 9 44 1 87 53
|
|
|
+ // 0 15 22 9 44 1 87 53 Use N (weight 8) for transition instead of AH (weight 2).
|
|
|
+ // 0 15 22 9 44 1 87 53 Since N is second phoneme, reverse the IN and OUT values.
|
|
|
+ // 0 11 17 8 47 1 98 56 * <-- (InBlendFrames-1) = (2-1) = 1 frames
|
|
|
+ // N
|
|
|
+ // 0 8 12 6 50 1 109 58 * <-- OutBlendFrames = 1
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ //
|
|
|
+ // Now, consider the reverse "NUS" (N AH S):
|
|
|
+ //
|
|
|
+ // flags ampl1 freq1 ampl2 freq2 ampl3 freq3 pitch
|
|
|
+ // ------------------------------------------------
|
|
|
+ // N
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61
|
|
|
+ // 0 5 6 5 54 0 121 61 Use N (weight 8) for transition instead of AH (weight 2)
|
|
|
+ // 0 5 6 5 54 0 121 61 <-- (OutBlendFrames-1) = (1-1) = 0 frames
|
|
|
+ // AH
|
|
|
+ // 0 8 11 6 51 0 110 59 * <-- InBlendFrames = 2
|
|
|
+ // 0 11 16 8 48 0 99 56 *
|
|
|
+ // 0 15 22 9 44 1 87 53 Use S (weight 18) for transition instead of AH (weight 2)
|
|
|
+ // 0 15 22 9 44 1 87 53 Since S is second phoneme, reverse the IN and OUT values.
|
|
|
+ // 0 9 18 5 51 1 90 55 * <-- (InBlendFrames-1) = (3-1) = 2
|
|
|
+ // 0 4 14 3 58 1 93 57 *
|
|
|
+ // S
|
|
|
+ // 241 2 10 2 65 1 96 59 * <-- OutBlendFrames = 1
|
|
|
+ // 241 0 6 0 73 0 99 61
|
|
|
+
|
|
|
+ A = 0;
|
|
|
+ mem44 = 0;
|
|
|
+ mem49 = 0; // mem49 starts at as 0
|
|
|
+ X = 0;
|
|
|
+ while(1) //while No. 1
|
|
|
+ {
|
|
|
+ // get the current and following phoneme
|
|
|
+ Y = phonemeIndexOutput[X];
|
|
|
+ A = phonemeIndexOutput[X + 1];
|
|
|
+ X++;
|
|
|
+
|
|
|
+ // exit loop at end token
|
|
|
+ if(A == 255) break; //goto pos47970;
|
|
|
+
|
|
|
+ // get the ranking of each phoneme
|
|
|
+ X = A;
|
|
|
+ mem56 = blendRank[A];
|
|
|
+ A = blendRank[Y];
|
|
|
+
|
|
|
+ // compare the rank - lower rank value is stronger
|
|
|
+ if(A == mem56) {
|
|
|
+ // same rank, so use out blend lengths from each phoneme
|
|
|
+ phase1 = outBlendLength[Y];
|
|
|
+ phase2 = outBlendLength[X];
|
|
|
+ } else if(A < mem56) {
|
|
|
+ // first phoneme is stronger, so us it's blend lengths
|
|
|
+ phase1 = inBlendLength[X];
|
|
|
+ phase2 = outBlendLength[X];
|
|
|
+ } else {
|
|
|
+ // second phoneme is stronger, so use it's blend lengths
|
|
|
+ // note the out/in are swapped
|
|
|
+ phase1 = outBlendLength[Y];
|
|
|
+ phase2 = inBlendLength[Y];
|
|
|
+ }
|
|
|
+
|
|
|
+ Y = mem44;
|
|
|
+ A = mem49 + phonemeLengthOutput[mem44]; // A is mem49 + length
|
|
|
+ mem49 = A; // mem49 now holds length + position
|
|
|
+ A = A + phase2; //Maybe Problem because of carry flag
|
|
|
+
|
|
|
+ //47776: ADC 42
|
|
|
+ speedcounter = A;
|
|
|
+ mem47 = 168;
|
|
|
+ phase3 = mem49 - phase1; // what is mem49
|
|
|
+ A = phase1 + phase2; // total transition?
|
|
|
+ mem38 = A;
|
|
|
+
|
|
|
+ X = A;
|
|
|
+ X -= 2;
|
|
|
+ if((X & 128) == 0)
|
|
|
+ do //while No. 2
|
|
|
+ {
|
|
|
+ //pos47810:
|
|
|
+
|
|
|
+ // mem47 is used to index the tables:
|
|
|
+ // 168 pitches[]
|
|
|
+ // 169 frequency1
|
|
|
+ // 170 frequency2
|
|
|
+ // 171 frequency3
|
|
|
+ // 172 amplitude1
|
|
|
+ // 173 amplitude2
|
|
|
+ // 174 amplitude3
|
|
|
+
|
|
|
+ mem40 = mem38;
|
|
|
+
|
|
|
+ if(mem47 == 168) // pitch
|
|
|
+ {
|
|
|
+ // unlike the other values, the pitches[] interpolates from
|
|
|
+ // the middle of the current phoneme to the middle of the
|
|
|
+ // next phoneme
|
|
|
+
|
|
|
+ unsigned char mem36, mem37;
|
|
|
+ // half the width of the current phoneme
|
|
|
+ mem36 = phonemeLengthOutput[mem44] >> 1;
|
|
|
+ // half the width of the next phoneme
|
|
|
+ mem37 = phonemeLengthOutput[mem44 + 1] >> 1;
|
|
|
+ // sum the values
|
|
|
+ mem40 = mem36 + mem37; // length of both halves
|
|
|
+ mem37 += mem49; // center of next phoneme
|
|
|
+ mem36 = mem49 - mem36; // center index of current phoneme
|
|
|
+ A = Read(
|
|
|
+ mem47, mem37); // value at center of next phoneme - end interpolation value
|
|
|
+ //A = mem[address];
|
|
|
+
|
|
|
+ Y = mem36; // start index of interpolation
|
|
|
+ mem53 = A - Read(mem47, mem36); // value to center of current phoneme
|
|
|
+ } else {
|
|
|
+ // value to interpolate to
|
|
|
+ A = Read(mem47, speedcounter);
|
|
|
+ // position to start interpolation from
|
|
|
+ Y = phase3;
|
|
|
+ // value to interpolate from
|
|
|
+ mem53 = A - Read(mem47, phase3);
|
|
|
+ }
|
|
|
+
|
|
|
+ //Code47503(mem40);
|
|
|
+ // ML : Code47503 is division with remainder, and mem50 gets the sign
|
|
|
+
|
|
|
+ // calculate change per frame
|
|
|
+ signed char m53 = (signed char)mem53;
|
|
|
+ mem50 = mem53 & 128;
|
|
|
+ unsigned char m53abs = abs(m53);
|
|
|
+ mem51 = m53abs % mem40; //abs((char)m53) % mem40;
|
|
|
+ mem53 = (unsigned char)((signed char)(m53) / mem40);
|
|
|
+
|
|
|
+ // interpolation range
|
|
|
+ X = mem40; // number of frames to interpolate over
|
|
|
+ Y = phase3; // starting frame
|
|
|
+
|
|
|
+ // linearly interpolate values
|
|
|
+
|
|
|
+ mem56 = 0;
|
|
|
+ //47907: CLC
|
|
|
+ //pos47908:
|
|
|
+ while(1) //while No. 3
|
|
|
+ {
|
|
|
+ A = Read(mem47, Y) + mem53; //carry alway cleared
|
|
|
+
|
|
|
+ mem48 = A;
|
|
|
+ Y++;
|
|
|
+ X--;
|
|
|
+ if(X == 0) break;
|
|
|
+
|
|
|
+ mem56 += mem51;
|
|
|
+ if(mem56 >= mem40) //???
|
|
|
+ {
|
|
|
+ mem56 -= mem40; //carry? is set
|
|
|
+ //if ((mem56 & 128)==0)
|
|
|
+ if((mem50 & 128) == 0) {
|
|
|
+ //47935: BIT 50
|
|
|
+ //47937: BMI 47943
|
|
|
+ if(mem48 != 0) mem48++;
|
|
|
+ } else
|
|
|
+ mem48--;
|
|
|
+ }
|
|
|
+ //pos47945:
|
|
|
+ Write(mem47, Y, mem48);
|
|
|
+ } //while No. 3
|
|
|
+
|
|
|
+ //pos47952:
|
|
|
+ mem47++;
|
|
|
+ //if (mem47 != 175) goto pos47810;
|
|
|
+ } while(mem47 != 175); //while No. 2
|
|
|
+ //pos47963:
|
|
|
+ mem44++;
|
|
|
+ X = mem44;
|
|
|
+ } //while No. 1
|
|
|
+
|
|
|
+ //goto pos47701;
|
|
|
+ //pos47970:
|
|
|
+
|
|
|
+ // add the length of this phoneme
|
|
|
+ mem48 = mem49 + phonemeLengthOutput[mem44];
|
|
|
+
|
|
|
+ // ASSIGN PITCH CONTOUR
|
|
|
+ //
|
|
|
+ // This subtracts the F1 frequency from the pitch to create a
|
|
|
+ // pitch contour. Without this, the output would be at a single
|
|
|
+ // pitch level (monotone).
|
|
|
+
|
|
|
+ // don't adjust pitch if in sing mode
|
|
|
+ if(!singmode) {
|
|
|
+ // iterate through the buffer
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ // subtract half the frequency of the formant 1.
|
|
|
+ // this adds variety to the voice
|
|
|
+ pitches[i] -= (frequency1[i] >> 1);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ phase1 = 0;
|
|
|
+ phase2 = 0;
|
|
|
+ phase3 = 0;
|
|
|
+ mem49 = 0;
|
|
|
+ speedcounter = 72; //sam standard speed
|
|
|
+
|
|
|
+ // RESCALE AMPLITUDE
|
|
|
+ //
|
|
|
+ // Rescale volume from a linear scale to decibels.
|
|
|
+ //
|
|
|
+
|
|
|
+ //amplitude rescaling
|
|
|
+ for(i = 255; i >= 0; i--) {
|
|
|
+ amplitude1[i] = amplitudeRescale[amplitude1[i]];
|
|
|
+ amplitude2[i] = amplitudeRescale[amplitude2[i]];
|
|
|
+ amplitude3[i] = amplitudeRescale[amplitude3[i]];
|
|
|
+ }
|
|
|
+
|
|
|
+ Y = 0;
|
|
|
+ A = pitches[0];
|
|
|
+ mem44 = A;
|
|
|
+ X = A;
|
|
|
+ mem38 = A - (A >> 2); // 3/4*A ???
|
|
|
+
|
|
|
+ // PROCESS THE FRAMES
|
|
|
+ //
|
|
|
+ // In traditional vocal synthesis, the glottal pulse drives filters, which
|
|
|
+ // are attenuated to the frequencies of the formants.
|
|
|
+ //
|
|
|
+ // SAM generates these formants directly with sin and rectangular waves.
|
|
|
+ // To simulate them being driven by the glottal pulse, the waveforms are
|
|
|
+ // reset at the beginning of each glottal pulse.
|
|
|
+
|
|
|
+ //finally the loop for sound output
|
|
|
+ //pos48078:
|
|
|
+ while(1) {
|
|
|
+ // get the sampled information on the phoneme
|
|
|
+ A = sampledConsonantFlag[Y];
|
|
|
+ mem39 = A;
|
|
|
+
|
|
|
+ // unvoiced sampled phoneme?
|
|
|
+ A = A & 248;
|
|
|
+ if(A != 0) {
|
|
|
+ // render the sample for the phoneme
|
|
|
+ RenderSample(&mem66);
|
|
|
+
|
|
|
+ // skip ahead two in the phoneme buffer
|
|
|
+ Y += 2;
|
|
|
+ mem48 -= 2;
|
|
|
+ } else {
|
|
|
+ // simulate the glottal pulse and formants
|
|
|
+ unsigned char ary[5];
|
|
|
+ unsigned int p1 =
|
|
|
+ phase1 * 256; // Fixed point integers because we need to divide later on
|
|
|
+ unsigned int p2 = phase2 * 256;
|
|
|
+ unsigned int p3 = phase3 * 256;
|
|
|
+ int k;
|
|
|
+ for(k = 0; k < 5; k++) {
|
|
|
+ signed char sp1 = (signed char)sinus[0xff & (p1 >> 8)];
|
|
|
+ signed char sp2 = (signed char)sinus[0xff & (p2 >> 8)];
|
|
|
+ signed char rp3 = (signed char)rectangle[0xff & (p3 >> 8)];
|
|
|
+ signed int sin1 = sp1 * ((unsigned char)amplitude1[Y] & 0x0f);
|
|
|
+ signed int sin2 = sp2 * ((unsigned char)amplitude2[Y] & 0x0f);
|
|
|
+ signed int rect = rp3 * ((unsigned char)amplitude3[Y] & 0x0f);
|
|
|
+ signed int mux = sin1 + sin2 + rect;
|
|
|
+ mux /= 32;
|
|
|
+ mux += 128; // Go from signed to unsigned amplitude
|
|
|
+ ary[k] = mux;
|
|
|
+ p1 += frequency1[Y] * 256 / 4; // Compromise, this becomes a shift and works well
|
|
|
+ p2 += frequency2[Y] * 256 / 4;
|
|
|
+ p3 += frequency3[Y] * 256 / 4;
|
|
|
+ }
|
|
|
+ // output the accumulated value
|
|
|
+ Output8BitAry(0, ary);
|
|
|
+ speedcounter--;
|
|
|
+ if(speedcounter != 0) goto pos48155;
|
|
|
+ Y++; //go to next amplitude
|
|
|
+
|
|
|
+ // decrement the frame count
|
|
|
+ mem48--;
|
|
|
+ }
|
|
|
+
|
|
|
+ // if the frame count is zero, exit the loop
|
|
|
+ if(mem48 == 0) return;
|
|
|
+ speedcounter = speed;
|
|
|
+ pos48155:
|
|
|
+
|
|
|
+ // decrement the remaining length of the glottal pulse
|
|
|
+ mem44--;
|
|
|
+
|
|
|
+ // finished with a glottal pulse?
|
|
|
+ if(mem44 == 0) {
|
|
|
+ pos48159:
|
|
|
+ // fetch the next glottal pulse length
|
|
|
+ A = pitches[Y];
|
|
|
+ mem44 = A;
|
|
|
+ A = A - (A >> 2);
|
|
|
+ mem38 = A;
|
|
|
+
|
|
|
+ // reset the formant wave generators to keep them in
|
|
|
+ // sync with the glottal pulse
|
|
|
+ phase1 = 0;
|
|
|
+ phase2 = 0;
|
|
|
+ phase3 = 0;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // decrement the count
|
|
|
+ mem38--;
|
|
|
+
|
|
|
+ // is the count non-zero and the sampled flag is zero?
|
|
|
+ if((mem38 != 0) || (mem39 == 0)) {
|
|
|
+ // reset the phase of the formants to match the pulse
|
|
|
+ phase1 += frequency1[Y];
|
|
|
+ phase2 += frequency2[Y];
|
|
|
+ phase3 += frequency3[Y];
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // voiced sampled phonemes interleave the sample with the
|
|
|
+ // glottal pulse. The sample flag is non-zero, so render
|
|
|
+ // the sample for the phoneme.
|
|
|
+ RenderSample(&mem66);
|
|
|
+ goto pos48159;
|
|
|
+ } //while
|
|
|
+
|
|
|
+ // The following code is never reached. It's left over from when
|
|
|
+ // the voiced sample code was part of this loop, instead of part
|
|
|
+ // of RenderSample();
|
|
|
+
|
|
|
+ //pos48315:
|
|
|
+ int tempA;
|
|
|
+ phase1 = A ^ 255;
|
|
|
+ Y = mem66;
|
|
|
+ do {
|
|
|
+ //pos48321:
|
|
|
+
|
|
|
+ mem56 = 8;
|
|
|
+ A = Read(mem47, Y);
|
|
|
+
|
|
|
+ //pos48327:
|
|
|
+ do {
|
|
|
+ //48327: ASL A
|
|
|
+ //48328: BCC 48337
|
|
|
+ tempA = A;
|
|
|
+ A = A << 1;
|
|
|
+ if((tempA & 128) != 0) {
|
|
|
+ X = 26;
|
|
|
+ // mem[54296] = X;
|
|
|
+ bufferpos += 150;
|
|
|
+ //
|
|
|
+ //
|
|
|
+ // buffer[bufferpos / 50] = (X & 15) * 16;
|
|
|
+ //
|
|
|
+ //
|
|
|
+
|
|
|
+ } else {
|
|
|
+ //mem[54296] = 6;
|
|
|
+ X = 6;
|
|
|
+ bufferpos += 150;
|
|
|
+ //
|
|
|
+ // buffer[bufferpos / 50] = (X & 15) * 16;
|
|
|
+ //
|
|
|
+ //
|
|
|
+ }
|
|
|
+
|
|
|
+ for(X = wait2; X > 0; X--)
|
|
|
+ ; //wait
|
|
|
+ mem56--;
|
|
|
+ } while(mem56 != 0);
|
|
|
+
|
|
|
+ Y++;
|
|
|
+ phase1++;
|
|
|
+
|
|
|
+ } while(phase1 != 0);
|
|
|
+ // if (phase1 != 0) goto pos48321;
|
|
|
+ A = 1;
|
|
|
+ mem44 = 1;
|
|
|
+ mem66 = Y;
|
|
|
+ Y = mem49;
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+// Create a rising or falling inflection 30 frames prior to
|
|
|
+// index X. A rising inflection is used for questions, and
|
|
|
+// a falling inflection is used for statements.
|
|
|
+
|
|
|
+void STM32SAM::AddInflection(unsigned char mem48, unsigned char phase1) {
|
|
|
+ //pos48372:
|
|
|
+ // mem48 = 255;
|
|
|
+ //pos48376:
|
|
|
+
|
|
|
+ // store the location of the punctuation
|
|
|
+ mem49 = X;
|
|
|
+ A = X;
|
|
|
+ int Atemp = A;
|
|
|
+
|
|
|
+ // backup 30 frames
|
|
|
+ A = A - 30;
|
|
|
+ // if index is before buffer, point to start of buffer
|
|
|
+ if(Atemp <= 30) A = 0;
|
|
|
+ X = A;
|
|
|
+
|
|
|
+ // FIXME: Explain this fix better, it's not obvious
|
|
|
+ // ML : A =, fixes a problem with invalid pitch with '.'
|
|
|
+ while((A = pitches[X]) == 127) X++;
|
|
|
+
|
|
|
+pos48398:
|
|
|
+ //48398: CLC
|
|
|
+ //48399: ADC 48
|
|
|
+
|
|
|
+ // add the inflection direction
|
|
|
+ A += mem48;
|
|
|
+ phase1 = A;
|
|
|
+
|
|
|
+ // set the inflection
|
|
|
+ pitches[X] = A;
|
|
|
+pos48406:
|
|
|
+
|
|
|
+ // increment the position
|
|
|
+ X++;
|
|
|
+
|
|
|
+ // exit if the punctuation has been reached
|
|
|
+ if(X == mem49) return; //goto pos47615;
|
|
|
+ if(pitches[X] == 255) goto pos48406;
|
|
|
+ A = phase1;
|
|
|
+ goto pos48398;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ SAM's voice can be altered by changing the frequencies of the
|
|
|
+ mouth formant (F1) and the throat formant (F2). Only the voiced
|
|
|
+ phonemes (5-29 and 48-53) are altered.
|
|
|
+*/
|
|
|
+void STM32SAM::SetMouthThroat() {
|
|
|
+ unsigned char initialFrequency;
|
|
|
+ unsigned char newFrequency = 0;
|
|
|
+ //unsigned char mouth; //mem38880
|
|
|
+ //unsigned char throat; //mem38881
|
|
|
+
|
|
|
+ // mouth formants (F1) 5..29
|
|
|
+ unsigned char mouthFormants5_29[30] = {0, 0, 0, 0, 0, 10, 14, 19, 24, 27,
|
|
|
+ 23, 21, 16, 20, 14, 18, 14, 18, 18, 16,
|
|
|
+ 13, 15, 11, 18, 14, 11, 9, 6, 6, 6};
|
|
|
+
|
|
|
+ // throat formants (F2) 5..29
|
|
|
+ unsigned char throatFormants5_29[30] = {255, 255, 255, 255, 255, 84, 73, 67, 63, 40,
|
|
|
+ 44, 31, 37, 45, 73, 49, 36, 30, 51, 37,
|
|
|
+ 29, 69, 24, 50, 30, 24, 83, 46, 54, 86};
|
|
|
+
|
|
|
+ // there must be no zeros in this 2 tables
|
|
|
+ // formant 1 frequencies (mouth) 48..53
|
|
|
+ unsigned char mouthFormants48_53[6] = {19, 27, 21, 27, 18, 13};
|
|
|
+
|
|
|
+ // formant 2 frequencies (throat) 48..53
|
|
|
+ unsigned char throatFormants48_53[6] = {72, 39, 31, 43, 30, 34};
|
|
|
+
|
|
|
+ unsigned char pos = 5; //mem39216
|
|
|
+ //pos38942:
|
|
|
+ // recalculate formant frequencies 5..29 for the mouth (F1) and throat (F2)
|
|
|
+ while(pos != 30) {
|
|
|
+ // recalculate mouth frequency
|
|
|
+ initialFrequency = mouthFormants5_29[pos];
|
|
|
+ if(initialFrequency != 0) newFrequency = trans(mouth, initialFrequency);
|
|
|
+ freq1data[pos] = newFrequency;
|
|
|
+
|
|
|
+ // recalculate throat frequency
|
|
|
+ initialFrequency = throatFormants5_29[pos];
|
|
|
+ if(initialFrequency != 0) newFrequency = trans(throat, initialFrequency);
|
|
|
+ freq2data[pos] = newFrequency;
|
|
|
+ pos++;
|
|
|
+ }
|
|
|
+
|
|
|
+ //pos39059:
|
|
|
+ // recalculate formant frequencies 48..53
|
|
|
+ pos = 48;
|
|
|
+ Y = 0;
|
|
|
+ while(pos != 54) {
|
|
|
+ // recalculate F1 (mouth formant)
|
|
|
+ initialFrequency = mouthFormants48_53[Y];
|
|
|
+ newFrequency = trans(mouth, initialFrequency);
|
|
|
+ freq1data[pos] = newFrequency;
|
|
|
+
|
|
|
+ // recalculate F2 (throat formant)
|
|
|
+ initialFrequency = throatFormants48_53[Y];
|
|
|
+ newFrequency = trans(throat, initialFrequency);
|
|
|
+ freq2data[pos] = newFrequency;
|
|
|
+ Y++;
|
|
|
+ pos++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//return = (mem39212*mem39213) >> 1
|
|
|
+unsigned char STM32SAM::trans(unsigned char mem39212, unsigned char mem39213) {
|
|
|
+ //pos39008:
|
|
|
+ unsigned char carry;
|
|
|
+ int temp;
|
|
|
+ unsigned char mem39214, mem39215;
|
|
|
+ A = 0;
|
|
|
+ mem39215 = 0;
|
|
|
+ mem39214 = 0;
|
|
|
+ X = 8;
|
|
|
+ do {
|
|
|
+ carry = mem39212 & 1;
|
|
|
+ mem39212 = mem39212 >> 1;
|
|
|
+ if(carry != 0) {
|
|
|
+ /*
|
|
|
+ 39018: LSR 39212
|
|
|
+ 39021: BCC 39033
|
|
|
+ */
|
|
|
+ carry = 0;
|
|
|
+ A = mem39215;
|
|
|
+ temp = (int)A + (int)mem39213;
|
|
|
+ A = A + mem39213;
|
|
|
+ if(temp > 255) carry = 1;
|
|
|
+ mem39215 = A;
|
|
|
+ }
|
|
|
+ temp = mem39215 & 1;
|
|
|
+ mem39215 = (mem39215 >> 1) | (carry ? 128 : 0);
|
|
|
+ carry = temp;
|
|
|
+ //39033: ROR 39215
|
|
|
+ X--;
|
|
|
+ } while(X != 0);
|
|
|
+ temp = mem39214 & 128;
|
|
|
+ mem39214 = (mem39214 << 1) | (carry ? 1 : 0);
|
|
|
+ carry = temp;
|
|
|
+ temp = mem39215 & 128;
|
|
|
+ mem39215 = (mem39215 << 1) | (carry ? 1 : 0);
|
|
|
+ carry = temp;
|
|
|
+
|
|
|
+ return mem39215;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Sam
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+//char input[]={"/HAALAOAO MAYN NAAMAEAE IHSTT SAEBAASTTIHAAN \x9b\x9b\0"};
|
|
|
+//unsigned char input[]={"/HAALAOAO \x9b\0"};
|
|
|
+//unsigned char input[]={"AA \x9b\0"};
|
|
|
+//unsigned char input[] = {"GUH5DEHN TAEG\x9b\0"};
|
|
|
+
|
|
|
+//unsigned char input[]={"AY5 AEM EY TAO4LXKIHNX KAX4MPYUX4TAH. GOW4 AH/HEH3D PAHNK.MEYK MAY8 DEY.\x9b\0"};
|
|
|
+//unsigned char input[]={"/HEH3LOW2, /HAW AH YUX2 TUXDEY. AY /HOH3P YUX AH FIYLIHNX OW4 KEY.\x9b\0"};
|
|
|
+//unsigned char input[]={"/HEY2, DHIHS IH3Z GREY2T. /HAH /HAH /HAH.AYL BIY5 BAEK.\x9b\0"};
|
|
|
+//unsigned char input[]={"/HAH /HAH /HAH \x9b\0"};
|
|
|
+//unsigned char input[]={"/HAH /HAH /HAH.\x9b\0"};
|
|
|
+//unsigned char input[]={".TUW BIY5Y3,, OHR NAA3T - TUW BIY5IYIY., DHAE4T IHZ DHAH KWEH4SCHAHN.\x9b\0"};
|
|
|
+//unsigned char input[]={"/HEY2, DHIHS \x9b\0"};
|
|
|
+
|
|
|
+//unsigned char input[]={" IYIHEHAEAAAHAOOHUHUXERAXIX \x9b\0"};
|
|
|
+//unsigned char input[]={" RLWWYMNNXBDGJZZHVDH \x9b\0"};
|
|
|
+//unsigned char input[]={" SSHFTHPTKCH/H \x9b\0"};
|
|
|
+
|
|
|
+//unsigned char input[]={" EYAYOYAWOWUW ULUMUNQ YXWXRXLX/XDX\x9b\0"};
|
|
|
+
|
|
|
+void STM32SAM::SetInput(char* _input) {
|
|
|
+ int i, l;
|
|
|
+ l = strlen(_input);
|
|
|
+ if(l > 254) l = 254;
|
|
|
+ for(i = 0; i < l; i++) {
|
|
|
+ input[i] = _input[i];
|
|
|
+ }
|
|
|
+ input[l] = 0;
|
|
|
+}
|
|
|
+
|
|
|
+// 168=pitches
|
|
|
+// 169=frequency1
|
|
|
+// 170=frequency2
|
|
|
+// 171=frequency3
|
|
|
+// 172=amplitude1
|
|
|
+// 173=amplitude2
|
|
|
+// 174=amplitude3
|
|
|
+
|
|
|
+void STM32SAM::Init() {
|
|
|
+ bufferpos = 0;
|
|
|
+ int i;
|
|
|
+ SetMouthThroat();
|
|
|
+
|
|
|
+ bufferpos = 0;
|
|
|
+ // TODO, check for free the memory, 10 seconds of output should be more than enough
|
|
|
+ //buffer = malloc(22050*10);
|
|
|
+
|
|
|
+ // buffer = (char*) calloc(1, sizeof(char));
|
|
|
+
|
|
|
+ /*
|
|
|
+ freq2data = &mem[45136];
|
|
|
+ freq1data = &mem[45056];
|
|
|
+ freq3data = &mem[45216];
|
|
|
+ */
|
|
|
+ //pitches = &mem[43008];
|
|
|
+ /*
|
|
|
+ frequency1 = &mem[43264];
|
|
|
+ frequency2 = &mem[43520];
|
|
|
+ frequency3 = &mem[43776];
|
|
|
+ */
|
|
|
+ /*
|
|
|
+ amplitude1 = &mem[44032];
|
|
|
+ amplitude2 = &mem[44288];
|
|
|
+ amplitude3 = &mem[44544];
|
|
|
+ */
|
|
|
+ //phoneme = &mem[39904];
|
|
|
+ /*
|
|
|
+ ampl1data = &mem[45296];
|
|
|
+ ampl2data = &mem[45376];
|
|
|
+ ampl3data = &mem[45456];
|
|
|
+ */
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ stress[i] = 0;
|
|
|
+ phonemeLength[i] = 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ for(i = 0; i < 60; i++) {
|
|
|
+ phonemeIndexOutput[i] = 0;
|
|
|
+ stressOutput[i] = 0;
|
|
|
+ phonemeLengthOutput[i] = 0;
|
|
|
+ }
|
|
|
+ phonemeindex[255] =
|
|
|
+ 255; //to prevent buffer overflow // ML : changed from 32 to 255 to stop freezing with long inputs
|
|
|
+}
|
|
|
+
|
|
|
+//int Code39771()
|
|
|
+int STM32SAM::SAMMain() {
|
|
|
+ Init();
|
|
|
+ phonemeindex[255] = 32; //to prevent buffer overflow
|
|
|
+
|
|
|
+ if(!Parser1()) {
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ Parser2();
|
|
|
+ CopyStress();
|
|
|
+ SetPhonemeLength();
|
|
|
+ AdjustLengths();
|
|
|
+ Code41240();
|
|
|
+ do {
|
|
|
+ A = phonemeindex[X];
|
|
|
+ if(A > 80) {
|
|
|
+ phonemeindex[X] = 255;
|
|
|
+ break; // error: delete all behind it
|
|
|
+ }
|
|
|
+ X++;
|
|
|
+ } while(X != 0);
|
|
|
+
|
|
|
+ //pos39848:
|
|
|
+ InsertBreath();
|
|
|
+
|
|
|
+ //mem[40158] = 255;
|
|
|
+
|
|
|
+ PrepareOutput();
|
|
|
+
|
|
|
+ return 1;
|
|
|
+}
|
|
|
+
|
|
|
+//void Code48547()
|
|
|
+void STM32SAM::PrepareOutput() {
|
|
|
+ A = 0;
|
|
|
+ X = 0;
|
|
|
+ Y = 0;
|
|
|
+
|
|
|
+ //pos48551:
|
|
|
+ while(1) {
|
|
|
+ A = phonemeindex[X];
|
|
|
+ if(A == 255) {
|
|
|
+ A = 255;
|
|
|
+ phonemeIndexOutput[Y] = 255;
|
|
|
+ Render();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ if(A == 254) {
|
|
|
+ X++;
|
|
|
+ int temp = X;
|
|
|
+ //mem[48546] = X;
|
|
|
+ phonemeIndexOutput[Y] = 255;
|
|
|
+ Render();
|
|
|
+ //X = mem[48546];
|
|
|
+ X = temp;
|
|
|
+ Y = 0;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ if(A == 0) {
|
|
|
+ X++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ phonemeIndexOutput[Y] = A;
|
|
|
+ phonemeLengthOutput[Y] = phonemeLength[X];
|
|
|
+ stressOutput[Y] = stress[X];
|
|
|
+ X++;
|
|
|
+ Y++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+//void Code41014()
|
|
|
+void STM32SAM::Insert(
|
|
|
+ unsigned char position /*var57*/,
|
|
|
+ unsigned char mem60,
|
|
|
+ unsigned char mem59,
|
|
|
+ unsigned char mem58) {
|
|
|
+ int i;
|
|
|
+ for(i = 253; i >= position; i--) // ML : always keep last safe-guarding 255
|
|
|
+ {
|
|
|
+ phonemeindex[i + 1] = phonemeindex[i];
|
|
|
+ phonemeLength[i + 1] = phonemeLength[i];
|
|
|
+ stress[i + 1] = stress[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ phonemeindex[position] = mem60;
|
|
|
+ phonemeLength[position] = mem59;
|
|
|
+ stress[position] = mem58;
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+//void Code48431()
|
|
|
+void STM32SAM::InsertBreath() {
|
|
|
+ unsigned char mem54;
|
|
|
+ unsigned char mem55;
|
|
|
+ unsigned char index; //variable Y
|
|
|
+ mem54 = 255;
|
|
|
+ X++;
|
|
|
+ mem55 = 0;
|
|
|
+ unsigned char mem66 = 0;
|
|
|
+ while(1) {
|
|
|
+ //pos48440:
|
|
|
+ X = mem66;
|
|
|
+ index = phonemeindex[X];
|
|
|
+ if(index == 255) return;
|
|
|
+ mem55 += phonemeLength[X];
|
|
|
+
|
|
|
+ if(mem55 < 232) {
|
|
|
+ if(index != 254) // ML : Prevents an index out of bounds problem
|
|
|
+ {
|
|
|
+ A = flags2[index] & 1;
|
|
|
+ if(A != 0) {
|
|
|
+ X++;
|
|
|
+ mem55 = 0;
|
|
|
+ Insert(X, 254, mem59, 0);
|
|
|
+ mem66++;
|
|
|
+ mem66++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ if(index == 0) mem54 = X;
|
|
|
+ mem66++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ X = mem54;
|
|
|
+ phonemeindex[X] = 31; // 'Q*' glottal stop
|
|
|
+ phonemeLength[X] = 4;
|
|
|
+ stress[X] = 0;
|
|
|
+ X++;
|
|
|
+ mem55 = 0;
|
|
|
+ Insert(X, 254, mem59, 0);
|
|
|
+ X++;
|
|
|
+ mem66 = X;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// Iterates through the phoneme buffer, copying the stress value from
|
|
|
+// the following phoneme under the following circumstance:
|
|
|
+
|
|
|
+// 1. The current phoneme is voiced, excluding plosives and fricatives
|
|
|
+// 2. The following phoneme is voiced, excluding plosives and fricatives, and
|
|
|
+// 3. The following phoneme is stressed
|
|
|
+//
|
|
|
+// In those cases, the stress value+1 from the following phoneme is copied.
|
|
|
+//
|
|
|
+// For example, the word LOITER is represented as LOY5TER, with as stress
|
|
|
+// of 5 on the diphtong OY. This routine will copy the stress value of 6 (5+1)
|
|
|
+// to the L that precedes it.
|
|
|
+
|
|
|
+//void Code41883()
|
|
|
+void STM32SAM::CopyStress() {
|
|
|
+ // loop thought all the phonemes to be output
|
|
|
+ unsigned char pos = 0; //mem66
|
|
|
+ while(1) {
|
|
|
+ // get the phomene
|
|
|
+ Y = phonemeindex[pos];
|
|
|
+
|
|
|
+ // exit at end of buffer
|
|
|
+ if(Y == 255) return;
|
|
|
+
|
|
|
+ // if CONSONANT_FLAG set, skip - only vowels get stress
|
|
|
+ if((flags[Y] & 64) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // get the next phoneme
|
|
|
+ Y = phonemeindex[pos + 1];
|
|
|
+ if(Y == 255) //prevent buffer overflow
|
|
|
+ {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ } else
|
|
|
+ // if the following phoneme is a vowel, skip
|
|
|
+ if((flags[Y] & 128) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // get the stress value at the next position
|
|
|
+ Y = stress[pos + 1];
|
|
|
+
|
|
|
+ // if next phoneme is not stressed, skip
|
|
|
+ if(Y == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // if next phoneme is not a VOWEL OR ER, skip
|
|
|
+ if((Y & 128) != 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // copy stress from prior phoneme to this one
|
|
|
+ stress[pos] = Y + 1;
|
|
|
+
|
|
|
+ // advance pointer
|
|
|
+ pos++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+// The input[] buffer contains a string of phonemes and stress markers along
|
|
|
+// the lines of:
|
|
|
+//
|
|
|
+// DHAX KAET IHZ AH5GLIY. <0x9B>
|
|
|
+//
|
|
|
+// The byte 0x9B marks the end of the buffer. Some phonemes are 2 bytes
|
|
|
+// long, such as "DH" and "AX". Others are 1 byte long, such as "T" and "Z".
|
|
|
+// There are also stress markers, such as "5" and ".".
|
|
|
+//
|
|
|
+// The first character of the phonemes are stored in the table signInputTable1[].
|
|
|
+// The second character of the phonemes are stored in the table signInputTable2[].
|
|
|
+// The stress characters are arranged in low to high stress order in stressInputTable[].
|
|
|
+//
|
|
|
+// The following process is used to parse the input[] buffer:
|
|
|
+//
|
|
|
+// Repeat until the <0x9B> character is reached:
|
|
|
+//
|
|
|
+// First, a search is made for a 2 character match for phonemes that do not
|
|
|
+// end with the '*' (wildcard) character. On a match, the index of the phoneme
|
|
|
+// is added to phonemeIndex[] and the buffer position is advanced 2 bytes.
|
|
|
+//
|
|
|
+// If this fails, a search is made for a 1 character match against all
|
|
|
+// phoneme names ending with a '*' (wildcard). If this succeeds, the
|
|
|
+// phoneme is added to phonemeIndex[] and the buffer position is advanced
|
|
|
+// 1 byte.
|
|
|
+//
|
|
|
+// If this fails, search for a 1 character match in the stressInputTable[].
|
|
|
+// If this succeeds, the stress value is placed in the last stress[] table
|
|
|
+// at the same index of the last added phoneme, and the buffer position is
|
|
|
+// advanced by 1 byte.
|
|
|
+//
|
|
|
+// If this fails, return a 0.
|
|
|
+//
|
|
|
+// On success:
|
|
|
+//
|
|
|
+// 1. phonemeIndex[] will contain the index of all the phonemes.
|
|
|
+// 2. The last index in phonemeIndex[] will be 255.
|
|
|
+// 3. stress[] will contain the stress value for each phoneme
|
|
|
+
|
|
|
+// input[] holds the string of phonemes, each two bytes wide
|
|
|
+// signInputTable1[] holds the first character of each phoneme
|
|
|
+// signInputTable2[] holds te second character of each phoneme
|
|
|
+// phonemeIndex[] holds the indexes of the phonemes after parsing input[]
|
|
|
+//
|
|
|
+// The parser scans through the input[], finding the names of the phonemes
|
|
|
+// by searching signInputTable1[] and signInputTable2[]. On a match, it
|
|
|
+// copies the index of the phoneme into the phonemeIndexTable[].
|
|
|
+//
|
|
|
+// The character <0x9B> marks the end of text in input[]. When it is reached,
|
|
|
+// the index 255 is placed at the end of the phonemeIndexTable[], and the
|
|
|
+// function returns with a 1 indicating success.
|
|
|
+int STM32SAM::Parser1() {
|
|
|
+ int i;
|
|
|
+ unsigned char sign1;
|
|
|
+ unsigned char sign2;
|
|
|
+ unsigned char position = 0;
|
|
|
+ X = 0;
|
|
|
+ A = 0;
|
|
|
+ Y = 0;
|
|
|
+
|
|
|
+ // CLEAR THE STRESS TABLE
|
|
|
+ for(i = 0; i < 256; i++) stress[i] = 0;
|
|
|
+
|
|
|
+ // THIS CODE MATCHES THE PHONEME LETTERS TO THE TABLE
|
|
|
+ // pos41078:
|
|
|
+ while(1) {
|
|
|
+ // GET THE FIRST CHARACTER FROM THE PHONEME BUFFER
|
|
|
+ sign1 = input[X];
|
|
|
+ // TEST FOR 155 (�) END OF LINE MARKER
|
|
|
+ if(sign1 == 155) {
|
|
|
+ // MARK ENDPOINT AND RETURN
|
|
|
+ phonemeindex[position] = 255; //mark endpoint
|
|
|
+ // REACHED END OF PHONEMES, SO EXIT
|
|
|
+ return 1; //all ok
|
|
|
+ }
|
|
|
+
|
|
|
+ // GET THE NEXT CHARACTER FROM THE BUFFER
|
|
|
+ X++;
|
|
|
+ sign2 = input[X];
|
|
|
+
|
|
|
+ // NOW sign1 = FIRST CHARACTER OF PHONEME, AND sign2 = SECOND CHARACTER OF PHONEME
|
|
|
+
|
|
|
+ // TRY TO MATCH PHONEMES ON TWO TWO-CHARACTER NAME
|
|
|
+ // IGNORE PHONEMES IN TABLE ENDING WITH WILDCARDS
|
|
|
+
|
|
|
+ // SET INDEX TO 0
|
|
|
+ Y = 0;
|
|
|
+ pos41095:
|
|
|
+
|
|
|
+ // GET FIRST CHARACTER AT POSITION Y IN signInputTable
|
|
|
+ // --> should change name to PhonemeNameTable1
|
|
|
+ A = signInputTable1[Y];
|
|
|
+
|
|
|
+ // FIRST CHARACTER MATCHES?
|
|
|
+ if(A == sign1) {
|
|
|
+ // GET THE CHARACTER FROM THE PhonemeSecondLetterTable
|
|
|
+ A = signInputTable2[Y];
|
|
|
+ // NOT A SPECIAL AND MATCHES SECOND CHARACTER?
|
|
|
+ if((A != '*') && (A == sign2)) {
|
|
|
+ // STORE THE INDEX OF THE PHONEME INTO THE phomeneIndexTable
|
|
|
+ phonemeindex[position] = Y;
|
|
|
+
|
|
|
+ // ADVANCE THE POINTER TO THE phonemeIndexTable
|
|
|
+ position++;
|
|
|
+ // ADVANCE THE POINTER TO THE phonemeInputBuffer
|
|
|
+ X++;
|
|
|
+
|
|
|
+ // CONTINUE PARSING
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // NO MATCH, TRY TO MATCH ON FIRST CHARACTER TO WILDCARD NAMES (ENDING WITH '*')
|
|
|
+
|
|
|
+ // ADVANCE TO THE NEXT POSITION
|
|
|
+ Y++;
|
|
|
+ // IF NOT END OF TABLE, CONTINUE
|
|
|
+ if(Y != 81) goto pos41095;
|
|
|
+
|
|
|
+ // REACHED END OF TABLE WITHOUT AN EXACT (2 CHARACTER) MATCH.
|
|
|
+ // THIS TIME, SEARCH FOR A 1 CHARACTER MATCH AGAINST THE WILDCARDS
|
|
|
+
|
|
|
+ // RESET THE INDEX TO POINT TO THE START OF THE PHONEME NAME TABLE
|
|
|
+ Y = 0;
|
|
|
+ pos41134:
|
|
|
+ // DOES THE PHONEME IN THE TABLE END WITH '*'?
|
|
|
+ if(signInputTable2[Y] == '*') {
|
|
|
+ // DOES THE FIRST CHARACTER MATCH THE FIRST LETTER OF THE PHONEME
|
|
|
+ if(signInputTable1[Y] == sign1) {
|
|
|
+ // SAVE THE POSITION AND MOVE AHEAD
|
|
|
+ phonemeindex[position] = Y;
|
|
|
+
|
|
|
+ // ADVANCE THE POINTER
|
|
|
+ position++;
|
|
|
+
|
|
|
+ // CONTINUE THROUGH THE LOOP
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ Y++;
|
|
|
+ if(Y != 81) goto pos41134; //81 is size of PHONEME NAME table
|
|
|
+
|
|
|
+ // FAILED TO MATCH WITH A WILDCARD. ASSUME THIS IS A STRESS
|
|
|
+ // CHARACTER. SEARCH THROUGH THE STRESS TABLE
|
|
|
+
|
|
|
+ // SET INDEX TO POSITION 8 (END OF STRESS TABLE)
|
|
|
+ Y = 8;
|
|
|
+
|
|
|
+ // WALK BACK THROUGH TABLE LOOKING FOR A MATCH
|
|
|
+ while((sign1 != stressInputTable[Y]) && (Y > 0)) {
|
|
|
+ // DECREMENT INDEX
|
|
|
+ Y--;
|
|
|
+ }
|
|
|
+
|
|
|
+ // REACHED THE END OF THE SEARCH WITHOUT BREAKING OUT OF LOOP?
|
|
|
+ if(Y == 0) {
|
|
|
+ //mem[39444] = X;
|
|
|
+ //41181: JSR 42043 //Error
|
|
|
+ // FAILED TO MATCH ANYTHING, RETURN 0 ON FAILURE
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+ // SET THE STRESS FOR THE PRIOR PHONEME
|
|
|
+ stress[position - 1] = Y;
|
|
|
+ } //while
|
|
|
+}
|
|
|
+
|
|
|
+//change phonemelength depedendent on stress
|
|
|
+//void Code41203()
|
|
|
+void STM32SAM::SetPhonemeLength() {
|
|
|
+ unsigned char A;
|
|
|
+ int position = 0;
|
|
|
+ while(phonemeindex[position] != 255) {
|
|
|
+ A = stress[position];
|
|
|
+ //41218: BMI 41229
|
|
|
+ if((A == 0) || ((A & 128) != 0)) {
|
|
|
+ phonemeLength[position] = phonemeLengthTable[phonemeindex[position]];
|
|
|
+ } else {
|
|
|
+ phonemeLength[position] = phonemeStressedLengthTable[phonemeindex[position]];
|
|
|
+ }
|
|
|
+ position++;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::Code41240() {
|
|
|
+ unsigned char pos = 0;
|
|
|
+
|
|
|
+ while(phonemeindex[pos] != 255) {
|
|
|
+ unsigned char index; //register AC
|
|
|
+ X = pos;
|
|
|
+ index = phonemeindex[pos];
|
|
|
+ if((flags[index] & 2) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ } else if((flags[index] & 1) == 0) {
|
|
|
+ Insert(pos + 1, index + 1, phonemeLengthTable[index + 1], stress[pos]);
|
|
|
+ Insert(pos + 2, index + 2, phonemeLengthTable[index + 2], stress[pos]);
|
|
|
+ pos += 3;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ do {
|
|
|
+ X++;
|
|
|
+ A = phonemeindex[X];
|
|
|
+ } while(A == 0);
|
|
|
+
|
|
|
+ if(A != 255) {
|
|
|
+ if((flags[A] & 8) != 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ if((A == 36) || (A == 37)) {
|
|
|
+ pos++; // '/H' '/X'
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ Insert(pos + 1, index + 1, phonemeLengthTable[index + 1], stress[pos]);
|
|
|
+ Insert(pos + 2, index + 2, phonemeLengthTable[index + 2], stress[pos]);
|
|
|
+ pos += 3;
|
|
|
+ };
|
|
|
+}
|
|
|
+
|
|
|
+// Rewrites the phonemes using the following rules:
|
|
|
+//
|
|
|
+// <DIPHTONG ENDING WITH WX> -> <DIPHTONG ENDING WITH WX> WX
|
|
|
+// <DIPHTONG NOT ENDING WITH WX> -> <DIPHTONG NOT ENDING WITH WX> YX
|
|
|
+// UL -> AX L
|
|
|
+// UM -> AX M
|
|
|
+// <STRESSED VOWEL> <SILENCE> <STRESSED VOWEL> -> <STRESSED VOWEL> <SILENCE> Q <VOWEL>
|
|
|
+// T R -> CH R
|
|
|
+// D R -> J R
|
|
|
+// <VOWEL> R -> <VOWEL> RX
|
|
|
+// <VOWEL> L -> <VOWEL> LX
|
|
|
+// G S -> G Z
|
|
|
+// K <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> KX <VOWEL OR DIPHTONG NOT ENDING WITH IY>
|
|
|
+// G <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> GX <VOWEL OR DIPHTONG NOT ENDING WITH IY>
|
|
|
+// S P -> S B
|
|
|
+// S T -> S D
|
|
|
+// S K -> S G
|
|
|
+// S KX -> S GX
|
|
|
+// <ALVEOLAR> UW -> <ALVEOLAR> UX
|
|
|
+// CH -> CH CH' (CH requires two phonemes to represent it)
|
|
|
+// J -> J J' (J requires two phonemes to represent it)
|
|
|
+// <UNSTRESSED VOWEL> T <PAUSE> -> <UNSTRESSED VOWEL> DX <PAUSE>
|
|
|
+// <UNSTRESSED VOWEL> D <PAUSE> -> <UNSTRESSED VOWEL> DX <PAUSE>
|
|
|
+
|
|
|
+//void Code41397()
|
|
|
+void STM32SAM::Parser2() {
|
|
|
+ unsigned char pos = 0; //mem66;
|
|
|
+ unsigned char mem58 = 0;
|
|
|
+
|
|
|
+ // Loop through phonemes
|
|
|
+ while(1) {
|
|
|
+ // SET X TO THE CURRENT POSITION
|
|
|
+ X = pos;
|
|
|
+ // GET THE PHONEME AT THE CURRENT POSITION
|
|
|
+ A = phonemeindex[pos];
|
|
|
+
|
|
|
+ // Is phoneme pause?
|
|
|
+ if(A == 0) {
|
|
|
+ // Move ahead to the
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // If end of phonemes flag reached, exit routine
|
|
|
+ if(A == 255) return;
|
|
|
+
|
|
|
+ // Copy the current phoneme index to Y
|
|
|
+ Y = A;
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // <DIPHTONG ENDING WITH WX> -> <DIPHTONG ENDING WITH WX> WX
|
|
|
+ // <DIPHTONG NOT ENDING WITH WX> -> <DIPHTONG NOT ENDING WITH WX> YX
|
|
|
+ // Example: OIL, COW
|
|
|
+
|
|
|
+ // Check for DIPHTONG
|
|
|
+ if((flags[A] & 16) == 0) goto pos41457;
|
|
|
+
|
|
|
+ // Not a diphthong. Get the stress
|
|
|
+ mem58 = stress[pos];
|
|
|
+
|
|
|
+ // End in IY sound?
|
|
|
+ A = flags[Y] & 32;
|
|
|
+
|
|
|
+ // If ends with IY, use YX, else use WX
|
|
|
+ if(A == 0)
|
|
|
+ A = 20;
|
|
|
+ else
|
|
|
+ A = 21; // 'WX' = 20 'YX' = 21
|
|
|
+ //pos41443:
|
|
|
+ // Insert at WX or YX following, copying the stress
|
|
|
+
|
|
|
+ Insert(pos + 1, A, mem59, mem58);
|
|
|
+ X = pos;
|
|
|
+ // Jump to ???
|
|
|
+ goto pos41749;
|
|
|
+
|
|
|
+ pos41457:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // UL -> AX L
|
|
|
+ // Example: MEDDLE
|
|
|
+
|
|
|
+ // Get phoneme
|
|
|
+ A = phonemeindex[X];
|
|
|
+ // Skip this rule if phoneme is not UL
|
|
|
+ if(A != 78) goto pos41487; // 'UL'
|
|
|
+ A = 24; // 'L' //change 'UL' to 'AX L'
|
|
|
+
|
|
|
+ pos41466:
|
|
|
+ // Get current phoneme stress
|
|
|
+ mem58 = stress[X];
|
|
|
+
|
|
|
+ // Change UL to AX
|
|
|
+ phonemeindex[X] = 13; // 'AX'
|
|
|
+ // Perform insert. Note code below may jump up here with different values
|
|
|
+ Insert(X + 1, A, mem59, mem58);
|
|
|
+ pos++;
|
|
|
+ // Move to next phoneme
|
|
|
+ continue;
|
|
|
+
|
|
|
+ pos41487:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // UM -> AX M
|
|
|
+ // Example: ASTRONOMY
|
|
|
+
|
|
|
+ // Skip rule if phoneme != UM
|
|
|
+ if(A != 79) goto pos41495; // 'UM'
|
|
|
+ // Jump up to branch - replaces current phoneme with AX and continues
|
|
|
+ A = 27; // 'M' //change 'UM' to 'AX M'
|
|
|
+
|
|
|
+ goto pos41466;
|
|
|
+ pos41495:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // UN -> AX N
|
|
|
+ // Example: FUNCTION
|
|
|
+
|
|
|
+ // Skip rule if phoneme != UN
|
|
|
+ if(A != 80) goto pos41503; // 'UN'
|
|
|
+
|
|
|
+ // Jump up to branch - replaces current phoneme with AX and continues
|
|
|
+ A = 28; // 'N' //change UN to 'AX N'
|
|
|
+
|
|
|
+ goto pos41466;
|
|
|
+ pos41503:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // <STRESSED VOWEL> <SILENCE> <STRESSED VOWEL> -> <STRESSED VOWEL> <SILENCE> Q <VOWEL>
|
|
|
+ // EXAMPLE: AWAY EIGHT
|
|
|
+
|
|
|
+ Y = A;
|
|
|
+ // VOWEL set?
|
|
|
+ A = flags[A] & 128;
|
|
|
+
|
|
|
+ // Skip if not a vowel
|
|
|
+ if(A != 0) {
|
|
|
+ // Get the stress
|
|
|
+ A = stress[X];
|
|
|
+
|
|
|
+ // If stressed...
|
|
|
+ if(A != 0) {
|
|
|
+ // Get the following phoneme
|
|
|
+ X++;
|
|
|
+ A = phonemeindex[X];
|
|
|
+ // If following phoneme is a pause
|
|
|
+
|
|
|
+ if(A == 0) {
|
|
|
+ // Get the phoneme following pause
|
|
|
+ X++;
|
|
|
+ Y = phonemeindex[X];
|
|
|
+
|
|
|
+ // Check for end of buffer flag
|
|
|
+ if(Y == 255) //buffer overflow
|
|
|
+ // ??? Not sure about these flags
|
|
|
+ A = 65 & 128;
|
|
|
+ else
|
|
|
+ // And VOWEL flag to current phoneme's flags
|
|
|
+ A = flags[Y] & 128;
|
|
|
+
|
|
|
+ // If following phonemes is not a pause
|
|
|
+ if(A != 0) {
|
|
|
+ // If the following phoneme is not stressed
|
|
|
+ A = stress[X];
|
|
|
+ if(A != 0) {
|
|
|
+ // 31 = 'Q'
|
|
|
+ Insert(X, 31, mem59, 0);
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULES FOR PHONEMES BEFORE R
|
|
|
+ // T R -> CH R
|
|
|
+ // Example: TRACK
|
|
|
+
|
|
|
+ // Get current position and phoneme
|
|
|
+ X = pos;
|
|
|
+ A = phonemeindex[pos];
|
|
|
+ if(A != 23) goto pos41611; // 'R'
|
|
|
+
|
|
|
+ // Look at prior phoneme
|
|
|
+ X--;
|
|
|
+ A = phonemeindex[pos - 1];
|
|
|
+ //pos41567:
|
|
|
+ if(A == 69) // 'T'
|
|
|
+ {
|
|
|
+ phonemeindex[pos - 1] = 42;
|
|
|
+ goto pos41779;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULES FOR PHONEMES BEFORE R
|
|
|
+ // D R -> J R
|
|
|
+ // Example: DRY
|
|
|
+
|
|
|
+ // Prior phonemes D?
|
|
|
+ if(A == 57) // 'D'
|
|
|
+ {
|
|
|
+ // Change D to J
|
|
|
+ phonemeindex[pos - 1] = 44;
|
|
|
+
|
|
|
+ goto pos41788;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULES FOR PHONEMES BEFORE R
|
|
|
+ // <VOWEL> R -> <VOWEL> RX
|
|
|
+ // Example: ART
|
|
|
+
|
|
|
+ // If vowel flag is set change R to RX
|
|
|
+ A = flags[A] & 128;
|
|
|
+
|
|
|
+ if(A != 0) phonemeindex[pos] = 18; // 'RX'
|
|
|
+
|
|
|
+ // continue to next phoneme
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+
|
|
|
+ pos41611:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // <VOWEL> L -> <VOWEL> LX
|
|
|
+ // Example: ALL
|
|
|
+
|
|
|
+ // Is phoneme L?
|
|
|
+ if(A == 24) // 'L'
|
|
|
+ {
|
|
|
+ // If prior phoneme does not have VOWEL flag set, move to next phoneme
|
|
|
+ if((flags[phonemeindex[pos - 1]] & 128) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Prior phoneme has VOWEL flag set, so change L to LX and move to next phoneme
|
|
|
+
|
|
|
+ phonemeindex[X] = 19; // 'LX'
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // G S -> G Z
|
|
|
+ //
|
|
|
+ // Can't get to fire -
|
|
|
+ // 1. The G -> GX rule intervenes
|
|
|
+ // 2. Reciter already replaces GS -> GZ
|
|
|
+
|
|
|
+ // Is current phoneme S?
|
|
|
+ if(A == 32) // 'S'
|
|
|
+ {
|
|
|
+ // If prior phoneme is not G, move to next phoneme
|
|
|
+ if(phonemeindex[pos - 1] != 60) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // Replace S with Z and move on
|
|
|
+
|
|
|
+ phonemeindex[pos] = 38; // 'Z'
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // K <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> KX <VOWEL OR DIPHTONG NOT ENDING WITH IY>
|
|
|
+ // Example: COW
|
|
|
+
|
|
|
+ // Is current phoneme K?
|
|
|
+ if(A == 72) // 'K'
|
|
|
+ {
|
|
|
+ // Get next phoneme
|
|
|
+ Y = phonemeindex[pos + 1];
|
|
|
+ // If at end, replace current phoneme with KX
|
|
|
+ if(Y == 255)
|
|
|
+ phonemeindex[pos] = 75; // ML : prevents an index out of bounds problem
|
|
|
+ else {
|
|
|
+ // VOWELS AND DIPHTONGS ENDING WITH IY SOUND flag set?
|
|
|
+ A = flags[Y] & 32;
|
|
|
+
|
|
|
+ // Replace with KX
|
|
|
+ if(A == 0) phonemeindex[pos] = 75; // 'KX'
|
|
|
+ }
|
|
|
+ } else
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // G <VOWEL OR DIPHTONG NOT ENDING WITH IY> -> GX <VOWEL OR DIPHTONG NOT ENDING WITH IY>
|
|
|
+ // Example: GO
|
|
|
+
|
|
|
+ // Is character a G?
|
|
|
+ if(A == 60) // 'G'
|
|
|
+ {
|
|
|
+ // Get the following character
|
|
|
+ unsigned char index = phonemeindex[pos + 1];
|
|
|
+
|
|
|
+ // At end of buffer?
|
|
|
+ if(index == 255) //prevent buffer overflow
|
|
|
+ {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ } else
|
|
|
+ // If diphtong ending with YX, move continue processing next phoneme
|
|
|
+ if((flags[index] & 32) != 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // replace G with GX and continue processing next phoneme
|
|
|
+
|
|
|
+ phonemeindex[pos] = 63; // 'GX'
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // S P -> S B
|
|
|
+ // S T -> S D
|
|
|
+ // S K -> S G
|
|
|
+ // S KX -> S GX
|
|
|
+ // Examples: SPY, STY, SKY, SCOWL
|
|
|
+
|
|
|
+ Y = phonemeindex[pos];
|
|
|
+ //pos41719:
|
|
|
+ // Replace with softer version?
|
|
|
+ A = flags[Y] & 1;
|
|
|
+ if(A == 0) goto pos41749;
|
|
|
+ A = phonemeindex[pos - 1];
|
|
|
+ if(A != 32) // 'S'
|
|
|
+ {
|
|
|
+ A = Y;
|
|
|
+ goto pos41812;
|
|
|
+ }
|
|
|
+ // Replace with softer version
|
|
|
+
|
|
|
+ phonemeindex[pos] = Y - 12;
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+
|
|
|
+ pos41749:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // <ALVEOLAR> UW -> <ALVEOLAR> UX
|
|
|
+ //
|
|
|
+ // Example: NEW, DEW, SUE, ZOO, THOO, TOO
|
|
|
+
|
|
|
+ // UW -> UX
|
|
|
+
|
|
|
+ A = phonemeindex[X];
|
|
|
+ if(A == 53) // 'UW'
|
|
|
+ {
|
|
|
+ // ALVEOLAR flag set?
|
|
|
+ Y = phonemeindex[X - 1];
|
|
|
+ A = flags2[Y] & 4;
|
|
|
+ // If not set, continue processing next phoneme
|
|
|
+ if(A == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ phonemeindex[X] = 16;
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ pos41779:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // CH -> CH CH' (CH requires two phonemes to represent it)
|
|
|
+ // Example: CHEW
|
|
|
+
|
|
|
+ if(A == 42) // 'CH'
|
|
|
+ {
|
|
|
+ // pos41783:
|
|
|
+
|
|
|
+ Insert(X + 1, A + 1, mem59, stress[X]);
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ pos41788:
|
|
|
+
|
|
|
+ // RULE:
|
|
|
+ // J -> J J' (J requires two phonemes to represent it)
|
|
|
+ // Example: JAY
|
|
|
+
|
|
|
+ if(A == 44) // 'J'
|
|
|
+ {
|
|
|
+ Insert(X + 1, A + 1, mem59, stress[X]);
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Jump here to continue
|
|
|
+ pos41812:
|
|
|
+
|
|
|
+ // RULE: Soften T following vowel
|
|
|
+ // NOTE: This rule fails for cases such as "ODD"
|
|
|
+ // <UNSTRESSED VOWEL> T <PAUSE> -> <UNSTRESSED VOWEL> DX <PAUSE>
|
|
|
+ // <UNSTRESSED VOWEL> D <PAUSE> -> <UNSTRESSED VOWEL> DX <PAUSE>
|
|
|
+ // Example: PARTY, TARDY
|
|
|
+
|
|
|
+ // Past this point, only process if phoneme is T or D
|
|
|
+
|
|
|
+ if(A != 69) // 'T'
|
|
|
+ if(A != 57) {
|
|
|
+ pos++; // 'D'
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ //pos41825:
|
|
|
+
|
|
|
+ // If prior phoneme is not a vowel, continue processing phonemes
|
|
|
+ if((flags[phonemeindex[X - 1]] & 128) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Get next phoneme
|
|
|
+ X++;
|
|
|
+ A = phonemeindex[X];
|
|
|
+ //pos41841
|
|
|
+ // Is the next phoneme a pause?
|
|
|
+ if(A != 0) {
|
|
|
+ // If next phoneme is not a pause, continue processing phonemes
|
|
|
+ if((flags[A] & 128) == 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // If next phoneme is stressed, continue processing phonemes
|
|
|
+ // FIXME: How does a pause get stressed?
|
|
|
+ if(stress[X] != 0) {
|
|
|
+ pos++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ //pos41856:
|
|
|
+ // Set phonemes to DX
|
|
|
+
|
|
|
+ phonemeindex[pos] = 30; // 'DX'
|
|
|
+ } else {
|
|
|
+ A = phonemeindex[X + 1];
|
|
|
+ if(A == 255) //prevent buffer overflow
|
|
|
+ A = 65 & 128;
|
|
|
+ else
|
|
|
+ // Is next phoneme a vowel or ER?
|
|
|
+ A = flags[A] & 128;
|
|
|
+
|
|
|
+ if(A != 0) phonemeindex[pos] = 30; // 'DX'
|
|
|
+ }
|
|
|
+
|
|
|
+ pos++;
|
|
|
+
|
|
|
+ } // while
|
|
|
+} // parser 2
|
|
|
+
|
|
|
+// Applies various rules that adjust the lengths of phonemes
|
|
|
+//
|
|
|
+// Lengthen <FRICATIVE> or <VOICED> between <VOWEL> and <PUNCTUATION> by 1.5
|
|
|
+// <VOWEL> <RX | LX> <CONSONANT> - decrease <VOWEL> length by 1
|
|
|
+// <VOWEL> <UNVOICED PLOSIVE> - decrease vowel by 1/8th
|
|
|
+// <VOWEL> <UNVOICED CONSONANT> - increase vowel by 1/2 + 1
|
|
|
+// <NASAL> <STOP CONSONANT> - set nasal = 5, consonant = 6
|
|
|
+// <VOICED STOP CONSONANT> {optional silence} <STOP CONSONANT> - shorten both to 1/2 + 1
|
|
|
+// <LIQUID CONSONANT> <DIPHTONG> - decrease by 2
|
|
|
+
|
|
|
+//void Code48619()
|
|
|
+void STM32SAM::AdjustLengths() {
|
|
|
+ // LENGTHEN VOWELS PRECEDING PUNCTUATION
|
|
|
+ //
|
|
|
+ // Search for punctuation. If found, back up to the first vowel, then
|
|
|
+ // process all phonemes between there and up to (but not including) the punctuation.
|
|
|
+ // If any phoneme is found that is a either a fricative or voiced, the duration is
|
|
|
+ // increased by (length * 1.5) + 1
|
|
|
+
|
|
|
+ // loop index
|
|
|
+ X = 0;
|
|
|
+ unsigned char index;
|
|
|
+
|
|
|
+ // iterate through the phoneme list
|
|
|
+ unsigned char loopIndex = 0;
|
|
|
+ while(1) {
|
|
|
+ // get a phoneme
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ // exit loop if end on buffer token
|
|
|
+ if(index == 255) break;
|
|
|
+
|
|
|
+ // not punctuation?
|
|
|
+ if((flags2[index] & 1) == 0) {
|
|
|
+ // skip
|
|
|
+ X++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // hold index
|
|
|
+ loopIndex = X;
|
|
|
+
|
|
|
+ // Loop backwards from this point
|
|
|
+ pos48644:
|
|
|
+
|
|
|
+ // back up one phoneme
|
|
|
+ X--;
|
|
|
+
|
|
|
+ // stop once the beginning is reached
|
|
|
+ if(X == 0) break;
|
|
|
+
|
|
|
+ // get the preceding phoneme
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ if(index != 255) //inserted to prevent access overrun
|
|
|
+ if((flags[index] & 128) == 0) goto pos48644; // if not a vowel, continue looping
|
|
|
+
|
|
|
+ //pos48657:
|
|
|
+ do {
|
|
|
+ // test for vowel
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ if(index != 255) //inserted to prevent access overrun
|
|
|
+ // test for fricative/unvoiced or not voiced
|
|
|
+ if(((flags2[index] & 32) == 0) || ((flags[index] & 4) != 0)) //nochmal �berpr�fen
|
|
|
+ {
|
|
|
+ //A = flags[Y] & 4;
|
|
|
+ //if(A == 0) goto pos48688;
|
|
|
+
|
|
|
+ // get the phoneme length
|
|
|
+ A = phonemeLength[X];
|
|
|
+
|
|
|
+ // change phoneme length to (length * 1.5) + 1
|
|
|
+ A = (A >> 1) + A + 1;
|
|
|
+
|
|
|
+ phonemeLength[X] = A;
|
|
|
+ }
|
|
|
+ // keep moving forward
|
|
|
+ X++;
|
|
|
+ } while(X != loopIndex);
|
|
|
+ // if (X != loopIndex) goto pos48657;
|
|
|
+ X++;
|
|
|
+ } // while
|
|
|
+
|
|
|
+ // Similar to the above routine, but shorten vowels under some circumstances
|
|
|
+
|
|
|
+ // Loop throught all phonemes
|
|
|
+ loopIndex = 0;
|
|
|
+ //pos48697
|
|
|
+
|
|
|
+ while(1) {
|
|
|
+ // get a phoneme
|
|
|
+ X = loopIndex;
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ // exit routine at end token
|
|
|
+ if(index == 255) return;
|
|
|
+
|
|
|
+ // vowel?
|
|
|
+ A = flags[index] & 128;
|
|
|
+ if(A != 0) {
|
|
|
+ // get next phoneme
|
|
|
+ X++;
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ // get flags
|
|
|
+ if(index == 255)
|
|
|
+ mem56 = 65; // use if end marker
|
|
|
+ else
|
|
|
+ mem56 = flags[index];
|
|
|
+
|
|
|
+ // not a consonant
|
|
|
+ if((flags[index] & 64) == 0) {
|
|
|
+ // RX or LX?
|
|
|
+ if((index == 18) || (index == 19)) // 'RX' & 'LX'
|
|
|
+ {
|
|
|
+ // get the next phoneme
|
|
|
+ X++;
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ // next phoneme a consonant?
|
|
|
+ if((flags[index] & 64) != 0) {
|
|
|
+ // RULE: <VOWEL> RX | LX <CONSONANT>
|
|
|
+
|
|
|
+ // decrease length of vowel by 1 frame
|
|
|
+ phonemeLength[loopIndex]--;
|
|
|
+ }
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // Got here if not <VOWEL>
|
|
|
+
|
|
|
+ // not voiced
|
|
|
+ if((mem56 & 4) == 0) {
|
|
|
+ // Unvoiced
|
|
|
+ // *, .*, ?*, ,*, -*, DX, S*, SH, F*, TH, /H, /X, CH, P*, T*, K*, KX
|
|
|
+
|
|
|
+ // not an unvoiced plosive?
|
|
|
+ if((mem56 & 1) == 0) {
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // P*, T*, K*, KX
|
|
|
+
|
|
|
+ // RULE: <VOWEL> <UNVOICED PLOSIVE>
|
|
|
+ // <VOWEL> <P*, T*, K*, KX>
|
|
|
+
|
|
|
+ // move back
|
|
|
+ X--;
|
|
|
+
|
|
|
+ // decrease length by 1/8th
|
|
|
+ mem56 = phonemeLength[X] >> 3;
|
|
|
+ phonemeLength[X] -= mem56;
|
|
|
+
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULE: <VOWEL> <VOICED CONSONANT>
|
|
|
+ // <VOWEL> <WH, R*, L*, W*, Y*, M*, N*, NX, DX, Q*, Z*, ZH, V*, DH, J*, B*, D*, G*, GX>
|
|
|
+
|
|
|
+ // decrease length
|
|
|
+ A = phonemeLength[X - 1];
|
|
|
+ phonemeLength[X - 1] = (A >> 2) + A + 1; // 5/4*A + 1
|
|
|
+
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // WH, R*, L*, W*, Y*, M*, N*, NX, Q*, Z*, ZH, V*, DH, J*, B*, D*, G*, GX
|
|
|
+
|
|
|
+ //pos48821:
|
|
|
+
|
|
|
+ // RULE: <NASAL> <STOP CONSONANT>
|
|
|
+ // Set punctuation length to 6
|
|
|
+ // Set stop consonant length to 5
|
|
|
+
|
|
|
+ // nasal?
|
|
|
+ if((flags2[index] & 8) != 0) {
|
|
|
+ // M*, N*, NX,
|
|
|
+
|
|
|
+ // get the next phoneme
|
|
|
+ X++;
|
|
|
+ index = phonemeindex[X];
|
|
|
+
|
|
|
+ // end of buffer?
|
|
|
+ if(index == 255)
|
|
|
+ A = 65 & 2; //prevent buffer overflow
|
|
|
+ else
|
|
|
+ A = flags[index] & 2; // check for stop consonant
|
|
|
+
|
|
|
+ // is next phoneme a stop consonant?
|
|
|
+ if(A != 0)
|
|
|
+
|
|
|
+ // B*, D*, G*, GX, P*, T*, K*, KX
|
|
|
+
|
|
|
+ {
|
|
|
+ // set stop consonant length to 6
|
|
|
+ phonemeLength[X] = 6;
|
|
|
+
|
|
|
+ // set nasal length to 5
|
|
|
+ phonemeLength[X - 1] = 5;
|
|
|
+ }
|
|
|
+ // move to next phoneme
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // WH, R*, L*, W*, Y*, Q*, Z*, ZH, V*, DH, J*, B*, D*, G*, GX
|
|
|
+
|
|
|
+ // RULE: <VOICED STOP CONSONANT> {optional silence} <STOP CONSONANT>
|
|
|
+ // Shorten both to (length/2 + 1)
|
|
|
+
|
|
|
+ // (voiced) stop consonant?
|
|
|
+ if((flags[index] & 2) != 0) {
|
|
|
+ // B*, D*, G*, GX
|
|
|
+
|
|
|
+ // move past silence
|
|
|
+ do {
|
|
|
+ // move ahead
|
|
|
+ X++;
|
|
|
+ index = phonemeindex[X];
|
|
|
+ } while(index == 0);
|
|
|
+
|
|
|
+ // check for end of buffer
|
|
|
+ if(index == 255) //buffer overflow
|
|
|
+ {
|
|
|
+ // ignore, overflow code
|
|
|
+ if((65 & 2) == 0) {
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ } else if((flags[index] & 2) == 0) {
|
|
|
+ // if another stop consonant, move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // RULE: <UNVOICED STOP CONSONANT> {optional silence} <STOP CONSONANT>
|
|
|
+
|
|
|
+ // X gets overwritten, so hold prior X value for debug statement
|
|
|
+ // int debugX = X;
|
|
|
+ // shorten the prior phoneme length to (length/2 + 1)
|
|
|
+ phonemeLength[X] = (phonemeLength[X] >> 1) + 1;
|
|
|
+ X = loopIndex;
|
|
|
+
|
|
|
+ // also shorten this phoneme length to (length/2 +1)
|
|
|
+ phonemeLength[loopIndex] = (phonemeLength[loopIndex] >> 1) + 1;
|
|
|
+
|
|
|
+ // move ahead
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+
|
|
|
+ // WH, R*, L*, W*, Y*, Q*, Z*, ZH, V*, DH, J*, **,
|
|
|
+
|
|
|
+ // RULE: <VOICED NON-VOWEL> <DIPHTONG>
|
|
|
+ // Decrease <DIPHTONG> by 2
|
|
|
+
|
|
|
+ // liquic consonant?
|
|
|
+ if((flags2[index] & 16) != 0) {
|
|
|
+ // R*, L*, W*, Y*
|
|
|
+
|
|
|
+ // get the prior phoneme
|
|
|
+ index = phonemeindex[X - 1];
|
|
|
+
|
|
|
+ // prior phoneme a stop consonant>
|
|
|
+ if((flags[index] & 2) != 0) {
|
|
|
+ // Rule: <LIQUID CONSONANT> <DIPHTONG>
|
|
|
+
|
|
|
+ // decrease the phoneme length by 2 frames (20 ms)
|
|
|
+ phonemeLength[X] -= 2;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // move to next phoneme
|
|
|
+ loopIndex++;
|
|
|
+ continue;
|
|
|
+ }
|
|
|
+ // goto pos48701;
|
|
|
+}
|
|
|
+
|
|
|
+// -------------------------------------------------------------------------
|
|
|
+// ML : Code47503 is division with remainder, and mem50 gets the sign
|
|
|
+void STM32SAM::Code47503(unsigned char mem52) {
|
|
|
+ Y = 0;
|
|
|
+ if((mem53 & 128) != 0) {
|
|
|
+ mem53 = -mem53;
|
|
|
+ Y = 128;
|
|
|
+ }
|
|
|
+ mem50 = Y;
|
|
|
+ A = 0;
|
|
|
+ for(X = 8; X > 0; X--) {
|
|
|
+ int temp = mem53;
|
|
|
+ mem53 = mem53 << 1;
|
|
|
+ A = A << 1;
|
|
|
+ if(temp >= 128) A++;
|
|
|
+ if(A >= mem52) {
|
|
|
+ A = A - mem52;
|
|
|
+ mem53++;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ mem51 = A;
|
|
|
+ if((mem50 & 128) != 0) mem53 = -mem53;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Reciter
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::Code37055(unsigned char mem59) {
|
|
|
+ X = mem59;
|
|
|
+ X--;
|
|
|
+ A = inputtemp[X];
|
|
|
+ Y = A;
|
|
|
+ A = tab36376[Y];
|
|
|
+ return;
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::Code37066(unsigned char mem58) {
|
|
|
+ X = mem58;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ Y = A;
|
|
|
+ A = tab36376[Y];
|
|
|
+}
|
|
|
+
|
|
|
+unsigned char STM32SAM::GetRuleByte(unsigned short mem62, unsigned char Y) {
|
|
|
+ unsigned int address = mem62;
|
|
|
+
|
|
|
+ if(mem62 >= 37541) {
|
|
|
+ address -= 37541;
|
|
|
+ return rules2[address + Y];
|
|
|
+ }
|
|
|
+ address -= 32000;
|
|
|
+ return rules[address + Y];
|
|
|
+}
|
|
|
+
|
|
|
+int STM32SAM::TextToPhonemes(unsigned char* input) // Code36484
|
|
|
+{
|
|
|
+ //unsigned char *tab39445 = &mem[39445]; //input and output
|
|
|
+ //unsigned char mem29;
|
|
|
+ unsigned char mem56; //output position for phonemes
|
|
|
+ unsigned char mem57;
|
|
|
+ unsigned char mem58;
|
|
|
+ unsigned char mem59;
|
|
|
+ unsigned char mem60;
|
|
|
+ unsigned char mem61;
|
|
|
+ unsigned short mem62; // memory position of current rule
|
|
|
+
|
|
|
+ unsigned char mem64; // position of '=' or current character
|
|
|
+ unsigned char mem65; // position of ')'
|
|
|
+ unsigned char mem66; // position of '('
|
|
|
+ unsigned char mem36653;
|
|
|
+
|
|
|
+ inputtemp[0] = 32;
|
|
|
+
|
|
|
+ // secure copy of input
|
|
|
+ // because input will be overwritten by phonemes
|
|
|
+ X = 1;
|
|
|
+ Y = 0;
|
|
|
+ do {
|
|
|
+ //pos36499:
|
|
|
+ A = input[Y] & 127;
|
|
|
+ if(A >= 112)
|
|
|
+ A = A & 95;
|
|
|
+ else if(A >= 96)
|
|
|
+ A = A & 79;
|
|
|
+
|
|
|
+ inputtemp[X] = A;
|
|
|
+ X++;
|
|
|
+ Y++;
|
|
|
+ } while(Y != 255);
|
|
|
+
|
|
|
+ X = 255;
|
|
|
+ inputtemp[X] = 27;
|
|
|
+ mem61 = 255;
|
|
|
+
|
|
|
+pos36550:
|
|
|
+ A = 255;
|
|
|
+ mem56 = 255;
|
|
|
+
|
|
|
+pos36554:
|
|
|
+ while(1) {
|
|
|
+ mem61++;
|
|
|
+ X = mem61;
|
|
|
+ A = inputtemp[X];
|
|
|
+ mem64 = A;
|
|
|
+ if(A == '[') {
|
|
|
+ mem56++;
|
|
|
+ X = mem56;
|
|
|
+ A = 155;
|
|
|
+ input[X] = 155;
|
|
|
+ //goto pos36542;
|
|
|
+ // Code39771(); //Code39777();
|
|
|
+ return 1;
|
|
|
+ }
|
|
|
+
|
|
|
+ //pos36579:
|
|
|
+ if(A != '.') break;
|
|
|
+ X++;
|
|
|
+ Y = inputtemp[X];
|
|
|
+ A = tab36376[Y] & 1;
|
|
|
+ if(A != 0) break;
|
|
|
+ mem56++;
|
|
|
+ X = mem56;
|
|
|
+ A = '.';
|
|
|
+ input[X] = '.';
|
|
|
+ } //while
|
|
|
+
|
|
|
+ //pos36607:
|
|
|
+ A = mem64;
|
|
|
+ Y = A;
|
|
|
+ A = tab36376[A];
|
|
|
+ mem57 = A;
|
|
|
+ if((A & 2) != 0) {
|
|
|
+ mem62 = 37541;
|
|
|
+ goto pos36700;
|
|
|
+ }
|
|
|
+
|
|
|
+ //pos36630:
|
|
|
+ A = mem57;
|
|
|
+ if(A != 0) goto pos36677;
|
|
|
+ A = 32;
|
|
|
+ inputtemp[X] = ' ';
|
|
|
+ mem56++;
|
|
|
+ X = mem56;
|
|
|
+ if(X > 120) goto pos36654;
|
|
|
+ input[X] = A;
|
|
|
+ goto pos36554;
|
|
|
+
|
|
|
+ // -----
|
|
|
+
|
|
|
+ //36653 is unknown. Contains position
|
|
|
+
|
|
|
+pos36654:
|
|
|
+ input[X] = 155;
|
|
|
+ A = mem61;
|
|
|
+ mem36653 = A;
|
|
|
+ // mem29 = A; // not used
|
|
|
+ // Code36538(); das ist eigentlich
|
|
|
+ return 1;
|
|
|
+ //Code39771();
|
|
|
+ //go on if there is more input ???
|
|
|
+ mem61 = mem36653;
|
|
|
+ goto pos36550;
|
|
|
+
|
|
|
+pos36677:
|
|
|
+ A = mem57 & 128;
|
|
|
+ if(A == 0) {
|
|
|
+ //36683: BRK
|
|
|
+ return 0;
|
|
|
+ }
|
|
|
+
|
|
|
+ // go to the right rules for this character.
|
|
|
+ X = mem64 - 'A';
|
|
|
+ mem62 = tab37489[X] | (tab37515[X] << 8);
|
|
|
+
|
|
|
+ // -------------------------------------
|
|
|
+ // go to next rule
|
|
|
+ // -------------------------------------
|
|
|
+
|
|
|
+pos36700:
|
|
|
+
|
|
|
+ // find next rule
|
|
|
+ Y = 0;
|
|
|
+ do {
|
|
|
+ mem62 += 1;
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ } while((A & 128) == 0);
|
|
|
+ Y++;
|
|
|
+
|
|
|
+ //pos36720:
|
|
|
+ // find '('
|
|
|
+ while(1) {
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ if(A == '(') break;
|
|
|
+ Y++;
|
|
|
+ }
|
|
|
+ mem66 = Y;
|
|
|
+
|
|
|
+ //pos36732:
|
|
|
+ // find ')'
|
|
|
+ do {
|
|
|
+ Y++;
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ } while(A != ')');
|
|
|
+ mem65 = Y;
|
|
|
+
|
|
|
+ //pos36741:
|
|
|
+ // find '='
|
|
|
+ do {
|
|
|
+ Y++;
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ A = A & 127;
|
|
|
+ } while(A != '=');
|
|
|
+ mem64 = Y;
|
|
|
+
|
|
|
+ X = mem61;
|
|
|
+ mem60 = X;
|
|
|
+
|
|
|
+ // compare the string within the bracket
|
|
|
+ Y = mem66;
|
|
|
+ Y++;
|
|
|
+ //pos36759:
|
|
|
+ while(1) {
|
|
|
+ mem57 = inputtemp[X];
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ if(A != mem57) goto pos36700;
|
|
|
+ Y++;
|
|
|
+ if(Y == mem65) break;
|
|
|
+ X++;
|
|
|
+ mem60 = X;
|
|
|
+ }
|
|
|
+
|
|
|
+ // the string in the bracket is correct
|
|
|
+
|
|
|
+ //pos36787:
|
|
|
+ A = mem61;
|
|
|
+ mem59 = mem61;
|
|
|
+
|
|
|
+pos36791:
|
|
|
+ while(1) {
|
|
|
+ mem66--;
|
|
|
+ Y = mem66;
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ mem57 = A;
|
|
|
+ //36800: BPL 36805
|
|
|
+ if((A & 128) != 0) goto pos37180;
|
|
|
+ X = A & 127;
|
|
|
+ A = tab36376[X] & 128;
|
|
|
+ if(A == 0) break;
|
|
|
+ X = mem59 - 1;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != mem57) goto pos36700;
|
|
|
+ mem59 = X;
|
|
|
+ }
|
|
|
+
|
|
|
+ //pos36833:
|
|
|
+ A = mem57;
|
|
|
+ if(A == ' ') goto pos36895;
|
|
|
+ if(A == '#') goto pos36910;
|
|
|
+ if(A == '.') goto pos36920;
|
|
|
+ if(A == '&') goto pos36935;
|
|
|
+ if(A == '@') goto pos36967;
|
|
|
+ if(A == '^') goto pos37004;
|
|
|
+ if(A == '+') goto pos37019;
|
|
|
+ if(A == ':') goto pos37040;
|
|
|
+ // Code42041(); //Error
|
|
|
+ //36894: BRK
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos36895:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 128;
|
|
|
+ if(A != 0) goto pos36700;
|
|
|
+pos36905:
|
|
|
+ mem59 = X;
|
|
|
+ goto pos36791;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos36910:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 64;
|
|
|
+ if(A != 0) goto pos36905;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos36920:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 8;
|
|
|
+ if(A == 0) goto pos36700;
|
|
|
+pos36930:
|
|
|
+ mem59 = X;
|
|
|
+ goto pos36791;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos36935:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 16;
|
|
|
+ if(A != 0) goto pos36930;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 72) goto pos36700;
|
|
|
+ X--;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if((A == 67) || (A == 83)) goto pos36930;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos36967:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 4;
|
|
|
+ if(A != 0) goto pos36930;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 72) goto pos36700;
|
|
|
+ if((A != 84) && (A != 67) && (A != 83)) goto pos36700;
|
|
|
+ mem59 = X;
|
|
|
+ goto pos36791;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37004:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 32;
|
|
|
+ if(A == 0) goto pos36700;
|
|
|
+
|
|
|
+pos37014:
|
|
|
+ mem59 = X;
|
|
|
+ goto pos36791;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37019:
|
|
|
+ X = mem59;
|
|
|
+ X--;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if((A == 'E') || (A == 'I') || (A == 'Y')) goto pos37014;
|
|
|
+ goto pos36700;
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37040:
|
|
|
+ Code37055(mem59);
|
|
|
+ A = A & 32;
|
|
|
+ if(A == 0) goto pos36791;
|
|
|
+ mem59 = X;
|
|
|
+ goto pos37040;
|
|
|
+
|
|
|
+ //---------------------------------------
|
|
|
+
|
|
|
+pos37077:
|
|
|
+ X = mem58 + 1;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 'E') goto pos37157;
|
|
|
+ X++;
|
|
|
+ Y = inputtemp[X];
|
|
|
+ X--;
|
|
|
+ A = tab36376[Y] & 128;
|
|
|
+ if(A == 0) goto pos37108;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 'R') goto pos37113;
|
|
|
+pos37108:
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+pos37113:
|
|
|
+ if((A == 83) || (A == 68)) goto pos37108; // 'S' 'D'
|
|
|
+ if(A != 76) goto pos37135; // 'L'
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 89) goto pos36700;
|
|
|
+ goto pos37108;
|
|
|
+
|
|
|
+pos37135:
|
|
|
+ if(A != 70) goto pos36700;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 85) goto pos36700;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A == 76) goto pos37108;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+pos37157:
|
|
|
+ if(A != 73) goto pos36700;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 78) goto pos36700;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A == 71) goto pos37108;
|
|
|
+ //pos37177:
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // -----------------------------------------
|
|
|
+
|
|
|
+pos37180:
|
|
|
+
|
|
|
+ A = mem60;
|
|
|
+ mem58 = A;
|
|
|
+
|
|
|
+pos37184:
|
|
|
+ Y = mem65 + 1;
|
|
|
+
|
|
|
+ //37187: CPY 64
|
|
|
+ // if(? != 0) goto pos37194;
|
|
|
+ if(Y == mem64) goto pos37455;
|
|
|
+ mem65 = Y;
|
|
|
+ //37196: LDA (62),y
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ mem57 = A;
|
|
|
+ X = A;
|
|
|
+ A = tab36376[X] & 128;
|
|
|
+ if(A == 0) goto pos37226;
|
|
|
+ X = mem58 + 1;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != mem57) goto pos36700;
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+pos37226:
|
|
|
+ A = mem57;
|
|
|
+ if(A == 32) goto pos37295; // ' '
|
|
|
+ if(A == 35) goto pos37310; // '#'
|
|
|
+ if(A == 46) goto pos37320; // '.'
|
|
|
+ if(A == 38) goto pos37335; // '&'
|
|
|
+ if(A == 64) goto pos37367; // ''
|
|
|
+ if(A == 94) goto pos37404; // ''
|
|
|
+ if(A == 43) goto pos37419; // '+'
|
|
|
+ if(A == 58) goto pos37440; // ':'
|
|
|
+ if(A == 37) goto pos37077; // '%'
|
|
|
+ //pos37291:
|
|
|
+ // Code42041(); //Error
|
|
|
+ //37294: BRK
|
|
|
+ return 0;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+pos37295:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 128;
|
|
|
+ if(A != 0) goto pos36700;
|
|
|
+pos37305:
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37310:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 64;
|
|
|
+ if(A != 0) goto pos37305;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37320:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 8;
|
|
|
+ if(A == 0) goto pos36700;
|
|
|
+
|
|
|
+pos37330:
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37335:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 16;
|
|
|
+ if(A != 0) goto pos37330;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 72) goto pos36700;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if((A == 67) || (A == 83)) goto pos37330;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37367:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 4;
|
|
|
+ if(A != 0) goto pos37330;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if(A != 72) goto pos36700;
|
|
|
+ if((A != 84) && (A != 67) && (A != 83)) goto pos36700;
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37404:
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 32;
|
|
|
+ if(A == 0) goto pos36700;
|
|
|
+pos37414:
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37184;
|
|
|
+
|
|
|
+ // --------------
|
|
|
+
|
|
|
+pos37419:
|
|
|
+ X = mem58;
|
|
|
+ X++;
|
|
|
+ A = inputtemp[X];
|
|
|
+ if((A == 69) || (A == 73) || (A == 89)) goto pos37414;
|
|
|
+ goto pos36700;
|
|
|
+
|
|
|
+ // ----------------------
|
|
|
+
|
|
|
+pos37440:
|
|
|
+
|
|
|
+ Code37066(mem58);
|
|
|
+ A = A & 32;
|
|
|
+ if(A == 0) goto pos37184;
|
|
|
+ mem58 = X;
|
|
|
+ goto pos37440;
|
|
|
+pos37455:
|
|
|
+ Y = mem64;
|
|
|
+ mem61 = mem60;
|
|
|
+
|
|
|
+pos37461:
|
|
|
+ //37461: LDA (62),y
|
|
|
+ A = GetRuleByte(mem62, Y);
|
|
|
+ mem57 = A;
|
|
|
+ A = A & 127;
|
|
|
+ if(A != '=') {
|
|
|
+ mem56++;
|
|
|
+ X = mem56;
|
|
|
+ input[X] = A;
|
|
|
+ }
|
|
|
+
|
|
|
+ //37478: BIT 57
|
|
|
+ //37480: BPL 37485 //not negative flag
|
|
|
+ if((mem57 & 128) == 0) goto pos37485; //???
|
|
|
+ goto pos36554;
|
|
|
+pos37485:
|
|
|
+ Y++;
|
|
|
+ goto pos37461;
|
|
|
+}
|
|
|
+
|
|
|
+// Constructor
|
|
|
+
|
|
|
+STM32SAM::STM32SAM(uint32_t STM32SAM_SPEED /* = 5 */) {
|
|
|
+ STM32SAM_SPEED = STM32SAM_SPEED & 0x1f; // limit it from 0 to 31
|
|
|
+
|
|
|
+ _STM32SAM_SPEED = STM32SAM_SPEED;
|
|
|
+
|
|
|
+ // set default voice
|
|
|
+
|
|
|
+ speed = 72;
|
|
|
+ pitch = 64;
|
|
|
+ mouth = 128;
|
|
|
+ throat = 128;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ wait1 = 7;
|
|
|
+ wait2 = 6;
|
|
|
+
|
|
|
+ mem59 = 0;
|
|
|
+
|
|
|
+ oldtimetableindex = 0;
|
|
|
+}
|
|
|
+
|
|
|
+STM32SAM::STM32SAM() {
|
|
|
+ _STM32SAM_SPEED = 7;
|
|
|
+
|
|
|
+ // set default voice
|
|
|
+
|
|
|
+ speed = 72;
|
|
|
+ pitch = 64;
|
|
|
+ mouth = 128;
|
|
|
+ throat = 128;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ wait1 = 7;
|
|
|
+ wait2 = 6;
|
|
|
+
|
|
|
+ mem59 = 0;
|
|
|
+
|
|
|
+ oldtimetableindex = 0;
|
|
|
+}
|
|
|
+
|
|
|
+/*
|
|
|
+ STM32SAM::~STM32SAM() {
|
|
|
+ {
|
|
|
+ // TODO: end();
|
|
|
+ }
|
|
|
+*/
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM sam (variable string, phonetic, sing, pitch, speed, mouth, throat)
|
|
|
+// STM32SAM say (sing off, phonetic off) (const string)
|
|
|
+// STM32SAM say (sing off, phonetic off) (variable string)
|
|
|
+// STM32SAM sing (sing on, phonetic off) (const string)
|
|
|
+// STM32SAM sing (sing on, phonetic off) (variable string)
|
|
|
+// STM32SAM sayPhonetic (sing off, phonetic on) (const string)
|
|
|
+// STM32SAM sayPhonetic (sing off, phonetic on) (variable string)
|
|
|
+// STM32SAM singPhonetic (sing on, phonetic on) (const string)
|
|
|
+// STM32SAM singPhonetic (sing on, phonetic on) (variable string)
|
|
|
+// STM32SAM voice (pitch, speed, mouth, throat)
|
|
|
+// STM32SAM setPitch (pitch)
|
|
|
+// STM32SAM setSpeed (speed)
|
|
|
+// STM32SAM setMouth (mouth)
|
|
|
+// STM32SAM setThroat (throat)
|
|
|
+//
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM sam (const string, phonetic, sing, pitch, speed, mouth, throat)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+char to_upper_case(char c) {
|
|
|
+ if(c >= 'a' && c <= 'z') {
|
|
|
+ return c - 'a' + 'A';
|
|
|
+ }
|
|
|
+ return c;
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::sam(
|
|
|
+ const char* argv,
|
|
|
+ unsigned char _phonetic,
|
|
|
+ unsigned char _singmode,
|
|
|
+ unsigned char _pitch,
|
|
|
+ unsigned char _speed,
|
|
|
+ unsigned char _mouth,
|
|
|
+ unsigned char _throat) {
|
|
|
+ phonetic = _phonetic;
|
|
|
+ singmode = _singmode;
|
|
|
+ pitch = _pitch;
|
|
|
+ speed = _speed;
|
|
|
+ mouth = _mouth;
|
|
|
+ throat = _throat;
|
|
|
+
|
|
|
+ int i;
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ for(i = 0; input[i] != 0; i++) {
|
|
|
+ if(i != 0) {
|
|
|
+ input[i] = to_upper_case((int)argv[i]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!phonetic) {
|
|
|
+ strncat(input, "[", 256);
|
|
|
+ if(!TextToPhonemes((unsigned char*)input)) {
|
|
|
+ // PrintUsage();
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ } else {
|
|
|
+ strncat(input, "\x9b", 256);
|
|
|
+ }
|
|
|
+
|
|
|
+ SetInput(input);
|
|
|
+
|
|
|
+ if(!SAMMain()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM sam (variable string, phonetic, sing, pitch, speed, mouth, throat)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::sam(
|
|
|
+ char* argv,
|
|
|
+ unsigned char _phonetic,
|
|
|
+ unsigned char _singmode,
|
|
|
+ unsigned char _pitch,
|
|
|
+ unsigned char _speed,
|
|
|
+ unsigned char _mouth,
|
|
|
+ unsigned char _throat) {
|
|
|
+ phonetic = _phonetic;
|
|
|
+ singmode = _singmode;
|
|
|
+ pitch = _pitch;
|
|
|
+ speed = _speed;
|
|
|
+ mouth = _mouth;
|
|
|
+ throat = _throat;
|
|
|
+
|
|
|
+ int i;
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ for(i = 0; input[i] != 0; i++) {
|
|
|
+ if(i != 0) {
|
|
|
+ input[i] = to_upper_case((int)argv[i]);
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ if(i < 256) {
|
|
|
+ input[i] = phonetic ? '\x9b' : '[';
|
|
|
+ }
|
|
|
+
|
|
|
+ if(!phonetic) {
|
|
|
+ if(!TextToPhonemes((unsigned char*)input)) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ SetInput(input);
|
|
|
+
|
|
|
+ if(!SAMMain()) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM say(sing off, phonetic off) (const string)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::say(const char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::say(char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM sing (sing on, phonetic off)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::sing(const char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 1;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::sing(char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 0;
|
|
|
+ singmode = 1;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM sayPhonetic (sing off, phonetic on)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::sayPhonetic(const char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 1;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::sayPhonetic(char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 1;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM singPhonetic (sing on, phonetic on)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::singPhonetic(const char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 1;
|
|
|
+ singmode = 1;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+void STM32SAM::singPhonetic(char* argv) {
|
|
|
+ int i;
|
|
|
+
|
|
|
+ phonetic = 1;
|
|
|
+ singmode = 0;
|
|
|
+
|
|
|
+ char const_input[256];
|
|
|
+
|
|
|
+ for(i = 0; i < 256; i++) {
|
|
|
+ const_input[i] = argv[i];
|
|
|
+ }
|
|
|
+
|
|
|
+ sam(const_input, phonetic, singmode, pitch, speed, mouth, throat);
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM voice (pitch, speed, mouth, throat)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::setVoice(
|
|
|
+ unsigned char _pitch /* = 64 */,
|
|
|
+ unsigned char _speed /* = 72 */,
|
|
|
+ unsigned char _mouth /* = 128 */,
|
|
|
+ unsigned char _throat /* = 128 */) {
|
|
|
+ pitch = _pitch;
|
|
|
+ speed = _speed;
|
|
|
+ mouth = _mouth;
|
|
|
+ throat = _throat;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM setPitch (pitch)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::setPitch(unsigned char _pitch /* = 64 */) {
|
|
|
+ pitch = _pitch;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM setSpeed (speed)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::setSpeed(unsigned char _speed /* = 72 */) {
|
|
|
+ speed = _speed;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM setMouth (mouth)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::setMouth(unsigned char _mouth /* = 128 */) {
|
|
|
+ mouth = _mouth;
|
|
|
+}
|
|
|
+
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// STM32SAM setThroat (throat)
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+void STM32SAM::setThroat(unsigned char _throat /* = 128 */) {
|
|
|
+ throat = _throat;
|
|
|
+}
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// Hardware
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
+// Hardware specifics, for easier porting to other microcontrollers
|
|
|
+
|
|
|
+//
|
|
|
+// Set PA8 pin as PWM, at 256 timer ticks overflow (8bit resolution)
|
|
|
+
|
|
|
+#include <math.h>
|
|
|
+#include <stm32wbxx_ll_tim.h>
|
|
|
+
|
|
|
+#define FURI_HAL_SPEAKER_TIMER TIM16
|
|
|
+#define FURI_HAL_SPEAKER_CHANNEL LL_TIM_CHANNEL_CH1
|
|
|
+
|
|
|
+void STM32SAM::begin(void) {
|
|
|
+#ifdef USE_ROGER_CORE
|
|
|
+
|
|
|
+ pinMode(PA8, PWM); // audio output pin
|
|
|
+
|
|
|
+ Timer1.setPeriod(
|
|
|
+ 4); // Can't set at 256 ticks, only in uS. First nearest uS is 4 (Roger core is only for bluepill, that means 72*4=288 ticks, or 128*4=512 ticks when overclocked. It's ok, just overall volume will be lower, because maximum volume will be 256/288 or 256/512)
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef USE_STM32duino_CORE
|
|
|
+ pinMode(PA8, OUTPUT);
|
|
|
+
|
|
|
+ PWM->pause();
|
|
|
+ PWM->setMode(1, TIMER_OUTPUT_COMPARE_PWM1, PA8); // TIM1 CH1 (PA8)
|
|
|
+ PWM->setPrescaleFactor(1);
|
|
|
+ PWM->setOverflow(256, TICK_FORMAT); // 256 ticks overflow, no matter the CPU (timer) speed
|
|
|
+ PWM->resume();
|
|
|
+
|
|
|
+#endif
|
|
|
+
|
|
|
+ LL_TIM_InitTypeDef TIM_InitStruct;
|
|
|
+ memset(&TIM_InitStruct, 0, sizeof(LL_TIM_InitTypeDef));
|
|
|
+ TIM_InitStruct.Prescaler = 4;
|
|
|
+ TIM_InitStruct.Autoreload = 255;
|
|
|
+ LL_TIM_Init(FURI_HAL_SPEAKER_TIMER, &TIM_InitStruct);
|
|
|
+
|
|
|
+ LL_TIM_OC_InitTypeDef TIM_OC_InitStruct;
|
|
|
+ memset(&TIM_OC_InitStruct, 0, sizeof(LL_TIM_OC_InitTypeDef));
|
|
|
+ TIM_OC_InitStruct.OCMode = LL_TIM_OCMODE_PWM1;
|
|
|
+ TIM_OC_InitStruct.OCState = LL_TIM_OCSTATE_ENABLE;
|
|
|
+ TIM_OC_InitStruct.CompareValue = 127;
|
|
|
+ LL_TIM_OC_Init(FURI_HAL_SPEAKER_TIMER, FURI_HAL_SPEAKER_CHANNEL, &TIM_OC_InitStruct);
|
|
|
+
|
|
|
+ LL_TIM_EnableAllOutputs(FURI_HAL_SPEAKER_TIMER);
|
|
|
+ LL_TIM_EnableCounter(FURI_HAL_SPEAKER_TIMER);
|
|
|
+} // begin
|
|
|
+
|
|
|
+inline void STM32SAM::SetAUDIO(unsigned char main_volume) {
|
|
|
+#ifdef USE_ROGER_CORE
|
|
|
+ Timer1.setCompare(TIMER_CH1, main_volume);
|
|
|
+#endif
|
|
|
+
|
|
|
+#ifdef USE_STM32duino_CORE
|
|
|
+ PWM->setCaptureCompare(1, main_volume, TICK_COMPARE_FORMAT);
|
|
|
+#endif
|
|
|
+
|
|
|
+ // if(main_volume > 64) {
|
|
|
+ // LL_TIM_OC_SetCompareCH1(FURI_HAL_SPEAKER_TIMER, 127);
|
|
|
+ // } else {
|
|
|
+ // LL_TIM_OC_SetCompareCH1(FURI_HAL_SPEAKER_TIMER, main_volume);
|
|
|
+ // }
|
|
|
+
|
|
|
+ float data = main_volume;
|
|
|
+ data /= 255.0f;
|
|
|
+ data -= 0.5f;
|
|
|
+ data *= 4.0f;
|
|
|
+ data = tanhf(data);
|
|
|
+
|
|
|
+ data += 0.5f;
|
|
|
+ data *= 255.0f;
|
|
|
+
|
|
|
+ if(data < 0) {
|
|
|
+ data = 0;
|
|
|
+ } else if(data > 255) {
|
|
|
+ data = 255;
|
|
|
+ }
|
|
|
+
|
|
|
+ LL_TIM_OC_SetCompareCH1(FURI_HAL_SPEAKER_TIMER, data);
|
|
|
+}
|
Willy-JL
