#include <vector>
#include <unordered_set>
+#include "post_to_main_thread.h"
+
#include <QOpenGLFunctions>
+#include <QWheelEvent>
+#include <QMouseEvent>
using namespace std;
using namespace std::chrono;
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())));
+ Frame *new_frame = new Frame(make_video_frame(frame.get()));
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame.reset(new_frame);
+ }
update();
store_pts(frame->pts);
break;
if (frame == nullptr || error) {
return true;
}
- current_frame.reset(new Frame(make_video_frame(frame.get())));
+ Frame *new_frame = new Frame(make_video_frame(frame.get()));
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame.reset(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;
glBegin(GL_QUADS);
+ // (0,0)
glVertexAttrib2f(1, tx1, ty1);
- glVertex2f(0.0f, 0.0f);
+ glVertex2f(zoom_matrix[2 * 3 + 0], zoom_matrix[2 * 3 + 1]);
+ // (0,1)
glVertexAttrib2f(1, tx1, ty2);
- glVertex2f(0.0f, 1.0f);
+ glVertex2f(zoom_matrix[1 * 3 + 0] + zoom_matrix[2 * 3 + 0], zoom_matrix[1 * 3 + 1] + zoom_matrix[2 * 3 + 1]);
+ // (1,1)
glVertexAttrib2f(1, tx2, ty2);
- glVertex2f(1.0f, 1.0f);
+ glVertex2f(zoom_matrix[0 * 3 + 0] + zoom_matrix[1 * 3 + 0] + zoom_matrix[2 * 3 + 0],
+ zoom_matrix[1 * 3 + 0] + zoom_matrix[1 * 3 + 1] + zoom_matrix[2 * 3 + 1]);
+ // (1,0)
glVertexAttrib2f(1, tx2, ty1);
- glVertex2f(1.0f, 0.0f);
+ glVertex2f(zoom_matrix[0 * 3 + 0] + zoom_matrix[2 * 3 + 0],
+ zoom_matrix[1 * 3 + 0] + zoom_matrix[2 * 3 + 1]);
glEnd();
}
-void VideoWidget::open(const string &filename)
+void matmul3x3(const double a[9], const double b[9], double res[9])
+{
+ for (int i = 0; i < 3; ++i) {
+ for (int j = 0; j < 3; ++j) {
+ double sum = 0.0;
+ for (int k = 0; k < 3; ++k) {
+ sum += a[i * 3 + k] * b[k * 3 + j];
+ }
+ res[i * 3 + j] = sum;
+ }
+ }
+}
+
+void VideoWidget::wheelEvent(QWheelEvent *event)
+{
+ int delta = event->angleDelta().y();
+ if (delta == 0) {
+ return;
+ }
+ double x = event->position().x() / width();
+ double y = 1.0 - event->position().y() / height();
+ double zoom = delta > 0 ? pow(1.005, delta) : pow(1/1.005, -delta);
+
+ const double inv_translation_matrix[9] = {
+ 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ -x, -y, 1.0
+ };
+ const double scale_matrix[9] = {
+ zoom, 0.0, 0.0,
+ 0.0, zoom, 0.0,
+ 0.0, 0.0, 1.0
+ };
+ const double translation_matrix[9] = {
+ 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ x, y, 1.0
+ };
+ double tmp1[9], tmp2[9];
+ matmul3x3(zoom_matrix, inv_translation_matrix, tmp1);
+ matmul3x3(tmp1, scale_matrix, tmp2);
+ matmul3x3(tmp2, translation_matrix, zoom_matrix);
+
+ fixup_zoom_matrix();
+ update();
+}
+
+void VideoWidget::mousePressEvent(QMouseEvent *e)
+{
+ 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();
+ }
+}
+
+void VideoWidget::mouseReleaseEvent(QMouseEvent *e)
+{
+ if (e->button() == Qt::LeftButton) {
+ dragging = false;
+ }
+}
+
+void VideoWidget::mouseMoveEvent(QMouseEvent *e)
+{
+ if (!dragging) {
+ return;
+ }
+ float dx = (e->position().x() - last_drag_x) / width();
+ float dy = (e->position().y() - last_drag_y) / height();
+
+ //zoom_matrix[6] += dx * zoom_matrix[0];
+ //zoom_matrix[7] += dy * zoom_matrix[4];
+ zoom_matrix[6] += dx;
+ zoom_matrix[7] -= dy;
+ fixup_zoom_matrix();
+
+ last_drag_x = e->position().x();
+ last_drag_y = e->position().y();
+
+ update();
+}
+
+// Normalize the matrix so that we never get skew or similar,
+// and also never can zoom or pan too far out.
+void VideoWidget::fixup_zoom_matrix()
+{
+ // Correct for any numerical errors (we know the matrix must be orthogonal
+ // and have zero rotation).
+ zoom_matrix[4] = zoom_matrix[0];
+ zoom_matrix[1] = zoom_matrix[2] = zoom_matrix[3] = zoom_matrix[5] = 0.0;
+ zoom_matrix[8] = 1.0;
+
+ // We can't zoom further out than 1:1. (Perhaps it would be nice to
+ // reuse the last zoom-in point to do this, but the center will have to do
+ // for now.)
+ if (zoom_matrix[0] < 1.0) {
+ const double zoom = 1.0 / zoom_matrix[0];
+ const double inv_translation_matrix[9] = {
+ 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ -0.5, -0.5, 1.0
+ };
+ const double scale_matrix[9] = {
+ zoom, 0.0, 0.0,
+ 0.0, zoom, 0.0,
+ 0.0, 0.0, 1.0
+ };
+ const double translation_matrix[9] = {
+ 1.0, 0.0, 0.0,
+ 0.0, 1.0, 0.0,
+ 0.5, 0.5, 1.0
+ };
+ double tmp1[9], tmp2[9];
+ matmul3x3(zoom_matrix, inv_translation_matrix, tmp1);
+ matmul3x3(tmp1, scale_matrix, tmp2);
+ matmul3x3(tmp2, translation_matrix, zoom_matrix);
+ }
+
+ // Looking at the points we'll draw with glVertex2f(), make sure none of them are
+ // inside the square (which would generally mean we've panned ourselves out-of-bounds).
+ // We simply adjust the translation, which is possible because we fixed scaling above.
+ zoom_matrix[6] = min(zoom_matrix[6], 0.0); // Left side (x=0).
+ zoom_matrix[7] = min(zoom_matrix[7], 0.0); // Bottom side (y=0).
+ zoom_matrix[6] = std::max(zoom_matrix[6], 1.0 - zoom_matrix[0]); // Right side (x=1).
+ zoom_matrix[7] = std::max(zoom_matrix[7], 1.0 - zoom_matrix[4]); // Top side (y=1).
+}
+
+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())));
+ Frame *new_frame = new Frame(make_video_frame(frame.get()));
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame.reset(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())));
+ Frame *new_frame = new Frame(make_video_frame(frame.get()));
+ {
+ lock_guard lock(current_frame_mu);
+ current_frame.reset(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)
projects / pkanalytics / blobdiff