senf/Socket/Protocols/DVB/DVBConfigParser.cc

   1 #include "DVBConfigParser.hh"
   2 #include <boost/assign/std/map.hpp>
   3 #include <senf/Utils/Exception.hh>
   4 #include <senf/Utils/Logger.hh>
   5 using namespace std;
   6 #define prefix_
   7
   8 senf::DVBConfigParser::DVBParams const senf::DVBConfigParser::params;
   9
  10 prefix_ senf::DVBConfigParser::DVBParams::DVBParams()
  11 {
  12
  13     boost::assign::insert(inversion)
  14     (   "INVERSION_OFF", INVERSION_OFF )
  15     (   "INVERSION_ON", INVERSION_ON )
  16     (   "INVERSION_AUTO", INVERSION_AUTO );
  17     boost::assign::insert(bandwidth)
  18     (   "BANDWIDTH_6_MHZ", BANDWIDTH_6_MHZ)
  19     (   "BANDWIDTH_7_MHZ", BANDWIDTH_7_MHZ)
  20     (   "BANDWIDTH_8_MHZ", BANDWIDTH_8_MHZ);
  21     boost::assign::insert(code_rate)
  22     (   "FEC_1_2", FEC_1_2)
  23     (   "FEC_2_3", FEC_2_3)
  24     (   "FEC_3_4", FEC_3_4)
  25     (   "FEC_4_5", FEC_4_5)
  26     (   "FEC_5_6", FEC_5_6)
  27     (   "FEC_6_7", FEC_6_7)
  28     (   "FEC_7_8", FEC_7_8)
  29     (   "FEC_8_9", FEC_8_9)
  30     (   "FEC_AUTO", FEC_AUTO)
  31     (   "FEC_NONE", FEC_NONE);
  32     boost::assign::insert(guard_interval)
  33     (   "GUARD_INTERVAL_1_16", GUARD_INTERVAL_1_16)
  34     (   "GUARD_INTERVAL_1_32", GUARD_INTERVAL_1_32)
  35     (   "GUARD_INTERVAL_1_4", GUARD_INTERVAL_1_4)
  36     (   "GUARD_INTERVAL_1_8", GUARD_INTERVAL_1_8);
  37     boost::assign::insert(hierarchy)
  38     (   "HIERARCHY_1", HIERARCHY_1)
  39     (   "HIERARCHY_2", HIERARCHY_2)
  40     (   "HIERARCHY_4", HIERARCHY_4)
  41     (   "HIERARCHY_NONE", HIERARCHY_NONE);
  42     boost::assign::insert(modulation)
  43     (   "QPSK", QPSK)
  44     (   "QAM_128", QAM_128)
  45     (   "QAM_16", QAM_16)
  46     (   "QAM_256", QAM_256)
  47     (   "QAM_32", QAM_32)
  48     (   "QAM_64", QAM_64);
  49     boost::assign::insert(transmit_mode)
  50     (   "TRANSMISSION_MODE_2K", TRANSMISSION_MODE_2K)
  51     (   "TRANSMISSION_MODE_8K", TRANSMISSION_MODE_8K);
  52 }
  53
  54 senf::DVBConfigParser::DVBConfigParser(fe_type_t type_, const string & configFilePath_) :
  55     type(type_),
  56     configFile()
  57 {
  58     initConfigFile(configFilePath_);
  59 }
  60
  61 senf::DVBConfigParser::~DVBConfigParser()
  62 {
  63     configFile.close();
  64 }
  65
  66 prefix_ void senf::DVBConfigParser::initConfigFile(string configFilePath_)
  67 {
  68     if (configFilePath_.size() == 0) {
  69         if ( !(::getenv ("HOME")) )
  70             SENF_THROW_SYSTEM_EXCEPTION("$HOME not set! You need it to use default configfile.");
  71         string configPath(::getenv ("HOME"));
  72         switch(type) {
  73             case FE_QPSK :
  74                 configPath += string("/.szap/channels.conf");
  75                 break;
  76             case FE_QAM :
  77                 configPath += string("/.czap/channels.conf");
  78                 break;
  79             case FE_OFDM :
  80                 configPath += string("/.tzap/channels.conf");
  81                 break;
  82             default:
  83                 SENF_THROW_SYSTEM_EXCEPTION("Could not determine type of card.");
  84         }
  85         configFilePath_ = configPath;
  86     }
  87     configFilePath = configFilePath_;
  88     configFile.open( configFilePath.c_str(), ios_base::in);
  89     if (configFile.bad())
  90         SENF_LOG((senf::log::IMPORTANT)  ("Could not open channels file"<< configFilePath << "." ));
  91     configFile.close();
  92 }
  93 prefix_ string senf::DVBConfigParser::getConfigLine(string channel)
  94 {
  95     string configLine;
  96     size_t pos;
  97     transform(channel.begin(), channel.end(), channel.begin(), ::toupper);
  98
  99     configFile.open( configFilePath.c_str(), ios_base::in);
 100     if (configFile.bad())
 101            SENF_THROW_SYSTEM_EXCEPTION("Could not read channels file: ") << configFilePath << ".";
 102
 103     while (configFile.good()) {
 104         getline( configFile, configLine );
 105         SENF_LOG((senf::log::NOTICE)  ("configLine: " << configLine ));
 106         transform(configLine.begin(), configLine.end(), configLine.begin(), ::toupper);
 107         pos = configLine.find(channel);
 108
 109         if (pos != string::npos && pos == 0) { // only first matching number should be interpreted as channel number
 110             configFile.close();
 111             return configLine; // Line found!
 112         }
 113     }
 114     configFile.close();
 115     SENF_THROW_SYSTEM_EXCEPTION("Channel \"")<< channel << "\" not found!";
 116     return channel;
 117 }
 118
 119 prefix_ dvb_frontend_parameters senf::DVBConfigParser::getFrontendParam(string configLine)
 120 {
 121     struct dvb_frontend_parameters frontend;
 122     transform(configLine.begin(), configLine.end(), configLine.begin(), ::toupper);
 123     boost::char_separator<char> sep(":");
 124     tokenizer tokens(configLine, sep);
 125     switch (type) {
 126         case FE_QPSK:
 127             frontend = getFrontendParamDVB_S(tokens);
 128             break;
 129         case FE_QAM:
 130             frontend = getFrontendParamDVB_C(tokens);
 131             break;
 132         case FE_OFDM:
 133             frontend = getFrontendParamDVB_T(tokens);
 134             break;
 135         default:
 136             SENF_THROW_SYSTEM_EXCEPTION("Could not determine type of card.");
 137     }
 138     return frontend;
 139 }
 140
 141 prefix_ dvb_frontend_parameters
 142 senf::DVBConfigParser::getFrontendParamDVB_T(const tokenizer & tokens)
 143 {
 144     struct dvb_frontend_parameters frontend;
 145     istringstream isst;
 146     int number;
 147     enum { p_Frequency=1, p_Inversion, p_Bandwidth, p_hp_code_rate, p_lp_code_rate, p_Mudualtion, p_Transmission, p_guard, p_hierarchy};
 148     vector<string> words( tokens.begin(), tokens.end() );
 149
 150     ::memset(&frontend, 0, sizeof(struct dvb_frontend_parameters));
 151
 152     /*if (words.size() < 10)
 153         SENF_THROW_SYSTEM_EXCEPTION("Too few arguments! There must be at least 10, but there are only: ") << words.size();*/
 154
 155     isst.str(words[p_Frequency]);
 156     isst >> number;
 157     if (isst.fail())
 158         SENF_THROW_SYSTEM_EXCEPTION("Cant parse frequency");
 159     frontend.frequency = number;
 160
 161     if (params.inversion.find(words[p_Inversion]) == params.inversion.end())
 162         SENF_THROW_SYSTEM_EXCEPTION("Cant parse inversion");
 163     frontend.inversion = params.inversion.find(words[p_Inversion])->second;
 164
 165     if (params.bandwidth.find(words[p_Bandwidth]) == params.bandwidth.end())
 166         SENF_THROW_SYSTEM_EXCEPTION("Cant parse bandwidth");
 167     frontend.u.ofdm.bandwidth = params.bandwidth.find(words[p_Bandwidth])->second;
 168
 169     if (params.code_rate.find(words[p_hp_code_rate]) == params.code_rate.end())
 170         SENF_THROW_SYSTEM_EXCEPTION("Cant parse high priority stream code rate");
 171     frontend.u.ofdm.code_rate_HP = params.code_rate.find(words[p_hp_code_rate])->second;
 172
 173     if (params.code_rate.find(words[p_lp_code_rate]) == params.code_rate.end())
 174         SENF_THROW_SYSTEM_EXCEPTION("Cant parse low priority stream code rate");
 175     frontend.u.ofdm.code_rate_LP = params.code_rate.find(words[p_lp_code_rate])->second;
 176
 177     if (params.modulation.find(words[p_Mudualtion]) == params.modulation.end())
 178         SENF_THROW_SYSTEM_EXCEPTION("Cant parse modulation");
 179     frontend.u.ofdm.constellation = params.modulation.find(words[p_Mudualtion])->second;
 180
 181     if (params.transmit_mode.find(words[p_Transmission]) == params.transmit_mode.end())
 182         SENF_THROW_SYSTEM_EXCEPTION("Cant parse transmission mode");
 183     frontend.u.ofdm.transmission_mode = params.transmit_mode.find(words[p_Transmission])->second;
 184
 185     if (params.guard_interval.find(words[p_guard]) == params.guard_interval.end())
 186         SENF_THROW_SYSTEM_EXCEPTION("Cant parse guard interval");
 187     frontend.u.ofdm.guard_interval = params.guard_interval.find(words[p_guard])->second;
 188
 189     if (params.hierarchy.find(words[p_hierarchy]) == params.hierarchy.end())
 190         SENF_THROW_SYSTEM_EXCEPTION("Cant parse hierarchy");
 191     frontend.u.ofdm.hierarchy_information = params.hierarchy.find(words[p_hierarchy])->second;
 192
 193     return frontend;
 194 }
 195
 196 prefix_ dvb_frontend_parameters
 197 senf::DVBConfigParser::getFrontendParamDVB_S(const tokenizer & tokens)
 198 {
 199     struct dvb_frontend_parameters frontend;
 200     istringstream isst;
 201     int number;
 202     enum { p_Frequency=1, p_Inversion, p_Symbole, p_code_rate};
 203     vector<string> words( tokens.begin(), tokens.end() ) ;
 204
 205     ::memset(&frontend, 0, sizeof(struct dvb_frontend_parameters));
 206
 207     if (words.size() < 5)
 208                 SENF_THROW_SYSTEM_EXCEPTION("Too few arguments! There must be at least 5, but there are only: ") << words.size();
 209
 210     isst.str(words[p_Frequency]);
 211     isst >> number;
 212     if (isst.fail())
 213         SENF_THROW_SYSTEM_EXCEPTION("Cant parse frequency");
 214     frontend.frequency = number;
 215
 216     if (params.inversion.find(words[p_Inversion]) == params.inversion.end())
 217         SENF_THROW_SYSTEM_EXCEPTION("Cant parse inversion");
 218     frontend.inversion = params.inversion.find(words[p_Inversion])->second;
 219
 220     isst.str(words[p_Symbole]);
 221     isst >> number;
 222     if (isst.fail())
 223         SENF_THROW_SYSTEM_EXCEPTION("Cant parse symbole rate");
 224     frontend.u.qpsk.symbol_rate = number;
 225
 226     if (params.code_rate.find(words[p_code_rate]) == params.code_rate.end())
 227         SENF_THROW_SYSTEM_EXCEPTION("Cant parse code rate");
 228     frontend.u.qpsk.fec_inner = params.code_rate.find(words[p_code_rate])->second;
 229
 230     return frontend;
 231 }
 232
 233 prefix_ dvb_frontend_parameters
 234 senf::DVBConfigParser::getFrontendParamDVB_C(const tokenizer & tokens)
 235 {
 236     struct dvb_frontend_parameters frontend;
 237     istringstream isst;
 238     int number;
 239     enum { p_Frequency=1, p_Inversion, p_Symbole, p_code_rate, p_modulation};
 240     vector<string> words( ++tokens.begin(), tokens.end() ) ;
 241
 242     ::memset(&frontend, 0, sizeof(struct dvb_frontend_parameters));
 243
 244     if (words.size() < 6)
 245         SENF_THROW_SYSTEM_EXCEPTION("Too few arguments! There must be at least 6, but there are only: ") << words.size();
 246
 247     isst.str(words[p_Frequency]);
 248     isst >> number;
 249     if (isst.fail())
 250         SENF_THROW_SYSTEM_EXCEPTION("Cant parse frequency");
 251     frontend.frequency = number;
 252
 253     if (params.inversion.find(words[p_Inversion]) == params.inversion.end())
 254         SENF_THROW_SYSTEM_EXCEPTION("Cant parse inversion");
 255     frontend.inversion = params.inversion.find(words[p_Inversion])->second;
 256
 257     isst.str(words[p_Symbole]);
 258     isst >> number;
 259     if (isst.fail())
 260         SENF_THROW_SYSTEM_EXCEPTION("Cant parse symbole rate");
 261     frontend.u.qam.symbol_rate = number;
 262
 263     if (params.code_rate.find(words[p_code_rate]) == params.code_rate.end())
 264         SENF_THROW_SYSTEM_EXCEPTION("Cant parse code rate");
 265     frontend.u.qam.fec_inner = params.code_rate.find(words[p_code_rate])->second;
 266
 267     if (params.modulation.find(words[p_modulation]) == params.modulation.end())
 268         SENF_THROW_SYSTEM_EXCEPTION("Cant parse modulation");
 269     frontend.u.qam.modulation = params.modulation.find(words[p_modulation])->second;
 270
 271     return frontend;
 272 }