include/lib/dvb/record.h

   1 #ifndef DISABLE_FILE
   2
   3 #ifndef __record_h
   4 #define __record_h
   5
   6 #include <libsig_comp.h>
   7 #include <lib/dvb/dvb.h>
   8 #include <lib/base/ebase.h>
   9 #include <lib/base/message.h>
  10 #include <lib/base/thread.h>
  11 #include <lib/base/eerror.h>
  12 #include <lib/base/estring.h>
  13 #include <lib/base/buffer.h>
  14
  15 #include <set>
  16
  17 #define RECORD_TELETEXT
  18 #define RECORD_SUBTITLES
  19
  20 /**
  21  * \brief The DVBRecorder
  22  *
  23  * A class which can record a TS consisting of given pids. The
  24  * recorder runs in a seperate thread and can be controlled
  25  * asynchronously. Internally this is done with a \c eMessagePump.
  26  * \todo Howto disable this warning?
  27  */
  28
  29 class eDVBRecorder: private eThread, public Object
  30 {
  31         enum { stateRunning = 1, stateStopped = 0, stateError = 2 }state;
  32         struct eDVBRecorderMessage
  33         {
  34                 enum eCode
  35                 {
  36                         rWriteError // disk full etc.
  37                 } code;
  38                 union
  39                 {
  40                         const char *filename;
  41                         int pid;
  42                         struct
  43                         {
  44                                 void *data;
  45                                 int len;
  46                         } write;
  47                 };
  48                 eDVBRecorderMessage() { }
  49                 eDVBRecorderMessage(eCode code): code(code) { }
  50                 eDVBRecorderMessage(eCode code, const char *filename): code(code), filename(filename) { }
  51                 eDVBRecorderMessage(eCode code, int pid): code(code), pid(pid) { }
  52                 eDVBRecorderMessage(eCode code, void *data, int len): code(code) { write.data=data; write.len=len; }
  53         };
  54         struct pid_t
  55         {
  56                 int pid;
  57                 int fd;
  58                 int flags;
  59                 bool operator < (const pid_t &p) const
  60                 {
  61                         return pid < p.pid;
  62                 }
  63         };
  64
  65         std::set<pid_t> pids, newpids;
  66         eFixedMessagePump<eDVBRecorderMessage> rmessagepump;
  67
  68         off64_t splitsize, size;
  69         int splits, dvrfd, outfd;
  70
  71         eString filename;
  72
  73         char buf[524144];
  74         int bufptr;
  75
  76         int written_since_last_sync;
  77         void thread();
  78         void gotBackMessage(const eDVBRecorderMessage &msg);
  79         inline int flushBuffer();
  80         int openFile(int suffix=0);
  81         void PatPmtWrite();
  82         __u8 *PmtData, *PatData;
  83         unsigned int PmtCC, PatCC;
  84         int pmtpid;
  85         eAUTable<PMT> tPMT;
  86         bool writePatPmt;
  87         void PMTready(int error);
  88         eLock splitlock;
  89 public:
  90                 /// the constructor
  91         eDVBRecorder(PMT *, PAT*);
  92                 /// the destructor
  93         ~eDVBRecorder();
  94
  95         void setWritePatPmtFlag() { writePatPmt=true; }
  96
  97         eString getFilename() { return filename; }
  98
  99         /**
 100          * \brief Opens a file
 101          *
 102          * This call will open a new filename. It will close open files.
 103          * \param filename Pointer to a filename. Existing files will be deleted. (life is cruel)
 104          */
 105         void open(const char *filename);
 106
 107         /**
 108          * \brief Adds a PID.
 109          *
 110          * This call will add a PID to record. Recording doesn't start until using \c start().
 111          * \sa eDVBRecorder::start
 112          */
 113         std::pair<std::set<eDVBRecorder::pid_t>::iterator,bool> addPID(int pid, int flags=0);
 114
 115         /**
 116          * \brief Removes a PID.
 117          *
 118          * This call will remove a PID.
 119          */
 120         void removePID(int pid);
 121
 122         /**
 123          * \brief Start recording.
 124          *
 125          * This call will start the recording. You can stop it with \c stop().
 126          * \sa eDVBRecorder::stop
 127          */
 128         void start();
 129
 130         /**
 131          * \brief Stop recording.
 132          *
 133          * This call will pause the recording. You can restart it (and append data) with \c start again.
 134          */
 135         void stop();
 136
 137         /**
 138          * \brief Closes recording file.
 139          *
 140          * This will close the recorded file.
 141          */
 142         void close();
 143
 144         /**
 145          * \brief Writes a section into the stream.
 146          *
 147          * This will generate aligned ts packets and thus write a section to the stream. CRC must be calculated by caller.
 148          * File must be already opened.
 149          * Len will be fetched out of table.
 150          */
 151         void writeSection(void *data, int pid, unsigned int &cc);
 152
 153         /**
 154          * \brief Adds a PID to running recording.
 155          *
 156          * This call will add a new PID to a running record. After add all new PIDs .. \c validatePIDs() must be called.
 157          * \sa eDVBRecorder::addNewPID
 158          */
 159         void addNewPID(int pid, int flags=0);
 160
 161         /**
 162          * \brief Validate all PIDs.
 163          *
 164          * This call will remove all PID they never contains in the pmt, and add all new PIDs. All PIDs must set with \c addNewPID before.
 165          * \sa eDVBRecorder::validatePIDs
 166          */
 167         void validatePIDs();
 168
 169         enum { recWriteError };
 170         Signal1<void,int> recMessage;
 171         eServiceReferenceDVB recRef;
 172         bool scrambled;
 173         void SetSlice(int slice);
 174 };
 175
 176 #endif
 177
 178 #endif //DISABLE_FILE