code.vuplus.com Git - vuplus_dvbapp/blob - lib/service/servicedvbrecord.cpp

   1 #include <lib/service/servicedvbrecord.h>
   2 #include <lib/base/eerror.h>
   3 #include <lib/dvb/epgcache.h>
   4 #include <fcntl.h>
   5
   6         /* for cutlist */
   7 #include <byteswap.h>
   8 #include <netinet/in.h>
   9
  10 #ifndef BYTE_ORDER
  11 #error no byte order defined!
  12 #endif
  13
  14 DEFINE_REF(eDVBServiceRecord);
  15
  16 eDVBServiceRecord::eDVBServiceRecord(const eServiceReferenceDVB &ref): m_ref(ref)
  17 {
  18         CONNECT(m_service_handler.serviceEvent, eDVBServiceRecord::serviceEvent);
  19         CONNECT(m_event_handler.m_eit_changed, eDVBServiceRecord::gotNewEvent);
  20         m_state = stateIdle;
  21         m_want_record = 0;
  22         m_tuned = 0;
  23         m_target_fd = -1;
  24         m_error = 0;
  25         m_streaming = 0;
  26         m_simulate = false;
  27         m_last_event_id = -1;
  28 }
  29
  30 void eDVBServiceRecord::serviceEvent(int event)
  31 {
  32         eDebug("RECORD service event %d", event);
  33         switch (event)
  34         {
  35         case eDVBServicePMTHandler::eventTuned:
  36         {
  37                 eDebug("tuned..");
  38                 m_tuned = 1;
  39
  40                         /* start feeding EIT updates */
  41                 ePtr<iDVBDemux> m_demux;
  42                 if (!m_service_handler.getDataDemux(m_demux))
  43                 {
  44                         eServiceReferenceDVB &ref = (eServiceReferenceDVB&) m_ref;
  45                         int sid = ref.getParentServiceID().get();
  46                         if (!sid)
  47                                 sid = ref.getServiceID().get();
  48                         if ( ref.getParentTransportStreamID().get() &&
  49                                 ref.getParentTransportStreamID() != ref.getTransportStreamID() )
  50                                 m_event_handler.startOther(m_demux, sid);
  51                         else
  52                                 m_event_handler.start(m_demux, sid);
  53                 }
  54
  55                 if (m_state == stateRecording && m_want_record)
  56                         doRecord();
  57                 m_event((iRecordableService*)this, evTunedIn);
  58                 break;
  59         }
  60         case eDVBServicePMTHandler::eventTuneFailed:
  61         {
  62                 eDebug("record failed to tune");
  63                 m_event((iRecordableService*)this, evTuneFailed);
  64                 break;
  65         }
  66         case eDVBServicePMTHandler::eventNewProgramInfo:
  67         {
  68                 if (m_state == stateIdle)
  69                         doPrepare();
  70                 else if (m_want_record) /* doRecord can be called from Prepared and Recording state */
  71                         doRecord();
  72                 m_event((iRecordableService*)this, evNewProgramInfo);
  73                 break;
  74         }
  75         case eDVBServicePMTHandler::eventMisconfiguration:
  76                 m_error = errMisconfiguration;
  77                 m_event((iRecordableService*)this, evTuneFailed);
  78                 break;
  79         case eDVBServicePMTHandler::eventNoResources:
  80                 m_error = errNoResources;
  81                 m_event((iRecordableService*)this, evTuneFailed);
  82                 break;
  83         }
  84 }
  85
  86 RESULT eDVBServiceRecord::prepare(const char *filename, time_t begTime, time_t endTime, int eit_event_id)
  87 {
  88         m_filename = filename;
  89         m_streaming = 0;
  90
  91         if (m_state == stateIdle)
  92         {
  93                 int ret = doPrepare();
  94                 if (!ret)
  95                 {
  96                         eEPGCache::getInstance()->Lock();
  97                         const eit_event_struct *event = 0;
  98                         eServiceReferenceDVB ref = m_ref.getParentServiceReference();
  99                         if (!ref.valid())
 100                                 ref = m_ref;
 101                         if ( eit_event_id != -1 )
 102                         {
 103                                 eDebug("query epg event id %d", eit_event_id);
 104                                 eEPGCache::getInstance()->lookupEventId(ref, eit_event_id, event);
 105                         }
 106                         if ( !event && (begTime != -1 && endTime != -1) )
 107                         {
 108                                 time_t queryTime = begTime + ((endTime-begTime)/2);
 109                                 tm beg, end, query;
 110                                 localtime_r(&begTime, &beg);
 111                                 localtime_r(&endTime, &end);
 112                                 localtime_r(&queryTime, &query);
 113                                 eDebug("query stime %d:%d:%d, etime %d:%d:%d, qtime %d:%d:%d",
 114                                         beg.tm_hour, beg.tm_min, beg.tm_sec,
 115                                         end.tm_hour, end.tm_min, end.tm_sec,
 116                                         query.tm_hour, query.tm_min, query.tm_sec);
 117                                 eEPGCache::getInstance()->lookupEventTime(ref, queryTime, event);
 118                         }
 119                         if ( event )
 120                         {
 121                                 eDebug("found event.. store to disc");
 122                                 std::string fname = filename;
 123                                 fname.erase(fname.length()-2, 2);
 124                                 fname+="eit";
 125                                 int fd = open(fname.c_str(), O_CREAT|O_WRONLY, 0777);
 126                                 if (fd>-1)
 127                                 {
 128                                         int evLen=HILO(event->descriptors_loop_length)+12/*EIT_LOOP_SIZE*/;
 129                                         int wr = ::write( fd, (unsigned char*)event, evLen );
 130                                         if ( wr != evLen )
 131                                                 eDebug("eit write error (%m)");
 132                                         ::close(fd);
 133                                 }
 134                         }
 135                         eEPGCache::getInstance()->Unlock();
 136                 }
 137                 return ret;
 138         }
 139         else
 140                 return -1;
 141 }
 142
 143 RESULT eDVBServiceRecord::prepareStreaming()
 144 {
 145         m_filename = "";
 146         m_streaming = 1;
 147         if (m_state == stateIdle)
 148                 return doPrepare();
 149         return -1;
 150 }
 151
 152 RESULT eDVBServiceRecord::start(bool simulate)
 153 {
 154         m_simulate = simulate;
 155         m_want_record = 1;
 156                 /* when tune wasn't yet successfully, doRecord stays in "prepared"-state which is fine. */
 157         m_event((iRecordableService*)this, evStart);
 158         return doRecord();
 159 }
 160
 161 RESULT eDVBServiceRecord::stop()
 162 {
 163         if (!m_simulate)
 164                 eDebug("stop recording!");
 165         if (m_state == stateRecording)
 166         {
 167                 if (m_record)
 168                         m_record->stop();
 169                 if (m_target_fd >= 0)
 170                 {
 171                         ::close(m_target_fd);
 172                         m_target_fd = -1;
 173                 }
 174
 175                 saveCutlist();
 176
 177                 m_state = statePrepared;
 178         } else if (!m_simulate)
 179                 eDebug("(was not recording)");
 180         if (m_state == statePrepared)
 181         {
 182                 m_record = 0;
 183                 m_state = stateIdle;
 184         }
 185         m_event((iRecordableService*)this, evRecordStopped);
 186         return 0;
 187 }
 188
 189 int eDVBServiceRecord::doPrepare()
 190 {
 191                 /* allocate a ts recorder if we don't already have one. */
 192         if (m_state == stateIdle)
 193         {
 194                 m_pids_active.clear();
 195                 m_state = statePrepared;
 196                 return m_service_handler.tune(m_ref, 0, 0, m_simulate);
 197         }
 198         return 0;
 199 }
 200
 201 int eDVBServiceRecord::doRecord()
 202 {
 203         int err = doPrepare();
 204         if (err)
 205         {
 206                 m_error = errTuneFailed;
 207                 m_event((iRecordableService*)this, evRecordFailed);
 208                 return err;
 209         }
 210
 211         if (!m_tuned)
 212                 return 0; /* try it again when we are tuned in */
 213
 214         if (!m_record && m_tuned && !m_streaming && !m_simulate)
 215         {
 216                 eDebug("Recording to %s...", m_filename.c_str());
 217                 ::remove(m_filename.c_str());
 218                 int fd = ::open(m_filename.c_str(), O_WRONLY|O_CREAT|O_LARGEFILE, 0644);
 219                 if (fd == -1)
 220                 {
 221                         eDebug("eDVBServiceRecord - can't open recording file!");
 222                         m_error = errOpenRecordFile;
 223                         m_event((iRecordableService*)this, evRecordFailed);
 224                         return errOpenRecordFile;
 225                 }
 226
 227                         /* turn off kernel caching strategies */
 228                 posix_fadvise(fd, 0, 0, POSIX_FADV_RANDOM);
 229
 230                 ePtr<iDVBDemux> demux;
 231                 if (m_service_handler.getDataDemux(demux))
 232                 {
 233                         eDebug("eDVBServiceRecord - NO DEMUX available!");
 234                         m_error = errNoDemuxAvailable;
 235                         m_event((iRecordableService*)this, evRecordFailed);
 236                         return errNoDemuxAvailable;
 237                 }
 238                 demux->createTSRecorder(m_record);
 239                 if (!m_record)
 240                 {
 241                         eDebug("eDVBServiceRecord - no ts recorder available.");
 242                         m_error = errNoTsRecorderAvailable;
 243                         m_event((iRecordableService*)this, evRecordFailed);
 244                         return errNoTsRecorderAvailable;
 245                 }
 246                 m_record->setTargetFD(fd);
 247                 m_record->setTargetFilename(m_filename.c_str());
 248                 m_record->connectEvent(slot(*this, &eDVBServiceRecord::recordEvent), m_con_record_event);
 249
 250                 m_target_fd = fd;
 251         }
 252
 253         if (m_streaming)
 254         {
 255                 m_state = stateRecording;
 256                 eDebug("start streaming...");
 257         } else
 258         {
 259                 eDebug("start recording...");
 260
 261                 eDVBServicePMTHandler::program program;
 262                 if (m_service_handler.getProgramInfo(program))
 263                         eDebug("getting program info failed.");
 264                 else
 265                 {
 266                         std::set<int> pids_to_record;
 267
 268                         pids_to_record.insert(0); // PAT
 269
 270                         if (program.pmtPid != -1)
 271                                 pids_to_record.insert(program.pmtPid); // PMT
 272
 273                         int timing_pid = -1, timing_pid_type = -1;
 274
 275                         eDebugNoNewLine("RECORD: have %d video stream(s)", program.videoStreams.size());
 276                         if (!program.videoStreams.empty())
 277                         {
 278                                 eDebugNoNewLine(" (");
 279                                 for (std::vector<eDVBServicePMTHandler::videoStream>::const_iterator
 280                                         i(program.videoStreams.begin());
 281                                         i != program.videoStreams.end(); ++i)
 282                                 {
 283                                         pids_to_record.insert(i->pid);
 284
 285                                         if (timing_pid == -1)
 286                                         {
 287                                                 timing_pid = i->pid;
 288                                                 timing_pid_type = i->type;
 289                                         }
 290
 291                                         if (i != program.videoStreams.begin())
 292                                                         eDebugNoNewLine(", ");
 293                                         eDebugNoNewLine("%04x", i->pid);
 294                                 }
 295                                 eDebugNoNewLine(")");
 296                         }
 297                         eDebugNoNewLine(", and %d audio stream(s)", program.audioStreams.size());
 298                         if (!program.audioStreams.empty())
 299                         {
 300                                 eDebugNoNewLine(" (");
 301                                 for (std::vector<eDVBServicePMTHandler::audioStream>::const_iterator
 302                                         i(program.audioStreams.begin());
 303                                         i != program.audioStreams.end(); ++i)
 304                                 {
 305                                         pids_to_record.insert(i->pid);
 306
 307                                         if (timing_pid == -1)
 308                                         {
 309                                                 timing_pid = i->pid;
 310                                                 timing_pid_type = -1;
 311                                         }
 312
 313                                         if (i != program.audioStreams.begin())
 314                                                 eDebugNoNewLine(", ");
 315                                         eDebugNoNewLine("%04x", i->pid);
 316                                 }
 317                                 eDebugNoNewLine(")");
 318                         }
 319                         if (!program.subtitleStreams.empty())
 320                         {
 321                                 eDebugNoNewLine(" (");
 322                                 for (std::vector<eDVBServicePMTHandler::subtitleStream>::const_iterator
 323                                         i(program.subtitleStreams.begin());
 324                                         i != program.subtitleStreams.end(); ++i)
 325                                 {
 326                                         pids_to_record.insert(i->pid);
 327
 328                                         if (i != program.subtitleStreams.begin())
 329                                                 eDebugNoNewLine(", ");
 330                                         eDebugNoNewLine("%04x", i->pid);
 331                                 }
 332                                 eDebugNoNewLine(")");
 333                         }
 334                         eDebugNoNewLine(", and the pcr pid is %04x", program.pcrPid);
 335                         if (program.pcrPid != 0x1fff)
 336                                 pids_to_record.insert(program.pcrPid);
 337                         eDebug(", and the text pid is %04x", program.textPid);
 338                         if (program.textPid != -1)
 339                                 pids_to_record.insert(program.textPid); // Videotext
 340
 341                                 /* find out which pids are NEW and which pids are obsolete.. */
 342                         std::set<int> new_pids, obsolete_pids;
 343
 344                         std::set_difference(pids_to_record.begin(), pids_to_record.end(),
 345                                         m_pids_active.begin(), m_pids_active.end(),
 346                                         std::inserter(new_pids, new_pids.begin()));
 347
 348                         std::set_difference(
 349                                         m_pids_active.begin(), m_pids_active.end(),
 350                                         pids_to_record.begin(), pids_to_record.end(),
 351                                         std::inserter(new_pids, new_pids.begin())
 352                                         );
 353
 354                         for (std::set<int>::iterator i(new_pids.begin()); i != new_pids.end(); ++i)
 355                         {
 356                                 eDebug("ADD PID: %04x", *i);
 357                                 m_record->addPID(*i);
 358                         }
 359
 360                         for (std::set<int>::iterator i(obsolete_pids.begin()); i != obsolete_pids.end(); ++i)
 361                         {
 362                                 eDebug("REMOVED PID: %04x", *i);
 363                                 m_record->removePID(*i);
 364                         }
 365
 366                         if (timing_pid != -1)
 367                                 m_record->setTimingPID(timing_pid, timing_pid_type);
 368
 369                         m_pids_active = pids_to_record;
 370
 371                         if (m_state != stateRecording)
 372                         {
 373                                 m_record->start();
 374                                 m_state = stateRecording;
 375                         }
 376                 }
 377         }
 378         m_error = 0;
 379         m_event((iRecordableService*)this, evRecordRunning);
 380         return 0;
 381 }
 382
 383 RESULT eDVBServiceRecord::frontendInfo(ePtr<iFrontendInformation> &ptr)
 384 {
 385         ptr = this;
 386         return 0;
 387 }
 388
 389 RESULT eDVBServiceRecord::connectEvent(const Slot2<void,iRecordableService*,int> &event, ePtr<eConnection> &connection)
 390 {
 391         connection = new eConnection((iRecordableService*)this, m_event.connect(event));
 392         return 0;
 393 }
 394
 395 RESULT eDVBServiceRecord::stream(ePtr<iStreamableService> &ptr)
 396 {
 397         ptr = this;
 398         return 0;
 399 }
 400
 401 extern void PutToDict(ePyObject &dict, const char*key, long val);  // defined in dvb/frontend.cpp
 402
 403 PyObject *eDVBServiceRecord::getStreamingData()
 404 {
 405         eDVBServicePMTHandler::program program;
 406         if (!m_tuned || m_service_handler.getProgramInfo(program))
 407         {
 408                 Py_RETURN_NONE;
 409         }
 410
 411         ePyObject r = program.createPythonObject();
 412         ePtr<iDVBDemux> demux;
 413         if (!m_service_handler.getDataDemux(demux))
 414         {
 415                 uint8_t demux_id;
 416                 if (!demux->getCADemuxID(demux_id))
 417                         PutToDict(r, "demux", demux_id);
 418         }
 419
 420         return r;
 421 }
 422
 423 void eDVBServiceRecord::recordEvent(int event)
 424 {
 425         switch (event)
 426         {
 427         case iDVBTSRecorder::eventWriteError:
 428                 eWarning("[eDVBServiceRecord] record write error");
 429                 stop();
 430                 m_event((iRecordableService*)this, evRecordWriteError);
 431                 return;
 432         default:
 433                 eDebug("unhandled record event %d", event);
 434         }
 435 }
 436
 437 void eDVBServiceRecord::gotNewEvent()
 438 {
 439         ePtr<eServiceEvent> event_now;
 440         m_event_handler.getEvent(event_now, 0);
 441
 442         if (!event_now)
 443                 return;
 444
 445         int event_id = event_now->getEventId();
 446
 447         pts_t p;
 448
 449         if (m_record)
 450         {
 451                 if (m_record->getCurrentPCR(p))
 452                         eDebug("getting PCR failed!");
 453                 else
 454                 {
 455                         static int i;
 456                         m_event_timestamps[/* event_id*/ ++i] = p;
 457                         eDebug("pcr of eit change: %llx", p);
 458                 }
 459         }
 460
 461         if (event_id != m_last_event_id)
 462                 eDebug("[eDVBServiceRecord] now running: %s (%d seconds)", event_now->getEventName().c_str(), event_now->getDuration());
 463
 464         m_last_event_id = event_id;
 465 }
 466
 467 void eDVBServiceRecord::saveCutlist()
 468 {
 469                         /* XXX: dupe of eDVBServicePlay::saveCuesheet, refactor plz */
 470         std::string filename = m_filename + ".cuts";
 471
 472         eDVBTSTools tstools;
 473
 474         if (tstools.openFile(m_filename.c_str()))
 475         {
 476                 eDebug("[eDVBServiceRecord] saving cutlist failed because tstools failed");
 477                 return;
 478         }
 479
 480         FILE *f = fopen(filename.c_str(), "wb");
 481
 482         if (f)
 483         {
 484                 unsigned long long where;
 485                 int what;
 486
 487                 for (std::map<int,pts_t>::iterator i(m_event_timestamps.begin()); i != m_event_timestamps.end(); ++i)
 488                 {
 489                         pts_t p = i->second;
 490                         off_t offset = 0; // fixme, we need to note down both
 491                         if (tstools.fixupPTS(offset, p))
 492                         {
 493                                 eDebug("[eDVBServiceRecord] fixing up PTS failed, not saving");
 494                                 continue;
 495                         }
 496                         eDebug("fixed up %llx to %llx (offset %llx)", i->second, p, offset);
 497 #if BYTE_ORDER == BIG_ENDIAN
 498                         where = p;
 499 #else
 500                         where = bswap_64(p);
 501 #endif
 502                         what = htonl(2); /* mark */
 503                         fwrite(&where, sizeof(where), 1, f);
 504                         fwrite(&what, sizeof(what), 1, f);
 505                 }
 506                 fclose(f);
 507         }
 508
 509 }