decoder/rds.c

   1 /*
   2  * Copyright (C) 2009, 2010 by Nils Faerber <nils.faerber@kernelconcepts.de>
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version
   7  * 2 of the License, or (at your option) any later version.
   8  *
   9  */
  10
  11 #include <stdio.h>
  12 #include <string.h>
  13 #include <stdlib.h>
  14 #include <time.h>
  15 #include <unistd.h>
  16 #include <sys/stat.h>
  17 #include <fcntl.h>
  18 #include <limits.h>
  19
  20 #include <sqlite3.h>
  21
  22 #include "rds.h"
  23 #include "rds_consts.h"
  24 #include "tmc.h"
  25
  26 //#define DEBUG 1
  27
  28
  29 static struct rds_info_s rds_info;
  30 static struct tm rds_time;
  31
  32 static struct _RDS_Private {
  33         void (*rds_PI_cb)(unsigned short PI, unsigned char ccode, unsigned char ptype, unsigned char pref, void *user_data);
  34         void *rds_PI_cb_data;
  35         void (*rds_sname_cb)(char *sname, void *user_data);
  36         void *rds_sname_cb_data;
  37         void (*rds_sinfo_cb)(unsigned char TP, unsigned char TA, unsigned char MS, unsigned char PTY, void *user_data);
  38         void *rds_sinfo_cb_data;
  39         void (*rds_radiotext_cb)(char *radio_text, void *user_data);
  40         void *rds_radiotext_cb_data;
  41         void (*rds_date_time_cb)(struct tm *dtime, void *user_data);
  42         void *rds_date_time_cb_data;
  43         void (*rds_afinfo_cb)(unsigned char cnt, double *AF, void *user_data);
  44         void *rds_afinfo_cb_data;
  45 } _rds_private;
  46
  47 void rds_init(void) {
  48         memset(&_rds_private, 0, sizeof(struct _RDS_Private));
  49 }
  50
  51 void rds_set_PI_cb(void (*rds_PI_cb)(unsigned short PI, unsigned char ccode, unsigned char ptype, unsigned char pref, void *user_data), void *user_data)
  52 {
  53         _rds_private.rds_PI_cb = rds_PI_cb;
  54         _rds_private.rds_PI_cb_data = user_data;
  55 }
  56
  57 void rds_set_sname_cb(void (*rds_sname_cb)(char *sname, void *user_data), void *user_data)
  58 {
  59         _rds_private.rds_sname_cb = rds_sname_cb;
  60         _rds_private.rds_sname_cb_data = user_data;
  61 }
  62
  63 void rds_set_sinfo_cb(void (*rds_sinfo_cb)(unsigned char TP, unsigned char TA, unsigned char MS, unsigned char PTY, void *user_data), void *user_data)
  64 {
  65         _rds_private.rds_sinfo_cb = rds_sinfo_cb;
  66         _rds_private.rds_sinfo_cb_data = user_data;
  67 }
  68
  69 void rds_set_afinfo_cb(void (*rds_afinfo_cb)(unsigned char cnt, double *AF, void *user_data), void *user_data)
  70 {
  71         _rds_private.rds_afinfo_cb = rds_afinfo_cb;
  72         _rds_private.rds_afinfo_cb_data = user_data;
  73 }
  74
  75 void rds_set_radiotext_cb(void (*rds_radiotext_cb)(char *radio_text, void *user_data), void *user_data)
  76 {
  77         _rds_private.rds_radiotext_cb = rds_radiotext_cb;
  78         _rds_private.rds_radiotext_cb_data = user_data;
  79 }
  80
  81 void rds_set_date_time_cb(void (*rds_date_time_cb)(struct tm *dtime, void *user_data), void *user_data)
  82 {
  83         _rds_private.rds_date_time_cb = rds_date_time_cb;
  84         _rds_private.rds_date_time_cb_data = user_data;
  85 }
  86
  87
  88 int rds_receive_group(int rds_fd, unsigned short *rdsgroup)
  89 {
  90 static unsigned char expected = 0;
  91 int rb;
  92 unsigned char rbuf[3];
  93 unsigned short block;
  94 unsigned char offset;
  95
  96         rb = read(rds_fd, rbuf, 3);
  97         if (rb <= 0)
  98                 exit(0); // just for testing
  99         if (rb != 3)
 100                 printf("#read err rb=%d\n", rb);
 101         block = rbuf[0] | (rbuf[1] << 8);
 102         offset = rbuf[2] & 0x07;
 103
 104         if (rbuf[2] & 0x80) {
 105                 if (OutputFlags & RDS_RECEIVE_INDICATOR)
 106                         printf("E");
 107         } else {
 108                 // printf("group block=0x%04x offs=0x%02x\n", block, offset);
 109                 if (offset != expected) {
 110                         if (OutputFlags & RDS_RECEIVE_INDICATOR)
 111                                 printf("block out of sync - resetting\n");
 112                         expected = 0;
 113                         memset(rdsgroup, 0, sizeof(rdsgroup));
 114                 } else {
 115                         rdsgroup[offset] = block;
 116                         expected++;
 117                         if (expected >= 4) {
 118                                 expected = 0;
 119                                 if (OutputFlags & RDS_RECEIVE_INDICATOR)
 120                                         printf(".\n");
 121                                 return 1;
 122                         }
 123                 }
 124         }
 125         if (OutputFlags & RDS_RECEIVE_INDICATOR)
 126                 printf(".");
 127         return 0;
 128 }
 129
 130
 131 enum RDSGroupType { GROUP_0A=0, GROUP_0B, GROUP_1A, GROUP_1B, GROUP_2A, GROUP_2B,
 132                     GROUP_3A, GROUP_3B, GROUP_4A, GROUP_4B, GROUP_5A, GROUP_5B,
 133                     GROUP_6A, GROUP_6B, GROUP_7A, GROUP_7B, GROUP_8A, GROUP_8B,
 134                     GROUP_9A, GROUP_9B, GROUP_10A, GROUP_10B, GROUP_11A, GROUP_11B,
 135                     GROUP_12A, GROUP_12B, GROUP_13A, GROUP_13B, GROUP_14A, GROUP_14B,
 136                     GROUP_15A, GROUP_15B, GROUP_UNKNOWN };
 137
 138 void rds_decode_group(unsigned short *rdsgroup)
 139 {
 140 static unsigned short ogrp[4];
 141 static unsigned char grp_decoded = 0;
 142 unsigned char grp_type = (rdsgroup[1] >> 11);
 143 unsigned char offs;
 144 static unsigned char otextAB = 0, newtext = 0;
 145 unsigned short PI = rdsgroup[0];
 146 unsigned char textAB = 0;
 147 int local_time_off = 0;
 148 int day_code = 0;
 149 int year_, mon_, K;
 150
 151         /* we want to wait for at least two identical group transmits */
 152         if (ogrp[0] != rdsgroup[0] || ogrp[1] != rdsgroup[1] || ogrp[2] != rdsgroup[2] || ogrp[3] != rdsgroup[3]) {
 153                 ogrp[0] = rdsgroup[0];
 154                 ogrp[1] = rdsgroup[1];
 155                 ogrp[2] = rdsgroup[2];
 156                 ogrp[3] = rdsgroup[3];
 157                 //printf("grp: 0x%04x 0x%04x 0x%04x 0x%04x\n", rdsgroup[0], rdsgroup[1], rdsgroup[2], rdsgroup[3]);
 158                 grp_decoded = 0;
 159                 return;
 160         }
 161         if (grp_decoded)
 162                 return;
 163
 164         if (rds_info.PI != PI) {
 165                 /* station change? */
 166                 memset(&rds_info, 0, sizeof(rds_info));
 167                 rds_info.LTN = -1;
 168                 memset(&rds_time, 0, sizeof(rds_time));
 169                 rds_info.ccode = (PI & 0xf000) >> 12;
 170                 rds_info.ptype = (PI & 0x0f00) >> 8;
 171                 rds_info.pref = (PI & 0x00ff);
 172                 if (rds_info.pref == 0) /* something is wrong here */
 173                         return;
 174                 rds_info.PI = rdsgroup[0];
 175                 if (_rds_private.rds_PI_cb != NULL)
 176                         _rds_private.rds_PI_cb(rds_info.PI, rds_info.ccode, rds_info.ptype, rds_info.pref, _rds_private.rds_PI_cb_data);
 177                 if (OutputFlags & RDS_OUTPUT_RDSINFO)
 178                         printf("PI=%d ccode=%X ptype=%X '%s' '%s' pref=%d\n", rds_info.PI, rds_info.ccode, rds_info.ptype, ptype_stext[rds_info.ptype], ptype_ltext[rds_info.ptype], rds_info.pref);
 179         }
 180
 181         switch (grp_type) {
 182                 case GROUP_0A: { /* basic switching and tuning */
 183                         unsigned char AFc1, AFc2;
 184                         float AF1=0, AF2=0;
 185
 186                         offs = (rdsgroup[1] & 0x03);
 187                         rds_info.sname[offs*2] = ((rdsgroup[3] & 0xff00) >> 8);
 188                         rds_info.sname[(offs*2)+1] = rdsgroup[3] & 0x00ff;
 189                         if (_rds_private.rds_sname_cb != NULL)
 190                                 _rds_private.rds_sname_cb(rds_info.sname, _rds_private.rds_sname_cb_data);
 191
 192                         rds_info.TA = (rdsgroup[1] & 0x10) >> 4;
 193                         rds_info.TP = (rdsgroup[1] & 0x400) >> 10;
 194                         rds_info.MS = (rdsgroup[1] & 0x08) >> 3;
 195                         rds_info.PTY = (rdsgroup[1] & 0x3e0) >> 5;
 196                         if (_rds_private.rds_sinfo_cb != NULL)
 197                                 _rds_private.rds_sinfo_cb(rds_info.TP, rds_info.TA, rds_info.MS, rds_info.PTY, _rds_private.rds_sinfo_cb_data);
 198
 199                         AFc1 = ((rdsgroup[2] & 0xff00) >> 8);
 200                         AFc2 = (rdsgroup[2] & 0x00ff);
 201                         if (AFc1 > 225 && AFc1 < 250) {
 202                                 if (OutputFlags & RDS_OUTPUT_STATION_ID)
 203                                         printf(" %d AFs follow:\n", AFc1-224);
 204                         } else if (AFc1 > 0 && AFc1 < 205)
 205                                 AF1 = (float)87.5 + ((float)AFc1 * .1);
 206                         else if (AFc1 == 205)
 207                                 printf(" filler- \n");
 208                         if (AFc2 > 0 && AFc2 < 205)
 209                                 AF2 = (float)87.5 + ((float)AFc2 * .1);
 210
 211                         if (OutputFlags & RDS_OUTPUT_STATION_ID)
 212                                 printf("sname = '%s' %s %s %s AF1=%3.2f AF2=%3.2f PTY='%s'\n",  rds_info.sname, rds_info.TP ? "TP" : "", rds_info.TA ? "TA" : "", rds_info.MS ? "M" : "S", AF1, AF2, PTY_text[rds_info.PTY]);
 213                         }
 214                         break;
 215                 case GROUP_0B:
 216                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 217                                 printf("group 0B\n");
 218                         break;
 219                 case GROUP_1A: { /* Programme Item Number and slow labelling codes */
 220                         unsigned char variant, day, hour, minute;
 221                         unsigned short tmc_id;
 222
 223                         variant = (rdsgroup[2] & (0x07 << 12)) >> 12;
 224                         day = (rdsgroup[3] & (0x1f << 11)) >> 11;
 225                         hour = (rdsgroup[3] & (0x1f << 6)) >> 6;
 226                         minute = (rdsgroup[3] & 0x3f);
 227                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 228                                 printf("1A var=%d day=%d %d:%d ", variant, day, hour, minute);
 229                         if (variant == 0) {
 230                                 rds_info.ECC = (rdsgroup[2] & 0xff);
 231                                 printf(" ccode=%d ECC=0x%02x '%s' ", rds_info.ccode, rds_info.ECC, ECC_text[((rds_info.ECC & 0x0f)*16)+(rds_info.ccode-1)]);
 232                         }
 233                         if (variant == 1) {
 234                                 tmc_id = (rdsgroup[2] & 0x0fff);
 235                                 printf(" TMC ID=0x%04x", tmc_id);
 236                         }
 237                         if (variant == 2) {
 238                                 printf(" Paging ID=0x%04x", (rdsgroup[2] & 0x0fff));
 239                         }
 240                         if (variant == 3) {
 241                                 rds_info.lang_code = (rdsgroup[2] & 0xff);
 242                                 printf(" language=0x%02x ", rds_info.lang_code);
 243                                 switch (rds_info.lang_code) {
 244                                         case 0x03:
 245                                                 printf("Catalan ");
 246                                                 break;
 247                                         case 0x08:
 248                                                 printf("German ");
 249                                                 break;
 250                                         case 0x0a:
 251                                                 printf("Spanish ");
 252                                                 break;
 253                                         case 0x15:
 254                                                 printf("Italian ");
 255                                                 break;
 256                                         case 0x18:
 257                                                 printf("Latvian ");
 258                                                 break;
 259                                         case 0x1d:
 260                                                 printf("Dutch ");
 261                                                 break;
 262                                         case 0x27:
 263                                                 printf("Finnish ");
 264                                                 break;
 265                                         default:
 266                                                 printf("unknown ");
 267                                                 break;
 268                                 };
 269                         }
 270                         if (variant == 7) {
 271                                 printf(" EWS Channel ID=0x%04x", (rdsgroup[2] & 0x0fff));
 272                         }
 273                         printf("\n");
 274                         } break;
 275                 case GROUP_1B:
 276                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 277                                 printf("group 1B\n");
 278                         break;
 279                 case GROUP_2A: /* 2A has 64 chars, 4 per group */
 280                 case GROUP_2B: /* 2B has 32 chars, 2 per group */
 281                         offs = (rdsgroup[1] & 0x0f);
 282                         textAB = (rdsgroup[1] & 0x10);
 283                         if (textAB != otextAB) {
 284                                 memset(rds_info.rtext, ' ', 64);
 285                                 rds_info.rtext[64] = '\0';
 286                         }
 287                         otextAB = textAB;
 288                         if (grp_type == GROUP_2A) {
 289                                 rds_info.rtext[offs*4] = ((rdsgroup[2] & 0xff00) >> 8);
 290                                 rds_info.rtext[(offs*4)+1] = (rdsgroup[2] & 0x00ff);
 291                                 rds_info.rtext[(offs*4)+2] = ((rdsgroup[3] & 0xff00) >> 8);
 292                                 rds_info.rtext[(offs*4)+3] = (rdsgroup[3] & 0x00ff);
 293                         } else {
 294                                 rds_info.rtext[offs*2] = ((rdsgroup[3] & 0xff00) >> 8);
 295                                 rds_info.rtext[(offs*2)+1] = (rdsgroup[3] & 0x00ff);
 296                         }
 297                         if (offs == 0) /* new text always starts at 0 */
 298                                 newtext = 1;
 299                         if ((offs == 15)) { /* all parts received */
 300                                 if (newtext == 1) {
 301                                         if (_rds_private.rds_radiotext_cb != NULL)
 302                                                 _rds_private.rds_radiotext_cb(rds_info.rtext, _rds_private.rds_radiotext_cb_data);
 303                                         if (OutputFlags & RDS_OUTPUT_RADIO_TEXT)
 304                                                 printf("RT '%s'\n", rds_info.rtext);
 305                                         newtext = 0;
 306                                 }
 307                         }
 308                         break;
 309                 case GROUP_3A: /* ODA - TMC alarm, */
 310                         rds_info.AID = rdsgroup[3];
 311                         /* TMC AID */
 312                         if (rds_info.AID == 0xcd46 || rds_info.AID == 0x0d45) {
 313                                 if ((rdsgroup[2] & 0xc000) == 0) {
 314                                         rds_info.LTN = (rdsgroup[2] & 0x0fc0) >> 6;
 315                                         rds_info.AFI = (rdsgroup[2] & 0x0020) >> 5;
 316                                         rds_info.M = (rdsgroup[2] & 0x0010) >> 4;
 317                                         rds_info.I = (rdsgroup[2] & 0x0008) >> 3;
 318                                         rds_info.N = (rdsgroup[2] & 0x0004) >> 2;
 319                                         rds_info.R = (rdsgroup[2] & 0x0002) >> 1;
 320                                         rds_info.U = (rdsgroup[2] & 0x0001);
 321                                 }
 322                                 if (rdsgroup[2] & 0x4000) {
 323                                         /* SID */
 324                                         if (rds_info.M) {
 325                                                 rds_info.G = (rdsgroup[2] & 0x3000) >> 12;
 326                                                 rds_info.Ta = (rdsgroup[2] & 0x0030) >> 4;
 327                                                 rds_info.Tw = (rdsgroup[2] & 0x000c) >> 2;
 328                                                 rds_info.Td = (rdsgroup[2] & 0x0003);
 329                                         } else {
 330                                         }
 331                                 }
 332                                 if (OutputFlags & RDS_OUTPUT_RDSINFO) {
 333                                         printf("AID = 0x%04x\n", rds_info.AID);
 334                                         printf("LTN ID = %d (0x%02x)\n", rds_info.LTN, rds_info.LTN);
 335                                         printf("Traffic information: ");
 336                                         if (rds_info.I)
 337                                                 printf("international ");
 338                                         if (rds_info.N)
 339                                                 printf("national ");
 340                                         if (rds_info.R)
 341                                                 printf("regional ");
 342                                         if (rds_info.U)
 343                                                 printf("urban ");
 344                                         printf("\n");
 345                                 }
 346                         } else if (rds_info.AID == 0x4bd7) {
 347                                 if (OutputFlags & RDS_OUTPUT_RDSINFO) {
 348                                         printf("RT+\nG2 = 0x%04x\n", rdsgroup[2]);
 349                                         printf("template = 0x%02x\n", (rdsgroup[2] & 0x00ff));
 350                                         printf("SCB = 0x%02x\n", (rdsgroup[2] & 0x0f00)>>8);
 351                                         printf("CB = 0x%02x\n", (rdsgroup[2] & 0x1000)>>12);
 352                                         printf("rfu = 0x%02x\n", (rdsgroup[2] & 0xe000)>>13);
 353                                 }
 354                         } else {
 355                                 printf("3A AID=0x%04x\n", rds_info.AID);
 356                         }
 357                         break;
 358                 case GROUP_3B:
 359                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 360                                 printf("group 3B\n");
 361                         break;
 362                 case GROUP_4A:
 363                         //printf("group 4A - time/date\n");
 364                         rds_time.tm_sec = 0; // date/time message is sent at 00 secs +/- .2sec
 365                         rds_time.tm_min = ((rdsgroup[3] & (0x3f << 6)) >> 6);
 366                         rds_time.tm_hour = ((rdsgroup[3] & (0x0f << 12)) >> 12) | ((rdsgroup[2] & 0x01) << 4);
 367                         local_time_off = (rdsgroup[3] & 0x0f) * ((rdsgroup[3] & 0x10) ? -1 : 1);
 368                         rds_time.tm_hour += local_time_off / 2;
 369                         rds_time.tm_min = (rds_time.tm_min + ((local_time_off % 2) * 30)) % 60;
 370
 371                         day_code = (((rdsgroup[2] & 0xfffe) >> 1) | ((rdsgroup[1] & 0x03) << 15)) /*+ local_time_off*/;
 372
 373                         year_ = ((float)day_code - 15078.2) / 365.25;
 374                         mon_ = ((day_code - 14956.1) - (int)(year_ * 365.25)) / 30.6001;
 375                         rds_time.tm_mday = day_code - 14956 - (int)(year_ * 365.25) - (int)(mon_ * 30.6001);
 376                         if (mon_ == 14 || mon_ == 15)
 377                                 K = 1;
 378                         else
 379                                 K = 0;
 380                         rds_time.tm_year = year_ + K;
 381                         rds_time.tm_mon = mon_ - 1 - (K * 12) - 1;
 382
 383                         rds_time.tm_isdst = -1;
 384
 385                         if (_rds_private.rds_date_time_cb != NULL)
 386                                 _rds_private.rds_date_time_cb(&rds_time, _rds_private.rds_date_time_cb_data);
 387
 388                         if (OutputFlags & RDS_OUTPUT_DATETIME)
 389                                 printf("%s", asctime(&rds_time));
 390 #ifdef DEBUG
 391                         printf("%d:%02d - local time offset = %d, %s (dcode = %d)\n", rds_time.tm_hour, rds_time.tm_min, local_time_off, asctime(&rds_time), day_code);
 392 #endif
 393                         //printf("day=%d month=%d year=%d\n", day, mon, year);
 394                         break;
 395                 case GROUP_4B:
 396                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 397                                 printf("GRP4B\n");
 398                         break;
 399                 case GROUP_5A:
 400                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 401                                 printf("GRP5A\n");
 402                         break;
 403                 case GROUP_5B:
 404                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 405                                 printf("GRP5B\n");
 406                         break;
 407                 case GROUP_6A:
 408                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 409                                 printf("GRP6A\n");
 410                         break;
 411                 case GROUP_6B:
 412                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 413                                 printf("GRP6B\n");
 414                         break;
 415                 case GROUP_7A:
 416                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 417                                 printf("GRP7A\n");
 418                         break;
 419                 case GROUP_7B:
 420                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 421                                 printf("GRP7B\n");
 422                         break;
 423                 case GROUP_8A:
 424                         if (rds_info.LTN != 0) // non TMCpro
 425                                 decode_tmc(rdsgroup);
 426                         if (rds_info.LTN == 0)
 427                                 printf("TMCpro\n");
 428                         break;
 429                 case GROUP_8B:
 430                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 431                                 printf("GRP8B\n");
 432                         break;
 433                 case GROUP_9A:
 434                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 435                                 printf("GRP9A\n");
 436                         break;
 437                 case GROUP_9B:
 438                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 439                                 printf("GRP9B\n");
 440                         break;
 441                 case GROUP_10A:
 442                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 443                                 printf("GRP10A\n");
 444                         break;
 445                 case GROUP_10B:
 446                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 447                                 printf("GRP10B\n");
 448                         break;
 449                 case GROUP_11A: /* Open Data Application ODA */
 450                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 451                                 printf("GRP11A ODA: #1=0x%02x #2=0x%04x #3=0x%04x\n", rdsgroup[1] & 0x1f, rdsgroup[2], rdsgroup[3]);
 452
 453                         /* we previously got an RT+ identifier, try RT+ decoding */
 454                         if (rds_info.AID == 0x4bd7) {
 455                                 printf("RT+\ntoggle: %s\n", (rdsgroup[1] & 0x10) ? "yes" : "no");
 456                                 printf("item running   : %s\n", (rdsgroup[1] & 0x08) ? "yes" : "no");
 457                                 printf("content type 1 : %d\n", (rdsgroup[1] & 0x07) << 3 | (rdsgroup[2] & 0x0e00) >> 13);
 458                                 printf("start marker 1 : %d\n", (rdsgroup[2] & 0x1f80) >> 7);
 459                                 printf("length marker 1: %d\n", (rdsgroup[2] & 0x007e) >> 1);
 460                                 printf("content type 2 : %d\n", (rdsgroup[1] & 0x01) << 4);
 461                                 printf("start marker 2 : %d\n", (rdsgroup[2] & 0x07e0) >> 5);
 462                                 printf("length marker 2: %d\n", (rdsgroup[2] & 0x001f));
 463                         }
 464                         break;
 465                 case GROUP_11B: /* Open Data Application ODA */
 466                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 467                                 printf("GRP11B\n");
 468                         printf("11B ODA: #1=0x%02x PI=0x%04x #3=0x%04x\n", rdsgroup[1] & 0x1f, rdsgroup[2], rdsgroup[3]);
 469                         break;
 470                 case GROUP_12A: /* Open Data Application ODA */
 471                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 472                                 printf("GRP12A\n");
 473                         break;
 474                 case GROUP_12B: /* Open Data Application ODA */
 475                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 476                                 printf("GRP12B\n");
 477                         break;
 478                 case GROUP_13A: /* Open Data Application ODA or paging */
 479                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 480                                 printf("GRP13A\n");
 481                         break;
 482                 case GROUP_13B: /* Open Data Application ODA */
 483                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 484                                 printf("GRP13B\n");
 485                         break;
 486                 case GROUP_14A: /* EON */ {
 487                         unsigned char variant = rdsgroup[1] & 0x0f;
 488                         unsigned char AFc1=0, AFc2=0;
 489                         float AF1=0, AF2=0;
 490                         unsigned short PI;
 491
 492                         rds_info.PTY = (rdsgroup[1] & 0x3e0) >> 5;
 493                         rds_info.TPTN = (rdsgroup[1] & 0x400) >> 10;
 494                         rds_info.TPON = (rdsgroup[1] & 0x10) >> 4;
 495                         PI = rdsgroup[3];
 496
 497                         if (variant <= 3) { // PS
 498                                 rds_info.PS[variant*2] = ((rdsgroup[2] & 0xff00) >> 8);
 499                                 rds_info.PS[(variant*2)+1] = (rdsgroup[2] & 0x00ff);
 500                         } else if (variant == 4) {
 501                                 printf("EON variant 4\n");
 502                         } else  if (variant >= 5 && variant <= 8) { // AF - alternate frequency
 503                                 AFc1 = ((rdsgroup[2] & 0xff00) >> 8);
 504                                 AFc2 = (rdsgroup[2] & 0x00ff);
 505                                 if (AFc1 > 0 && AFc1 < 205)
 506                                         AF1 = (float)87.5 + ((float)AFc1 * .1);
 507                                 else if (AFc1 >= 225 && AFc1 <= 249)
 508                                         AF1 = AFc1 - 224;
 509                                 if (AFc2 > 0 && AFc2 < 205)
 510                                         AF2 = (float)87.5 + ((float)AFc2 * .1);
 511                                 else if (AFc2 >= 225 && AFc2 <= 249)
 512                                         AF2 = AFc2 - 224;
 513                         }
 514                         if (OutputFlags & RDS_OUTPUT_EON) {
 515                                 printf("EON var=0x%01x PTY=%d ('%s') PS='%s' AF1=%3.2f (%d) AF2=%3.2f (%d) PI=%d\n", variant, rds_info.PTY, PTY_text[rds_info.PTY], rds_info.PS, AF1, AFc1, AF2, AFc2, PI);
 516                         }
 517                         } break;
 518                 case GROUP_14B: /* Enhanced Other Networks information */
 519                         if (OutputFlags & RDS_OUTPUT_EON)
 520                                 printf("GRP14B: Enhanced Other Networks information\n");
 521                         break;
 522                 case GROUP_15A:
 523                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 524                                 printf("GRP15A\n");
 525                         break;
 526                 case GROUP_15B: /* Fast basic tuning and switching information */
 527                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 528                                 printf("GRP15B: Fast basic tuning and switching information\n");
 529                         break;
 530                 default:
 531                         if (OutputFlags & RDS_OUTPUT_UNKNGRP)
 532                                 printf("unkn. RDS group %d\n", grp_type);
 533                         break;
 534         }
 535
 536         /* done with this group */
 537         grp_decoded = 1;
 538 }
 539