Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-07-01 22:08:55 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
b019ba47474bc854d8fbf400ed1a117864803c41
Momentum-Firmware/applications/plugins/sam/stm32_sam.cpp
T
RogueMaster 3380d5c1c1 sam
2022-10-16 19:43:50 -04:00

5704 lines
172 KiB
C++
Raw Blame History

#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(!phonetic) {
strncat(input, "[", 256);
if(!TextToPhonemes((unsigned char*)input)) {
// PrintUsage();
return;
}
} else {
strncat(input, "\x9b", 256);
}
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);
}
Reference in New Issue View Git Blame Copy Permalink