working!

selfdrive/ui/qt/onroad/annotated_camera.cc

@@ -91,7 +91,7 @@ mat4 AnnotatedCameraWidget::calcFrameMatrix() {
 void AnnotatedCameraWidget::paintGL() {
   UIState *s = uiState();
   SubMaster &sm = *(s->sm);
-  sm.update(0);
+  sm.update();
   const double start_draw_t = millis_since_boot();
 
   // draw camera frame

selfdrive/ui/qt/onroad/onroad_home.cc

@@ -44,8 +44,6 @@ void OnroadWindow::updateState(const UIState &s) {
     return;
   }
 
-  fprintf(stderr, "updating\n");
-
   emit drewOnroadFrame(new QImage(grab().toImage()));
 
   alerts->updateState(s);

selfdrive/ui/qt/widgets/cameraview.cc

@@ -334,6 +334,7 @@ void CameraWidget::vipcThread() {
         QThread::msleep(100);
         continue;
       }
+      qDebug().nospace() << "connected to stream " << requested_stream_type << ", was connected to " << cur_stream;
       emit vipcAvailableStreamsUpdated(streams);
 
       if (!vipc_client->connect(false)) {

selfdrive/ui/ui.cc

@@ -107,7 +107,6 @@ UIState::UIState(QObject *parent) : QObject(parent) {
 }
 
 void UIState::update() {
-  fprintf(stderr, "updatng ui state\n");
   update_sockets(this);
   update_state(this);
   updateStatus();

tools/clip/.gitignore

@@ -0,0 +1 @@
+clip

tools/clip/application.cc

@@ -28,29 +28,64 @@ Application::Application(int argc, char *argv[]) {
   recorder = new Recorder;
   recorder->moveToThread(recorderThread);
   QObject::connect(recorderThread, &QThread::finished, recorder, &QObject::deleteLater);
-  recorderThread->start();
   QObject::connect(window, &OnroadWindow::drewOnroadFrame, recorder, &Recorder::saveFrame, Qt::QueuedConnection);
+  QObject::connect(app, &QCoreApplication::aboutToQuit, recorderThread, &QThread::quit);
 
   window->setAttribute(Qt::WA_DontShowOnScreen);
   window->setAttribute(Qt::WA_Mapped);
   window->setAttribute(Qt::WA_NoSystemBackground);
+  recorderThread->start();
+
+  // Initialize and start replay
+  initReplay();
+  replayThread = QThread::create([this] { startReplay(); });
+  replayThread->start();
 }
 
-void Application::close() const {
+void Application::initReplay() {
-  recorderThread->quit();
+  std::vector<std::string> allow;
-  app->quit();
+  std::vector<std::string> block;
+  replay = std::make_unique<Replay>("a2a0ccea32023010|2023-07-27--13-01-19", allow, block, nullptr,
+                                  REPLAY_FLAG_NONE & REPLAY_FLAG_ECAM & REPLAY_FLAG_DCAM);
+}
+
+void Application::startReplay() {
+  if (!replay || !replay->load()) {
+    qWarning() << "Failed to load replay";
+    return;
+  }
+
+  qInfo() << "Replay started.";
+  replayRunning = true;
+  replay->setEndSeconds(120);
+  replay->start(60);
+  replay->waitUntilEnd();
+  qInfo() << "Replay ended.";
+  replayRunning = false;
+  QMetaObject::invokeMethod(app, "quit", Qt::QueuedConnection);
 }
 
 Application::~Application() {
-  delete recorder;
+  if (replayThread) {
-  delete recorderThread;
+    replayThread->quit();
+    replayThread->wait();
+    delete replayThread;
+  }
+
+  if (recorderThread) {
+    recorderThread->quit();
+    recorderThread->wait();
+  }
+
   delete window;
   delete app;
 }
 
 int Application::exec() const {
+  std::this_thread::sleep_for(std::chrono::seconds(3));
   setMainWindow(window);
-  return app->exec();
+  app->exec();
+  return 0;
 }
 
 

tools/clip/application.h

@@ -1,5 +1,7 @@
 #pragma once
 #include <selfdrive/ui/qt/onroad/onroad_home.h>
+#include <tools/replay/replay.h>
+#include <QThread>
 
 #include "recorder/widget.h"
 
@@ -10,9 +12,18 @@ public:
     ~Application();
     int exec() const;
     void close() const;
+
 private:
+    void initReplay();
+    void startReplay();
+
     QApplication *app;
     QThread *recorderThread = nullptr;
     Recorder *recorder = nullptr;
     OnroadWindow *window;
+
+    // Replay related members
+    std::unique_ptr<Replay> replay;
+    QThread *replayThread = nullptr;
+    bool replayRunning = false;
 };

tools/clip/main.cc

@@ -1,42 +1,12 @@
 #include <iostream>
-#include <selfdrive/ui/ui.h>
-
 #include "application.h"
-#include "tools/replay/replay.h"
-
-void startReplayThread() {
-  std::vector<std::string> allow = (std::vector<std::string>{
-    "modelV2", "controlsState", "liveCalibration", "radarState", "deviceState",
-    "pandaStates", "carParams", "driverMonitoringState", "carState", "driverStateV2",
-    "wideRoadCameraState", "managerState", "selfdriveState", "longitudinalPlan",
-  });
-
-  std::vector<std::string> block;
-  Replay replay("a2a0ccea32023010|2023-07-27--13-01-19", allow, block);
-
-  if (!replay.load()) {
-    return;
-  }
-
-  std::cout << "Replay started." << std::endl;
-  replay.setEndSeconds(66);
-  replay.start(60);
-  replay.waitUntilEnd();
-  std::cout << "Replay ended." << std::endl;
-  raise(SIGINT);
-}
 
 int main(int argc, char *argv[]) {
   Application a(argc, argv);
 
-  std::thread thread(startReplayThread);
-  std::this_thread::sleep_for(std::chrono::milliseconds(2000));
-
   if (a.exec()) {
     std::cerr << "Failed to start app." << std::endl;
   }
 
-  thread.join();
-  a.close();
   return 0;
 }

tools/clip/recorder/ffmpeg.cc

@@ -101,7 +101,7 @@ FFmpegEncoder::FFmpegEncoder(const QString& outputFile, int width, int height, i
 
 FFmpegEncoder::~FFmpegEncoder() {
   if (initialized) {
-    // encodeFrame(nullptr);  // Flush encoder
+    encodeFrame(nullptr);
     av_write_trailer(format_ctx);
     if (!(format_ctx->oformat->flags & AVFMT_NOFILE) && format_ctx->pb) {
       avio_closep(&format_ctx->pb);

tools/clip/recorder/widget.cc

@@ -8,7 +8,6 @@ Recorder::Recorder(QObject *parent) : QObject(parent) {
 
 Recorder::~Recorder() {
     delete encoder;
-    QObject::~QObject();
 }
 
 void Recorder::saveFrame(QImage *frame) {

tools/replay/replay.cc

@@ -320,7 +320,7 @@ std::vector<Event>::const_iterator Replay::publishEvents(std::vector<Event>::con
       loop_start_ts = current_nanos;
       prev_replay_speed = speed_;
     } else if (time_diff > 0) {
-      precise_nano_sleep(time_diff, interrupt_requested_);
+      std::this_thread::sleep_for(std::chrono::nanoseconds(time_diff));
     }
 
     if (interrupt_requested_) break;

tools/replay/seg_mgr.h

@@ -20,7 +20,7 @@ public:
     bool isSegmentLoaded(int n) const { return segments.find(n) != segments.end(); }
   };
 
-  SegmentManager(const std::string &route_name, uint32_t flags, const std::string &data_dir = "")
+  SegmentManager(const std::string &route_name, uint32_t flags, const std::string &data_dir = "/tmp/clip")
       : flags_(flags), route_(route_name, data_dir), event_data_(std::make_shared<EventData>()) {}
   ~SegmentManager();