/ - Diff - PeerStreamer - Redmine

     .deps
     Makefile
     Makefile.in
     dvbcat
     dvbd
     dvblist
     dvbsched
+    k
     lextime.c
     parsetime.c

     #include <cerrno>
     #include <ctime>
     #include <algorithm>
     #include <cassert>
     Connection::Connection(TunerManager *tm, int dataFD)
       : dataFD(dataFD), priority(0),
-...
     bool Connection::doSubscribe()
+    {
       bool result = true;
       int n = 0;
       for (DemuxerList::iterator i = demuxers.begin(); i != demuxers.end(); i++)
       for (DemuxerList::iterator i = demuxers.begin(); i != demuxers.end(); i++)
         result = (*i)->subscribe(this) && result;
       if (!result) {
         doUnsubscribe();
         return false;
+      }
       return true;
+    }
-...
         SavePriority save(this, p - 1);
         // Try to allocate the new demuxers
         tm->getDemuxers(newType, newChannel, newDemuxers, p);
         tm->getDemuxers(newType, newChannel, true, newDemuxers, p);
         retuning = false;
         if (newDemuxers.empty())

     static void set_ts_filt(int fd,uint16_t pid, dmx_pes_type_t pestype);
     Demuxer::Demuxer(Tuner *tuner, int pid, Demuxer::PESType pestype)
     Demuxer::Demuxer(Tuner *tuner, int pid, bool convertToPS, Demuxer::PESType pestype)
       : tuner(tuner), pid(pid), demuxFD(-1)
+    {
       init_ipack(&packer, IPACKS, output, 1);
-...
     void Demuxer::receiveData(unsigned char *data, unsigned size)
+    {
       // 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 (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;
+      }
         if ( buf[3] & 0x20) {  // adaptation field?
           off = buf[4] + 1;
+        }
       instant_repack(buf+4+off, TS_SIZE-4-off, p);
         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)

     protected:
       friend class Tuner;
       Demuxer(Tuner *tuner, int pid, PESType pestype);
       Demuxer(Tuner *tuner, int pid, bool convertToPS, PESType pestype);
       virtual ~Demuxer();
     public:
-...
     private:
       Tuner *tuner;
       int pid;
       bool convertToPS;
       int demuxFD;
       ipack packer;
       int pesType;

src/fakedemuxer.cpp
18	18
19	19	#include "fakedemuxer.h"
20	20
21		FakeDemuxer::FakeDemuxer(Tuner *tuner, int pid, PESType pestype)
22		: Demuxer(tuner, pid, pestype)
	21	FakeDemuxer::FakeDemuxer(Tuner *tuner, int pid, bool convertToPS, PESType pestype)
	22	: Demuxer(tuner, pid, convertToPS, pestype)
23	23	{
24	24	}
25	25

     class FakeDemuxer : public Demuxer {
     protected:
       friend class FakeTuner;
       FakeDemuxer(Tuner *tuner, int pid, PESType pestype);
       FakeDemuxer(Tuner *tuner, int pid, bool convertToPS, PESType pestype);
     protected:
       virtual bool openDemux();

src/faketuner.cpp
29	29	setTuneParams(realTuner.getTuneParams());
30	30	}
31	31
32		Demuxer *FakeTuner::makeNewDemuxer(int pid, Demuxer::PESType pesType) const
	32	Demuxer *FakeTuner::makeNewDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const
33	33	{
34		return new FakeDemuxer(const_cast<FakeTuner *>(this), pid, pesType);
	34	return new FakeDemuxer(const_cast<FakeTuner *>(this), pid, convertToPS, pesType);
35	35	}
36	36
37	37	bool FakeTuner::openFrontend()

       FakeTuner( const Tuner &realTuner );
     protected:
       virtual Demuxer *makeNewDemuxer(int pid, Demuxer::PESType pesType) const;
       virtual Demuxer *makeNewDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const;
       virtual bool openFrontend();
       virtual void closeFrontend();
       virtual bool openDvr();

         exit(0);
       chdir("/");
       umask(0);
       umask(022);
       setsid();
       // Fork #2

       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;
       for (int h = 0; h < 2; h++) {
         DemuxerMap &dm = demuxerMap[h];
         for (DemuxerMap::iterator i = dm.begin(); i != dm.end(); i++) {
           PIDMap &pidmap = i->second;
           for (PIDMap::iterator j = pidmap.begin(); j != pidmap.end(); j++)
     	delete j->second;
+        }
+      }
+    }
-...
       return s.readyToRead(dvrFD);
+    }
     Demuxer *Tuner::makeNewDemuxer(int pid, Demuxer::PESType pesType) const
     Demuxer *Tuner::makeNewDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const
+    {
       return new Demuxer(const_cast<Tuner *>(this), pid, pesType);
       return new Demuxer(const_cast<Tuner *>(this), pid, convertToPS, pesType);
+    }
     // Keep a list of all the demuxers ever created
     Demuxer *Tuner::getDemuxer(int pid, Demuxer::PESType pesType) const
     Demuxer *Tuner::getDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const
+    {
       // Strictly speaking getDemuxer() is not a const
       // method, however, it does have minimal side
-...
       assert(tuneParams != NULL);
       PIDMap &pidMap = demuxerMap[tuneParams];
       DemuxerMap &dm = demuxerMap[ convertToPS ? 1 : 0 ];
       PIDMap &pidMap = dm[tuneParams];
       Demuxer *&demuxer = pidMap[pid];
       if (demuxer == NULL)
         demuxer = makeNewDemuxer(pid, pesType);
         demuxer = makeNewDemuxer(pid, convertToPS, pesType);
       return demuxer;
+    }

       virtual void addSelectFDs(Select &) const;
       virtual bool isReady(const Select &) const;
       Demuxer *getDemuxer(int pid, Demuxer::PESType pesType) const;
       Demuxer *getDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const;
       int getMaxNumSubscribers() const { return 8; }
       virtual bool subscribe(Sink *s);
-...
       void process();
     protected:
       virtual Demuxer *makeNewDemuxer(int pid, Demuxer::PESType pesType) const;
       virtual Demuxer *makeNewDemuxer(int pid, bool convertToPS, Demuxer::PESType pesType) const;
       virtual bool openFrontend();
       virtual void closeFrontend();
       virtual bool openDvr();
-...
       typedef std::map <int, Demuxer *> PIDMap;
       typedef std::map <const TuneParams *, PIDMap> DemuxerMap;
       mutable DemuxerMap demuxerMap;
       // demuxerMap[0] for TS
       // demuxerMap[1] for PS
       mutable DemuxerMap demuxerMap[2];
     };
     #endif // __TUNER_H

     	  continue;
+          }
           Demuxer *audio = t->getDemuxer(c->getAudioPID(), Demuxer::Audio);
           Demuxer *video = t->getDemuxer(c->getVideoPID(), Demuxer::Video);
           Demuxer *audio = t->getDemuxer(c->getAudioPID(), false, Demuxer::Audio);
           Demuxer *video = t->getDemuxer(c->getVideoPID(), false, Demuxer::Video);
           // Check to see if perhaps someone else has already
           // tuned the audio or video channels (this should
-...
+    }
     void TunerManager::getDemuxers(const std::string &type, const std::string &channel,
     			       DemuxerList &demuxers, int priority)
     			       bool convertToPS, DemuxerList &demuxers, int priority)
+    {
       TypeTunerMap::iterator li = typeTunerMap.find(type);
       assert(li != typeTunerMap.end());
-...
           if (!t->getTuneParams()->sameAsExceptPIDs(*c))
     	continue;
           Demuxer *audio = t->getDemuxer(c->getAudioPID(), Demuxer::Audio);
           Demuxer *video = t->getDemuxer(c->getVideoPID(), Demuxer::Video);
           Demuxer *audio = t->getDemuxer(c->getAudioPID(), convertToPS, Demuxer::Audio);
           Demuxer *video = t->getDemuxer(c->getVideoPID(), convertToPS, Demuxer::Video);
           // Check to see if perhaps someone else has already
           // tuned the audio or video channels (this should

     	    const std::string &channels );
       void getDemuxers(const std::string &type, const std::string &channel,
     		   DemuxerList &demuxers, int priority);
     		   bool convertToPS, DemuxerList &demuxers, int priority);
       bool canGetDemuxers(const std::string &type, const std::string &channel,
     		      int priority) const;

PeerStreamer

Revision 2cecea08