using namespace std::chrono;
using namespace bmusb;
+namespace {
+
+steady_clock::time_point compute_frame_start(int64_t frame_pts, int64_t pts_origin, const AVRational &video_timebase, const steady_clock::time_point &origin, double rate)
+{
+ const duration<double> pts((frame_pts - pts_origin) * double(video_timebase.num) / double(video_timebase.den));
+ return origin + duration_cast<steady_clock::duration>(pts / rate);
+}
+
+} // namespace
+
FFmpegCapture::FFmpegCapture(const string &filename, unsigned width, unsigned height)
: filename(filename), width(width), height(height)
{
return;
}
running = true;
- producer_thread_should_quit = false;
+ producer_thread_should_quit.unquit();
producer_thread = thread(&FFmpegCapture::producer_thread_func, this);
}
return;
}
running = false;
- producer_thread_should_quit = true;
+ producer_thread_should_quit.quit();
producer_thread.join();
}
snprintf(thread_name, sizeof(thread_name), "FFmpeg_C_%d", card_index);
pthread_setname_np(pthread_self(), thread_name);
- while (!producer_thread_should_quit) {
+ while (!producer_thread_should_quit.should_quit()) {
string pathname = search_for_file(filename);
if (filename.empty()) {
fprintf(stderr, "%s not found, sleeping one second and trying again...\n", filename.c_str());
- sleep(1);
+ producer_thread_should_quit.sleep_for(seconds(1));
continue;
}
if (!play_video(pathname)) {
// Error.
fprintf(stderr, "Error when playing %s, sleeping one second and trying again...\n", pathname.c_str());
- sleep(1);
+ producer_thread_should_quit.sleep_for(seconds(1));
continue;
}
unique_ptr<AVCodecContext, decltype(avcodec_close)*> codec_ctx_cleanup(
codec_ctx.get(), avcodec_close);
- steady_clock::time_point start = steady_clock::now();
+ internal_rewind();
+ double rate = 1.0;
unique_ptr<SwsContext, decltype(sws_freeContext)*> sws_ctx(nullptr, sws_freeContext);
int sws_last_width = -1, sws_last_height = -1;
// Main loop.
- while (!producer_thread_should_quit) {
+ while (!producer_thread_should_quit.should_quit()) {
// Process any queued commands from other threads.
vector<QueuedCommand> commands;
{
swap(commands, command_queue);
}
for (const QueuedCommand &cmd : commands) {
- if (cmd.command == QueuedCommand::REWIND) {
+ switch (cmd.command) {
+ case QueuedCommand::REWIND:
if (av_seek_frame(format_ctx.get(), /*stream_index=*/-1, /*timestamp=*/0, /*flags=*/0) < 0) {
fprintf(stderr, "%s: Rewind failed, stopping play.\n", pathname.c_str());
}
- start = steady_clock::now();
- continue;
+ internal_rewind();
+ break;
+
+ case QueuedCommand::CHANGE_RATE:
+ start = next_frame_start;
+ pts_origin = last_pts;
+ rate = cmd.new_rate;
+ break;
}
}
fprintf(stderr, "%s: Rewind failed, not looping.\n", pathname.c_str());
return true;
}
- start = steady_clock::now();
+ internal_rewind();
continue;
}
video_format.has_signal = true;
video_format.is_connected = true;
- const duration<double> pts(frame->pts * double(video_timebase.num) / double(video_timebase.den));
- const steady_clock::time_point frame_start = start + duration_cast<steady_clock::duration>(pts);
+ next_frame_start = compute_frame_start(frame->pts, pts_origin, video_timebase, start, rate);
+ last_pts = frame->pts;
FrameAllocator::Frame video_frame = video_frame_allocator->alloc_frame();
if (video_frame.data != nullptr) {
int linesizes[4] = { int(video_format.stride), 0, 0, 0 };
sws_scale(sws_ctx.get(), frame->data, frame->linesize, 0, frame->height, pic_data, linesizes);
video_frame.len = video_format.stride * height;
- video_frame.received_timestamp = frame_start;
+ video_frame.received_timestamp = next_frame_start;
}
FrameAllocator::Frame audio_frame;
audio_format.bits_per_sample = 32;
audio_format.num_channels = 8;
- this_thread::sleep_until(frame_start);
+ producer_thread_should_quit.sleep_until(next_frame_start);
frame_callback(timecode++,
video_frame, 0, video_format,
audio_frame, 0, audio_format);
}
return true;
}
+
+void FFmpegCapture::internal_rewind()
+{
+ pts_origin = last_pts = 0;
+ start = next_frame_start = steady_clock::now();
+}