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

#include "tuner.h"

#include "connection.h"

#include <iostream>

#include <cstdlib>

#include <climits>

#include <sys/ioctl.h>

#include <stdio.h>

#include <stdint.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <time.h>

#include <unistd.h>

#include <linux/dvb/dmx.h>

#define IPACKS 2048

#define TS_SIZE 188

static void set_ts_filt(int fd,uint16_t pid, dmx_pes_type_t pestype);

Demuxer::Demuxer(Tuner *tuner, int pid, bool convertToPS, Demuxer::PESType pestype)

  : tuner(tuner), pid(pid), demuxFD(-1)

{

  init_ipack(&packer, IPACKS, output, 1);

  switch (pestype) {

  case Video: this->pesType = int(DMX_PES_VIDEO); break;

  case Audio: this->pesType = int(DMX_PES_AUDIO); break;

  case Teletext: this->pesType = int(DMX_PES_TELETEXT); break;

  }

  packer.data = this;

}

Demuxer::~Demuxer()

{

  unsubscribeAll();

  free_ipack(&packer);

}

// Static function for use by the ipack code

void Demuxer::output(uint8_t *data, int size, void *priv)

{

  Demuxer *d = (Demuxer *) priv;

  d->sendData(data, (unsigned) size);

}

bool Demuxer::openDemux()

{

  std::string demuxDev = tuner->getDemuxerDevice();

  demuxFD = open(demuxDev.c_str(), O_RDWR);

  return (demuxFD >= 0);

}

void Demuxer::closeDemux()

{

  if (demuxFD >= 0) {

    ::close(demuxFD);

    demuxFD = -1;

  }

}

void Demuxer::setTSFilt( bool dmxOther )

{

  dmx_pes_type_t thePesType = 

    (dmxOther ? dmx_pes_type_t(pesType) : DMX_PES_OTHER);

  set_ts_filt(demuxFD, pid, thePesType);

}

bool Demuxer::subscribe(Sink *s)

{

  if (getNumSubscribers() == 0) {

    if (!openDemux()) {

      std::cerr << "Failed to open demuxer\n";

      return false;

    }

    // DVB Seems to like AUDIO / VIDEO only for the first two PIDs

    // otherwise OTHER must be used.

    bool dmxOther = (tuner->getNumSubscribers() >= 2);

    if (!tuner->subscribe(this)) {

      closeDemux();

      return false;

    }

    setTSFilt(dmxOther);

  }

  return Source::subscribe(s);

}

void Demuxer::unsubscribe(Sink *s) 

{

  Source::unsubscribe(s);

  if (getNumSubscribers() == 0) {

    close(demuxFD);

    tuner->unsubscribe(this);

  }

}

void Demuxer::notifyUnsubscribe(Source *)

{

  // This method is called when the tuner manager

  // forcefully unsubscribes demuxers from the channel.

  // Since our source is no longer available

  // we should unsubscribe the clients.

  unsubscribeAll();

}

void Demuxer::receiveData(unsigned char *data, unsigned size)

{

  if (convertToPS) {

    // adapted from my_ts_to_ps( uint8_t* buf, uint16_t pida, uint16_t pidv)

    // in dvbstream.c (Dave Chapman)

    uint16_t pid;

    ipack *p = &this->packer;

    uint8_t off = 0;

    uint8_t *buf = (uint8_t *) data;

    pid = get_pid(buf+1);

    if (!(buf[3]&0x10)) // no payload?

      return;

    // Is this our packet?

    if (pid != this->pid)

      return;

    if ( buf[1]&0x40) {

      if (p->plength == MMAX_PLENGTH-6){

        p->plength = p->found-6;

        p->found = 0;

        send_ipack(p);

        reset_ipack(p);

      }

    }

    if ( buf[3] & 0x20) {  // adaptation field?

      off = buf[4] + 1;

    }

    instant_repack(buf+4+off, TS_SIZE-4-off, p);

  }

  else {

    if (get_pid(data + 1) == pid)

      sendData(data, (unsigned) size);

  }

}

static void set_ts_filt(int fd,uint16_t pid, dmx_pes_type_t pestype)

{

  // From Dave Chapman's dvbstream.c

  struct dmx_pes_filter_params pesFilterParams;

  pesFilterParams.pid     = pid;

  pesFilterParams.input   = DMX_IN_FRONTEND;

  pesFilterParams.output  = DMX_OUT_TS_TAP;

#ifdef NEWSTRUCT

  pesFilterParams.pes_type = pestype;

#else

  pesFilterParams.pesType = pestype;

#endif

  pesFilterParams.flags   = 0;

  if (ioctl(fd, DMX_SET_PES_FILTER, &pesFilterParams) < 0)  {

    fprintf(stderr,"FILTER %i: ",pid);

    perror("DMX SET PES FILTER");

  }

  if (ioctl(fd, DMX_START, &pesFilterParams) < 0)  {

    fprintf(stderr,"FILTER %i: ",pid);

    perror("DMX START");

  }

}