proper uecp

src/lua_api.c

@@ -162,18 +162,12 @@ BOOL_GETTER(tp)
 BOOL_SETTER(ta)
 BOOL_GETTER(ta)
 
-BOOL_SETTER(rt1_enabled)
-BOOL_GETTER(rt1_enabled)
-
-BOOL_SETTER(rt2_enabled)
-BOOL_GETTER(rt2_enabled)
+BOOL_SETTER(rt_enabled)
+BOOL_GETTER(rt_enabled)
 
 BOOL_SETTER(ptyn_enabled)
 BOOL_GETTER(ptyn_enabled)
 
-INT_SETTER(rt_type)
-INT_GETTER(rt_type)
-
 int lua_set_rds2_mode(lua_State *localL) {
 	enc->encoder_data.rds2_mode = luaL_checkinteger(localL, 1);
     return 0;
@@ -238,20 +232,6 @@ int lua_get_rds_writing_program(lua_State *localL) {
     return 1;
 }
 
-int lua_set_rds_rt_switching_period(lua_State *localL) {
-	enc->data[writing_program].rt_switching_period = luaL_checkinteger(localL, 1);
-	enc->state[writing_program].rt_switching_period_state = enc->data[writing_program].rt_switching_period;
-    return 0;
-}
-INT_GETTER(rt_switching_period)
-
-int lua_set_rds_rt_text_timeout(lua_State *localL) {
-	enc->data[writing_program].rt_text_timeout = luaL_checkinteger(localL, 1);
-	enc->state[writing_program].rt_text_timeout_state = enc->data[writing_program].rt_text_timeout;
-    return 0;
-}
-INT_GETTER(rt_text_timeout)
-
 int lua_put_rds_custom_group(lua_State *localL) {
 	enc->state[writing_program].custom_group[0] = 1;
 	enc->state[writing_program].custom_group[1] = luaL_checkinteger(localL, 1);
@@ -272,9 +252,7 @@ int lua_put_rds2_custom_group(lua_State *localL) {
 STR_SETTER(ptyn, set_rds_ptyn)
 STR_SETTER(ps, set_rds_ps)
 STR_SETTER(tps, set_rds_tps)
-STR_SETTER(rt1, set_rds_rt1)
-STR_SETTER(rt2, set_rds_rt2)
-STR_SETTER(default_rt, set_rds_default_rt)
+STR_SETTER(rt, set_rds_rt)
 
 STR_RAW_SETTER(lps, set_rds_lps)
 STR_RAW_GETTER(lps, LPS_LENGTH)
@@ -293,6 +271,11 @@ STR_RAW_GETTER(grp_sqc, 32)
 
 AF_SETTER(af_group0, af, RDSAFs, add_rds_af)
 
+int lua_toggle_rt_ab(lua_State *localL) {
+    TOGGLE(enc->state[writing_program].rt_ab);
+    return 0;
+}
+
 int lua_set_rds_eon(lua_State *localL) {
     int eon = luaL_checkinteger(localL, 1);
     if(eon >= EONs) return luaL_error(localL, "eon index exceeded");

src/lua_api.h

@@ -38,18 +38,12 @@ int lua_get_rds_tp(lua_State *localL);
 int lua_set_rds_ta(lua_State *localL);
 int lua_get_rds_ta(lua_State *localL);
 
-int lua_set_rds_rt1_enabled(lua_State *localL);
-int lua_get_rds_rt1_enabled(lua_State *localL);
-
-int lua_set_rds_rt2_enabled(lua_State *localL);
-int lua_get_rds_rt2_enabled(lua_State *localL);
+int lua_set_rds_rt_enabled(lua_State *localL);
+int lua_get_rds_rt_enabled(lua_State *localL);
 
 int lua_set_rds_ptyn_enabled(lua_State *localL);
 int lua_get_rds_ptyn_enabled(lua_State *localL);
 
-int lua_set_rds_rt_type(lua_State *localL);
-int lua_get_rds_rt_type(lua_State *localL);
-
 int lua_set_rds2_mode(lua_State *localL);
 int lua_get_rds2_mode(lua_State *localL);
 
@@ -71,26 +65,20 @@ int lua_get_rds_program(lua_State *localL);
 int lua_set_rds_writing_program(lua_State *localL);
 int lua_get_rds_writing_program(lua_State *localL);
 
-int lua_set_rds_rt_switching_period(lua_State *localL);
-int lua_get_rds_rt_switching_period(lua_State *localL);
-
-int lua_set_rds_rt_text_timeout(lua_State *localL);
-int lua_get_rds_rt_text_timeout(lua_State *localL);
-
 int lua_put_rds_custom_group(lua_State *localL);
 int lua_put_rds2_custom_group(lua_State *localL);
 
 int lua_set_rds_lps(lua_State *localL);
 int lua_get_rds_lps(lua_State *localL);
 int lua_set_rds_af_group0(lua_State *localL);
-int lua_set_rds_default_rt(lua_State *localL);
-int lua_set_rds_rt2(lua_State *localL);
-int lua_set_rds_rt1(lua_State *localL);
+int lua_set_rds_rt(lua_State *localL);
 int lua_set_rds_tps(lua_State *localL);
 int lua_set_rds_ps(lua_State *localL);
 int lua_set_rds_ptyn(lua_State *localL);
 int lua_set_rds_grp_sqc(lua_State *localL);
 
+int lua_toggle_rt_ab(lua_State *localL);
+
 int lua_set_rds_eon(lua_State *localL);
 int lua_get_rds_eon(lua_State *localL);
 int lua_set_rds_udg(lua_State *localL);

src/lua_rds.c

@@ -92,36 +92,23 @@ void init_lua(RDSEncoder* _enc) {
     lua_registertotable(L, "set_ta", lua_set_rds_ta);
     lua_registertotable(L, "get_ta", lua_get_rds_ta);
 
-    lua_registertotable(L, "set_rt1_enabled", lua_set_rds_rt1_enabled);
-    lua_registertotable(L, "get_rt1_enabled", lua_get_rds_rt1_enabled);
-
-    lua_registertotable(L, "set_rt2_enabled", lua_set_rds_rt2_enabled);
-    lua_registertotable(L, "get_rt2_enabled", lua_get_rds_rt2_enabled);
+    lua_registertotable(L, "set_rt_enabled", lua_set_rds_rt_enabled);
+    lua_registertotable(L, "get_rt_enabled", lua_get_rds_rt_enabled);
 
     lua_registertotable(L, "set_ptyn_enabled", lua_set_rds_ptyn_enabled);
     lua_registertotable(L, "get_ptyn_enabled", lua_get_rds_ptyn_enabled);
 
-    lua_registertotable(L, "set_rt_type", lua_set_rds_rt_type);
-    lua_registertotable(L, "get_rt_type", lua_get_rds_rt_type);
-
     lua_registertotable(L, "set_rds2_mode", lua_set_rds2_mode);
     lua_registertotable(L, "get_rds2_mode", lua_get_rds2_mode);
 
     lua_registertotable(L, "set_link", lua_set_rds_link);
     lua_registertotable(L, "get_link", lua_get_rds_link);
 
-    lua_registertotable(L, "set_rt_switching_period", lua_set_rds_rt_switching_period);
-    lua_registertotable(L, "get_rt_switching_period", lua_get_rds_rt_switching_period);
-
-    lua_registertotable(L, "set_rt_text_timeout", lua_set_rds_rt_text_timeout);
-    lua_registertotable(L, "get_rt_text_timeout", lua_get_rds_rt_text_timeout);
-
     lua_registertotable(L, "set_ptyn", lua_set_rds_ptyn);
     lua_registertotable(L, "set_ps", lua_set_rds_ps);
     lua_registertotable(L, "set_tps", lua_set_rds_tps);
-    lua_registertotable(L, "set_rt1", lua_set_rds_rt1);
-    lua_registertotable(L, "set_rt2", lua_set_rds_rt2);
-    lua_registertotable(L, "set_default_rt", lua_set_rds_default_rt);
+    lua_registertotable(L, "set_rt", lua_set_rds_rt);
+    lua_registertotable(L, "toggle_rt_ab", lua_toggle_rt_ab);
 
     lua_registertotable(L, "set_lps", lua_set_rds_lps);
     lua_registertotable(L, "get_lps", lua_get_rds_lps);
@@ -362,10 +349,29 @@ void lua_call_table(const char* function) {
 }
 
 void lua_call_tfunction_nolock(const char* name) {
-    char table_name[256];
-    lua_call_function_nolock(name);
-    snprintf(table_name, sizeof(table_name), "%ss", name);
-    lua_call_table_nolock(table_name);
+    lua_getglobal(L, "hooks");
+    lua_getfield(L, -1, name);
+
+    if (!lua_istable(L, -1)) {
+        lua_pop(L, 2);
+        return;
+    }
+
+    lua_Integer len = lua_rawlen(L, -1);
+    for (lua_Integer i = 1; i <= len; i++) {
+        lua_rawgeti(L, -1, i);
+        if (lua_isfunction(L, -1)) {
+            if (lua_pcall(L, 0, 0, 0) != LUA_OK) {
+                fprintf(stderr,
+                        "Lua error: %s at '%s[%lld]'\n",
+                        lua_tostring(L, -1),
+                        name,
+                        (long long)i);
+                lua_pop(L, 1);
+            }
+        } else lua_pop(L, 1);
+    }
+    lua_pop(L, 2); // pop table
 }
 
 void lua_call_tfunction(const char* name) {

src/rds.c

@@ -101,7 +101,7 @@ static uint8_t check_rds_good_group(RDSEncoder* enc, char* grp) {
 	uint8_t good_group = 0;
 	if(*grp == '0') good_group = 1;
 	if(*grp == '1' && (enc->data[enc->program].ecc != 0 || enc->data[enc->program].slc_data != 0)) good_group = 1;
-	if(*grp == '2' && (enc->data[enc->program].rt1_enabled || enc->data[enc->program].rt2_enabled)) good_group = 1;
+	if(*grp == '2' && enc->data[enc->program].rt_enabled) good_group = 1;
 	if(*grp == 'A' && enc->data[enc->program].ptyn_enabled) good_group = 1;
 	if(*grp == 'E') {
 		for (int i = 0; i < EONs; i++) {
@@ -133,28 +133,6 @@ void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
 
 	if(utc->tm_sec != enc->state[enc->program].last_second) {
 		enc->state[enc->program].last_second = utc->tm_sec;
-
-		if(enc->data[enc->program].rt1_enabled && enc->data[enc->program].current_rt == 0 && enc->state[enc->program].rt_text_timeout_state != 0) {
-			enc->state[enc->program].rt_text_timeout_state--;
-			if(enc->state[enc->program].rt_text_timeout_state == 0) {
-				enc->state[enc->program].rt_update = 1;
-				memset(enc->state[enc->program].rt_text, 0, RT_LENGTH);
-				memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].default_rt, RT_LENGTH);
-				enc->state[enc->program].rt_segments = enc->state[enc->program].default_rt_segments;
-			}
-		}
-		if(enc->data[enc->program].rt1_enabled && enc->data[enc->program].rt2_enabled && enc->state[enc->program].rt_switching_period_state != 0) {
-			enc->state[enc->program].rt_switching_period_state--;
-			if(enc->state[enc->program].rt_switching_period_state == 0) {
-				TOGGLE(enc->data[enc->program].current_rt);
-				memset(enc->state[enc->program].rt_text, 0, RT_LENGTH);
-				if (enc->data[enc->program].current_rt == 1) memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].rt2, RT_LENGTH);
-				else memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].rt1, RT_LENGTH);
-				enc->state[enc->program].rt_state = 0;
-				enc->state[enc->program].rt_switching_period_state = enc->data[enc->program].rt_switching_period;
-			}
-		}
-
 		lua_call_tfunction("tick");
 	}
 
@@ -327,10 +305,8 @@ void reset_rds_state(RDSEncoder* enc, uint8_t program) {
 	tempCoder.program = program;
 	memset(&tempCoder.state[program], 0, sizeof(RDSState));
 
-	tempCoder.state[program].rt_ab = 1;
 	tempCoder.state[program].ptyn_ab = 1;
-	set_rds_rt1(&tempCoder, enc->data[program].rt1, program);
-	set_rds_rt2(&tempCoder, enc->data[program].rt2, program);
+	set_rds_rt(&tempCoder, enc->data[program].rt, program);
 	set_rds_ps(&tempCoder, enc->data[program].ps, program);
 	set_rds_tps(&tempCoder, enc->data[program].tps, program);
 	set_rds_lps(&tempCoder, enc->data[program].lps, program);
@@ -360,13 +336,9 @@ void set_rds_defaults(RDSEncoder* enc, uint8_t program) {
 	enc->data[program].tp = 1;
 	enc->data[program].pi = 0xFFFF;
 	strcpy((char *)enc->data[program].ps, "* RDS * ");
-	enc->data[program].rt1_enabled = 1;
+	enc->data[program].rt_enabled = 1;
 
-	memset(enc->data[program].rt1, ' ', 64);
-	memset(enc->data[program].rt2, ' ', 64);
-	memset(enc->data[program].default_rt, ' ', 64);
-
-	enc->data[program].rt_type = 2;
+	memset(enc->data[program].rt, ' ', 64);
 
 	reset_rds_state(enc, program);
 }

src/rds.h

@@ -46,7 +46,7 @@ typedef struct {
 	uint16_t pi;
 
 	char ps[PS_LENGTH];
-	char rt1[RT_LENGTH];
+	char rt[RT_LENGTH];
 
 	uint8_t ecc;
 	uint16_t slc_data : 12;
@@ -58,14 +58,7 @@ typedef struct {
 
 	char tps[PS_LENGTH];
 
-	uint8_t rt1_enabled : 1;
-	uint8_t rt2_enabled : 1;
-	uint8_t rt_type : 2;
-	uint8_t rt_text_timeout;
-	uint8_t rt_switching_period;
-	uint8_t current_rt : 1;
-	char default_rt[RT_LENGTH];
-	char rt2[RT_LENGTH];
+	uint8_t rt_enabled : 1;
 
 	uint8_t ptyn_enabled : 1;
 	char ptyn[PTYN_LENGTH];
@@ -108,11 +101,8 @@ typedef struct {
 	char rt_text[RT_LENGTH];
 	uint8_t rt_state : 5;
 	uint8_t rt_update : 1;
-	uint8_t rt2_update : 1;
 	uint8_t rt_ab : 1;
 	uint8_t rt_segments : 5;
-	uint8_t rt2_segments : 5;
-	uint8_t default_rt_segments : 5;
 
 	char ptyn_text[PTYN_LENGTH];
 	uint8_t ptyn_state : 1;
@@ -127,9 +117,6 @@ typedef struct {
 	uint16_t custom_group[GROUP_LENGTH];
 	uint16_t custom_group2[GROUP_LENGTH + 1];
 
-	uint8_t rt_switching_period_state;
-	uint8_t rt_text_timeout_state;
-
 	uint8_t data_ecc : 1;
 	uint8_t grp_seq_idx[4];
 	uint8_t udg_idxs[2];
@@ -195,9 +182,7 @@ void add_checkwords(RDSGroup *group, uint8_t *bits);
 void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream);
 void get_rds_bits(RDSEncoder* enc, uint8_t *bits, uint8_t stream);
 
-void set_rds_rt1(RDSEncoder* enc, const char *rt1, uint8_t program);
-void set_rds_rt2(RDSEncoder* enc, const char *rt2, uint8_t program);
-void set_rds_default_rt(RDSEncoder* enc, const char *rt, uint8_t program);
+void set_rds_rt(RDSEncoder* enc, const char *rt, uint8_t program);
 void set_rds_ps(RDSEncoder* enc, const char *ps, uint8_t program);
 void set_rds_tps(RDSEncoder* enc, const char *tps, uint8_t program);
 void set_rds_lps(RDSEncoder* enc, const char *lps, uint8_t program);

src/rds_groups.c

@@ -87,44 +87,25 @@ void get_rds_fasttuning_group(RDSEncoder* enc, RDSGroup *group) {
 }
 
 void get_rds_rt_group(RDSEncoder* enc, RDSGroup *group) {
-	if (enc->state[enc->program].rt_update && enc->data[enc->program].rt1_enabled && enc->data[enc->program].current_rt == 0) {
-		memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].rt1, RT_LENGTH);
-		TOGGLE(enc->state[enc->program].rt_ab);
+	if (enc->state[enc->program].rt_update && enc->data[enc->program].rt_enabled) {
+		memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].rt, RT_LENGTH);
 		enc->state[enc->program].rt_update = 0;
 		enc->state[enc->program].rt_state = 0;
-		enc->data[enc->program].current_rt = 0;
-	}
-	if(enc->state[enc->program].rt2_update && enc->data[enc->program].rt2_enabled && enc->data[enc->program].current_rt) {
-		memcpy(enc->state[enc->program].rt_text, enc->data[enc->program].rt2, RT_LENGTH);
-		TOGGLE(enc->state[enc->program].rt_ab);
-		enc->state[enc->program].rt2_update = 0;
-		enc->state[enc->program].rt_state = 0;
-		enc->data[enc->program].current_rt = 1;
-	}
-
-	uint8_t ab = enc->state[enc->program].rt_ab;
-	switch (enc->data[enc->program].rt_type)
-	{
-	case 0:
-		ab = 0;
-		break;
-	case 1:
-		ab = (enc->data[enc->program].current_rt == 0) ? 0 : 1;
-		break;
-	default: break;
 	}
 
 	group->b |= 2 << 12;
-	group->b |= ab << 4;
+	group->b |= enc->state[enc->program].rt_ab << 4;
 	group->b |= enc->state[enc->program].rt_state;
-	group->c =  enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4    ] << 8;
+	group->c =  enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4] << 8;
 	group->c |= enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4 + 1];
 	group->d =  enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4 + 2] << 8;
 	group->d |= enc->state[enc->program].rt_text[enc->state[enc->program].rt_state * 4 + 3];
 
-	uint8_t segments = (enc->data[enc->program].current_rt == 1) ? enc->state[enc->program].rt2_segments : enc->state[enc->program].rt_segments;
 	enc->state[enc->program].rt_state++;
-	if (enc->state[enc->program].rt_state >= segments || enc->state[enc->program].rt_state >= 16) enc->state[enc->program].rt_state = 0;
+	if (enc->state[enc->program].rt_state >= enc->state[enc->program].rt_segments || enc->state[enc->program].rt_state >= 16) {
+		lua_call_tfunction("rt_transmission");
+		enc->state[enc->program].rt_state = 0;
+	}
 }
 
 void get_rdsp_ct_group(RDSGroup *group, time_t now) {

src/rds_setters.c

@@ -1,20 +1,18 @@
 #include "rds.h"
 
-void set_rds_rt1(RDSEncoder* enc, const char *rt1, uint8_t program) {
+void set_rds_rt(RDSEncoder* enc, const char *rt, uint8_t program) {
 	uint8_t i = 0, len = 0;
 
-	enc->state[program].rt_text_timeout_state = enc->data[program].rt_text_timeout;
-
 	enc->state[program].rt_update = 1;
 
-	memset(enc->data[program].rt1, ' ', RT_LENGTH);
-	while (*rt1 != 0 && len < RT_LENGTH) enc->data[program].rt1[len++] = *rt1++;
+	memset(enc->data[program].rt, ' ', RT_LENGTH);
+	while (*rt != 0 && len < RT_LENGTH) enc->data[program].rt[len++] = *rt++;
 
-	while (len > 0 && enc->data[program].rt1[len - 1] == ' ') len--;
+	while (len > 0 && enc->data[program].rt[len - 1] == ' ') len--;
 
 	if (len < RT_LENGTH) {
 		enc->state[program].rt_segments = 0;
-		enc->data[program].rt1[len++] = '\r';
+		enc->data[program].rt[len++] = '\r';
 		while (i < len) {
 			i += 4;
 			enc->state[program].rt_segments++;
@@ -23,46 +21,6 @@ void set_rds_rt1(RDSEncoder* enc, const char *rt1, uint8_t program) {
 	if(enc->state[program].rt_segments > 16) enc->state[program].rt_segments = 16; //make sure
 }
 
-void set_rds_default_rt(RDSEncoder* enc, const char *rt, uint8_t program) {
-	uint8_t i = 0, len = 0;
-
-	memset(enc->data[program].default_rt, ' ', RT_LENGTH);
-	while (*rt != 0 && len < RT_LENGTH) enc->data[program].default_rt[len++] = *rt++;
-
-	while (len > 0 && enc->data[program].default_rt[len - 1] == ' ') len--;
-
-	if (len < RT_LENGTH) {
-		enc->state[program].default_rt_segments = 0;
-		enc->data[program].default_rt[len++] = '\r';
-		while (i < len) {
-			i += 4;
-			enc->state[program].default_rt_segments++;
-		}
-	} else enc->state[program].default_rt_segments = 16;
-	if(enc->state[program].default_rt_segments > 16) enc->state[program].default_rt_segments = 16; //make sure
-}
-
-void set_rds_rt2(RDSEncoder* enc, const char *rt2, uint8_t program) {
-	uint8_t i = 0, len = 0;
-
-	enc->state[program].rt2_update = 1;
-
-	memset(enc->data[program].rt2, ' ', RT_LENGTH);
-	while (*rt2 != 0 && len < RT_LENGTH) enc->data[program].rt2[len++] = *rt2++;
-
-	while (len > 0 && enc->data[program].rt2[len - 1] == ' ') len--;
-
-	if (len < RT_LENGTH) {
-		enc->state[program].rt2_segments = 0;
-		enc->data[program].rt2[len++] = '\r';
-		while (i < len) {
-			i += 4;
-			enc->state[program].rt2_segments++;
-		}
-	} else enc->state[program].rt2_segments = 16;
-	if(enc->state[program].rt2_segments > 16) enc->state[program].rt2_segments = 16; //make sure
-}
-
 void set_rds_ps(RDSEncoder* enc, const char *ps, uint8_t program) {
 	uint8_t len = 0;
 
@@ -93,7 +51,7 @@ void set_rds_lps(RDSEncoder* enc, const char *lps, uint8_t program) {
 		return;
 	}
 	memset(enc->data[program].lps, ' ', LPS_LENGTH);
-	while (*lps != 0 && len < LPS_LENGTH) enc->data[program].lps[len++] = *lps++;
+	while (*lps != '\r' && *lps != 0 && len < LPS_LENGTH) enc->data[program].lps[len++] = *lps++;
 
 	if (len < LPS_LENGTH) {
 		enc->state[program].lps_segments = 0;