+#include "export.h"
+
#include "clip_list.h"
#include "defs.h"
-#include "export.h"
#include "flags.h"
#include "frame_on_disk.h"
#include "player.h"
#include <QMessageBox>
#include <QProgressDialog>
-
#include <future>
-#include <vector>
-
#include <unistd.h>
+#include <vector>
extern "C" {
#include <libavformat/avformat.h>
// Create the streams. Note that some of them could be without frames
// (we try to maintain the stream indexes in the export).
- vector<AVStream *> video_streams;
+ vector<AVStream *> video_streams;
for (unsigned stream_idx = 0; stream_idx <= last_stream_idx; ++stream_idx) {
AVStream *avstream_video = avformat_new_stream(avctx, nullptr);
if (avstream_video == nullptr) {
fprintf(stderr, "avformat_new_stream() failed\n");
exit(1);
}
- avstream_video->time_base = AVRational{1, TIMEBASE};
+ avstream_video->time_base = AVRational{ 1, TIMEBASE };
avstream_video->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
avstream_video->codecpar->codec_id = AV_CODEC_ID_MJPEG;
avstream_video->codecpar->width = global_flags.width; // Might be wrong, but doesn't matter all that much.
}
}
string jpeg = readers[first_frame_stream_idx].read_frame(first_frame);
- int64_t scaled_pts = av_rescale_q(first_frame.pts, AVRational{1, TIMEBASE},
- video_streams[first_frame_stream_idx]->time_base);
+ int64_t scaled_pts = av_rescale_q(first_frame.pts, AVRational{ 1, TIMEBASE },
+ video_streams[first_frame_stream_idx]->time_base);
buffered_jpegs.emplace_back(BufferedJPEG{ scaled_pts, first_frame_stream_idx, std::move(jpeg) });
if (buffered_jpegs.size() >= 1000) {
if (!write_buffered_jpegs(avctx, buffered_jpegs)) {
if (progress.wasCanceled()) {
unlink(filename.c_str());
return;
- }
+ }
}
if (!write_buffered_jpegs(avctx, buffered_jpegs)) {
progress.setMaximum(100000);
progress.setValue(0);
- double total_length = compute_time_left(clips, {{0, 0.0}});
+ vector<ClipWithID> clips_with_id;
+ for (const Clip &clip : clips) {
+ clips_with_id.emplace_back(ClipWithID{ clip, 0 });
+ }
+ TimeRemaining total_length = compute_total_time(clips_with_id);
promise<void> done_promise;
future<void> done = done_promise.get_future();
- std::atomic<double> current_value{0.0};
- size_t clip_idx = 0;
+ std::atomic<double> current_value{ 0.0 };
Player player(/*destination=*/nullptr, Player::FILE_STREAM_OUTPUT, closer.release());
- player.set_done_callback([&done_promise, &clip_idx, &clips] {
- if (clip_idx >= clips.size()) {
- done_promise.set_value();
- }
+ player.set_done_callback([&done_promise] {
+ done_promise.set_value();
});
- player.set_progress_callback([¤t_value, &clips, total_length] (const std::map<size_t, double> &player_progress) {
- current_value = 1.0 - compute_time_left(clips, player_progress) / total_length;
+ player.set_progress_callback([¤t_value, total_length](const std::map<uint64_t, double> &player_progress, TimeRemaining time_remaining) {
+ current_value = 1.0 - time_remaining.t / total_length.t; // Nothing to do about the infinite clips.
});
- player.play(clips);
+ player.play(clips_with_id);
while (done.wait_for(std::chrono::milliseconds(100)) != future_status::ready && !progress.wasCanceled()) {
progress.setValue(lrint(100000.0 * current_value));
}