RDSParser Class Reference

#include <rdsparser.h>

Public Types
typedef std::map< unsigned int, std::string >	psns_map_t
typedef std::pair< unsigned int, std::string >	psns_map_kv_t
typedef std::map< unsigned int, std::set< double > >	freqs_map_t
typedef std::pair< unsigned int, std::set< double > >	freqs_map_kv_t
typedef std::set< double >	freqs_set_t

Public Member Functions
	RDSParser ()
	~RDSParser ()
void	parseGroup (unsigned int *group)
void	clearAllFields ()
void	clearUpdateFlags ()

Public Attributes
bool	m_pi_updated
unsigned int	m_pi_count
unsigned int	m_pi_program_identification
unsigned char	m_pi_program_type
bool	m_pi_traffic_program
int	m_pi_country_identification
int	m_pi_area_coverage_index
bool	m_g0_updated
bool	m_g0_af_updated
unsigned int	m_g0_count
char	m_g0_program_service_name [8+1]
unsigned char	m_g0_psn_bitmap
bool	m_g0_traffic_announcement
bool	m_g0_music_speech
bool	m_g0_mono_stereo
bool	m_g0_artificial_head
bool	m_g0_compressed
bool	m_g0_static_pty
std::set< double >	m_g0_alt_freq
bool	m_g1_updated
unsigned int	m_g1_count
int	m_g1_country_page_index
	negative if not received More...
int	m_g1_country_index
	negative if not received More...
int	m_g1_language_index
	negative if not received More...
unsigned int	m_g1_pin_day
unsigned int	m_g1_pin_hour
unsigned int	m_g1_pin_minute
bool	m_g2_updated
unsigned int	m_g2_count
char	m_g2_radiotext [64+1]
bool	m_g3_updated
unsigned int	m_g3_count
bool	m_g3_groupB
unsigned int	m_g3_appGroup
unsigned int	m_g3_message
unsigned int	m_g3_aid
bool	m_g4_updated
unsigned int	m_g4_count
unsigned int	m_g4_hours
unsigned int	m_g4_minutes
unsigned int	m_g4_seconds
unsigned int	m_g4_year
unsigned int	m_g4_month
unsigned int	m_g4_day
double	m_g4_local_time_offset
bool	m_g5_updated
bool	m_g6_updated
bool	m_g7_updated
unsigned int	m_g5_count
unsigned int	m_g6_count
unsigned int	m_g7_count
bool	m_g8_updated
unsigned int	m_g8_count
bool	m_g8_diversion_recommended
unsigned int	m_g8_dp_ci
bool	m_g8_sign
unsigned int	m_g8_extent
unsigned int	m_g8_event
unsigned int	m_g8_location
int	m_g8_label_index
	negative if not received More...
int	m_g8_content
bool	m_g9_updated
unsigned int	m_g9_count
unsigned int	m_g9_varA
unsigned int	m_g9_cA
unsigned int	m_g9_dA
unsigned int	m_g9_varB
unsigned int	m_g9_dB
bool	m_g10_updated
bool	m_g11_updated
bool	m_g12_updated
bool	m_g13_updated
unsigned int	m_g10_count
unsigned int	m_g11_count
unsigned int	m_g12_count
unsigned int	m_g13_count
bool	m_g14_updated
unsigned int	m_g14_count
psns_map_t	m_g14_program_service_names
	key: PI, value: PSN More...
freqs_map_t	m_g14_alt_freqs
	key: PI, value: set of alternate frequencies (MHz) More...
freqs_map_t	m_g14_mapped_freqs
	key: PI, value: set of mapped frequencies (MHz) More...
char	m_g14_program_service_name [8+1]
std::set< double >	m_g14_alt_freq_set
std::set< double >	m_g14_mapped_freq_set
unsigned int	m_g14_psn_counter
bool	m_g14_data_available
bool	m_g15_updated
unsigned int	m_g15_count

Static Public Attributes
static const unsigned int	offset_pos [5] = {0,1,2,3,2}
static const unsigned int	offset_word [5] = {252,408,360,436,848}
static const unsigned int	syndrome [5] = {383,14,303,663,748}
static const char *const	offset_name [] = {"A","B","C","D","C'"}
static const std::string	pty_table [32]
static const std::string	pi_country_codes [15][5]
static const std::string	coverage_area_codes [16]
static const std::string	rds_group_acronyms [16]
static const std::string	rds_group_acronym_tags [16]
static const std::string	language_codes [44]
static const std::string	tmc_duration [8][2]
static const int	optional_content_lengths [16] = {3,3,5,5,5,8,8,8,8,11,16,16,16,16,0,0}
static const std::string	label_descriptions [16]

Private Member Functions
double	decode_af (unsigned int)
void	decode_optional_content (int, unsigned long int *)
void	decode_type0 (unsigned int *group, bool B)
void	decode_type1 (unsigned int *group, bool B)
void	decode_type2 (unsigned int *group, bool B)
void	decode_type3 (unsigned int *group, bool B)
void	decode_type4 (unsigned int *group, bool B)
void	decode_type5 (unsigned int *group, bool B)
void	decode_type6 (unsigned int *group, bool B)
void	decode_type7 (unsigned int *group, bool B)
void	decode_type8 (unsigned int *group, bool B)
void	decode_type9 (unsigned int *group, bool B)
void	decode_type10 (unsigned int *group, bool B)
void	decode_type11 (unsigned int *group, bool B)
void	decode_type12 (unsigned int *group, bool B)
void	decode_type13 (unsigned int *group, bool B)
void	decode_type14 (unsigned int *group, bool B)
void	decode_type15 (unsigned int *group, bool B)

Private Attributes
unsigned char	pi_country_identification
unsigned char	pi_program_reference_number
bool	radiotext_AB_flag
bool	debug
bool	log

Detailed Description

Definition at line 26 of file rdsparser.h.

Member Typedef Documentation

freqs_map_kv_t

typedef std::pair<unsigned int, std::set<double> > RDSParser::freqs_map_kv_t

Definition at line 32 of file rdsparser.h.

freqs_map_t

typedef std::map<unsigned int, std::set<double> > RDSParser::freqs_map_t

Definition at line 31 of file rdsparser.h.

freqs_set_t

typedef std::set<double> RDSParser::freqs_set_t

Definition at line 33 of file rdsparser.h.

psns_map_kv_t

typedef std::pair<unsigned int, std::string> RDSParser::psns_map_kv_t

Definition at line 30 of file rdsparser.h.

psns_map_t

typedef std::map<unsigned int, std::string> RDSParser::psns_map_t

Definition at line 29 of file rdsparser.h.

Constructor & Destructor Documentation

RDSParser()

RDSParser::RDSParser

(

)

Definition at line 235 of file rdsparser.cpp.

References clearAllFields().

{
    clearAllFields();
}

Here is the call graph for this function:

~RDSParser()

RDSParser::~RDSParser

(

)

Definition at line 240 of file rdsparser.cpp.

{
}

Member Function Documentation

clearAllFields()

void RDSParser::clearAllFields

(

)

Definition at line 270 of file rdsparser.cpp.

References clearUpdateFlags(), m_g0_alt_freq, m_g0_artificial_head, m_g0_compressed, m_g0_count, m_g0_mono_stereo, m_g0_music_speech, m_g0_program_service_name, m_g0_psn_bitmap, m_g0_static_pty, m_g0_traffic_announcement, m_g10_count, m_g11_count, m_g12_count, m_g13_count, m_g14_alt_freq_set, m_g14_alt_freqs, m_g14_count, m_g14_mapped_freq_set, m_g14_mapped_freqs, m_g14_program_service_name, m_g14_program_service_names, m_g14_psn_counter, m_g15_count, m_g1_count, m_g1_country_index, m_g1_country_page_index, m_g1_language_index, m_g1_pin_day, m_g1_pin_hour, m_g1_pin_minute, m_g2_count, m_g2_radiotext, m_g3_aid, m_g3_appGroup, m_g3_count, m_g3_groupB, m_g3_message, m_g4_count, m_g4_day, m_g4_hours, m_g4_local_time_offset, m_g4_minutes, m_g4_month, m_g4_seconds, m_g4_year, m_g5_count, m_g6_count, m_g7_count, m_g8_content, m_g8_count, m_g8_diversion_recommended, m_g8_dp_ci, m_g8_event, m_g8_extent, m_g8_label_index, m_g8_location, m_g8_sign, m_g9_cA, m_g9_count, m_g9_dA, m_g9_dB, m_g9_varA, m_g9_varB, m_pi_area_coverage_index, m_pi_count, m_pi_country_identification, m_pi_program_identification, m_pi_program_type, m_pi_traffic_program, pi_country_identification, and pi_program_reference_number.

Referenced by BFMDemodGUI::on_clearData_clicked(), and RDSParser().

{
    // PI data
    m_pi_count = 0;
    m_pi_program_identification = 0;
    m_pi_program_type = 0;
    m_pi_area_coverage_index = 0;
    m_pi_country_identification = 0;
    m_pi_traffic_program = false;
    pi_country_identification = 0;
    pi_program_reference_number = 0;

    // Group 00 data
    m_g0_count = 0;
    std::memset(m_g0_program_service_name, ' ', sizeof(m_g0_program_service_name));
    m_g0_program_service_name[sizeof(m_g0_program_service_name) - 1] = '\0';
    m_g0_psn_bitmap = 0;
    m_g0_traffic_announcement = false;
    m_g0_music_speech = false;
    m_g0_mono_stereo = false;
    m_g0_artificial_head = false;
    m_g0_compressed = false;
    m_g0_static_pty = false;
    m_g0_alt_freq.clear();

    // Group 01 data
    m_g1_count = 0;
    m_g1_country_page_index = -1;
    m_g1_country_index = -1;
    m_g1_language_index = -1;
    m_g1_pin_day = 0;
    m_g1_pin_hour = 0;
    m_g1_pin_minute = 0;

    // Group 02 data
    m_g2_count = 0;
    std::memset(m_g2_radiotext, ' ', sizeof(m_g2_radiotext));
    m_g2_radiotext[sizeof(m_g2_radiotext) - 1] = '\0';

    // Group 03 data
    m_g3_count = 0;
    m_g3_groupB = false;
    m_g3_appGroup = 0;
    m_g3_message = 0;
    m_g3_aid = 0;


    // Group 04 data
    m_g4_count = 0;
    m_g4_hours = 0;
    m_g4_minutes = 0;
    m_g4_seconds = 0;
    m_g4_year = 0;
    m_g4_month = 0;
    m_g4_day = 0;
    m_g4_local_time_offset = 0.0;

    // Group 05..07 data
    m_g5_count = 0;
    m_g6_count = 0;
    m_g7_count = 0;

    // Group 08 data
    m_g8_count = 0;
    m_g8_diversion_recommended = false;
    m_g8_dp_ci = 0;
    m_g8_sign = false;
    m_g8_extent = 0;
    m_g8_event = 0;
    m_g8_location = 0;
    m_g8_label_index = -1;
    m_g8_content = 0;

    // Group 09 data
    m_g9_varA = 0;
    m_g9_cA = 0;
    m_g9_dA = 0;
    m_g9_varB = 0;
    m_g9_dB = 0;

    // Group 10..13 data
    m_g9_count = 0;
    m_g10_count = 0;
    m_g11_count = 0;
    m_g12_count = 0;
    m_g13_count = 0;

    // Group 14
    m_g14_count = 0;
    m_g14_program_service_names.clear();
    m_g14_alt_freqs.clear();
    m_g14_mapped_freqs.clear();
    std::memset(m_g14_program_service_name, ' ', sizeof(m_g14_program_service_name));
    m_g14_program_service_name[8] = '\0';
    m_g14_alt_freq_set.clear();
    m_g14_mapped_freq_set.clear();
    m_g14_psn_counter = 0;

    // Group 15
    m_g15_count = 0;

    clearUpdateFlags();
}

Here is the call graph for this function:

Here is the caller graph for this function:

clearUpdateFlags()

void RDSParser::clearUpdateFlags

(

)

Definition at line 244 of file rdsparser.cpp.

References debug, log, m_g0_af_updated, m_g0_updated, m_g10_updated, m_g11_updated, m_g12_updated, m_g13_updated, m_g14_data_available, m_g14_updated, m_g15_updated, m_g1_updated, m_g2_updated, m_g3_updated, m_g4_updated, m_g5_updated, m_g6_updated, m_g7_updated, m_g8_updated, m_g9_updated, m_pi_updated, and radiotext_AB_flag.

Referenced by clearAllFields(), and BFMDemodGUI::rdsUpdate().

{
    m_pi_updated = false;
    m_g0_updated = false;
    m_g0_af_updated = false;
    m_g1_updated = false;
    m_g2_updated = false;
    m_g3_updated = false;
    m_g4_updated = false;
    m_g5_updated = false;
    m_g6_updated = false;
    m_g7_updated = false;
    m_g8_updated = false;
    m_g9_updated = false;
    m_g10_updated = false;
    m_g11_updated = false;
    m_g12_updated = false;
    m_g13_updated = false;
    m_g14_updated = false;
    m_g14_data_available = false;
    m_g15_updated = false;
    radiotext_AB_flag = false;
    debug = false;
    log = false;
}

Here is the caller graph for this function:

decode_af()

double RDSParser::decode_af ( unsigned int  af_code )

private

Definition at line 588 of file rdsparser.cpp.

Referenced by decode_type0().

{
    static bool vhf_or_lfmf             = 0; // 0 = vhf, 1 = lf/mf
    double alt_frequency                = 0; // in kHz

    if ((af_code == 0) ||                          // not to be used
        ( af_code == 205) ||                      // filler code
        ((af_code >= 206) && (af_code <= 223)) || // not assigned
        ( af_code == 224) ||                      // No AF exists
        ( af_code >= 251))                        // not assigned
    {
        alt_frequency   = 0;
    }

    if ((af_code >= 225) && (af_code <= 249))      // VHF frequencies follow
    {
        alt_frequency   = 0;
        vhf_or_lfmf     = 1;
    }

    if (af_code == 250)                            // an LF/MF frequency follows
    {
        alt_frequency   = 0;
        vhf_or_lfmf     = 0;
    }

    if ((af_code > 0) && (af_code < 205) && vhf_or_lfmf) {
        alt_frequency = 100.0 * (af_code + 875);          // VHF (87.6-107.9MHz)
    }
    else if ((af_code > 0) && (af_code < 16) && !vhf_or_lfmf) {
        alt_frequency = 153.0 + (af_code - 1) * 9;        // LF (153-279kHz)
    }
    else if ((af_code > 15) && (af_code < 136) && !vhf_or_lfmf) {
        alt_frequency = 531.0 + (af_code - 16) * 9 + 531; // MF (531-1602kHz)
    }

    return alt_frequency;
}

Here is the caller graph for this function:

decode_optional_content()

void RDSParser::decode_optional_content ( int  no_groups, unsigned long int *  free_format  )

private

Definition at line 932 of file rdsparser.cpp.

References i, label_descriptions, m_g8_content, and m_g8_label_index.

Referenced by decode_type8().

{
    int content_length = 0;
    int ff_pointer     = 0;

    if (no_groups == 0)
    {
        int i = 0;
//  for (int i = no_groups; i == 0; i--) i is always 0 if no_groups is 0 and exit else skip
//  {
        ff_pointer = 12 + 16;

        while(ff_pointer >= 7) // ff_pointer must be >= 0 and is decreased by 7 in the loop
        {
            ff_pointer -= 4;
            m_g8_label_index = (free_format[i] && ((0xf << ff_pointer) != 0)) ? 1 : 0;
            content_length = 3; // optional_content_lengths[m_g8_label_index]; // always 3
            ff_pointer -= content_length;
            m_g8_content = (free_format[i] && ((int(std::pow(2, content_length) - 1) << ff_pointer) != 0)) ? 1 : 0;

            qDebug() << "RDSParser::decode_optional_content:"
                    << " TMC optional content (" << label_descriptions[m_g8_label_index].c_str() << ")"
                    << ": " << m_g8_content;
        }
    }
}

Here is the caller graph for this function:

decode_type0()

void RDSParser::decode_type0 ( unsigned int *  group, bool  B  )

private

Definition at line 467 of file rdsparser.cpp.

References decode_af(), m_g0_af_updated, m_g0_alt_freq, m_g0_artificial_head, m_g0_compressed, m_g0_count, m_g0_mono_stereo, m_g0_music_speech, m_g0_program_service_name, m_g0_psn_bitmap, m_g0_static_pty, m_g0_traffic_announcement, m_g0_updated, and m_pi_traffic_program.

Referenced by parseGroup().

{
    unsigned int af_code_1 = 0;
    unsigned int af_code_2 = 0;
    unsigned int  no_af    = 0;
    double af_1            = 0;
    double af_2            = 0;

    m_g0_count++;
    m_g0_updated = true;

    m_pi_traffic_program      = (group[1] >> 10) & 0x01;       // "TP"
    m_g0_traffic_announcement = (group[1] >>  4) & 0x01;       // "TA"
    m_g0_music_speech         = (group[1] >>  3) & 0x01;       // "MuSp"

    bool decoder_control_bit      = (group[1] >> 2) & 0x01; // "DI"
    unsigned char segment_address =  group[1] & 0x03;       // "DI segment"

    if (segment_address == 0)
    {
        std::memset(m_g0_program_service_name, ' ', sizeof(m_g0_program_service_name));
        m_g0_program_service_name[sizeof(m_g0_program_service_name) - 1] = '\0';
        m_g0_psn_bitmap = 0;
    }

    m_g0_program_service_name[segment_address * 2]     = (group[3] >> 8) & 0xff;
    m_g0_program_service_name[segment_address * 2 + 1] =  group[3]       & 0xff;
    m_g0_psn_bitmap |= 1<<segment_address;

    /* see page 41, table 9 of the standard */
    switch (segment_address)
    {
        case 0:
            m_g0_mono_stereo = decoder_control_bit;
            break;
        case 1:
            m_g0_artificial_head = decoder_control_bit;
            break;
        case 2:
            m_g0_compressed = decoder_control_bit;
            break;
        case 3:
            m_g0_static_pty = decoder_control_bit;
            break;
        default:
            break;
    }

    /* unused
    flagstring[0] = m_pi_traffic_program        ? '1' : '0';
    flagstring[1] = m_g0_traffic_announcement   ? '1' : '0';
    flagstring[2] = m_g0_music_speech           ? '1' : '0';
    flagstring[3] = m_g0_mono_stereo            ? '1' : '0';
    flagstring[4] = m_g0_artificial_head        ? '1' : '0';
    flagstring[5] = m_g0_compressed             ? '1' : '0';
    flagstring[6] = m_g0_static_pty             ? '1' : '0';*/

    static std::string af_string;

    if (!B)
    { // type 0A
        af_code_1 = int(group[2] >> 8) & 0xff;
        af_code_2 = int(group[2])      & 0xff;
        af_1 = decode_af(af_code_1);
        af_2 = decode_af(af_code_2);

        if (af_1)
        {
            // @TODO: Find proper header or STL on OSX
            auto res = m_g0_alt_freq.insert(af_1/1e3);
            m_g0_af_updated = m_g0_af_updated || res.second;
            no_af += 1;
        }

        if (af_2)
        {
            // @TODO: Find proper header or STL on OSX
            auto res = m_g0_alt_freq.insert(af_2/1e3);
            m_g0_af_updated = m_g0_af_updated || res.second;
            no_af += 2;
        }

        /*
        std::string af1_string;
        std::string af2_string;

        // only AF1 => no_af==1, only AF2 => no_af==2, both AF1 and AF2 => no_af==3
        if(no_af)
        {
            if(af_1 > 80e3) {
                af1_string = str(boost::format("%2.2fMHz") % (af_1/1e3));
            } else if((af_1<2e3)&&(af_1>100)) {
                af1_string = str(boost::format("%ikHz") % int(af_1));
            }

            if(af_2 > 80e3) {
                af2_string = str(boost::format("%2.2fMHz") % (af_2/1e3));
            } else if ((af_2 < 2e3) && (af_2 > 100)) {
                af2_string = str(boost::format("%ikHz") % int(af_2));
            }
        }

        if(no_af == 1) {
            af_string = af1_string;
        } else if(no_af == 2) {
            af_string = af2_string;
        } else if(no_af == 3) {
            af_string = str(boost::format("%s, %s") % af1_string %af2_string);
        }*/
    }

    /*
    qDebug() << "RDSParser::decode_type0: "
            << "\"" << std::string(m_g0_program_service_name, 8).c_str()
            << "\" -" << (m_pi_traffic_program ? "TP" : "!TP")
            << '-' << (m_g0_traffic_announcement ? "TA" : "!TA")
            << '-' << (m_g0_music_speech ? "Music" : "Speech")
            << '-' << (m_g0_mono_stereo ? "MONO" : "STEREO")
            << " - AF:" << af_string.c_str();*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_type1()

void RDSParser::decode_type1 ( unsigned int *  group, bool  B  )

private

Definition at line 627 of file rdsparser.cpp.

References m_g1_count, m_g1_country_index, m_g1_country_page_index, m_g1_language_index, m_g1_pin_day, m_g1_pin_hour, m_g1_pin_minute, and m_g1_updated.

Referenced by parseGroup().

{
    int ecc    = 0;
    int paging = 0;
    char country_code           = (group[0] >> 12) & 0x0f;
    char radio_paging_codes     =  group[1]        & 0x1f;
    int variant_code            = (group[2] >> 12) & 0x7;
    unsigned int slow_labelling =  group[2]        & 0xfff;
    m_g1_pin_day    = (unsigned int)((group[3] >> 11) & 0x1f);
    m_g1_pin_hour   = (unsigned int)((group[3] >>  6) & 0x1f);
    m_g1_pin_minute = (unsigned int) (group[3]        & 0x3f);

    m_g1_count++;

    if (radio_paging_codes) {
        //qDebug() << "RDSParser::decode_type1: paging codes: " << int(radio_paging_codes) << " ";
    }

    if (m_g1_pin_day || m_g1_pin_hour || m_g1_pin_minute) {
        m_g1_updated = true;
        /*
        std::string s = str(boost::format("program item: %id, %i, %i ") % day % hour % minute);
        qDebug() << "RDSParser::decode_type1: " << s.c_str();*/
    }

    if (!B)
    {
        switch (variant_code)
        {
            case 0: // paging + ecc
                paging = (slow_labelling >> 8) & 0x0f;
                ecc    =  slow_labelling       & 0xff;
                if (paging) {
                    //qDebug() << "RDSParser::decode_type1: " << "paging: " << paging << " ";
                }
                if ((ecc > 223) && (ecc < 229)) {
                    m_g1_updated = true;
                    m_g1_country_page_index = country_code - 1;
                    m_g1_country_index = ecc - 224;
                    /*
                    qDebug() << "RDSParser::decode_type1: " << "extended country code: "
                        << (pi_country_codes[country_code-1][ecc-224]).c_str();*/
                } else {
                    qDebug() << "RDSParser::decode_type1: " << "invalid extended country code: " << ecc;
                }
                break;
            case 1: // TMC identification
                //qDebug() << "RDSParser::decode_type1: TMC identification code received";
                break;
            case 2: // Paging identification
                //qDebug() << "RDSParser::decode_type1: Paging identification code received";
                break;
            case 3: // language codes
                if (slow_labelling < 44) {
                    m_g1_updated = true;
                    m_g1_language_index = slow_labelling;
                    //qDebug() << "RDSParser::decode_type1: " << "language: " << language_codes[slow_labelling].c_str();
                } else {
                    qDebug() << "RDSParser::decode_type1: " << "language: invalid language code " << slow_labelling;
                }
                break;
            default:
                break;
        }
    }
}

Here is the caller graph for this function:

decode_type10()

void RDSParser::decode_type10 ( unsigned int *  group, bool  B  )

private

Definition at line 977 of file rdsparser.cpp.

References m_g10_count, and m_g10_updated.

Referenced by parseGroup().

{
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type10: type 10 not implemented yet";
    m_g10_updated = true;
    m_g10_count++;
}

Here is the caller graph for this function:

decode_type11()

void RDSParser::decode_type11 ( unsigned int *  group, bool  B  )

private

Definition at line 986 of file rdsparser.cpp.

References m_g11_count, and m_g11_updated.

Referenced by parseGroup().

{
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type11: type 11 not implemented yet";
    m_g11_updated = true;
    m_g11_count++;
}

Here is the caller graph for this function:

decode_type12()

void RDSParser::decode_type12 ( unsigned int *  group, bool  B  )

private

Definition at line 995 of file rdsparser.cpp.

References m_g12_count, and m_g12_updated.

Referenced by parseGroup().

{
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type12: type 12 not implemented yet";
    m_g12_updated = true;
    m_g12_count++;
}

Here is the caller graph for this function:

decode_type13()

void RDSParser::decode_type13 ( unsigned int *  group, bool  B  )

private

Definition at line 1004 of file rdsparser.cpp.

References m_g13_count, and m_g13_updated.

Referenced by parseGroup().

{
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type13: type 13 not implemented yet";
    m_g13_updated = true;
    m_g13_count++;
}

Here is the caller graph for this function:

decode_type14()

void RDSParser::decode_type14 ( unsigned int *  group, bool  B  )

private

Definition at line 1013 of file rdsparser.cpp.

References m_g14_alt_freq_set, m_g14_alt_freqs, m_g14_count, m_g14_data_available, m_g14_mapped_freq_set, m_g14_mapped_freqs, m_g14_program_service_name, m_g14_program_service_names, m_g14_psn_counter, and m_g14_updated.

Referenced by parseGroup().

{
    char variant_code        = group[1] & 0x0f;
    unsigned int information = group[2];
    unsigned int pi_on       = group[3];

    bool ta_on = 0;
    double af_1 = 0;
    double af_2 = 0;

    m_g14_updated = true;
    m_g14_count++;

    if (!B)
    {
        switch (variant_code)
        {
            case 0: // PS(ON)
            case 1: // PS(ON)
            case 2: // PS(ON)
            case 3: // PS(ON)
            {
                m_g14_program_service_name[variant_code * 2    ] = (information >> 8) & 0xff;
                m_g14_program_service_name[variant_code * 2 + 1] =  information       & 0xff;
                m_g14_psn_counter++;
                //qDebug() << "RDSParser::decode_type14: PS(ON): \"" << std::string(m_g14_program_service_name, 8).c_str() << "\"";
                break;
            }
            case 4: // AF
            {
                af_1 = 100.0 * (((information >> 8) & 0xff) + 875);
                af_2 = 100.0 * ((information & 0xff) + 875);
                m_g14_alt_freq_set.insert(af_1/1000.0);
                m_g14_alt_freq_set.insert(af_2/1000.0);
                /*
                std::string s = str(boost::format("AF:%3.2fMHz %3.2fMHz") % (af_1/1000) % (af_2/1000));
                qDebug() << "RDSParser::decode_type14: " << s.c_str();*/
                break;
            }
            case 5: // mapped frequencies
            case 6: // mapped frequencies
            case 7: // mapped frequencies
            case 8: // mapped frequencies
            {
                af_1 = 100.0 * (((information >> 8) & 0xff) + 875);
                af_2 = 100.0 * ((information & 0xff) + 875);
                m_g14_mapped_freq_set.insert(af_2/1000.0);
                /*
                std::string s = str(boost::format("TN:%3.2fMHz - ON:%3.2fMHz") % (af_1/1000) % (af_2/1000));
                qDebug() << "RDSParser::decode_type14: " << s.c_str();*/
                break;
            }
            case 9: // mapped frequencies (AM)
            {
                af_1 = 100.0 * (((information >> 8) & 0xff) + 875);
                af_2 = 9.0 * ((information & 0xff) - 16) + 531;
                m_g14_mapped_freq_set.insert(af_2/1000.0);
                /*
                std::string s = str(boost::format("TN:%3.2fMHz - ON:%ikHz") % (af_1/1000) % int(af_2));
                qDebug() << "RDSParser::decode_type14: " << s.c_str();*/
                break;
            }
            case 10: // unallocated
                break;
            case 11: // unallocated
                break;
            case 12: // linkage information
            {
                if (m_g14_psn_counter == 4)
                {
                    //qDebug("RDSParser::decode_type14: m_g14_psn_updated: %d", m_g14_psn_counter);
                    std::pair<psns_map_t::iterator, bool> ret = m_g14_program_service_names.insert(psns_map_kv_t(pi_on, std::string(m_g14_program_service_name)));
                    std::memset(m_g14_program_service_name, ' ', sizeof(m_g14_program_service_name));
                    m_g14_program_service_name[8] = '\0';
                    m_g14_psn_counter = 0;
                    m_g14_data_available = ret.second;
                }

                if (m_g14_alt_freq_set.size() > 0)
                {
                    //qDebug("RDSParser::decode_type14: m_g14_alt_freq_set updated");

                    std::pair<freqs_map_t::iterator, bool> retMap;
                    std::pair<freqs_set_t::iterator, bool> retSet;
                    bool updated = false;

                    freqs_map_t::iterator mIt = m_g14_alt_freqs.find(pi_on);

                    if (mIt == m_g14_alt_freqs.end()) // key does not exist yet => insert the whole set
                    {
                        retMap = m_g14_alt_freqs.insert(freqs_map_kv_t(pi_on, m_g14_alt_freq_set));
                        updated |= retMap.second;
                    }
                    else // merge sets
                    {
                        freqs_set_t::iterator sIt = m_g14_alt_freq_set.begin();
                        const freqs_set_t::iterator sItEnd = m_g14_alt_freq_set.end();

                        for (; sIt != sItEnd; ++sIt)
                        {
                            retSet = (mIt->second).insert(*sIt);
                            updated |= retSet.second;
                        }
                    }

                    m_g14_alt_freq_set.clear();
                    m_g14_data_available |= updated;
                }

                if (m_g14_mapped_freq_set.size() > 0)
                {
                    //qDebug("RDSParser::decode_type14: m_g14_mapped_freq_set updated");

                    std::pair<freqs_map_t::iterator, bool> retMap;
                    std::pair<freqs_set_t::iterator, bool> retSet;
                    bool updated = false;

                    freqs_map_t::iterator mIt = m_g14_mapped_freqs.find(pi_on);

                    if (mIt == m_g14_mapped_freqs.end()) // key does not exist yet => insert the whole set
                    {
                        retMap = m_g14_mapped_freqs.insert(freqs_map_kv_t(pi_on, m_g14_mapped_freq_set));
                        updated |= retMap.second;
                    }
                    else // merge sets
                    {
                        freqs_set_t::iterator sIt = m_g14_mapped_freq_set.begin();
                        const freqs_set_t::iterator sItEnd = m_g14_mapped_freq_set.end();

                        for (; sIt != sItEnd; ++sIt)
                        {
                            retSet = (mIt->second).insert(*sIt);
                            updated |= retSet.second;
                        }
                    }

                    m_g14_mapped_freq_set.clear();
                    m_g14_data_available |= updated;
                }

                /*
                std::string s = str(boost::format("Linkage information: %x%x") % ((information >> 8) & 0xff) % (information & 0xff));
                qDebug() << "RDSParser::decode_type14: " << s.c_str();*/
                break;
            }
            case 13: // PTY(ON), TA(ON)
            {
                ta_on = information & 0x01;
                //qDebug() << "RDSParser::decode_type14: PTY(ON):" << pty_table[int(pty_on)].c_str();
                if(ta_on) {
                    qDebug() << "RDSParser::decode_type14:  - TA";
                }
                break;
            }
            case 14: // PIN(ON)
            {
                /*
                std::string s = str(boost::format("PIN(ON):%x%x") % ((information >> 8) & 0xff) % (information & 0xff));
                qDebug() << "RDSParser::decode_type14: " << s.c_str();*/
                break;
            }
            case 15: // Reserved for broadcasters use
                break;
            default:
                //qDebug() << "RDSParser::decode_type14: invalid variant code:" << variant_code;
                break;
        }
    }

    /*
    if (pi_on)
    {
        std::string pistring = str(boost::format("%04X") % pi_on);
        qDebug() << "RDSParser::decode_type14: PI(ON):" << pistring.c_str();

        if (tp_on) {
            qDebug() << "RDSParser::decode_type14: TP(ON)";
        }
    }*/
}

Here is the caller graph for this function:

decode_type15()

void RDSParser::decode_type15 ( unsigned int *  group, bool  B  )

private

Definition at line 1194 of file rdsparser.cpp.

References m_g15_count, and m_g15_updated.

Referenced by parseGroup().

{
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type5: type 15 not implemented yet";
    m_g15_updated = true;
    m_g15_count++;
}

Here is the caller graph for this function:

decode_type2()

void RDSParser::decode_type2 ( unsigned int *  group, bool  B  )

private

Definition at line 694 of file rdsparser.cpp.

References m_g2_count, m_g2_radiotext, m_g2_updated, and radiotext_AB_flag.

Referenced by parseGroup().

{
    unsigned char text_segment_address_code = group[1] & 0x0f;

    m_g2_updated = true;
    m_g2_count++;

    // when the A/B flag is toggled, flush your current radiotext
    if (radiotext_AB_flag != ((group[1] >> 4) & 0x01))
    {
        std::memset(m_g2_radiotext, ' ', sizeof(m_g2_radiotext));
        m_g2_radiotext[sizeof(m_g2_radiotext) - 1] = '\0';
    }

    radiotext_AB_flag = (group[1] >> 4) & 0x01;

    if (!B)
    {
        m_g2_radiotext[text_segment_address_code * 4    ] = (group[2] >> 8) & 0xff;
        m_g2_radiotext[text_segment_address_code * 4 + 1] =  group[2]       & 0xff;
        m_g2_radiotext[text_segment_address_code * 4 + 2] = (group[3] >> 8) & 0xff;
        m_g2_radiotext[text_segment_address_code * 4 + 3] =  group[3]       & 0xff;
    }
    else
    {
        m_g2_radiotext[text_segment_address_code * 2    ] = (group[3] >> 8) & 0xff;
        m_g2_radiotext[text_segment_address_code * 2 + 1] =  group[3]       & 0xff;
    }

    /*
    qDebug() << "RDSParser::decode_type2: " << "Radio Text " << (radiotext_AB_flag ? 'B' : 'A')
        << ": " << std::string(m_g2_radiotext, sizeof(m_g2_radiotext)).c_str();*/
}

Here is the caller graph for this function:

decode_type3()

void RDSParser::decode_type3 ( unsigned int *  group, bool  B  )

private

Definition at line 728 of file rdsparser.cpp.

References m_g3_aid, m_g3_appGroup, m_g3_count, m_g3_groupB, m_g3_message, and m_g3_updated.

Referenced by parseGroup().

{
    if (B) {
        qDebug() << "RDSParser::decode_type3: type 3B not implemented yet";
        return;
    }

    int application_group = (group[1] >> 1) & 0xf;
    int group_type        =  group[1] & 0x1;
    int message           =  group[2];
    int aid               =  group[3];


    m_g3_updated = true;
    m_g3_count++;

    /*
    qDebug() << "RDSParser::decode_type3: aid group: " << application_group
        << " " << (group_type ? 'B' : 'A');*/

    if ((application_group == 8) && (group_type == 0))
    { // 8A
        int variant_code = (message >> 14) & 0x3;

        if (variant_code == 0)
        {
//          int ltn  = (message >> 6) & 0x3f; // location table number
//          bool afi = (message >> 5) & 0x1;  // alternative freq. indicator
//          bool M   = (message >> 4) & 0x1;  // mode of transmission
//          bool I   = (message >> 3) & 0x1;  // international
//          bool N   = (message >> 2) & 0x1;  // national
//          bool R   = (message >> 1) & 0x1;  // regional
//          bool U   =  message       & 0x1;  // urban

            /*
            qDebug() << "RDSParser::decode_type3: location table: " << ltn << " - "
                << (afi ? "AFI-ON" : "AFI-OFF") << " - "
                << (M   ? "enhanced mode" : "basic mode") << " - "
                << (I   ? "international " : "")
                << (N   ? "national " : "")
                << (R   ? "regional " : "")
                << (U   ? "urban" : "")
                << " aid: " << aid;*/
        }
        else if (variant_code==1)
        {
//          int G   = (message >> 12) & 0x3;  // gap
//          int sid = (message >>  6) & 0x3f; // service identifier
//          int gap_no[4] = {3, 5, 8, 11};
            /*
            qDebug() << "RDSParser::decode_type3: gap: " << gap_no[G] << " groups, SID: "
                << sid << " ";*/
        }
    }

    m_g3_groupB = group_type;
    m_g3_appGroup = application_group;
    m_g3_message = message;
    m_g3_aid = aid;

    //qDebug() << "RDSParser::decode_type3: message: " << message << " - aid: " << aid;
}

Here is the caller graph for this function:

decode_type4()

void RDSParser::decode_type4 ( unsigned int *  group, bool  B  )

private

Definition at line 791 of file rdsparser.cpp.

References m_g4_count, m_g4_day, m_g4_hours, m_g4_local_time_offset, m_g4_minutes, m_g4_month, m_g4_updated, and m_g4_year.

Referenced by parseGroup().

{
    if (B)
    {
        qDebug() << "RDSParser::decode_type4: type 4B not implemented yet";
        return;
    }

    m_g4_updated = true;
    m_g4_count++;

    m_g4_hours   = ((group[2] & 0x1) << 4) | ((group[3] >> 12) & 0x0f);
    m_g4_minutes =  (group[3] >> 6) & 0x3f;
    m_g4_local_time_offset = .5 * (group[3] & 0x1f);

    if ((group[3] >> 5) & 0x1) {
        m_g4_local_time_offset *= -1;
    }

    double modified_julian_date = ((group[1] & 0x03) << 15) | ((group[2] >> 1) & 0x7fff);

    m_g4_year  = int((modified_julian_date - 15078.2) / 365.25);
    m_g4_month = int((modified_julian_date - 14956.1 - int(m_g4_year * 365.25)) / 30.6001);
    m_g4_day   =               modified_julian_date - 14956 - int(m_g4_year * 365.25) - int(m_g4_month * 30.6001);
    bool K = ((m_g4_month == 14) || (m_g4_month == 15)) ? 1 : 0;
    m_g4_year += K;
    m_g4_month -= 1 + K * 12;

    /*
    std::string time = str(boost::format("%02i.%02i.%4i, %02i:%02i (%+.1fh)")\
        % m_g4_day % m_g4_month % (1900 + m_g4_year) % m_g4_hours % m_g4_minutes % m_g4_local_time_offset);

    qDebug() << "RDSParser::decode_type4: Clocktime: " << time.c_str();*/

    //send_message(5,time);
}

Here is the caller graph for this function:

decode_type5()

void RDSParser::decode_type5 ( unsigned int *  group, bool  B  )

private

Definition at line 828 of file rdsparser.cpp.

References m_g5_count, and m_g5_updated.

Referenced by parseGroup().

                                                        {
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type5: type5 not implemented yet";
    m_g5_updated = true;
    m_g5_count++;
}

Here is the caller graph for this function:

decode_type6()

void RDSParser::decode_type6 ( unsigned int *  group, bool  B  )

private

Definition at line 836 of file rdsparser.cpp.

References m_g6_count, and m_g6_updated.

Referenced by parseGroup().

                                                        {
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type6: type 6 not implemented yet";
    m_g6_updated = true;
    m_g6_count++;
}

Here is the caller graph for this function:

decode_type7()

void RDSParser::decode_type7 ( unsigned int *  group, bool  B  )

private

Definition at line 844 of file rdsparser.cpp.

References m_g7_count, and m_g7_updated.

Referenced by parseGroup().

                                                        {
    (void) group;
    (void) B;
    qDebug() << "RDSParser::decode_type7: type 7 not implemented yet";
    m_g7_updated = true;
    m_g7_count++;
}

Here is the caller graph for this function:

decode_type8()

void RDSParser::decode_type8 ( unsigned int *  group, bool  B  )

private

Definition at line 852 of file rdsparser.cpp.

References decode_optional_content(), RDSTMC::get_tmc_event_code_index(), RDSTMC::get_tmc_events(), m_g8_count, m_g8_diversion_recommended, m_g8_dp_ci, m_g8_event, m_g8_extent, m_g8_location, m_g8_sign, m_g8_updated, and tmc_duration.

Referenced by parseGroup().

{
    if (B)
    {
        qDebug() << "RDSParser::decode_type8: type 8B not implemented yet";
        return;
    }

    m_g8_updated = true;
    m_g8_count++;

    bool T = (group[1] >> 4) & 0x1; // 0 = user message, 1 = tuning info
    bool F = (group[1] >> 3) & 0x1; // 0 = multi-group, 1 = single-group
    bool D = (group[2] >> 15) & 0x1; // 1 = diversion recommended
    m_g8_diversion_recommended = D;

    static unsigned long int free_format[4];
    static int no_groups = 0;

    if (T)
    { // tuning info
        qDebug() << "RDSParser::decode_type8: #tuning info# ";
        int variant = group[1] & 0xf;

        if((variant > 3) && (variant < 10)) {
            qDebug() << "RDSParser::decode_type8: variant: " << variant << " - "
                << group[2] << " " << group[3];
        } else {
            qDebug() << "RDSParser::decode_type8: invalid variant: " << variant;
        }

    }
    else if (F || D)
    { // single-group or 1st of multi-group
        m_g8_dp_ci            =  group[1]        & 0x7;   // duration & persistence or continuity index
        m_g8_sign             = (group[2] >> 14) & 0x1;   // event direction, 0 = +, 1 = -
        m_g8_extent           = (group[2] >> 11) & 0x7;   // number of segments affected
        m_g8_event            =  group[2]        & 0x7ff; // event code, defined in ISO 14819-2
        m_g8_location         =  group[3];                // location code, defined in ISO 14819-3

        qDebug() << "RDSParser::decode_type8: #user msg# " << (D ? "diversion recommended, " : "");

        if (F) {
            qDebug() << "RDSParser::decode_type8: single-grp, duration:" << (tmc_duration[m_g8_dp_ci][0]).c_str();
        } else {
            qDebug() << "RDSParser::decode_type8: multi-grp, continuity index:" << m_g8_dp_ci;
        }

        int event_line = RDSTMC::get_tmc_event_code_index(m_g8_event, 1);

        qDebug() << "RDSParser::decode_type8: extent:" << (m_g8_sign ? "-" : "") << m_g8_extent + 1 << " segments"
            << ", event" << m_g8_event << ":" << RDSTMC::get_tmc_events(event_line, 1).c_str()
            << ", location:" << m_g8_location;

    }
    else
    { // 2nd or more of multi-group
        unsigned int ci = group[1] & 0x7;          // countinuity index
        bool sg = (group[2] >> 14) & 0x1;          // second group
        unsigned int gsi = (group[2] >> 12) & 0x3; // group sequence

        qDebug() << "RDSParser::decode_type8: #user msg# multi-grp, continuity index:" << ci
            << (sg ? ", second group" : "") << ", gsi:" << gsi;

        qDebug() << "RDSParser::decode_type8: free format: " << (group[2] & 0xfff) << " "
            << group[3];
        // it's not clear if gsi=N-2 when gs=true

        if (sg) {
            no_groups = gsi;
        }

        free_format[gsi] = ((group[2] & 0xfff) << 12) | group[3];

        if (gsi == 0) {
            decode_optional_content(no_groups, free_format);
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_type9()

void RDSParser::decode_type9 ( unsigned int *  group, bool  B  )

private

Definition at line 959 of file rdsparser.cpp.

References m_g9_cA, m_g9_count, m_g9_dA, m_g9_dB, m_g9_updated, m_g9_varA, and m_g9_varB.

Referenced by parseGroup().

                                                       {

    if (B)
    {
        m_g9_varB = group[1] & 0x1f;
        m_g9_dB   = group[3];
    }
    else
    {
        m_g9_varA = group[1] & 0x1f;
        m_g9_cA   = group[2];
        m_g9_dA   = group[3];
    }

    m_g9_updated = true;
    m_g9_count++;
}

Here is the caller graph for this function:

parseGroup()

void RDSParser::parseGroup

(

unsigned int *

group

)

Parses a group retrieved by the decoder

Definition at line 374 of file rdsparser.cpp.

References decode_type0(), decode_type1(), decode_type10(), decode_type11(), decode_type12(), decode_type13(), decode_type14(), decode_type15(), decode_type2(), decode_type3(), decode_type4(), decode_type5(), decode_type6(), decode_type7(), decode_type8(), decode_type9(), m_pi_area_coverage_index, m_pi_count, m_pi_country_identification, m_pi_program_identification, m_pi_program_type, m_pi_traffic_program, and m_pi_updated.

Referenced by BFMDemod::feed().

{
    unsigned int group_type = (unsigned int)((group[1] >> 12) & 0xf);
    bool ab = (group[1] >> 11 ) & 0x1;

    /*
    qDebug() << "RDSParser::parseGroup:"
            << " type: " << group_type << (ab ? 'B' :'A')
            << " (" << rds_group_acronyms[group_type].c_str() << ")";*/

    m_pi_count++;
    m_pi_updated = true;

    m_pi_program_identification = group[0];                // "PI"
    m_pi_traffic_program        = (group[1] >> 10) & 0x01; // "TP"
    m_pi_program_type           = (group[1] >> 5) & 0x1f;  // "PTY"
    m_pi_country_identification = (m_pi_program_identification >> 12) & 0xf;
    m_pi_area_coverage_index = (m_pi_program_identification >> 8) & 0xf;

    /*
    std::string pistring = str(boost::format("%04X") % m_pi_program_identification);

    qDebug() << "RDSParser::parseGroup:"
            << " PI:" << pistring.c_str()
            << " - " << "PTY:" << pty_table[m_pi_program_type].c_str()
            << " (country:" << (pi_country_codes[m_pi_country_identification - 1][0]).c_str()
            << "/" << (pi_country_codes[m_pi_country_identification - 1][1]).c_str()
            << "/" << (pi_country_codes[m_pi_country_identification - 1][2]).c_str()
            << "/" << (pi_country_codes[m_pi_country_identification - 1][3]).c_str()
            << "/" << (pi_country_codes[m_pi_country_identification - 1][4]).c_str()
            << ", area:" << coverage_area_codes[m_pi_area_coverage_index].c_str()
            << ", program:" << int(pi_program_reference_number) << ")";*/

    switch (group_type) {
        case 0:
            decode_type0(group, ab);
            break;
        case 1:
            decode_type1(group, ab);
            break;
        case 2:
            decode_type2(group, ab);
            break;
        case 3:
            decode_type3(group, ab);
            break;
        case 4:
            decode_type4(group, ab);
            break;
        case 5:
            decode_type5(group, ab);
            break;
        case 6:
            decode_type6(group, ab);
            break;
        case 7:
            decode_type7(group, ab);
            break;
        case 8:
            decode_type8(group, ab);
            break;
        case 9:
            decode_type9(group, ab);
            break;
        case 10:
            decode_type10(group, ab);
            break;
        case 11:
            decode_type11(group, ab);
            break;
        case 12:
            decode_type12(group, ab);
            break;
        case 13:
            decode_type13(group, ab);
            break;
        case 14:
            decode_type14(group, ab);
            break;
        case 15:
            decode_type15(group, ab);
            break;
    }

    /*
    #define HEX(a) std::hex << std::setfill('0') << std::setw(4) << long(a) << std::dec
    for(int i = 0; i < 4; i++) {
        dout << "  " << HEX(group[i]);
    }
    dout << std::endl;*/
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

coverage_area_codes

const std::string RDSParser::coverage_area_codes

static

Initial value:

= {
    "Local",
    "International",
    "National",
    "Supra-regional",
    "Regional 1",
    "Regional 2",
    "Regional 3",
    "Regional 4",
    "Regional 5",
    "Regional 6",
    "Regional 7",
    "Regional 8",
    "Regional 9",
    "Regional 10",
    "Regional 11",
    "Regional 12"
}

Definition at line 165 of file rdsparser.h.

Referenced by BFMDemodGUI::rdsUpdate().

debug

bool RDSParser::debug

private

Definition at line 197 of file rdsparser.h.

Referenced by clearUpdateFlags().

label_descriptions

const std::string RDSParser::label_descriptions

static

Initial value:

= {
    "Duration",
    "Control code",
    "Length of route affected",
    "Speed limit advice",
    "Quantifier",
    "Quantifier",
    "Supplementary information code",
    "Explicit start time",
    "Explicit stop time",
    "Additional event",
    "Detailed diversion instructions",
    "Destination",
    "RFU (Reserved for future use)",
    "Cross linkage to source of problem, or another route",
    "Separator",
    "RFU (Reserved for future use)"
}

Definition at line 171 of file rdsparser.h.

Referenced by decode_optional_content(), and BFMDemodGUI::rdsUpdate().

language_codes

const std::string RDSParser::language_codes

static

Definition at line 168 of file rdsparser.h.

Referenced by BFMDemodGUI::rdsUpdate().

log

bool RDSParser::log

private

Definition at line 198 of file rdsparser.h.

Referenced by clearUpdateFlags().

m_g0_af_updated

bool RDSParser::m_g0_af_updated

Definition at line 57 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_alt_freq

std::set<double> RDSParser::m_g0_alt_freq

Definition at line 67 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), BFMDemodGUI::rdsUpdate(), and BFMDemod::webapiFormatRDSReport().

m_g0_artificial_head

bool RDSParser::m_g0_artificial_head

Definition at line 64 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type0().

m_g0_compressed

bool RDSParser::m_g0_compressed

Definition at line 65 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type0().

m_g0_count

unsigned int RDSParser::m_g0_count

Definition at line 58 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_mono_stereo

bool RDSParser::m_g0_mono_stereo

Definition at line 63 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_music_speech

bool RDSParser::m_g0_music_speech

Definition at line 62 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_program_service_name

char RDSParser::m_g0_program_service_name[8+1]

Definition at line 59 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_psn_bitmap

unsigned char RDSParser::m_g0_psn_bitmap

Definition at line 60 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_static_pty

bool RDSParser::m_g0_static_pty

Definition at line 66 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type0().

m_g0_traffic_announcement

bool RDSParser::m_g0_traffic_announcement

Definition at line 61 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g0_updated

bool RDSParser::m_g0_updated

Definition at line 56 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type0(), and BFMDemodGUI::rdsUpdate().

m_g10_count

unsigned int RDSParser::m_g10_count

Definition at line 137 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type10().

m_g10_updated

bool RDSParser::m_g10_updated

Definition at line 133 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type10().

m_g11_count

unsigned int RDSParser::m_g11_count

Definition at line 138 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type11().

m_g11_updated

bool RDSParser::m_g11_updated

Definition at line 134 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type11().

m_g12_count

unsigned int RDSParser::m_g12_count

Definition at line 139 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type12().

m_g12_updated

bool RDSParser::m_g12_updated

Definition at line 135 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type12().

m_g13_count

unsigned int RDSParser::m_g13_count

Definition at line 140 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type13().

m_g13_updated

bool RDSParser::m_g13_updated

Definition at line 136 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type13().

m_g14_alt_freq_set

std::set<double> RDSParser::m_g14_alt_freq_set

Definition at line 149 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type14().

m_g14_alt_freqs

freqs_map_t RDSParser::m_g14_alt_freqs

key: PI, value: set of alternate frequencies (MHz)

Definition at line 146 of file rdsparser.h.

Referenced by clearAllFields(), decode_type14(), and BFMDemodGUI::on_g14ProgServiceNames_currentIndexChanged().

m_g14_count

unsigned int RDSParser::m_g14_count

Definition at line 144 of file rdsparser.h.

Referenced by clearAllFields(), decode_type14(), and BFMDemodGUI::rdsUpdate().

m_g14_data_available

bool RDSParser::m_g14_data_available

Definition at line 152 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type14(), and BFMDemodGUI::rdsUpdate().

m_g14_mapped_freq_set

std::set<double> RDSParser::m_g14_mapped_freq_set

Definition at line 150 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type14().

m_g14_mapped_freqs

freqs_map_t RDSParser::m_g14_mapped_freqs

key: PI, value: set of mapped frequencies (MHz)

Definition at line 147 of file rdsparser.h.

Referenced by clearAllFields(), decode_type14(), and BFMDemodGUI::on_g14ProgServiceNames_currentIndexChanged().

m_g14_program_service_name

char RDSParser::m_g14_program_service_name[8+1]

Definition at line 148 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type14().

m_g14_program_service_names

psns_map_t RDSParser::m_g14_program_service_names

key: PI, value: PSN

Definition at line 145 of file rdsparser.h.

Referenced by clearAllFields(), decode_type14(), and BFMDemodGUI::rdsUpdate().

m_g14_psn_counter

unsigned int RDSParser::m_g14_psn_counter

Definition at line 151 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type14().

m_g14_updated

bool RDSParser::m_g14_updated

Definition at line 143 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type14(), and BFMDemodGUI::rdsUpdate().

m_g15_count

unsigned int RDSParser::m_g15_count

Definition at line 156 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type15().

m_g15_updated

bool RDSParser::m_g15_updated

Definition at line 155 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type15().

m_g1_count

unsigned int RDSParser::m_g1_count

Definition at line 71 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_country_index

int RDSParser::m_g1_country_index

negative if not received

Definition at line 73 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_country_page_index

int RDSParser::m_g1_country_page_index

negative if not received

Definition at line 72 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_language_index

int RDSParser::m_g1_language_index

negative if not received

Definition at line 74 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_pin_day

unsigned int RDSParser::m_g1_pin_day

Definition at line 75 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_pin_hour

unsigned int RDSParser::m_g1_pin_hour

Definition at line 76 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_pin_minute

unsigned int RDSParser::m_g1_pin_minute

Definition at line 77 of file rdsparser.h.

Referenced by clearAllFields(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g1_updated

bool RDSParser::m_g1_updated

Definition at line 70 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type1(), and BFMDemodGUI::rdsUpdate().

m_g2_count

unsigned int RDSParser::m_g2_count

Definition at line 81 of file rdsparser.h.

Referenced by clearAllFields(), decode_type2(), and BFMDemodGUI::rdsUpdate().

m_g2_radiotext

char RDSParser::m_g2_radiotext[64+1]

Definition at line 82 of file rdsparser.h.

Referenced by clearAllFields(), decode_type2(), and BFMDemodGUI::rdsUpdate().

m_g2_updated

bool RDSParser::m_g2_updated

Definition at line 80 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type2(), and BFMDemodGUI::rdsUpdate().

m_g3_aid

unsigned int RDSParser::m_g3_aid

Definition at line 90 of file rdsparser.h.

Referenced by clearAllFields(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g3_appGroup

unsigned int RDSParser::m_g3_appGroup

Definition at line 88 of file rdsparser.h.

Referenced by clearAllFields(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g3_count

unsigned int RDSParser::m_g3_count

Definition at line 86 of file rdsparser.h.

Referenced by clearAllFields(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g3_groupB

bool RDSParser::m_g3_groupB

Definition at line 87 of file rdsparser.h.

Referenced by clearAllFields(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g3_message

unsigned int RDSParser::m_g3_message

Definition at line 89 of file rdsparser.h.

Referenced by clearAllFields(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g3_updated

bool RDSParser::m_g3_updated

Definition at line 85 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type3(), and BFMDemodGUI::rdsUpdate().

m_g4_count

unsigned int RDSParser::m_g4_count

Definition at line 94 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_day

unsigned int RDSParser::m_g4_day

Definition at line 100 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_hours

unsigned int RDSParser::m_g4_hours

Definition at line 95 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_local_time_offset

double RDSParser::m_g4_local_time_offset

Definition at line 101 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_minutes

unsigned int RDSParser::m_g4_minutes

Definition at line 96 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_month

unsigned int RDSParser::m_g4_month

Definition at line 99 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_seconds

unsigned int RDSParser::m_g4_seconds

Definition at line 97 of file rdsparser.h.

Referenced by clearAllFields().

m_g4_updated

bool RDSParser::m_g4_updated

Definition at line 93 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g4_year

unsigned int RDSParser::m_g4_year

Definition at line 98 of file rdsparser.h.

Referenced by clearAllFields(), decode_type4(), and BFMDemodGUI::rdsUpdate().

m_g5_count

unsigned int RDSParser::m_g5_count

Definition at line 107 of file rdsparser.h.

Referenced by clearAllFields(), decode_type5(), and BFMDemodGUI::rdsUpdate().

m_g5_updated

bool RDSParser::m_g5_updated

Definition at line 104 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type5(), and BFMDemodGUI::rdsUpdate().

m_g6_count

unsigned int RDSParser::m_g6_count

Definition at line 108 of file rdsparser.h.

Referenced by clearAllFields(), decode_type6(), and BFMDemodGUI::rdsUpdate().

m_g6_updated

bool RDSParser::m_g6_updated

Definition at line 105 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type6(), and BFMDemodGUI::rdsUpdate().

m_g7_count

unsigned int RDSParser::m_g7_count

Definition at line 109 of file rdsparser.h.

Referenced by clearAllFields(), decode_type7(), and BFMDemodGUI::rdsUpdate().

m_g7_updated

bool RDSParser::m_g7_updated

Definition at line 106 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type7(), and BFMDemodGUI::rdsUpdate().

m_g8_content

int RDSParser::m_g8_content

Definition at line 121 of file rdsparser.h.

Referenced by clearAllFields(), decode_optional_content(), and BFMDemodGUI::rdsUpdate().

m_g8_count

unsigned int RDSParser::m_g8_count

Definition at line 113 of file rdsparser.h.

Referenced by clearAllFields(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g8_diversion_recommended

bool RDSParser::m_g8_diversion_recommended

Definition at line 114 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type8().

m_g8_dp_ci

unsigned int RDSParser::m_g8_dp_ci

Definition at line 115 of file rdsparser.h.

Referenced by clearAllFields(), and decode_type8().

m_g8_event

unsigned int RDSParser::m_g8_event

Definition at line 118 of file rdsparser.h.

Referenced by clearAllFields(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g8_extent

unsigned int RDSParser::m_g8_extent

Definition at line 117 of file rdsparser.h.

Referenced by clearAllFields(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g8_label_index

int RDSParser::m_g8_label_index

negative if not received

Definition at line 120 of file rdsparser.h.

Referenced by clearAllFields(), decode_optional_content(), and BFMDemodGUI::rdsUpdate().

m_g8_location

unsigned int RDSParser::m_g8_location

Definition at line 119 of file rdsparser.h.

Referenced by clearAllFields(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g8_sign

bool RDSParser::m_g8_sign

Definition at line 116 of file rdsparser.h.

Referenced by clearAllFields(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g8_updated

bool RDSParser::m_g8_updated

Definition at line 112 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type8(), and BFMDemodGUI::rdsUpdate().

m_g9_cA

unsigned int RDSParser::m_g9_cA

Definition at line 127 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_count

unsigned int RDSParser::m_g9_count

Definition at line 125 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_dA

unsigned int RDSParser::m_g9_dA

Definition at line 128 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_dB

unsigned int RDSParser::m_g9_dB

Definition at line 130 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_updated

bool RDSParser::m_g9_updated

Definition at line 124 of file rdsparser.h.

Referenced by clearUpdateFlags(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_varA

unsigned int RDSParser::m_g9_varA

Definition at line 126 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_g9_varB

unsigned int RDSParser::m_g9_varB

Definition at line 129 of file rdsparser.h.

Referenced by clearAllFields(), decode_type9(), and BFMDemodGUI::rdsUpdate().

m_pi_area_coverage_index

int RDSParser::m_pi_area_coverage_index

Definition at line 53 of file rdsparser.h.

Referenced by clearAllFields(), parseGroup(), and BFMDemodGUI::rdsUpdate().

m_pi_count

unsigned int RDSParser::m_pi_count

Definition at line 48 of file rdsparser.h.

Referenced by clearAllFields(), parseGroup(), and BFMDemodGUI::rdsUpdate().

m_pi_country_identification

int RDSParser::m_pi_country_identification

Definition at line 52 of file rdsparser.h.

Referenced by clearAllFields(), and parseGroup().

m_pi_program_identification

unsigned int RDSParser::m_pi_program_identification

Definition at line 49 of file rdsparser.h.

Referenced by clearAllFields(), parseGroup(), and BFMDemodGUI::rdsUpdate().

m_pi_program_type

unsigned char RDSParser::m_pi_program_type

Definition at line 50 of file rdsparser.h.

Referenced by clearAllFields(), parseGroup(), and BFMDemodGUI::rdsUpdate().

m_pi_traffic_program

bool RDSParser::m_pi_traffic_program

Definition at line 51 of file rdsparser.h.

Referenced by clearAllFields(), decode_type0(), parseGroup(), and BFMDemodGUI::rdsUpdate().

m_pi_updated

bool RDSParser::m_pi_updated

Definition at line 47 of file rdsparser.h.

Referenced by clearUpdateFlags(), parseGroup(), and BFMDemodGUI::rdsUpdate().

offset_name

const char *const RDSParser::offset_name = {"A","B","C","D","C'"}

static

Definition at line 162 of file rdsparser.h.

offset_pos

const unsigned int RDSParser::offset_pos = {0,1,2,3,2}

static

Definition at line 159 of file rdsparser.h.

offset_word

const unsigned int RDSParser::offset_word = {252,408,360,436,848}

static

Definition at line 160 of file rdsparser.h.

optional_content_lengths

const int RDSParser::optional_content_lengths = {3,3,5,5,5,8,8,8,8,11,16,16,16,16,0,0}

static

Definition at line 170 of file rdsparser.h.

pi_country_codes

const std::string RDSParser::pi_country_codes

static

Initial value:

= {
    {"DE","GR","MA","__","MD"},
    {"DZ","CY","CZ","IE","EE"},
    {"AD","SM","PL","TR","__"},
    {"IL","CH","VA","MK","__"},
    {"IT","JO","SK","__","__"},
    {"BE","FI","SY","__","UA"},
    {"RU","LU","TN","__","__"},
    {"PS","BG","__","NL","PT"},
    {"AL","DK","LI","LV","SI"},
    {"AT","GI","IS","LB","__"},
    {"HU","IQ","MC","__","__"},
    {"MT","GB","LT","HR","__"},
    {"DE","LY","YU","__","__"},
    {"__","RO","ES","SE","__"},
    {"EG","FR","NO","BY","BA"}
}

Definition at line 164 of file rdsparser.h.

Referenced by BFMDemodGUI::rdsUpdate().

pi_country_identification

unsigned char RDSParser::pi_country_identification

private

Definition at line 193 of file rdsparser.h.

Referenced by clearAllFields().

pi_program_reference_number

unsigned char RDSParser::pi_program_reference_number

private

Definition at line 194 of file rdsparser.h.

Referenced by clearAllFields().

pty_table

const std::string RDSParser::pty_table

static

Definition at line 163 of file rdsparser.h.

Referenced by BFMDemodGUI::rdsUpdate().

radiotext_AB_flag

bool RDSParser::radiotext_AB_flag

private

Definition at line 196 of file rdsparser.h.

Referenced by clearUpdateFlags(), and decode_type2().

rds_group_acronym_tags

const std::string RDSParser::rds_group_acronym_tags

static

Initial value:

= {
    "BAS",
    "PIN",
    "TXT",
    "AID",
    "TIM",
    "TDC",
    "IH_",
    "RP_",
    "TMC",
    "EWS",
    "___",
    "___",
    "___",
    "___",
    "EON",
    "___"
}

Definition at line 167 of file rdsparser.h.

Referenced by BFMDemodGUI::rdsUpdateFixedFields().

rds_group_acronyms

const std::string RDSParser::rds_group_acronyms

static

Initial value:

= {
    "BASIC",
    "PIN/SL",
    "RT",
    "AID",
    "CT",
    "TDC",
    "IH",
    "RP",
    "TMC",
    "EWS",
    "___",
    "___",
    "___",
    "___",
    "EON",
    "___"
}

Definition at line 166 of file rdsparser.h.

syndrome

const unsigned int RDSParser::syndrome = {383,14,303,663,748}

static

Definition at line 161 of file rdsparser.h.

tmc_duration

const std::string RDSParser::tmc_duration

static

Initial value:

=
{
    {"no duration given", "no duration given"},
    {"15 minutes", "next few hours"},
    {"30 minutes", "rest of the day"},
    {"1 hour", "until tomorrow evening"},
    {"2 hours", "rest of the week"},
    {"3 hours", "end of next week"},
    {"4 hours", "end of the month"},
    {"rest of the day", "long period"}
}

Definition at line 169 of file rdsparser.h.

Referenced by decode_type8().

---

The documentation for this class was generated from the following files:

• plugins/channelrx/demodbfm/rdsparser.h
• plugins/channelrx/demodbfm/rdsparser.cpp