#include <vector>
#include <unordered_set>
+#include "post_to_main_thread.h"
+
#include <QOpenGLFunctions>
#include <QWheelEvent>
#include <QMouseEvent>
relative_seek_ms += cmd.relative_seek_ms;
relative_seek_frames += cmd.relative_seek_frames;
} else if (cmd.command == QueuedCommand::SEEK_ABSOLUTE) {
- base_pts = cmd.seek_ms;
+ base_pts = av_rescale_q(cmd.seek_ms, AVRational{ 1, 1000 }, video_timebase);
relative_seek_ms = 0;
relative_seek_frames = 0;
}
queue.pop_front();
queued_frames = std::move(queue);
}
- current_frame.reset(new Frame(make_video_frame(frame.get())));
+ shared_ptr<Frame> new_frame = make_video_frame(frame.get());
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame = std::move(new_frame);
+ }
update();
store_pts(frame->pts);
break;
if (frame == nullptr || error) {
return true;
}
- current_frame.reset(new Frame(make_video_frame(frame.get())));
+ shared_ptr<Frame> new_frame = make_video_frame(frame.get());
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame = std::move(new_frame);
+ }
update();
store_pts(frame->pts);
}
void VideoWidget::paintGL()
{
- std::shared_ptr<Frame> frame = current_frame;
+ std::shared_ptr<Frame> frame;
+ {
+ lock_guard lock(current_frame_mu);
+ frame = current_frame;
+ }
if (frame == nullptr) {
glClear(GL_COLOR_BUFFER_BIT);
return;
void VideoWidget::mousePressEvent(QMouseEvent *e)
{
- if (e->button() == Qt::LeftButton) {
+ if (e->button() == Qt::BackButton) {
+ emit mouse_back_clicked();
+ } else if (e->button() == Qt::ForwardButton) {
+ emit mouse_forward_clicked();
+ } else if (e->button() == Qt::LeftButton) {
dragging = true;
last_drag_x = e->position().x();
last_drag_y = e->position().y();
zoom_matrix[7] = std::max(zoom_matrix[7], 1.0 - zoom_matrix[4]); // Top side (y=1).
}
-void VideoWidget::open(const string &filename)
+bool VideoWidget::open(const string &filename)
{
stop();
internal_rewind();
pathname = filename;
play();
+
+ while (running == STARTING) {
+ // Poor man's condition variable...
+ usleep(10000);
+ sched_yield();
+ }
+ return (running != VIDEO_FILE_ERROR);
}
void VideoWidget::play()
{
- if (running) {
+ if (running != NOT_RUNNING && running != VIDEO_FILE_ERROR) {
std::lock_guard<std::mutex> lock(queue_mu);
command_queue.push_back(QueuedCommand { QueuedCommand::RESUME });
producer_thread_should_quit.wakeup();
return;
}
- running = true;
+ running = STARTING;
producer_thread_should_quit.unquit();
+ if (producer_thread.joinable()) {
+ producer_thread.join();
+ }
producer_thread = std::thread(&VideoWidget::producer_thread_func, this);
}
void VideoWidget::pause()
{
- if (!running) {
+ if (running == NOT_RUNNING || running == VIDEO_FILE_ERROR) {
return;
}
std::lock_guard<std::mutex> lock(queue_mu);
void VideoWidget::seek(int64_t relative_seek_ms)
{
- if (!running) {
+ if (running == NOT_RUNNING || running == VIDEO_FILE_ERROR) {
return;
}
std::lock_guard<std::mutex> lock(queue_mu);
void VideoWidget::seek_frames(int64_t relative_seek_frames)
{
- if (!running) {
+ if (running == NOT_RUNNING || running == VIDEO_FILE_ERROR) {
return;
}
std::lock_guard<std::mutex> lock(queue_mu);
void VideoWidget::seek_absolute(int64_t position_ms)
{
- if (!running) {
+ if (running == NOT_RUNNING || running == VIDEO_FILE_ERROR) {
return;
}
std::lock_guard<std::mutex> lock(queue_mu);
void VideoWidget::stop()
{
- if (!running) {
+ if (running == NOT_RUNNING || running == VIDEO_FILE_ERROR) {
return;
}
- running = false;
producer_thread_should_quit.quit();
producer_thread.join();
}
{
if (!producer_thread_should_quit.should_quit()) {
if (!play_video(pathname)) {
- // TODO: Send the error back to the UI somehow.
+ running = VIDEO_FILE_ERROR;
+ } else {
+ running = NOT_RUNNING;
}
}
}
AVFrameWithDeleter video_avframe = av_frame_alloc_unique();
bool eof = false;
do {
- AVPacket pkt;
+ AVPacket *pkt = av_packet_alloc();
unique_ptr<AVPacket, decltype(av_packet_unref)*> pkt_cleanup(
- &pkt, av_packet_unref);
- av_init_packet(&pkt);
- pkt.data = nullptr;
- pkt.size = 0;
- if (av_read_frame(format_ctx, &pkt) == 0) {
- if (pkt.stream_index == video_stream_index) {
- if (avcodec_send_packet(video_codec_ctx, &pkt) < 0) {
+ pkt, av_packet_unref);
+ pkt->data = nullptr;
+ pkt->size = 0;
+ if (av_read_frame(format_ctx, pkt) == 0) {
+ if (pkt->stream_index == video_stream_index) {
+ if (avcodec_send_packet(video_codec_ctx, pkt) < 0) {
fprintf(stderr, "%s: Cannot send packet to video codec.\n", pathname.c_str());
*error = true;
return AVFrameWithDeleter(nullptr);
internal_rewind();
+ running = RUNNING;
+
// Main loop.
int consecutive_errors = 0;
double rate = 1.0;
bool finished_wakeup;
finished_wakeup = producer_thread_should_quit.sleep_until(next_frame_start);
if (finished_wakeup) {
- current_frame.reset(new Frame(make_video_frame(frame.get())));
+ shared_ptr<Frame> new_frame = make_video_frame(frame.get());
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame = std::move(new_frame);
+ }
last_frame = steady_clock::now();
update();
break;
if (paused) {
// Just paused, so present the frame immediately and then go into deep sleep.
- current_frame.reset(new Frame(make_video_frame(frame.get())));
+ shared_ptr<Frame> new_frame = make_video_frame(frame.get());
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame = std::move(new_frame);
+ }
last_frame = steady_clock::now();
update();
break;
{
last_pts = pts;
last_position = lrint(pts * double(video_timebase.num) / double(video_timebase.den) * 1000);
- emit position_changed(last_position);
+ post_to_main_thread([this, last_position{last_position.load()}] {
+ emit position_changed(last_position);
+ });
}
// Taken from Movit (see the comment there for explanation)
}
}
-VideoWidget::Frame VideoWidget::make_video_frame(const AVFrame *frame)
+shared_ptr<VideoWidget::Frame> VideoWidget::alloc_frame(unsigned width, unsigned height, unsigned chroma_width, unsigned chroma_height)
+{
+ lock_guard lock(freelist_mu);
+ for (auto it = frame_freelist.begin(); it != frame_freelist.end(); ++it) {
+ if ((*it)->width == width &&
+ (*it)->height == height &&
+ (*it)->chroma_width == chroma_width &&
+ (*it)->chroma_height == chroma_height) {
+ Frame *frame = *it;
+ frame_freelist.erase(it);
+ return shared_ptr<Frame>{frame, free_frame};
+ }
+ }
+
+ Frame *frame = new Frame;
+ frame->owner = this;
+ frame->width = width;
+ frame->height = height;
+ frame->chroma_width = chroma_width;
+ frame->chroma_height = chroma_height;
+
+ size_t len = frame->width * frame->height + 2 * frame->chroma_width * frame->chroma_height;
+ frame->data.reset(new uint8_t[len]);
+
+ return shared_ptr<Frame>{frame, free_frame};
+}
+
+void VideoWidget::free_frame(VideoWidget::Frame *frame)
+{
+ VideoWidget *self = frame->owner;
+ lock_guard lock(self->freelist_mu);
+ if (self->frame_freelist.size() >= 16) {
+ delete self->frame_freelist.front();
+ self->frame_freelist.pop_front();
+ }
+ self->frame_freelist.push_back(frame);
+}
+
+shared_ptr<VideoWidget::Frame> VideoWidget::make_video_frame(const AVFrame *frame)
{
- Frame video_frame;
AVFrameWithDeleter sw_frame;
if (frame->format == AV_PIX_FMT_VAAPI ||
int linesizes[4] = { 0, 0, 0, 0 };
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(sws_dst_format);
- video_frame.width = frame->width;
- video_frame.height = frame->height;
- video_frame.chroma_width = AV_CEIL_RSHIFT(int(frame->width), desc->log2_chroma_w);
- video_frame.chroma_height = AV_CEIL_RSHIFT(int(frame->height), desc->log2_chroma_h);
+ shared_ptr<Frame> video_frame = alloc_frame(
+ frame->width,
+ frame->height,
+ AV_CEIL_RSHIFT(int(frame->width), desc->log2_chroma_w),
+ AV_CEIL_RSHIFT(int(frame->height), desc->log2_chroma_h));
// We always assume left chroma placement for now.
- cbcr_offset[0] = compute_chroma_offset(0.0f, 1 << desc->log2_chroma_w, video_frame.chroma_width);
- cbcr_offset[1] = compute_chroma_offset(0.5f, 1 << desc->log2_chroma_h, video_frame.chroma_height);
-
- size_t len = frame->width * frame->height + 2 * video_frame.chroma_width * video_frame.chroma_height;
- video_frame.data.reset(new uint8_t[len]);
+ cbcr_offset[0] = compute_chroma_offset(0.0f, 1 << desc->log2_chroma_w, video_frame->chroma_width);
+ cbcr_offset[1] = compute_chroma_offset(0.5f, 1 << desc->log2_chroma_h, video_frame->chroma_height);
- pic_data[0] = video_frame.data.get();
+ pic_data[0] = video_frame->data.get();
linesizes[0] = frame->width;
pic_data[1] = pic_data[0] + frame->width * frame->height;
- linesizes[1] = video_frame.chroma_width;
+ linesizes[1] = video_frame->chroma_width;
- pic_data[2] = pic_data[1] + video_frame.chroma_width * video_frame.chroma_height;
- linesizes[2] = video_frame.chroma_width;
+ pic_data[2] = pic_data[1] + video_frame->chroma_width * video_frame->chroma_height;
+ linesizes[2] = video_frame->chroma_width;
sws_scale(sws_ctx.get(), frame->data, frame->linesize, 0, frame->height, pic_data, linesizes);