BRNSystems/audiocodec
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity
Files
master
audiocodec/main.c
Bruno Rybársky 98d971d92d thing
2026-07-20 23:18:26 +02:00

606 lines
19 KiB
C
Raw Permalink Blame History

#include <stdint.h>
#include <stdio.h>
#include <time.h>
#include <SDL2/SDL.h>
#include "font.h"
#include "decoder.h"
#include "goertzel.h"
#include "texteditor.h"
//The window we'll be rendering to
SDL_Window *window = NULL;
volatile bool running = true;
//The surface contained by the window
SDL_Renderer *renderer = NULL;
#define SCREEN_WIDTH 1280
#define SCREEN_HEIGHT 720
const int targetFPS = 60;
const int delayNeeded = 1000 / targetFPS;
SDL_Texture *cpuStateTexture;
int selectedModemSetting = 0;
#define biggerFont fonts[0]
#define smallFont fonts[1]
#define smallerFont fonts[2]
#define fontCount 3
BitmapFont fonts[fontCount];
static const char *tx_state_name(TxState state) {
switch (state) {
case TX_IDLE: return "IDLE";
case TX_PREAMBLE: return "PREAMBLE";
case TX_PACKET: return "PACKET";
case TX_END: return "END";
}
return "?";
}
static const char *rx_state_name(RxState state) {
switch (state) {
case RX_SEARCH: return "SEARCH";
case RX_SYNC: return "SYNC";
case RX_MAGIC: return "MAGIC";
case RX_DATA: return "DATA";
}
return "?";
}
static const char *setting_name(int setting) {
switch (setting) {
case 0: return "DATA START";
case 1: return "DATA END";
case 2: return "SPACING";
case 3: return "SYMBOL";
case 4: return "CLOCK0";
case 5: return "CLOCK1";
case 6: return "OUT DEVICE";
case 7: return "IN DEVICE";
default: return "UNKNOWN";
}
}
static void apply_modem_settings(void) {
SDL_LockAudioDevice(dev);
SDL_LockAudioDevice(inputDev);
stopEncoder(&encoder);
encoder.clock0 = goertzel_bin_freq(
encoder.clock0,
SAMPLE_RATE,
encoder.symbolSamples);
encoder.clock1 = goertzel_bin_freq(
encoder.clock1,
SAMPLE_RATE,
encoder.symbolSamples);
decoder.startFreq = encoder.startFreq;
decoder.endFreq = encoder.endFreq;
decoder.dataSpacing = encoder.dataSpacing;
decoder.symbolSamples = encoder.symbolSamples;
decoder.clock0 = encoder.clock0;
decoder.clock1 = encoder.clock1;
decoder_rebuild_tones(&decoder);
SDL_UnlockAudioDevice(inputDev);
SDL_UnlockAudioDevice(dev);
}
static void adjust_modem_setting(int delta) {
switch (selectedModemSetting) {
case 0:
if ((int)encoder.startFreq + delta * 50 >= 200)
encoder.startFreq += delta * 50;
break;
case 1:
if ((int)encoder.endFreq + delta * 50 >= 200)
encoder.endFreq += delta * 50;
break;
case 2:
if ((int)encoder.dataSpacing + delta * 5 >= 25)
encoder.dataSpacing += delta * 5;
break;
case 3:
if ((int)encoder.symbolSamples + delta * 48 >= 240)
encoder.symbolSamples += delta * 48;
break;
case 4:
if ((int)encoder.clock0 + delta * 50 >= 500)
encoder.clock0 += delta * 50;
break;
case 5:
if ((int)encoder.clock1 + delta * 50 >= 500)
encoder.clock1 += delta * 50;
break;
case 6:
case 7:
// Device selection handled separately
break;
}
apply_modem_settings();
}
static void render_modem_text(SDL_Renderer *renderer) {
char line[256];
// TX info on the left
snprintf(
line,
sizeof(line),
"TX %-8s BYTE %u/%u BIT %u PRE %u SYNC %u",
tx_state_name(encoder.state),
encoder.byteIndex,
encoder.bufferSize,
encoder.bitIndex,
encoder.preambleSymbols,
encoder.syncIndex);
renderText(renderer, smallerFont, line, 10, 8);
// RX info on the right
snprintf(
line,
sizeof(line),
"RX %-8s BYTES %u LAST %02X BESTSYNC %d/4 PHASE %d",
rx_state_name(decoder.rxState),
decoder.bufferSize,
decoder.lastDecodedByte,
decoder.bestSyncScore,
decoder.bestSyncPhase);
renderText(renderer, smallerFont, line, 640, 8);
// Clock info below RX
snprintf(
line,
sizeof(line),
"CLK E0 %08.5f E1 %08.5f R %02.1f HIST %02X/%u",
decoder.clockEnergy0,
decoder.clockEnergy1,
decoder.clockRatio,
decoder.clockHistory,
decoder.clockCount);
renderText(renderer, smallerFont, line, 640, 22);
// Settings display with highlighting
const char *settingStr = setting_name(selectedModemSetting);
snprintf(
line,
sizeof(line),
">> %s START %u END %u SPACE %u SYM %u CLK %u/%u [F8 SELECT] [+/- CHANGE]",
settingStr,
encoder.startFreq,
encoder.endFreq,
encoder.dataSpacing,
encoder.symbolSamples,
encoder.clock0,
encoder.clock1);
// Highlight the settings line with a colored background
SDL_Rect settingsBG = {5, 48, 1270, 14};
SDL_SetRenderDrawColor(renderer, 64, 80, 96, 128);
SDL_RenderFillRect(renderer, &settingsBG);
renderText(renderer, smallerFont, line, 10, 50);
}
static void render_tone_bars(SDL_Renderer *renderer) {
const int dataTones = MAX_FSK_TONES;
const int tones = dataTones + 2; // clocks are indices 0,1
const int x = 500;
const int y = 650;
const int maxHeight = 192;
const int barWidth = 8;
const int gap = 4;
SDL_SetRenderDrawColor(renderer, 64, 64, 64, 255);
SDL_Rect frame = {x - 4, y - maxHeight - 4, tones * (barWidth + gap) + 4, maxHeight + 24};
SDL_RenderDrawRect(renderer, &frame);
// Draw clocks first (indices 0 and 1)
for (int i = 0; i < tones; i++) {
int idx;
if (i < 2) idx = i; // clock indices 0,1
else idx = 2 + (i - 2); // data indices start at 2
float ratio = 0.0f;
if (decoder.maxEnergy > 0.0f)
ratio = decoder.energies[idx] / decoder.maxEnergy;
if (ratio > 1.0f)
ratio = 1.0f;
SDL_Rect barRect;
barRect.w = barWidth;
barRect.h = (int)(ratio * maxHeight);
barRect.x = x + i * (barWidth + gap);
barRect.y = y - barRect.h;
if (idx < 2)
SDL_SetRenderDrawColor(renderer, 255, 192, 64, 255); // clock
else if ((idx - 2) & 1)
SDL_SetRenderDrawColor(renderer, 80, 180, 255, 255); // 1-tone
else
SDL_SetRenderDrawColor(renderer, 80, 255, 140, 255); // 0-tone
SDL_RenderFillRect(renderer, &barRect);
}
char label[128];
snprintf(label, sizeof(label), "TONE ENERGY: CLOCK0, CLOCK1, BIT0..BIT15");
renderText(renderer, smallerFont, label, x, y + 6);
}
int render() {
SDL_SetRenderDrawColor(renderer, 32, 32, 32, 255);
SDL_RenderClear(renderer);
SDL_Rect rect2;
rect2.x = 100;
rect2.y = 46;
rect2.w = 0;
rect2.h = 0;
if (cpuStateTexture) {
SDL_QueryTexture(cpuStateTexture, NULL, NULL, &rect2.w, &rect2.h);
SDL_RenderCopy(renderer, cpuStateTexture, NULL, &rect2);
}
render_modem_text(renderer);
render_tone_bars(renderer);
for (int i = 0; i < editorCount; i++) {
editor_render(&editors[i], renderer, &encoder, i, activeEditorIndex == i, cursorShown);
}
frames++;
if (!(frames % 60)) {
cursorShown = !cursorShown;
}
SDL_RenderPresent(renderer);
return 0;
}
int init() {
//Initialize SDL
SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, NULL);
SDL_SetHint(SDL_HINT_VIDEO_HIGHDPI_DISABLED, "1");
SDL_SetHint(SDL_HINT_RENDER_DRIVER, "opengl");
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) < 0) {
printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
return 1;
}
//Initialize SDL_ttf
if (TTF_Init() == -1) {
printf("SDL_ttf could not initialize! SDL_ttf Error: %s\n", TTF_GetError());
return 1;
}
//Create window
window = SDL_CreateWindow("RISC-B simulator", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH,
SCREEN_HEIGHT, SDL_WINDOW_SHOWN | SDL_WINDOW_RESIZABLE);
if (window == NULL) {
printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
return 1;
}
//Get window surface
renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
if (renderer == NULL) {
printf("Renderer could not be created SDL_Error: %s\n", SDL_GetError());
return 1;
}
// Create OpenGL context
SDL_GLContext glContext = SDL_GL_CreateContext(window);
if (!glContext) {
fprintf(stderr, "SDL_GL_CreateContext failed: %s\n", SDL_GetError());
exit(1);
}
// Use OpenGL context
SDL_GL_MakeCurrent(window, glContext); // Make sure OpenGL context is current before any OpenGL rendering
SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
biggerFont = prepText(renderer, 16, "PublicPixel.ttf", 255, 255, 255, 255);
smallFont = prepText(renderer, 12, "PublicPixel.ttf", 255, 255, 255, 255);
smallerFont = prepText(renderer, 8, "PublicPixel.ttf", 255, 255, 255, 255);
init_editor(&transmitEditor, &smallFont, 10, 80, renderer, 35, 1000, 28, false);
init_editor(&receivedEditor, &smallFont, 500, 80, renderer, 35, 1000, 28, false);
initAudioEncoder();
initAudioDecoder(renderer);
strcpy(encoder.buffer, "Hello there\nThis is just a test message\n");
encoder.bufferSize = strlen(encoder.buffer);
updateDump(&transmitEditor, renderer);
// Auto-start encoder for testing
//startEncoder(&encoder);
SDL_Rect viewport = {0, 0, SCREEN_WIDTH, SCREEN_HEIGHT};
SDL_RenderSetViewport(renderer, &viewport);
SDL_RenderSetLogicalSize(renderer, SCREEN_WIDTH, SCREEN_HEIGHT);
return 0;
}
int processEvent(SDL_Event e) {
if (e.type == SDL_QUIT) { return 0; }
else if (e.type == SDL_WINDOWEVENT && e.window.event == SDL_WINDOWEVENT_RESIZED) {
int newWidth = e.window.data1;
int newHeight = e.window.data2;
for (int editorIndex = 0; editorIndex < editorCount; editorIndex++) {
generate_string_display(&editors[editorIndex], renderer);
}
//updateState(true);
// Adjust the viewport to match the new window size;
SDL_Rect viewport = {0, 0, newWidth, newHeight};
SDL_RenderSetViewport(renderer, &viewport);
} else if (e.type == SDL_KEYDOWN) {
int keySym = ConvertKPToNonKP(e.key.keysym.sym);
int keyMod = e.key.keysym.mod;
cursorShown = true;
bool moved = false;
switch (keySym) {
case SDLK_UP:
move_cursor_relative(&activeEditor, -1, 0, false, renderer);
if (keyMod & KMOD_CTRL) {
encoder.byteIndex--;
}
moved = true;
break;
case SDLK_PAGEUP:
move_cursor_relative(&activeEditor, -activeEditor.displayLineCount, -1, true, renderer);
moved = true;
break;
case SDLK_DOWN:
move_cursor_relative(&activeEditor, 1, 0, false, renderer);
if (keyMod & KMOD_CTRL) {
encoder.byteIndex++;
}
moved = true;
break;
case SDLK_PAGEDOWN:
move_cursor_relative(&activeEditor, activeEditor.displayLineCount, 0, true, renderer);
moved = true;
break;
case SDLK_LEFT:
move_cursor_relative(&activeEditor, 0, -1, false, renderer);
moved = true;
break;
case SDLK_HOME:
if (keyMod & KMOD_CTRL) {
move_cursor(&activeEditor, 0, 0, false, renderer);
moved = true;
break;
}
move_cursor(&activeEditor, activeEditor.cursor_line, 0, false, renderer);
moved = true;
break;
case SDLK_RIGHT:
move_cursor_relative(&activeEditor, 0, 1, false, renderer);
moved = true;
break;
case SDLK_END:
int lineLen = strlen(activeEditor.lines[activeEditor.cursor_line].text);
if (keyMod & KMOD_CTRL) {
move_cursor(&activeEditor, activeEditor.maxLines - 1, lineLen, false, renderer);
moved = true;
break;
}
move_cursor(&activeEditor, activeEditor.cursor_line, lineLen, false, renderer);
moved = true;
break;
case SDLK_d:
if (keyMod & KMOD_CTRL && !activeEditor.readOnly) {
insert_line_rel(&activeEditor, renderer);
memset(activeEditor.lines[activeEditor.cursor_line].text, 0, activeEditor.max_line_width);
strcpy(activeEditor.lines[activeEditor.cursor_line].text,
activeEditor.lines[activeEditor.cursor_line - 1].text);
activeEditor.lines[activeEditor.cursor_line].active = 1;
move_cursor_relative(&activeEditor, 0, activeEditor.max_line_width, false, renderer);
generate_string_display(&activeEditor, renderer);
}
break;
case SDLK_ESCAPE:
stopEncoder(&encoder);
break;
case SDLK_s:
if (keyMod & KMOD_CTRL) {
FILE *fptr;
char fname[20];
snprintf(fname, sizeof(fname), "data%lu.bin", time(NULL));
fptr = fopen(fname, "wb");
unsigned int sizeBuffer = sizeof(encoder.buffer);
if (encoder.bufferSize < sizeBuffer) {
sizeBuffer = encoder.bufferSize;
}
fwrite(encoder.buffer, sizeBuffer, 1, fptr);
fclose(fptr);
return 1;
}
break;
case SDLK_l:
if (keyMod & KMOD_CTRL) {
FILE *fptr;
char fname[20];
sscanf(editors[0].lines[editors[0].cursor_line].text, "%s", fname);
fptr = fopen(fname, "rb");
if (fptr) {
memset(encoder.buffer, 0, sizeof(encoder.buffer));
encoder.bufferSize = fread(
encoder.buffer,
1,
sizeof(encoder.buffer),
fptr);
fclose(fptr);
updateDump(&transmitEditor, renderer);
}
return 1;
}
break;
case SDLK_BACKSPACE:
if (!activeEditor.readOnly) {
remove_character(&activeEditor, false, renderer);
moved = true;
}
break;
case SDLK_DELETE:
if (keyMod & KMOD_CTRL) {
memset(encoder.buffer, 0, sizeof(encoder.buffer));
encoder.bufferSize = 0;
updateDump(&transmitEditor, renderer);
} else if (keyMod & KMOD_ALT) {
memset(decoder.buffer, 0, sizeof(decoder.buffer));
decoder.bufferSize = 0;
updateDump(&receivedEditor, renderer);
} else {
if (!activeEditor.readOnly) {
remove_character(&activeEditor, true, renderer);
moved = true;
}
}
break;
case SDLK_RETURN:
break;
case SDLK_F5:
updateDump(&transmitEditor, renderer);
updateDump(&receivedEditor, renderer);
break;
case SDLK_F7:
startEncoder(&encoder);
break;
case SDLK_F8:
selectedModemSetting++;
if (selectedModemSetting >= 8)
selectedModemSetting = 0;
break;
case SDLK_PLUS:
case SDLK_EQUALS:
adjust_modem_setting(1);
break;
case SDLK_MINUS:
adjust_modem_setting(-1);
break;
case SDLK_INSERT:
activeEditor.overwrite = !activeEditor.overwrite;
break;
case SDLK_RETURN2:
if (!activeEditor.readOnly) {
insert_line_rel(&activeEditor, renderer);
moved = true;
}
break;
case SDLK_TAB:
activeEditorIndex++;
if (activeEditorIndex >= editorCount) {
activeEditorIndex = 0;
}
activeEditor = editors[activeEditorIndex];
break;
default:
break;
}
} else if (e.type == SDL_TEXTINPUT) {
for (int i = 0; e.text.text[i] != '\0'; i++) { // Iterate over the input string
char keySym = e.text.text[i];
if (!activeEditor.readOnly && activeEditor.cursor_pos <= activeEditor.max_line_width) {
if (keySym >= 32 && keySym <= 126) { // Printable ASCII range
if (keySym > 0x60 && keySym < 0x7b) { // Convert lowercase to uppercase
keySym -= 0x20;
}
if (activeEditor.cursor_pos < activeEditor.max_line_width) {
insert_character(&activeEditor, keySym, renderer);
}
}
}
}
} else if (e.type == SDL_MOUSEBUTTONDOWN) {
SDL_Rect viewport;
SDL_RenderGetViewport(renderer, &viewport);
SDL_Rect mouset;
mouset.w = 1;
mouset.h = 1;
SDL_GetMouseState(&mouset.x, &mouset.y);
// Translate mouse coordinates to viewport space
SDL_Rect mouse;
mouse.w = 1;
mouse.h = 1;
mouse.x = ((mouset.x - viewport.x) * SCREEN_WIDTH) / viewport.w;
mouse.y = (mouset.y - viewport.y) * SCREEN_HEIGHT / viewport.h;
}
return 1;
}
int main(void) {
int status = init();
if (status) {
return status;
}
//Hack to get window to stay up
SDL_Event e;
Uint64 start;
Uint64 end;
while (running) {
start = SDL_GetTicks64();
while (SDL_PollEvent(&e)) {
running = processEvent(e);
}
updateDump(&receivedEditor, decoder.renderer);
status = render();
if (status) {
return status;
}
end = SDL_GetTicks64();
const unsigned long timeNeeded = end - start;
if (timeNeeded < delayNeeded) {
SDL_Delay(delayNeeded - timeNeeded);
}
}
for (uint8_t i = 0; i < editorCount; i++) {
destroy_editor(&editors[i]);
}
for (uint8_t i = 0; i < fontCount; i++) {
destroyFont(&fonts[i]);
}
puts(SDL_GetError());
if (cpuStateTexture) SDL_DestroyTexture(cpuStateTexture);
if (renderer) SDL_DestroyRenderer(renderer);
if (window) SDL_DestroyWindow(window);
SDL_Quit();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink