Fix loading of existing frames with -d.

[nageru] / main.cpp

diff --git a/main.cpp b/main.cpp
index 42b1867dfb82e061d98ab1d12f62c0ba035e510a..6cd4741225b95c18b94764782147dfa00adcae8b 100644 (file)
--- a/main.cpp
+++ b/main.cpp
@@ -1,14 +1,16 @@
 #include <assert.h>
-#include <dirent.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <sys/types.h>
-
+#include <atomic>
 #include <chrono>
 #include <condition_variable>
+#include <dirent.h>
+#include <getopt.h>
 #include <memory>
 #include <mutex>
+#include <stdint.h>
+#include <stdio.h>
 #include <string>
+#include <sys/stat.h>
+#include <sys/types.h>
 #include <thread>
 #include <vector>
 
@@ -16,17 +18,14 @@ extern "C" {
 #include <libavformat/avformat.h>
 }
 
-#include <QApplication>
-
-#include <movit/init.h>
-#include <movit/util.h>
-
 #include "clip_list.h"
 #include "context.h"
 #include "defs.h"
-#include "mainwindow.h"
+#include "disk_space_estimator.h"
 #include "ffmpeg_raii.h"
+#include "flags.h"
 #include "httpd.h"
+#include "mainwindow.h"
 #include "player.h"
 #include "post_to_main_thread.h"
 #include "ref_counted_gl_sync.h"
@@ -34,10 +33,15 @@ extern "C" {
 #include "ui_mainwindow.h"
 #include "vaapi_jpeg_decoder.h"
 
+#include <QApplication>
+#include <movit/init.h>
+#include <movit/util.h>
+
 using namespace std;
 using namespace std::chrono;
 
-std::mutex RefCountedGLsync::fence_lock;
+mutex RefCountedGLsync::fence_lock;
+atomic<bool> should_quit{false};
 
 int64_t start_pts = -1;
 
@@ -47,7 +51,8 @@ int64_t current_pts = 0;
 string filename_for_frame(unsigned stream_idx, int64_t pts)
 {
        char filename[256];
-       snprintf(filename, sizeof(filename), "frames/cam%d-pts%09ld.jpeg", stream_idx, pts);
+       snprintf(filename, sizeof(filename), "%s/frames/cam%d-pts%09ld.jpeg",
+               global_flags.working_directory.c_str(), stream_idx, pts);
        return filename;
 }
 
@@ -60,9 +65,30 @@ int record_thread_func();
 
 int main(int argc, char **argv)
 {
+       parse_flags(argc, argv);
+       if (optind == argc) {
+               global_flags.stream_source = "multiangle.mp4";
+               global_flags.slow_down_input = true;
+       } else if (optind + 1 == argc) {
+               global_flags.stream_source = argv[optind];
+       } else {
+               usage();
+               exit(1);
+       }
+
+       string frame_dir = global_flags.working_directory + "/frames";
+
+       struct stat st;
+       if (stat(frame_dir.c_str(), &st) == -1) {
+               fprintf(stderr, "%s does not exist, creating it.\n", frame_dir.c_str());
+               if (mkdir(frame_dir.c_str(), 0777) == -1) {
+                       perror(global_flags.working_directory.c_str());
+                       exit(1);
+               }
+       }
+
        avformat_network_init();
        global_httpd = new HTTPD;
-       global_httpd->start(DEFAULT_HTTPD_PORT);
 
        QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts, true);
 
@@ -98,20 +124,30 @@ int main(int argc, char **argv)
                // TODO: Delete the surface, too.
        }
 
-       MainWindow mainWindow;
-       mainWindow.show();
+       MainWindow main_window;
+       main_window.show();
 
-       load_existing_frames();
-       thread(record_thread_func).detach();
+       global_httpd->add_endpoint("/queue_status", bind(&MainWindow::get_queue_status, &main_window), HTTPD::NO_CORS_POLICY);
+       global_httpd->start(DEFAULT_HTTPD_PORT);
 
        init_jpeg_vaapi();
 
-       return app.exec();
+       load_existing_frames();
+       thread record_thread(record_thread_func);
+
+       int ret = app.exec();
+
+       should_quit = true;
+       record_thread.join();
+       JPEGFrameView::shutdown();
+
+       return ret;
 }
 
 void load_existing_frames()
 {
-       DIR *dir = opendir("frames/");
+       string frame_dir = global_flags.working_directory + "/frames";
+       DIR *dir = opendir(frame_dir.c_str());
        if (dir == nullptr) {
                perror("frames/");
                start_pts = 0;
@@ -154,22 +190,25 @@ void load_existing_frames()
 
 int record_thread_func()
 {
-       auto format_ctx = avformat_open_input_unique("multiangle.mp4", nullptr, nullptr);
+       auto format_ctx = avformat_open_input_unique(global_flags.stream_source.c_str(), nullptr, nullptr);
        if (format_ctx == nullptr) {
-               fprintf(stderr, "%s: Error opening file\n", "example.mp4");
+               fprintf(stderr, "%s: Error opening file\n", global_flags.stream_source.c_str());
                return 1;
        }
 
        int64_t last_pts = -1;
        int64_t pts_offset;
 
-       for ( ;; ) {
+       while (!should_quit.load()) {
                AVPacket pkt;
                unique_ptr<AVPacket, decltype(av_packet_unref)*> pkt_cleanup(
                        &pkt, av_packet_unref);
                av_init_packet(&pkt);
                pkt.data = nullptr;
                pkt.size = 0;
+
+               // TODO: Make it possible to abort av_read_frame() (use an interrupt callback);
+               // right now, should_quit will be ignored if it's hung on I/O.
                if (av_read_frame(format_ctx.get(), &pkt) != 0) {
                        break;
                }
@@ -195,6 +234,8 @@ int record_thread_func()
                fwrite(pkt.data, pkt.size, 1, fp);
                fclose(fp);
 
+               global_disk_space_estimator->report_write(filename, pts);
+
                post_to_main_thread([pkt, pts] {
                        if (pkt.stream_index == 0) {
                                global_mainwindow->ui->input1_display->setFrame(pkt.stream_index, pts, /*interpolated=*/false);
@@ -210,8 +251,7 @@ int record_thread_func()
                assert(pkt.stream_index < MAX_STREAMS);
                frames[pkt.stream_index].push_back(pts);
 
-               // Hack. Remove when we're dealing with live streams.
-               if (last_pts != -1) {
+               if (last_pts != -1 && global_flags.slow_down_input) {
                        this_thread::sleep_for(microseconds((pts - last_pts) * 1000000 / TIMEBASE));
                }
                last_pts = pts;