PeerStreamer

/*

  Copyright 2003 John Knottenbelt

  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 2 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, write to the Free Software

  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.

*/

#include "config.h"

#include "tuneparams.h"

#include "stringutil.h"

#include <map>

#include <iostream>

#include <cstdlib>

#include "tune.h"

// DVB-T Tuning Parameters 

DVBTTuneParams::DVBTTuneParams(const std::string &name, int apid, int vpid)

  : TuneParams(name, apid, vpid),

    freq(0),

    qam(CONSTELLATION_DEFAULT),

    inv(INVERSION_OFF),

    fec1(HP_CODERATE_DEFAULT),

    fec2(HP_CODERATE_DEFAULT),

    hier(HIERARCHY_DEFAULT),

    bandw(BANDWIDTH_DEFAULT),

    mode(TRANSMISSION_MODE_DEFAULT),

    guard(GUARD_INTERVAL_DEFAULT)

{

}

DVBTTuneParams::~DVBTTuneParams()

{

}

// transTable is an auxillary mapping from

// string keywords (eg FEC_1_2) to numbers

// FEC_1_2. Used in parsing. See translate() and

// DVBTTuneParams::createFromTZAP() 

typedef std::map<std::string, int> StringIntMap;

static StringIntMap transTable;

static bool transTableSetup = false;

static int translate(const std::string &t) 

{

  if (!transTableSetup) {

    transTable["INVERSION_AUTO"] = INVERSION_AUTO;

    transTable["INVERSION_OFF"] = INVERSION_OFF;

    transTable["INVERSION_ON"] = INVERSION_ON;

    transTable["FEC_NONE"] = FEC_NONE;

    transTable["FEC_1_2"] = FEC_1_2;

    transTable["FEC_2_3"] = FEC_2_3;

    transTable["FEC_3_4"] = FEC_3_4;

    transTable["QAM_16"] = QAM_16;

    transTable["QAM_64"] = QAM_64;

    transTable["GUARD_INTERVAL_1_8"] = GUARD_INTERVAL_1_8;

    transTable["GUARD_INTERVAL_1_16"] = GUARD_INTERVAL_1_16;

    transTable["GUARD_INTERVAL_1_32"] = GUARD_INTERVAL_1_32;

    transTable["HIERARCHY_NONE"] = HIERARCHY_NONE;

    transTable["BANDWIDTH_7_MHZ"] = BANDWIDTH_7_MHZ;

    transTable["BANDWIDTH_8_MHZ"] = BANDWIDTH_8_MHZ;

    transTable["TRANSMISSION_MODE_2K"] = TRANSMISSION_MODE_2K;

    transTable["TRANSMISSION_MODE_8K"] = TRANSMISSION_MODE_8K;

  }

  StringIntMap::const_iterator i = transTable.find(t);

  if (i == transTable.end()) {

    std::cerr << "Fatal Error: no translation for \"" << t << "\" in " << __FILE__ << ":" << __LINE__ << "\n";

    exit(1);

  }

  return i->second;

}

DVBTTuneParams *DVBTTuneParams::createFromTZAP(const std::string &line)

{

  // It is assumed that the line is a valid TZAP conf line

  // (not a comment) 

  std::vector<std::string> v;

  splitString(line, ':', v);

  std::string &newName = v[0];

  int vpid = toUnsignedLong(v[10]);

  int apid = toUnsignedLong(v[11]);

  DVBTTuneParams *p = new DVBTTuneParams(newName, vpid, apid);

  p->freq = toUnsignedLong(v[1]);

  p->inv = translate(v[2]);

  p->bandw = translate(v[3]);

  p->fec1 = translate(v[4]);

  p->fec2 = translate(v[5]);

  p->qam = translate(v[6]);

  p->mode = translate(v[7]);

  p->guard = translate(v[8]);

  p->hier = translate(v[9]);

  return p;

}

bool DVBTTuneParams::tune(int frontendFD) const

{

  // Possible todo:

  // Change tune_it to observe lower code rate (fec2)

  // Give it three goes at least!

  for (int i = 0; i < 3; i++) {

    int rc = tune_it(frontendFD, 

                     0,                // old fd_sec 

                     freq / 1000, 

                     0,                // Symbol Rate for DVB-C or DVB-S 

                     0,                // Polarity 

                     -1,        // Tone  

                     fe_spectral_inversion_t(inv), 

                     0,                // diseqc 

                     fe_modulation_t(qam),

                     fe_code_rate_t(fec1), 

                     fe_transmit_mode_t(mode),

                     fe_guard_interval_t(guard), 

                     fe_bandwidth_t(bandw));

    if (rc >= 0)

      return true;

  }

  std::cerr << "Fatal error: failed to tune channel " << name << "\n";

  return false;

}

bool DVBTTuneParams::sameAsExceptPIDs(const TuneParams &other) const

{

  const DVBTTuneParams &x = dynamic_cast<const DVBTTuneParams&>(other);

  if (&x == NULL)

    return false;

  return (freq == x.freq &&

          inv == x.inv &&

          bandw == x.bandw &&

          fec1 == x.fec1 &&

          fec2 == x.fec2 &&

          qam == x.qam &&

          mode == x.mode &&

          guard == x.guard &&

          hier == x.hier);

}