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 "tuner.h"

#include "demuxer.h"

#include "tuneparams.h"

#include "psfilter.h"

#include "debug.h"

#include <iostream>

#include <cstdlib>

#include <cerrno>

#include <cstring>

#include <cassert>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

// Size of a TS packet

#define TS_SIZE 188

Tuner::Tuner( const std::string &frontendDevice )

    : numReaders(0),

      frontendFD(-1),

      dvrFD(-1),

      tuneParams(NULL), oldTuneParams(NULL),

      frontendDevice(frontendDevice),

      closeTimer(1000, &Tuner::reallyCloseFrontendCallback, this)

{

  // Derive the demuxDevice from the frontend string

  unsigned fPos = frontendDevice.find("frontend");

  if (fPos == std::string::npos) {

    std::cerr << "Fatal error: frontendDevice not in expected form\n";

    exit(1);

  }

  demuxDevice = frontendDevice;

  demuxDevice.replace(fPos, 8, "demux" );

  dvrDevice = frontendDevice;

  dvrDevice.replace(fPos, 8, "dvr" );

  if (debugging) {

    // Debugging information

    std::cerr << "frontend: " << frontendDevice << "\n"

              << "demux: " << demuxDevice << "\n"

              << "dvr: " << dvrDevice << std::endl;

  }

}

Tuner::~Tuner()

{

  SinkList copy = subscribers;

  unsubscribeAll();

  // Destroy all the Demuxes

  for (DemuxerMap::iterator i = demuxerMap.begin(); i != demuxerMap.end(); i++) {

    PIDMap &pidmap = i->second;

    for (PIDMap::iterator j = pidmap.begin(); j != pidmap.end(); j++)

      delete j->second;

  }

  // Destroy all the PSFilters

  for (PSFilterMap::iterator i = psfilterMap.begin(); i != psfilterMap.end(); i++) 

    delete i->second;

}

void Tuner::setTuneParams(const TuneParams *tuneParams)

{

  if (numReaders > 0) {

    std::cerr << "Fatal error: can't change tuning parameters while readers > 0\n";

    exit(1);

  }

  this->tuneParams = tuneParams;

}

void Tuner::addSelectFDs(Select &s) const

{

  if (dvrFD != -1)

    s.addReadFD(dvrFD);

}

bool Tuner::isReady(const Select &s) const {

  if (dvrFD == -1)

    return false;

  return s.readyToRead(dvrFD);

}

Demuxer *Tuner::makeNewDemuxer(int pid, Demuxer::PESType pesType) const

{

  return new Demuxer(const_cast<Tuner *>(this), pid, pesType);

}

// Keep a list of all the demuxers ever created

Source *Tuner::getDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const

{

  // Strictly speaking getDemuxer() is not a const

  // method, however, it does have minimal side

  // effects since creating a Demuxer is not

  // the same thing as subscribing to one.

  if (pid == 0)

    return NULL;

  assert(tuneParams != NULL);

  DemuxerMap &dm = demuxerMap;

  PIDMap &pidMap = dm[tuneParams];

  Demuxer *&demuxer = pidMap[pid];

  if (demuxer == NULL) 

    demuxer = makeNewDemuxer(pid, pesType);

  if (!convertToPS) 

    return demuxer;

  PSFilter *&psfilter = psfilterMap[demuxer];

  if (psfilter == NULL) 

    psfilter = new PSFilter(demuxer);

  return psfilter;

}

bool Tuner::openFrontend()

{

  closeTimer.stop();

  // Front end is already open, no need to close it.

  if (frontendFD != -1) 

    return true;

  if((frontendFD = open(frontendDevice.c_str(),O_RDWR)) < 0){

    std::cerr << "Error opening frontend device " << frontendDevice << ":" 

              << strerror(errno) << std::endl;

    return false;

  }

  else 

    return true;

}

void Tuner::closeFrontend()

{

  if (frontendFD >= 0) {

    // Take a second to actually close the front end

    // So that if another channel of the same frequency

    // is requested in that time we don't have to waste time re-tuning.

    closeTimer.start();

    oldTuneParams = tuneParams;

  }

}

void Tuner::reallyCloseFrontendCallback( void *arg )

{

  Tuner *self = (Tuner *) arg;

  close(self->frontendFD);

  self->frontendFD = -1;

  self->oldTuneParams = 0;

}

bool Tuner::openDvr()

{

  if((dvrFD = open(dvrDevice.c_str(),O_RDONLY|O_NONBLOCK)) < 0){

    std::cerr << "Error opening DVR device " << dvrDevice << ":" 

              << strerror(errno) << std::endl;

    return false;

  }

  return true;

}

void Tuner::closeDvr()

{

  if (dvrFD >= 0) {

    close(dvrFD);

    dvrFD = -1;

  }

}

bool Tuner::tune()

{

  if (tuneParams == oldTuneParams)

    return true;

  if (!tuneParams->tune(frontendFD))

    return false;

  oldTuneParams = tuneParams;

  return true;

}

bool Tuner::subscribe(Sink *s)

{

  // On the first subscriber make sure to tune the channel

  // and open the dvr device 

  if (getNumSubscribers() == 0) {

    assert(tuneParams);

    if (!openFrontend())

      return false;

    if (!tune()) {

      closeFrontend();

      return false;

    }

    if (!openDvr()) {

      closeFrontend();

      return false;

    }

  }

  return Source::subscribe(s);

}

void Tuner::unsubscribe(Sink *s)

{

  Source::unsubscribe(s);

  // On the last subscriber close down the dvr channel

  if (getNumSubscribers() == 0) {

    closeDvr();

    closeFrontend();

  }

}

void Tuner::process() {

  if (dvrFD == -1) 

    return;

  unsigned char data[TS_SIZE];

  int  bytesread;

  if ((bytesread = read(dvrFD, (char *) data, TS_SIZE)) > 0) 

    sendData(data, (unsigned) bytesread);

}