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