remove redundant functions, comments, correct function names, optimize the encoder a little bit

src/ascii_cmd.c

@@ -15,35 +15,35 @@ typedef struct {
 static void handle_ptyn(char *arg, RDSModulator* mod, char* output) {
 	arg[PTYN_LENGTH*2] = 0;
 	set_rds_ptyn(mod->enc, convert_to_rdscharset(arg));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_tps(char *arg, RDSModulator* mod, char* output) {
 	arg[PS_LENGTH*2] = 0;
 	set_rds_tps(mod->enc, convert_to_rdscharset(arg));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rt1(char *arg, RDSModulator* mod, char* output) {
 	arg[RT_LENGTH*2] = 0;
 	set_rds_rt1(mod->enc, convert_to_rdscharset(arg));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rt2(char *arg, RDSModulator* mod, char* output) {
 	arg[RT_LENGTH*2] = 0;
 	set_rds_rt2(mod->enc, convert_to_rdscharset(arg));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_pty(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].pty = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ecc(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].ecc = strtoul(arg, NULL, 16);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rtp(char *arg, RDSModulator* mod, char* output) {
@@ -51,8 +51,8 @@ static void handle_rtp(char *arg, RDSModulator* mod, char* output) {
 
 	if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
 		set_rds_rtplus_tags(mod->enc, tags);
-		strcpy(output, "+\0");
-	} else strcpy(output, "-\0");
+		strcpy(output, "+");
+	} else strcpy(output, "-");
 }
 
 static void handle_ertp(char *arg, RDSModulator* mod, char* output) {
@@ -60,8 +60,8 @@ static void handle_ertp(char *arg, RDSModulator* mod, char* output) {
 
 	if (sscanf(arg, "%hhu,%hhu,%hhu,%hhu,%hhu,%hhu", &tags[0], &tags[1], &tags[2], &tags[3], &tags[4], &tags[5]) == 6) {
 		set_rds_ertplus_tags(mod->enc, tags);
-		strcpy(output, "+\0");
-	} else strcpy(output, "-\0");
+		strcpy(output, "+");
+	} else strcpy(output, "-");
 }
 
 static void handle_link(char *arg, RDSModulator* mod, char* output) {
@@ -71,60 +71,60 @@ static void handle_link(char *arg, RDSModulator* mod, char* output) {
 	}
 
 	mod->enc->state[mod->enc->program].eon_linkage = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_lps(char *arg, RDSModulator* mod, char* output) {
 	arg[LPS_LENGTH*2] = 0;
 	set_rds_lps(mod->enc, arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ert(char *arg, RDSModulator* mod, char* output) {
 	arg[ERT_LENGTH*2] = 0;
 	set_rds_ert(mod->enc, arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ps(char *arg, RDSModulator* mod, char* output) {
 	arg[PS_LENGTH*2] = 0;
 	set_rds_ps(mod->enc, convert_to_rdscharset(arg));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ct(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].ct = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_dpty(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].dpty = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_slcd(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].slc_data = strtoul(arg, NULL, 16);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_tp(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].tp = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ta(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].ta = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_pi(char *arg, RDSModulator* mod, char* output) {
 	uint16_t pi_value = strtoul(arg, NULL, 16);
 	if ((pi_value & 0xF000) == 0) {
-		strcpy(output, "-\0");
+		strcpy(output, "-");
 		return;
 	}
 	mod->enc->data[mod->enc->program].pi = pi_value;
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_af(char *arg, RDSModulator* mod, char* output) {
@@ -153,12 +153,10 @@ static void handle_af(char *arg, RDSModulator* mod, char* output) {
 	af_iter = af;
 	memset(&new_af, 0, sizeof(RDSAFs));
 
-	while (arg_count-- != 0) {
-		add_rds_af(&new_af, *af_iter++);
-	}
+	while (arg_count-- != 0) add_rds_af(&new_af, *af_iter++);
 
 	memcpy(&(mod->enc->data[mod->enc->program].af), &new_af, sizeof(mod->enc->data[mod->enc->program].af));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_afo(char *arg, RDSModulator* mod, char* output) {
@@ -185,27 +183,24 @@ static void handle_afo(char *arg, RDSModulator* mod, char* output) {
 	af_iter = af;
 	memset(&new_af_oda, 0, sizeof(RDSAFsODA));
 
-	while (arg_count-- != 0) {
-		add_rds_af_oda(&new_af_oda, *af_iter++);
-	}
+	while (arg_count-- != 0) add_rds_af_oda(&new_af_oda, *af_iter++);
 
 	memcpy(&(mod->enc->data[mod->enc->program].af_oda), &new_af_oda, sizeof(mod->enc->data[mod->enc->program].af_oda));
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_adr(char *arg, RDSModulator* mod, char* output) {
 	uint16_t ids[2];
 	int count = sscanf(arg, "%4hu,%4hu", &ids[0], &ids[1]);
-	if(count == 1) {
-		mod->enc->encoder_data.encoder_addr[0] = ids[0];
-	} else if(count == 2) {
+	if(count == 1) mod->enc->encoder_data.encoder_addr[0] = ids[0];
+	else if(count == 2) {
 		mod->enc->encoder_data.encoder_addr[0] = ids[0];
 		mod->enc->encoder_data.encoder_addr[1] = ids[1];
 	} else {
-		strcpy(output, "-\0");
+		strcpy(output, "-");
 		return;
 	}
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_site(char *arg, RDSModulator* mod, char* output) {
@@ -217,10 +212,10 @@ static void handle_site(char *arg, RDSModulator* mod, char* output) {
 		mod->enc->encoder_data.site_addr[0] = ids[0];
 		mod->enc->encoder_data.site_addr[1] = ids[1];
 	} else {
-		strcpy(output, "-\0");
+		strcpy(output, "-");
 		return;
 	}
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_g(char *arg, RDSModulator* mod, char* output) {
@@ -231,56 +226,54 @@ static void handle_g(char *arg, RDSModulator* mod, char* output) {
 		mod->enc->state[mod->enc->program].custom_group[1] = blocks[0];
 		mod->enc->state[mod->enc->program].custom_group[2] = blocks[1];
 		mod->enc->state[mod->enc->program].custom_group[3] = blocks[2];
-		strcpy(output, "+\0");
+		strcpy(output, "+");
 	} else if(count == 4) {
 		mod->enc->state[mod->enc->program].custom_group2[0] = 1;
 		mod->enc->state[mod->enc->program].custom_group2[1] = blocks[0];
 		mod->enc->state[mod->enc->program].custom_group2[2] = blocks[1];
 		mod->enc->state[mod->enc->program].custom_group2[3] = blocks[2];
 		mod->enc->state[mod->enc->program].custom_group2[4] = blocks[3];
-		strcpy(output, "+\0");
-	} else {
-		strcpy(output, "-\0");
-	}
+		strcpy(output, "+");
+	} else strcpy(output, "-");
 }
 
 static void handle_rt1en(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].rt1_enabled = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rt2en(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].rt2_enabled = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rtper(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].rt_switching_period = atoi(arg);
 	mod->enc->state[mod->enc->program].rt_switching_period_state = mod->enc->data[mod->enc->program].rt_switching_period;
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_ptynen(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].ptyn_enabled = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
-static void handle_rtprun(char *arg, RDSModulator* mod, char* output) {
-	int flag1, flag2;
-	if (sscanf(arg, "%d,%d", &flag1, &flag2) == 2) {
-		set_rds_rtplus_flags(mod->enc, flag1);
-		if(flag2) mod->enc->rtpState[mod->enc->program][0].toggle ^= 1;
-	} else set_rds_rtplus_flags(mod->enc, atoi(arg));
-	strcpy(output, "+\0");
+static void handle_rtprun(char *arg, RDSModulator *mod, char *output) {
+	int flag1 = 0, flag2 = 0;
+	if (sscanf(arg, "%d,%d", &flag1, &flag2) < 1) flag1 = atoi(arg);
+	mod->enc->rtpData[mod->enc->program][0].enabled = (flag1 == 2);
+	mod->enc->rtpData[mod->enc->program][0].running = flag1 & 1;
+	if (flag2) mod->enc->rtpState[mod->enc->program][0].toggle ^= 1;
+	strcpy(output, "+");
 }
 
 static void handle_ertprun(char *arg, RDSModulator* mod, char* output) {
-	int flag1, flag2;
-	if (sscanf(arg, "%d,%d", &flag1, &flag2) == 2) {
-		set_rds_ertplus_flags(mod->enc, flag1);
-		if(flag2) mod->enc->rtpState[mod->enc->program][1].toggle ^= 1;
-	} else set_rds_ertplus_flags(mod->enc, atoi(arg));
-	strcpy(output, "+\0");
+	int flag1 = 0, flag2 = 0;
+	if (sscanf(arg, "%d,%d", &flag1, &flag2) < 1) flag1 = atoi(arg);
+	mod->enc->rtpData[mod->enc->program][1].enabled = (flag1 == 2);
+	mod->enc->rtpData[mod->enc->program][1].running = flag1 & 1;
+	if (flag2) mod->enc->rtpState[mod->enc->program][1].toggle ^= 1;
+	strcpy(output, "+");
 }
 
 static void handle_program(char *arg, RDSModulator* mod, char* output) {
@@ -294,12 +287,12 @@ static void handle_program(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->data[mod->enc->program].ta = 0;
 	mod->enc->data[(uint8_t)program].ta = 0;
 	mod->enc->program = (uint8_t)program;
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_rds2mod(char *arg, RDSModulator* mod, char* output) {
 	mod->enc->encoder_data.rds2_mode = atoi(arg);
-	strcpy(output, "+\0");
+	strcpy(output, "+");
 }
 
 static void handle_grpseq(char *arg, RDSModulator* mod, char* output) {
@@ -417,7 +410,7 @@ static void handle_init(char *arg, RDSModulator* mod, char* output) {
 static void handle_ver(char *arg, RDSModulator* mod, char* output) {
 	(void)arg;
 	(void)mod;
-	sprintf(output, "RDS95 v. %s - (C) 2025 radio95", VERSION);
+	sprintf(output, "rds95 v. %s - (C) 2025 radio95", VERSION);
 }
 
 static void handle_eonen(char *arg, char *pattern, RDSModulator* mod, char* output) {
@@ -620,9 +613,7 @@ void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output) {
 				break;
 			}
 		}
-		if(!reached) {
-			return;
-		}
+		if(!reached) return;
 	}
 	if(mod->enc->encoder_data.ascii_data.expected_site_addr != 0) {
 		uint8_t reached = 0;
@@ -632,9 +623,7 @@ void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output) {
 				break;
 			}
 		}
-		if(!reached) {
-			return;
-		}
+		if(!reached) return;
 	}
 
 	char *cmd, *arg;

src/ascii_cmd.h

@@ -4,6 +4,6 @@
 #include "lib.h"
 #define CMD_BUFFER_SIZE	255
 #define CTL_BUFFER_SIZE	(CMD_BUFFER_SIZE * 2)
-#define READ_TIMEOUT_MS	200
+#define READ_TIMEOUT_MS	225
 
 void process_ascii_cmd(RDSModulator* mod, char *str, char *cmd_output);

src/lib.c

@@ -14,7 +14,6 @@ int _strnlen(const char *s, int maxlen) {
 	return len;
 }
 
-// For RDS2 RFT, file error checking, and UECP
 uint16_t crc16_ccitt(char* data, uint16_t len) {
 	uint16_t i, crc=0xFFFF;
 	for (i=0; i < len; i++ ) {
@@ -27,7 +26,7 @@ uint16_t crc16_ccitt(char* data, uint16_t len) {
 	return ((crc ^= 0xFFFF) & 0xFFFF);
 }
 
-uint16_t get_block_grom_group(RDSGroup *group, uint8_t block) {
+uint16_t get_block_from_group(RDSGroup *group, uint8_t block) {
 	switch (block) {
 	case 0: return group->a;
 	case 1: return group->b;
@@ -53,7 +52,7 @@ void add_checkwords(RDSGroup *group, uint8_t *bits)
 		offset_word = offset_words[i];
 		if (i == 2 && group->is_type_b) offset_word = offset_words[4];
 
-		uint16_t block = get_block_grom_group(group, i);
+		uint16_t block = get_block_from_group(group, i);
 
 		uint16_t block_crc = 0;
 		uint8_t j, bit, msb;
@@ -65,9 +64,7 @@ void add_checkwords(RDSGroup *group, uint8_t *bits)
 			*bits++ = bit;
 		}
 		uint16_t check = block_crc ^ offset_word;
-		for (j = 0; j < POLY_DEG; j++) {
-			*bits++ = (check & ((1 << (POLY_DEG - 1)) >> j)) != 0;
-		}
+		for (j = 0; j < POLY_DEG; j++) *bits++ = (check & ((1 << (POLY_DEG - 1)) >> j)) != 0;
 	}
 }
 

src/lib.h

@@ -8,7 +8,7 @@ int _strnlen(const char *s, int maxlen);
 
 uint16_t crc16_ccitt(char *data, uint16_t len);
 
-uint16_t get_block_grom_group(RDSGroup *group, uint8_t block);
+uint16_t get_block_from_group(RDSGroup *group, uint8_t block);
 
 void add_checkwords(RDSGroup *group, uint8_t *bits);
 uint8_t add_rds_af_oda(RDSAFsODA *af_list, float freq);

src/rds.c

@@ -167,7 +167,6 @@ static void get_rds_ps_group(RDSEncoder* enc, RDSGroup *group) {
 
 static void get_rds_fasttuning_group(RDSEncoder* enc, RDSGroup *group) {
 	group->b |= 15 << 12;
-
 	group->b |= 1 << 11;
 	group->is_type_b = 1;
 
@@ -205,8 +204,7 @@ static void get_rds_rt_group(RDSEncoder* enc, RDSGroup *group) {
 	case 1:
 		ab = (enc->data[enc->program].current_rt == 0) ? 0 : 1;
 		break;
-	default:
-		break;
+	default: break;
 	}
 
 	group->b |= 2 << 12;
@@ -221,23 +219,20 @@ static void get_rds_rt_group(RDSEncoder* enc, RDSGroup *group) {
 	enc->state[enc->program].rt_state++;
 	if (enc->state[enc->program].rt_state == segments) enc->state[enc->program].rt_state = 0;
 }
-static void get_rds_rtp_oda_group(RDSEncoder* enc, RDSGroup *group) {
-	(void)enc;
+static void get_rdsp_rtp_oda_group(RDSGroup *group) {
 	group->b |= 3 << 12;
 	group->b |= 11 << 1;
 	group->d = ODA_AID_RTPLUS;
 }
 
-static void get_rds_ertp_oda_group(RDSEncoder* enc, RDSGroup *group) {
-	(void)enc;
+static void get_rdsp_ertp_oda_group(RDSGroup *group) {
 	group->b |= 3 << 12;
 
 	group->b |= 13 << 1;
 	group->d = ODA_AID_ERTPLUS;
 }
 
-static void get_rds_ert_oda_group(RDSEncoder* enc, RDSGroup *group) {
-	(void)enc;
+static void get_rdsp_ert_oda_group(RDSGroup *group) {
 	group->b |= 3 << 12;
 
 	group->b |= 12 << 1;
@@ -245,15 +240,14 @@ static void get_rds_ert_oda_group(RDSEncoder* enc, RDSGroup *group) {
 	group->d = ODA_AID_ERT;
 }
 
-static void get_oda_af_oda_group(RDSEncoder* enc, RDSGroup *group) {
-	(void)enc;
+static void get_rdsp_oda_af_oda_group( RDSGroup *group) {
 	group->b |= 3 << 12;
 
 	group->b |= 7 << 1;
 	group->d = ODA_AID_ODAAF;
 }
 
-static void get_oda_af_group(RDSEncoder* enc, RDSGroup *group) {
+static void get_rds_oda_af_group(RDSEncoder* enc, RDSGroup *group) {
 	uint16_t af[4];
 	get_next_af_oda(enc, af);
 
@@ -271,15 +265,12 @@ static void get_oda_af_group(RDSEncoder* enc, RDSGroup *group) {
 	group->d |= af[3] & 0xFF;
 }
 
-static void get_rds_ct_group(RDSEncoder* enc, RDSGroup *group) {
-	(void)enc;
+static void get_rdsp_ct_group(RDSGroup *group, time_t now) {
 	struct tm *utc, *local_time;
-	time_t now;
 	uint8_t l;
 	uint32_t mjd;
 	int16_t offset;
 
-	now = time(NULL);
 	utc = gmtime(&now);
 
 	l = utc->tm_mon <= 1 ? 1 : 0;
@@ -540,17 +531,17 @@ static void get_rds_sequence_group(RDSEncoder* enc, RDSGroup *group, char* grp,
 			break;
 		case 'R':
 			if(enc->state[enc->program].rtp_oda == 0) get_rds_rtplus_group(enc, group);
-			else get_rds_rtp_oda_group(enc, group);
+			else get_rdsp_rtp_oda_group(group);
 			enc->state[enc->program].rtp_oda ^= 1;
 			break;
 		case 'P':
 			if(enc->state[enc->program].ert_oda == 0) get_rds_ertplus_group(enc, group);
-			else get_rds_ertp_oda_group(enc, group);
+			else get_rdsp_ertp_oda_group(group);
 			enc->state[enc->program].ert_oda ^= 1;
 			break;
 		case 'S':
 			if(enc->state[enc->program].ert_oda == 0) get_rds_ert_group(enc, group);
-			else get_rds_ert_oda_group(enc, group);
+			else get_rdsp_ert_oda_group(group);
 			enc->state[enc->program].ert_oda ^= 1;
 			break;
 		case 'F':
@@ -560,8 +551,8 @@ static void get_rds_sequence_group(RDSEncoder* enc, RDSGroup *group, char* grp,
 			get_rds_fasttuning_group(enc, group);
 			break;
 		case 'U':
-			if(enc->state[enc->program].af_oda == 0) get_oda_af_group(enc, group);
-			else get_oda_af_oda_group(enc, group);
+			if(enc->state[enc->program].af_oda == 0) get_rds_oda_af_group(enc, group);
+			else get_rdsp_oda_af_oda_group(group);
 			enc->state[enc->program].af_oda ^= 1;
 			break;
 	}
@@ -606,6 +597,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
 
 	if (utc->tm_min != enc->state[enc->program].last_minute) {
 		enc->state[enc->program].last_minute = utc->tm_min;
+
 		uint8_t eon_has_ta = 0;
 		for (int i = 0; i < 4; i++) {
 			if (enc->data[enc->program].eon[i].enabled && enc->data[enc->program].eon[i].ta) {
@@ -644,7 +636,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
 		}
 
 		if(enc->data[enc->program].ct && stream == 0) {
-			get_rds_ct_group(enc, group);
+			get_rdsp_ct_group(group, now);
 			goto group_coded;
 		}
 	}
@@ -662,7 +654,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
 			group->b = enc->state[enc->program].last_stream0_group[0];
 			group->c = enc->state[enc->program].last_stream0_group[1];
 			group->d = enc->state[enc->program].last_stream0_group[2];
-			group->is_type_b = (group->a == 0 && IS_TYPE_B(group->b));
+			group->is_type_b = enc->state[enc->program].last_stream0_group_type_b;
 			goto group_coded_rds2;
 		} else if(enc->encoder_data.rds2_mode == 1) {
 			while(good_group == 0) {
@@ -677,6 +669,7 @@ static void get_rds_group(RDSEncoder* enc, RDSGroup *group, uint8_t stream) {
 
 				if(!good_group) cant_find_group++;
 				else cant_find_group = 0;
+				
 				if(!good_group && cant_find_group == 23) {
 					cant_find_group = 0;
 					break;
@@ -734,6 +727,7 @@ group_coded:
 	enc->state[enc->program].last_stream0_group[0] = group->b;
 	enc->state[enc->program].last_stream0_group[1] = group->c;
 	enc->state[enc->program].last_stream0_group[2] = group->d;
+	enc->state[enc->program].last_stream0_group_type_b = group->is_type_b;
 	return;
 }
 
@@ -910,16 +904,6 @@ void set_rds_ert(RDSEncoder* enc, char *ert) {
 	} else enc->state[enc->program].ert_segments = 32;
 }
 
-void set_rds_rtplus_flags(RDSEncoder* enc, uint8_t flags) {
-	enc->rtpData[enc->program][0].enabled = (flags==2);
-	enc->rtpData[enc->program][0].running = flags & 1;
-}
-
-void set_rds_ertplus_flags(RDSEncoder* enc, uint8_t flags) {
-	enc->rtpData[enc->program][1].enabled = (flags==2);
-	enc->rtpData[enc->program][1].running = flags & 1;
-}
-
 void set_rds_rtplus_tags(RDSEncoder* enc, uint8_t *tags) {
 	enc->rtpData[enc->program][0].type[0] = tags[0] & 0x3f;
 	enc->rtpData[enc->program][0].start[0] = tags[1] & 0x3f;

src/rds.h

@@ -173,6 +173,7 @@ typedef struct {
 	uint8_t eon_linkage : 1;
 
 	uint16_t last_stream0_group[3];
+	uint8_t last_stream0_group_type_b : 1;
 } RDSState;
 
 typedef struct {
@@ -242,14 +243,13 @@ void reset_rds_state(RDSEncoder* enc, uint8_t program);
 void set_rds_defaults(RDSEncoder* enc, uint8_t program);
 void init_rds_encoder(RDSEncoder* enc);
 void get_rds_bits(RDSEncoder* enc, uint8_t *bits, uint8_t stream);
+
 void set_rds_rt1(RDSEncoder* enc, char *rt1);
 void set_rds_rt2(RDSEncoder* enc, char *rt2);
 void set_rds_ps(RDSEncoder* enc, char *ps);
 void set_rds_tps(RDSEncoder* enc, char *tps);
 void set_rds_lps(RDSEncoder* enc, char *lps);
 void set_rds_ert(RDSEncoder *enc, char *ert);
-void set_rds_rtplus_flags(RDSEncoder *enc, uint8_t flags);
-void set_rds_ertplus_flags(RDSEncoder *enc, uint8_t flags);
 void set_rds_rtplus_tags(RDSEncoder *enc, uint8_t *tags);
 void set_rds_ertplus_tags(RDSEncoder *enc, uint8_t *tags);
 void set_rds_ptyn(RDSEncoder *enc, char *ptyn);