path: root/src/fig0_21.cpp

/*
    Copyright (C) 2014 CSP Innovazione nelle ICT s.c.a r.l. (http://www.csp.it/)
    Copyright (C) 2017 Matthias P. Braendli (http://www.opendigitalradio.org)
    Copyright (C) 2015 Data Path

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

    Authors:
         Sergio Sagliocco <sergio.sagliocco@csp.it>
         Matthias P. Braendli <matthias@mpb.li>
                   / |  |-  ')|)  |-|_ _ (|,_   .|  _  ,_ \
         Data Path \(|(||_(|/_| (||_||(a)_||||(|||.(_()|||/

*/

#include "figs.hpp"
#include <cstdio>
#include <cstring>
#include <map>
#include <unordered_set>

static std::unordered_set<int> regions_seen;

bool fig0_21_is_complete(int region_id)
{
    bool complete = regions_seen.count(region_id);

    if (complete) {
        regions_seen.clear();
    }
    else {
        regions_seen.insert(region_id);
    }

    return complete;
}


// FIG 0/21 Frequency Information
// ETSI EN 300 401 8.1.8
fig_result_t fig0_21(fig0_common_t& fig0, const display_settings_t &disp)
{
    uint8_t* f = fig0.f;
    fig_result_t r;

    int i = 1;
    while (i < fig0.figlen) {
        const uint16_t RegionId = (f[i] << 3) | (f[i+1] >> 5);
        r.complete |= fig0_21_is_complete(RegionId);
        const uint8_t Length_FI_list = f[i+1] & 0x1F; // in bytes
        r.msgs.push_back(strprintf("RegionId=0x%03x", RegionId));
        r.msgs.push_back(strprintf("Len=%d Bytes", Length_FI_list));
        i += 2;
        const int FI_start_ix = i;

        for (size_t FI_ix = 0; i < FI_start_ix + Length_FI_list; FI_ix++) {
            if (i + 3 > fig0.figlen) {
                r.errors.push_back("FIG0/21 too small!");
                break;
            }

            const uint16_t Id_field = (f[i] << 8) | f[i+1];
            const uint8_t RandM = f[i+2] >> 4;
            const bool Continuity_flag = (f[i+2] >> 3) & 0x01;
            const uint8_t Length_Freq_list = f[i+2] & 0x07; // in bytes
            r.msgs.emplace_back(1,
                    strprintf("Length Freq list=%d", Length_Freq_list));
            i += 3;

            std::string idfield;
            switch (RandM) {
                case 0x0:
                case 0x1: idfield = "EId"; break;
                case 0x6: idfield = "DRM Service Id"; break;
                case 0x8: idfield = "RDS PI"; break;
                case 0x9:
                case 0xa:
                case 0xc: idfield = "Dummy"; break;
                case 0xe: idfield = "AMSS Service Id"; break;
                default:
                          idfield = "invalid";
                          r.errors.emplace_back("R&M invalid");
                          break;
            }
            r.msgs.emplace_back(1,
                    strprintf("ID field=0x%X ", Id_field) + idfield);

            std::string rm_str;
            switch (RandM) {
                case 0x0: rm_str = "DAB ensemble, no local windows"; break;
                case 0x6: rm_str = "DRM"; break;
                case 0x8: rm_str = "FM with RDS"; break;
                case 0x9: rm_str = "FM without RDS"; break;
                case 0xa: rm_str = "AM (MW in 9 kHz steps & LW)"; break;
                case 0xc: rm_str = "AM (MW in 5 kHz steps & SW)"; break;
                case 0xe: rm_str = "AMSS"; break;
                default:
                          rm_str = "Rfu";
                          r.errors.emplace_back("R&M is Rfu");
                          break;
            }
            r.msgs.emplace_back(1,
                    strprintf("R&M=0x%1x ", RandM) + rm_str);

            std::string continuity_str;
            if ((fig0.oe() == 0) || ((fig0.oe() == 1) && (RandM != 0x6) &&
                        ((RandM < 0x8) || (RandM > 0xa)) && (RandM != 0xc) && (RandM != 0xe))) {
                if (Continuity_flag == 0) {
                    switch (RandM) {
                        case 0x0:
                        case 0x1:
                            continuity_str = "=continuous output not expected";
                            break;
                        case 0x6:
                            continuity_str = "=no compensating time delay on DRM audio signal";
                            break;
                        case 0x8:
                        case 0x9:
                            continuity_str = "=no compensating time delay on FM audio signal";
                            break;
                        case 0xa:
                        case 0xc:
                        case 0xe:
                            continuity_str = "=no compensating time delay on AM audio signal";
                            break;
                        default:
                            continuity_str = "=Rfu";
                            break;
                    }
                }
                else {  // Continuity_flag == 1
                    switch (RandM) {
                        case 0x0:
                        case 0x1:
                            continuity_str = "=continuous output possible";
                            break;
                        case 0x6:
                            continuity_str = "=compensating time delay on DRM audio signal";
                            break;
                        case 0x8:
                        case 0x9:
                            continuity_str = "=compensating time delay on FM audio signal";
                            break;
                        case 0xa:
                        case 0xc:
                        case 0xe:
                            continuity_str = "=compensating time delay on AM audio signal";
                            break;
                        default:
                            continuity_str = "=Rfu";
                            r.errors.emplace_back("continuity is Rfu");
                            break;
                    }
                }
            }
            else {  // fig0.oe() == 1
                continuity_str = "=reserved for future addition";
                r.errors.emplace_back("Rfu");
            }

            r.msgs.emplace_back(1,
                    strprintf("Continuity flag=%d ", Continuity_flag) +
                    continuity_str);

            const uint64_t key =
                ((uint64_t)fig0.oe() << 32) | ((uint64_t)fig0.pd() << 31) |
                ((uint64_t)RegionId << 20) | ((uint64_t)Id_field << 4) |
                (uint64_t)RandM;
            r.msgs.emplace_back(1,
                    strprintf("database key=0x%09" PRId64, key));

            // CEI Change Event Indication
            if (Length_Freq_list == 0) {
                r.msgs.emplace_back(1, "CEI");
            }

            // Iterate over the frequency infos
            switch (RandM) {
                case 0x0:
                case 0x1:
                    {
                        // Each entry is 24 bits (5 control + 19 freq)
                        const size_t bytes_per_entry = 3;
                        const int num_freqs = Length_Freq_list / bytes_per_entry;

                        if (Length_Freq_list % bytes_per_entry != 0) {
                            r.errors.push_back("Length of freq list incorrect size");
                        }

                        for (int freq_ix = 0; freq_ix < num_freqs; freq_ix++) {
                            if (i + bytes_per_entry > fig0.figlen) {
                                r.errors.push_back(strprintf(
                                            "FIG 0/21 too small for"
                                            " FI %d, freq %d",
                                            FI_ix, freq_ix));
                                break;
                            }

                            const uint8_t Control_field = (f[i] >> 3);
                            const uint32_t freq = 16 *
                                (((uint32_t)(f[i] & 0x07) << 16) |
                                 ((uint32_t)f[i+1] << 8) |
                                 (uint32_t)f[i+2]);
                            i += bytes_per_entry;
                            if (freq == 0) {
                                r.errors.emplace_back(strprintf(
                                            "Frequency not to be used (0) in"
                                            " FI %d, freq %d",
                                            FI_ix, freq_ix));
                                continue;
                            }
                            const uint8_t Control_field_trans_mode = (Control_field >> 1) & 0x07;
                            if ((Control_field & 0x10) == 0) {
                                r.msgs.emplace_back(2,
                                        strprintf("%d KHz", freq));
                                if ((Control_field & 0x01) == 0) {
                                    r.msgs.emplace_back(2,
                                            "geographically adjacent area");
                                }
                                else {  // (Control_field & 0x01) == 1
                                    r.msgs.emplace_back(2,
                                            "no geographically adjacent area");
                                }
                                if (Control_field_trans_mode == 0) {
                                    r.msgs.emplace_back(2,
                                            "no transmission mode signalled");
                                }
                                else if (Control_field_trans_mode <= 4) {
                                    r.msgs.emplace_back(2,
                                            strprintf("transmission mode %d",
                                                Control_field_trans_mode));
                                }
                                else {  // Control_field_trans_mode > 4
                                    r.msgs.emplace_back(2,
                                            strprintf("invalid transmission mode 0x%x",
                                                Control_field_trans_mode));
                                }
                            }
                            else {  // (Control_field & 0x10) == 0x10
                                r.msgs.emplace_back(2,
                                        strprintf("%d KHz,"
                                            "invalid Control field b23 0x%x",
                                            freq, Control_field));
                            }
                        }
                    }
                    break;
                case 0x8:
                case 0x9:
                case 0xA:
                    {
                        // entries are 8-bit freq
                        const size_t bytes_per_entry = 1;
                        const int num_freqs = Length_Freq_list / bytes_per_entry;

                        for (int freq_ix = 0; freq_ix < num_freqs; freq_ix++) {
                            if (i + bytes_per_entry > fig0.figlen) {
                                r.errors.push_back(strprintf(
                                            "FIG 0/21 too small for"
                                            " FI %d, freq %d",
                                            FI_ix, freq_ix));
                            }

                            const uint8_t freq = f[i];
                            i++;
                            if (freq == 0) {
                                r.errors.emplace_back(
                                        "Frequency not to be used (0)");
                                continue;
                            }

                            if (RandM == 0xA) {
                                if (freq < 16) {
                                    r.msgs.emplace_back(2,
                                            strprintf("%d KHz",
                                                144 + ((uint32_t)freq * 9)));
                                }
                                else {  // f[k] >= 16
                                    r.msgs.emplace_back(2,
                                            strprintf("%d KHz",
                                                387 + ((uint32_t)freq * 9)));
                                }
                            }
                            else {  // RandM == 8 or 9
                                r.msgs.emplace_back(2,
                                        strprintf("%.1f MHz",
                                            87.5 + ((float)freq * 0.1)));
                            }
                        }
                    }
                    break;
                case 0xC:
                    {
                        // freqs are 16-bit
                        const size_t bytes_per_entry = 2;
                        const int num_freqs = Length_Freq_list / bytes_per_entry;

                        if (Length_Freq_list % bytes_per_entry != 0) {
                            r.errors.push_back("Length of freq list incorrect size");
                        }
                        for (int freq_ix = 0; freq_ix < num_freqs; freq_ix++) {
                            if (i + bytes_per_entry > fig0.figlen) {
                                r.errors.push_back(strprintf(
                                            "FIG 0/21 too small for"
                                            " FI %d, freq %d",
                                            FI_ix, freq_ix));
                            }

                            // freqs are 16-bit
                            const uint16_t freq = 5 *
                                (((uint16_t)f[i] << 8) |
                                 (uint32_t)f[i+1]);
                            i += bytes_per_entry;
                            if (freq != 0) {
                                r.msgs.emplace_back(2,
                                        strprintf("%d KHz", freq));
                            }
                            else {
                                r.errors.emplace_back(
                                        "Frequency not to be used (0)");
                            }
                        }
                    }
                    break;
                case 0x6:
                case 0xE:
                    {
                        // There is a first 8-bit entry, and the
                        // list contains 16-bit freqs
                        if (i + 1 > fig0.figlen) {
                            r.errors.push_back(strprintf(
                                        "FIG 0/21 too small for"
                                        " control of"
                                        " FI %d",
                                        FI_ix));
                        }

                        const size_t bytes_per_entry = 2;
                        const int num_freqs = (Length_Freq_list-1) / bytes_per_entry;

                        if ((Length_Freq_list-1) % bytes_per_entry != 0) {
                            r.errors.push_back("Length of freq list incorrect size");
                        }
                        const uint32_t Id_field2 = f[i];
                        i++;

                        for (int freq_ix = 0; freq_ix < num_freqs; freq_ix++) {
                            if (i + bytes_per_entry > fig0.figlen) {
                                r.errors.push_back(strprintf(
                                            "FIG 0/21 too small for"
                                            " FI %d, freq %d",
                                            FI_ix, freq_ix));
                            }
                            // entries are 16bit freq
                            const uint16_t freq =
                                ((((uint16_t)f[i] & 0x7f) << 8) |
                                 (uint16_t)f[i+1]);
                            i += bytes_per_entry;

                            if (freq != 0) {
                                r.msgs.emplace_back(2,
                                        strprintf("%d KHz", freq));
                            }
                            else {
                                r.errors.emplace_back(
                                        "Frequency not to be used (0)");
                            }

                            const uint32_t srv_id = (Id_field2 << 16) | Id_field;
                            if (RandM == 0x6) {
                                r.msgs.emplace_back(2,
                                        strprintf("DRM Service Id 0x%X", srv_id));
                            }
                            else if (RandM == 0xE) {
                                r.msgs.emplace_back(2,
                                        strprintf("AMSS Service Id 0x%X", srv_id));
                            }
                        }
                    }
                    break;
                default:
                    r.errors.push_back(strprintf("Invalid R&M"));
                    break;
            }
        }
    }

    return r;
}