Method startSession

pj_app/src/StreamingSourceManager.cpp:259–425

}

void StreamingSourceManager::startSession(const QString& plugin_id) {
  const LoadedDataSource* source_ptr = resolveStreamSource(extensions_, plugin_id);
  if (source_ptr == nullptr) {
    qCWarning(lcStream) << "Stream plugin not found:" << plugin_id;
    emit setupError(tr("Stream plugin '%1' not found.").arg(plugin_id));
    return;
  }
  const LoadedDataSource& source = *source_ptr;
  const QString source_name = QString::fromStdString(source.name);

  DataSourceHandle handle = source.library.createHandle();
  if (!handle.valid()) {
    qCWarning(lcStream) << "createHandle failed for" << source_name;
    emit setupError(tr("Plugin '%1': createHandle failed.").arg(source_name));
    return;
  }

  DataEngine& engine = session_manager_.dataEngine();
  const QString display_name = QStringLiteral("[stream] %1").arg(source_name);

  // One TimeDomain per stream so each is independently time-shiftable on the
  // Source Timeline. DUAL-ENGINE: the secondary (pause/tail buffer) must hold
  // the SAME id, so force it explicitly — the two engines' counters drift
  // whenever the primary gets a domain the secondary doesn't (e.g. a file load
  // between streams). Relying on counter order would desync them.
  auto td_or = engine.createTimeDomain(display_name.toStdString());
  if (!td_or.has_value()) {
    emit setupError(tr("Could not create the time domain."));
    return;
  }
  const TimeDomainId td_id = *td_or;
  auto mirrored_td = secondary_data_engine_->createTimeDomain(display_name.toStdString(), td_id);
  if (!mirrored_td.has_value() || *mirrored_td != td_id) {
    emit setupError(tr("secondary time domain lockstep failed."));
    return;
  }

  auto dataset_or =
      engine.createDataset(DatasetDescriptor{.source_name = display_name.toStdString(), .time_domain_id = td_id});
  if (!dataset_or.has_value()) {
    emit setupError(tr("createDataset failed: %1").arg(QString::fromStdString(dataset_or.error())));
    return;
  }
  const DatasetId dataset_id = static_cast<DatasetId>(*dataset_or);
  const PJ_data_source_handle_t source_handle{static_cast<uint32_t>(dataset_id)};

  // Lockstep mirror onto the secondary engine. Topics are mirrored
  // individually inside DataSourceRuntimeHost; the dataset has to exist here so
  // cbEnsureParserBinding can use the same DatasetId on both engines without
  // translation. Create it with the SAME id explicitly: the two engines'
  // auto-increment counters drift whenever the primary gets a dataset the
  // secondary doesn't (e.g. a file load between streams), so a plain
  // createDataset() on the secondary would return a different id and the next
  // stream would abort here. Forcing the id keeps them in lockstep regardless.
  auto mirrored_dataset = secondary_data_engine_->createDataset(
      DatasetDescriptor{.source_name = display_name.toStdString(), .time_domain_id = td_id}, dataset_id);
  if (!mirrored_dataset.has_value()) {
    emit setupError(tr("secondary createDataset failed: %1").arg(QString::fromStdString(mirrored_dataset.error())));