diff --git a/.travis.yml b/.travis.yml
index 4c822eb..413347c 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -5,27 +5,29 @@ language: cpp
 addons:
   apt:
     sources:
-      - sourceline: 'deb http://en.archive.ubuntu.com/ubuntu/ artful main universe'
+      - sourceline: 'ppa:jonathonf/ffmpeg-4'
+      - sourceline: 'ppa:adrozdoff/cmake'
+      - sourceline: 'ppa:boost-latest/ppa'
     packages:
       - cmake
       - python3
-      - libboost-chrono-dev 
-      - libboost-filesystem-dev 
-      - libboost-system-dev 
+      - libboost-chrono-dev
+      - libboost-filesystem-dev
+      - libboost-system-dev
       - libboost-timer-dev
-      - libboost-thread-dev 
-      - libboost-test-dev 
-      - libavcodec-dev 
-      - libavformat-dev 
+      - libboost-thread-dev
+      - libboost-test-dev
+      - libavcodec-dev
+      - libavformat-dev
       - libavutil-dev
       - libavfilter-dev
       - libavdevice-dev
       - libswresample-dev
       - libswscale-dev
-      - fluid 
-      - libfltk1.3-dev 
+      - fluid
+      - libfltk1.3-dev
       - libgl1-mesa-dev
       - libjsoncpp-dev
-      - libopencv-dev 
+      - libopencv-dev
       - lcov
 script: python3 misc/checks.py lint && cmake . && cmake --build .
\ No newline at end of file
diff --git a/CMakeLists.txt b/CMakeLists.txt
index ec43ef8..00a25b1 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -6,8 +6,14 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${CMAKE_CURRENT_SOURCE_DIR}/cmake-mod
 set(Boost_USE_STATIC_LIBS ON)
 set(CMAKE_CXX_STANDARD 14)
 set(FLTK_SKIP_FLUID true)
-set(CMAKE_BUILD_TYPE Debug)
-# set(CMAKE_BUILD_TYPE Release)
+
+if ($ENV{VCUTTER_DEBUG})
+    message("Compliling in Debug build type")
+    set(CMAKE_BUILD_TYPE Debug)
+else ($ENV{VCUTTER_DEBUG})
+    message("Compliling in Release build type")
+    set(CMAKE_BUILD_TYPE Release)
+endif ($ENV{VCUTTER_DEBUG})
 
 find_path(AVCODEC_INCLUDE_DIR libavcodec/avcodec.h)
 find_library(AVCODEC_LIBRARY avcodec)
diff --git a/src/clippings/clipping.cpp b/src/clippings/clipping.cpp
index bdc80b3..87e83e4 100644
--- a/src/clippings/clipping.cpp
+++ b/src/clippings/clipping.cpp
@@ -6,10 +6,10 @@
 namespace vcutter {
 
 
-Clipping::Clipping(const char *path, bool path_is_video) : ClippingRender(path, path_is_video), clipping_ref_(this){
+Clipping::Clipping(const char *path, bool path_is_video, frame_callback_t frame_cb) : ClippingRender(path, path_is_video, frame_cb), clipping_ref_(this){
 }
 
-Clipping::Clipping(const Json::Value * root) : ClippingRender(root), clipping_ref_(this) {
+Clipping::Clipping(const Json::Value * root, frame_callback_t frame_cb) : ClippingRender(root, frame_cb), clipping_ref_(this) {
 }
 
 ClippingRef & Clipping::ref() {
diff --git a/src/clippings/clipping.h b/src/clippings/clipping.h
index 6270f46..8fd2828 100644
--- a/src/clippings/clipping.h
+++ b/src/clippings/clipping.h
@@ -11,8 +11,8 @@ namespace vcutter {
 
 class Clipping: public ClippingRender {
  public:
-    explicit Clipping(const Json::Value * root);
-    Clipping(const char *path, bool path_is_video);
+    Clipping(const Json::Value * root, frame_callback_t frame_cb);
+    Clipping(const char *path, bool path_is_video, frame_callback_t frame_cb);
     virtual ~Clipping(){}
     ClippingRef & ref();
  private:
diff --git a/src/clippings/clipping_conversion.h b/src/clippings/clipping_conversion.h
index a66466d..4f8762d 100644
--- a/src/clippings/clipping_conversion.h
+++ b/src/clippings/clipping_conversion.h
@@ -9,7 +9,6 @@
 #include <memory>
 #include <list>
 #include <atomic>
-#include <boost/core/noncopyable.hpp>
 #include "src/clippings/clipping_iterator.h"
 #include "src/clippings/clipping.h"
 #include "src/common/buffers.h"
@@ -28,7 +27,9 @@ class ProgressHandler {
     virtual void set_progress(uint32_t progress, uint32_t max_progress) = 0;
 };
 
-class ClippingConversion: private boost::noncopyable {
+class ClippingConversion {
+   ClippingConversion(const ClippingConversion&) = delete;
+   ClippingConversion& operator=(const ClippingConversion&) = delete;
  public:
     ClippingConversion(std::shared_ptr<ProgressHandler> prog_handler, std::shared_ptr<ClippingRender> clipping, uint32_t max_memory=419430400);
 
diff --git a/src/clippings/clipping_data.cpp b/src/clippings/clipping_data.cpp
index f8bfecb..78f0e9d 100644
--- a/src/clippings/clipping_data.cpp
+++ b/src/clippings/clipping_data.cpp
@@ -76,11 +76,13 @@ void ClippingData::load_file(const char *path) {
     saved_path_ = path;
 }
 
-void ClippingData::save(const char *path) {
+void ClippingData::save(const char *path, bool preserve_path) {
     JsonFile jsf(path, false, false);
     jsf["ClippingData"] = serialize();
     jsf.save();
-    saved_path_ = path;
+    if (preserve_path) {
+        saved_path_ = path;
+    }
 }
 
 std::string ClippingData::saved_path() {
diff --git a/src/clippings/clipping_data.h b/src/clippings/clipping_data.h
index 8cf2f5b..a48e2ab 100644
--- a/src/clippings/clipping_data.h
+++ b/src/clippings/clipping_data.h
@@ -9,14 +9,15 @@
 #include <string>
 #include <list>
 
-#include <boost/core/noncopyable.hpp>
 #include <jsoncpp/json/json.h>
 
 #include "src/clippings/clipping_key.h"
 
 namespace vcutter {
 
-class ClippingData: private boost::noncopyable {
+class ClippingData {
+    ClippingData(const ClippingData&) = delete;
+    ClippingData& operator=(const ClippingData&) = delete;
  public:
     explicit ClippingData(const Json::Value * root);
     explicit ClippingData(const char *path);
@@ -27,7 +28,7 @@ class ClippingData: private boost::noncopyable {
     void h(uint32_t value);
     void add(const ClippingKey & key);
     ClippingKey at(uint32_t frame);
-    void save(const char *path);
+    void save(const char *path, bool preserve_path=true);
     std::string saved_path();
     Json::Value serialize();
     uint32_t req_buffer_size();
diff --git a/src/clippings/clipping_frame.cpp b/src/clippings/clipping_frame.cpp
index 3cdb13f..d145a05 100644
--- a/src/clippings/clipping_frame.cpp
+++ b/src/clippings/clipping_frame.cpp
@@ -5,7 +5,8 @@
 
 namespace vcutter {
 
-ClippingFrame::ClippingFrame(const char *path, bool path_is_video) : ClippingData(path_is_video ? "" : path) {
+ClippingFrame::ClippingFrame(const char *path, bool path_is_video, frame_callback_t frame_cb) : ClippingData(path_is_video ? "" : path) {
+    frame_cb_ = frame_cb;
     if (path_is_video) {
         video_path(path);
         video_open();
@@ -14,7 +15,8 @@ ClippingFrame::ClippingFrame(const char *path, bool path_is_video) : ClippingDat
     }
 }
 
-ClippingFrame::ClippingFrame(const Json::Value * root) : ClippingData(root) {
+ClippingFrame::ClippingFrame(const Json::Value * root, frame_callback_t frame_cb) : ClippingData(root) {
+    frame_cb_ = frame_cb;
     video_open();
 }
 
@@ -23,7 +25,7 @@ void ClippingFrame::video_open() {
         return;
     }
 
-    player_.reset(new Player(video_path().c_str()));
+    player_.reset(new Player(video_path().c_str(), frame_cb_));
 
     if (!good()){
         return;
@@ -195,5 +197,8 @@ ClippingKey ClippingFrame::current_key() {
     return at(player_->info()->position());
 }
 
+frame_callback_t ClippingFrame::frame_callback() {
+    return frame_cb_;
+}
 
 }  // namespace vcutter
diff --git a/src/clippings/clipping_frame.h b/src/clippings/clipping_frame.h
index 22095a1..fe660bf 100644
--- a/src/clippings/clipping_frame.h
+++ b/src/clippings/clipping_frame.h
@@ -15,8 +15,8 @@ namespace vcutter {
 
 class ClippingFrame: public ClippingData {
  public:
-    explicit ClippingFrame(const Json::Value * root);
-    ClippingFrame(const char *path, bool path_is_video);
+    ClippingFrame(const Json::Value * root, frame_callback_t frame_cb);
+    ClippingFrame(const char *path, bool path_is_video, frame_callback_t frame_cb);
     virtual ~ClippingFrame(){}
     Player *player();
     bool good();
@@ -39,10 +39,12 @@ class ClippingFrame: public ClippingData {
     uint32_t default_w() override;
     uint32_t default_h() override;
     uint32_t frame_count() override;
+    frame_callback_t frame_callback();
  private:
     void video_open();
 
  private:
+    frame_callback_t frame_cb_;
     std::unique_ptr<Player> player_;
 };
 
diff --git a/src/clippings/clipping_ref.h b/src/clippings/clipping_ref.h
index 16c88e0..0997302 100644
--- a/src/clippings/clipping_ref.h
+++ b/src/clippings/clipping_ref.h
@@ -6,13 +6,14 @@
 #define SRC_CLIPPINGS_CLIPPING_REF_H_
 
 #include <inttypes.h>
-#include <boost/core/noncopyable.hpp>
 
 namespace vcutter {
 
 class ClippingFrame;
 
-class ClippingRef: private boost::noncopyable {
+class ClippingRef {
+    ClippingRef(const ClippingRef&) = delete;
+    ClippingRef& operator=(const ClippingRef&) = delete;
  public:
     ClippingRef(ClippingFrame *clipping);
     bool has_ref();
diff --git a/src/clippings/clipping_render.cpp b/src/clippings/clipping_render.cpp
index 0c85892..b640557 100644
--- a/src/clippings/clipping_render.cpp
+++ b/src/clippings/clipping_render.cpp
@@ -56,10 +56,10 @@ void copy_center(cv::Mat& source, cv::Mat& target) {
 
 }  // namespace tmp
 
-ClippingRender::ClippingRender(const char *path, bool path_is_video) : ClippingFrame(path, path_is_video) {
+ClippingRender::ClippingRender(const char *path, bool path_is_video, frame_callback_t frame_cb) : ClippingFrame(path, path_is_video, frame_cb) {
 }
 
-ClippingRender::ClippingRender(const Json::Value * root) : ClippingFrame(root) {
+ClippingRender::ClippingRender(const Json::Value * root, frame_callback_t frame_cb) : ClippingFrame(root, frame_cb) {
 }
 
 void ClippingRender::render(ClippingKey key, uint8_t *source_buffer, uint32_t target_w, uint32_t target_h, uint8_t *buffer) {
@@ -139,7 +139,7 @@ void ClippingRender::render(ClippingKey key, uint8_t *buffer) {
 }
 
 std::shared_ptr<ClippingRender> ClippingRender::clone() {
-  std::shared_ptr<ClippingRender> clipping(new ClippingRender(video_path().c_str(), true));
+  std::shared_ptr<ClippingRender> clipping(new ClippingRender(video_path().c_str(), true, frame_callback()));
   clipping->wh(w(), h());
 
   for (const auto & k : keys()) {
diff --git a/src/clippings/clipping_render.h b/src/clippings/clipping_render.h
index 18a7657..21ed1a7 100644
--- a/src/clippings/clipping_render.h
+++ b/src/clippings/clipping_render.h
@@ -15,8 +15,8 @@ namespace vcutter {
 
 class ClippingRender: public ClippingFrame {
  public:
-    explicit ClippingRender(const Json::Value * root);
-    ClippingRender(const char *path, bool path_is_video);
+    explicit ClippingRender(const Json::Value * root, frame_callback_t frame_cb);
+    ClippingRender(const char *path, bool path_is_video,  frame_callback_t frame_cb);
     virtual ~ClippingRender(){}
     void render(ClippingKey key, uint32_t target_w, uint32_t target_h, uint8_t *buffer);
     void render(ClippingKey key, uint8_t *buffer);
diff --git a/src/clippings/clipping_session.cpp b/src/clippings/clipping_session.cpp
index e7d03d4..bb77b65 100644
--- a/src/clippings/clipping_session.cpp
+++ b/src/clippings/clipping_session.cpp
@@ -11,13 +11,13 @@ namespace {
 const char *kCLIPPING_SESSION_NAME = "-clipping-session.vcutter";
 }  // namespace
 
-ClippingSession::ClippingSession(const char *session_name, const char *path, bool path_is_video)
- : Clipping(path, path_is_video), session_name_(session_name) {
+ClippingSession::ClippingSession(const char *session_name, const char *path, bool path_is_video, frame_callback_t frame_cb)
+ : Clipping(path, path_is_video, frame_cb), session_name_(session_name) {
     Fl::add_timeout(1.0, &ClippingSession::fltk_timeout_handler, this);
 }
 
-ClippingSession::ClippingSession(const char *session_name, const Json::Value * root)
- : Clipping(root), session_name_(session_name) {
+ClippingSession::ClippingSession(const char *session_name, const Json::Value * root, frame_callback_t frame_cb)
+ : Clipping(root, frame_cb), session_name_(session_name) {
 }
 
 ClippingSession::~ClippingSession() {
@@ -33,7 +33,7 @@ void ClippingSession::fltk_timeout_handler(void* clipping_session) {
 void ClippingSession::save_session() {
     if (last_version_ != version()) {
         last_version_ = version();
-        save(session_path().c_str());
+        save(session_path().c_str(), false);
     }
 }
 
@@ -41,11 +41,11 @@ std::string ClippingSession::session_path() {
     return temp_filepath((session_name_ + kCLIPPING_SESSION_NAME).c_str());
 }
 
-std::unique_ptr<ClippingSession> ClippingSession::restore_session(const char *session_name) {
+std::unique_ptr<ClippingSession> ClippingSession::restore_session(const char *session_name, frame_callback_t frame_cb) {
     std::string path = temp_filepath((std::string(session_name) + kCLIPPING_SESSION_NAME).c_str());
 
     std::unique_ptr<ClippingSession> result(
-        new ClippingSession(session_name, path.c_str(), false)
+        new ClippingSession(session_name, path.c_str(), false, frame_cb)
     );
 
     if (!result->good()) {
diff --git a/src/clippings/clipping_session.h b/src/clippings/clipping_session.h
index 912c877..bb88885 100644
--- a/src/clippings/clipping_session.h
+++ b/src/clippings/clipping_session.h
@@ -17,11 +17,11 @@ namespace vcutter {
 */
 class ClippingSession: public Clipping {
  public:
-    explicit ClippingSession(const char *session_name, const Json::Value * root);
-    ClippingSession(const char *session_name, const char *path, bool path_is_video);
+    explicit ClippingSession(const char *session_name, const Json::Value * root, frame_callback_t frame_cb);
+    ClippingSession(const char *session_name, const char *path, bool path_is_video, frame_callback_t frame_cb);
     virtual ~ClippingSession();
     static void fltk_timeout_handler(void* clipping_session);
-    static std::unique_ptr<ClippingSession> restore_session(const char *session_name);
+    static std::unique_ptr<ClippingSession> restore_session(const char *session_name, frame_callback_t frame_cb);
  private:
     std::string session_path();
     void save_session();
diff --git a/src/common/buffers.h b/src/common/buffers.h
index c32be77..ab8682a 100644
--- a/src/common/buffers.h
+++ b/src/common/buffers.h
@@ -6,12 +6,13 @@
 
 #include <memory>
 #include <vector>
-#include <boost/core/noncopyable.hpp>
 
 
 namespace vcutter {
 
-class CharBuffer: private boost::noncopyable {
+class CharBuffer {
+   CharBuffer(const CharBuffer&) = delete;
+   CharBuffer& operator=(const CharBuffer&) = delete;
  public:
     CharBuffer(uint32_t size) {
         data = new uint8_t[size];
@@ -25,7 +26,9 @@ class CharBuffer: private boost::noncopyable {
 };
 
 
-class StackBuffer: private  boost::noncopyable {
+class StackBuffer {
+    StackBuffer(const StackBuffer&) = delete;
+    StackBuffer& operator=(const StackBuffer&) = delete;
  public:
     StackBuffer(uint32_t individual_size, uint32_t buffer_count);
     virtual ~StackBuffer(){}
diff --git a/src/player/player.cpp b/src/player/player.cpp
index 2cf81c4..7d0ffd5 100644
--- a/src/player/player.cpp
+++ b/src/player/player.cpp
@@ -55,9 +55,7 @@ void Player::init_frame_changed_notifier() {
 }
 
 void Player::timeout_handler(void* ud) {
-    if (static_cast<Player *>(ud)->frame_changed(true)) {
-        static_cast<Player *>(ud)->frame_changed_cb_(static_cast<Player *>(ud));
-    }
+    static_cast<Player *>(ud)->notify_frame_changed();
     Fl::repeat_timeout(kON_FRAME_TIMEOUT_INTERVAL, &Player::timeout_handler, ud);
 }
 
@@ -125,12 +123,19 @@ void Player::noop() {
     call_async([](){});
 }
 
+void Player::notify_frame_changed() {
+    if (frame_changed_cb_ && frame_changed(true)) {
+        frame_changed_cb_(this);
+    }
+}
+
 void Player::stop() {
     stop_playing();
     call_async([this] () {
         decoder_->seek_frame(0);
         frame_changed_.store(true);
     });
+    notify_frame_changed();
 }
 
 void Player::next() {
@@ -139,6 +144,7 @@ void Player::next() {
         decoder_->next();
         frame_changed_.store(true);
     });
+    notify_frame_changed();
 }
 
 void Player::prior() {
@@ -147,6 +153,7 @@ void Player::prior() {
         decoder_->prior();
         frame_changed_.store(true);
     });
+    notify_frame_changed();
 }
 
 void Player::seek_frame(int64_t frame) {
@@ -154,6 +161,7 @@ void Player::seek_frame(int64_t frame) {
         decoder_->seek_frame(frame);
         frame_changed_.store(true);
     });
+    notify_frame_changed();
 }
 
 void Player::seek_time(int64_t ms_time) {
@@ -161,6 +169,7 @@ void Player::seek_time(int64_t ms_time) {
         decoder_->seek_time(ms_time);
         frame_changed_.store(true);
     });
+    notify_frame_changed();
 }
 
 void Player::replace_callback(async_callback_t callback) {
diff --git a/src/player/player.h b/src/player/player.h
index e93e9d9..480f2a7 100644
--- a/src/player/player.h
+++ b/src/player/player.h
@@ -40,13 +40,13 @@ class Player {
     bool is_playing_interval();
     bool execution_finished();
     void execute(context_callback_t callback);
-    bool frame_changed(bool clear_flag); // turn private
     void set_frame_changed_callback(frame_callback_t frame_changed_cb);
     void clear_frame_changed_callback();
   private:
     void init(const char *path);
     void init_frame_changed_notifier();
     static void timeout_handler(void* ud);
+    bool frame_changed(bool clear_flag);
     void replace_callback(async_callback_t callback);
     void wait_callback();
     void call_async(async_callback_t callback);
@@ -55,6 +55,7 @@ class Player {
     void stop_playing();
     void run_callback();
     bool grab_frame();
+    void notify_frame_changed();
   private:
     bool finished_;
     bool playing_;
diff --git a/src/viewer/editor/clipping_editor.cpp b/src/viewer/editor/clipping_editor.cpp
index a8fe75d..f4ea191 100644
--- a/src/viewer/editor/clipping_editor.cpp
+++ b/src/viewer/editor/clipping_editor.cpp
@@ -88,6 +88,10 @@ void ClippingEditor::update(Clipping *clipping) {
     redraw();
 }
 
+Clipping *ClippingEditor::current_clipping() {
+    return clipping_;
+}
+
 void ClippingEditor::viewer_draw(BufferViewer *viewer, bool *handled, const unsigned char* buffer, uint32_t w, uint32_t h) {
     if (!clipping_) {
         return;
diff --git a/src/viewer/editor/clipping_editor.h b/src/viewer/editor/clipping_editor.h
index a1b7069..c6969eb 100644
--- a/src/viewer/editor/clipping_editor.h
+++ b/src/viewer/editor/clipping_editor.h
@@ -28,6 +28,7 @@ class ClippingEditor: public BufferViewer, public BufferSupplier, public DrawHan
     virtual ~ClippingEditor();
     void invalidate();
     void update(Clipping *clipping);
+    Clipping *current_clipping();
     void draw_operations();
     bool first_frame_cache_initialized();
     bool last_frame_cache_initialized();
diff --git a/src/vstream/encoder.cpp b/src/vstream/encoder.cpp
index 079e266..4a199c8 100644
--- a/src/vstream/encoder.cpp
+++ b/src/vstream/encoder.cpp
@@ -166,8 +166,8 @@ bool EncoderImp::find_codec() {
         codec_id = AV_CODEC_ID_HEVC;
     } else if (strcmp(kVP9_CODEC, codec_name_.c_str()) == 0) {
         codec_id = AV_CODEC_ID_VP9;
-    } else if (strcmp(kAV1_CODEC, codec_name_.c_str()) == 0) {
-        codec_id = AV_CODEC_ID_AV1;
+    // } else  if (strcmp(kAV1_CODEC, codec_name_.c_str()) == 0) {
+        // codec_id = AV_CODEC_ID_AV1;
     } else {
         report_error("Invalid codec name");
         return NULL;
diff --git a/src/wnd_cutter/clipping_actions.cpp b/src/wnd_cutter/clipping_actions.cpp
index 58a9b15..380bfda 100644
--- a/src/wnd_cutter/clipping_actions.cpp
+++ b/src/wnd_cutter/clipping_actions.cpp
@@ -52,7 +52,9 @@ void ClippingActions::close() {
 }
 
 bool ClippingActions::open(const std::string& path, bool path_is_video) {
-    clipping_.reset(new ClippingSession("cwnd", path.c_str(), path_is_video));
+    clipping_.reset(new ClippingSession("cwnd", path.c_str(), path_is_video, [this] (Player* player) {
+        handler_->handle_frame_changed(player);
+    }));
     return handle_opened_clipping();
 }
 
@@ -68,7 +70,12 @@ bool ClippingActions::handle_opened_clipping() {
 }
 
 bool ClippingActions::restore_session() {
-    std::shared_ptr<ClippingSession> restored(std::move(ClippingSession::restore_session("cwnd")));
+    std::shared_ptr<ClippingSession> restored(std::move(ClippingSession::restore_session(
+        "cwnd",
+        [this] (Player* player) {
+            handler_->handle_frame_changed(player);
+        }
+    )));
 
     if (!restored) {
         return false;
diff --git a/src/wnd_cutter/clipping_actions.h b/src/wnd_cutter/clipping_actions.h
index e278abb..2397d65 100644
--- a/src/wnd_cutter/clipping_actions.h
+++ b/src/wnd_cutter/clipping_actions.h
@@ -19,6 +19,7 @@ class ClippingActionsHandler {
     virtual void handle_clipping_resized() = 0;
     virtual void handle_clipping_keys_changed() = 0;
     virtual void handle_buffer_modified() = 0;
+    virtual void handle_frame_changed(Player *player) = 0;
 };
 
 class ClippingActions {
diff --git a/src/wnd_cutter/cutter_window.cpp b/src/wnd_cutter/cutter_window.cpp
index fe226bf..6e46d41 100644
--- a/src/wnd_cutter/cutter_window.cpp
+++ b/src/wnd_cutter/cutter_window.cpp
@@ -99,7 +99,7 @@ void CutterWindow::resize_controls() {
     parent_->position(parent_x, parent_y);
 
     if (visible()) {
-        update_buffers(true);
+        // update_buffers(false);
         redraw_frame();
     }
 }
@@ -156,7 +156,7 @@ void CutterWindow::handle_clipping_opened(bool opened) {
         return;
     }
 
-    player()->seek_frame(clipping()->first_frame());
+    clipping_editor_->update(clipping());
 
     player_bar_->update();
     redraw_frame();
@@ -165,7 +165,7 @@ void CutterWindow::handle_clipping_opened(bool opened) {
     update_title();
     clipping_version_ = clipping()->version();
 
-    update_buffers(true);
+    // update_buffers(false);
 }
 
 void CutterWindow::close() {
@@ -226,7 +226,7 @@ void CutterWindow::action_clear_ref() {
         return;
     }
     clipping()->ref().clear_reference();
-    update_buffers(true);
+    // update_buffers(false);
 }
 
 void CutterWindow::action_goto_reference() {
@@ -234,7 +234,7 @@ void CutterWindow::action_goto_reference() {
     if (clipping()->ref().get_reference_frame(&frame)) {
         player()->pause();
         player()->seek_frame(frame);
-        update_buffers(true);
+        // update_buffers(false);
     }
 }
 
@@ -256,7 +256,7 @@ void CutterWindow::redraw_frame(bool update_key_list) {
 }
 
 void CutterWindow::handle_buffer_modified() {
-    update_buffers(true);
+    // update_buffers(false);
 }
 
 void CutterWindow::update_buffers(bool frame_changed) {
@@ -271,6 +271,9 @@ void CutterWindow::update_buffers(bool frame_changed) {
         clipping_editor_->update(clipping());
         side_bar_->viewer()->update_preview(clipping());
     } else {
+        if (clipping_editor_->current_clipping() != clipping()) {
+            clipping_editor_->update(clipping());
+        }
         clipping_editor_->draw_operations();
         if (clipping_editor_->key_changed(true)) {
             side_bar_->update();
@@ -285,9 +288,13 @@ void CutterWindow::update_buffers(bool frame_changed) {
     side_bar_->update(true);
 }
 
+void CutterWindow::handle_frame_changed(Player *player) {
+    update_buffers(true);
+}
+
 void CutterWindow::poll_actions() {
     if (clipping()) {
-        update_buffers(player()->frame_changed(true));
+        update_buffers(false);
         if (wink_comparison_ && clipping_editor_->compare_box() && !player()->is_playing()) {
             ++wink_lap_;
             if (wink_lap_ > 11) {
@@ -300,6 +307,7 @@ void CutterWindow::poll_actions() {
 
 void CutterWindow::action_toggle_compare() {
     clipping_editor_->toggle_compare_box();
+    wink_comparison_ = false;
 }
 
 void CutterWindow::action_toggle_compare_wink() {
diff --git a/src/wnd_cutter/cutter_window.h b/src/wnd_cutter/cutter_window.h
index 7bbc652..0886d7f 100644
--- a/src/wnd_cutter/cutter_window.h
+++ b/src/wnd_cutter/cutter_window.h
@@ -54,6 +54,7 @@ class CutterWindow : public ClippingActionsHandler {
     void handle_clipping_keys_changed() override;
     void handle_buffer_modified() override;
     bool clipping_actions_active() override;
+    void handle_frame_changed(Player *player) override;
 
  private:
     void clear(bool clear_controls = true);
diff --git a/src/wnd_cutter/side_bar.cpp b/src/wnd_cutter/side_bar.cpp
index 32302cd..1f2f668 100644
--- a/src/wnd_cutter/side_bar.cpp
+++ b/src/wnd_cutter/side_bar.cpp
@@ -97,9 +97,10 @@ void SideBar::resize_controls() {
     int key_list_w = parent_->w() - base_left;
     int bottom_size = parent_->h() - left_component_->h();
     int key_list_size = left_component_->h() - key_list_w - bottom_size - 38;
-    int key_list_top = 33 + key_list_->h();
+
     key_list_->size(key_list_w, key_list_size);
-    viewer_->position(base_left, key_list_top);
+    int key_list_top = 33 + key_list_->h();
+
     viewer_->position(base_left, key_list_top + 1);
 
     btn_new_key_->position(base_left, 3);
diff --git a/src/wnd_main/main_window.cpp b/src/wnd_main/main_window.cpp
index 6134e40..ac42df2 100644
--- a/src/wnd_main/main_window.cpp
+++ b/src/wnd_main/main_window.cpp
@@ -168,7 +168,7 @@ void MainWindow::init_main_menu() {
     menu_edit_->add("Swap width and height", "", ca->action_swap_wh(), 0, GROUP_CLIPPING_OPEN, xpm::arrow_dwn_16x16);
     menu_edit_->add("Clear all keys", "", ca->action_clear_keys(), 0, GROUP_CLIPPING_OPEN, xpm::erase_all_16x16);
     menu_compare_ = menu_edit_->add("Compare first last frame", "", action_toggle_compare_box(), FL_MENU_TOGGLE, GROUP_CLIPPING_OPEN, xpm::eye_16x16);
-    menu_compare_alt_ = menu_edit_->add("Alternate comparation", "", action_wink_comparison(), FL_MENU_DIVIDER | FL_MENU_TOGGLE, GROUP_CLIPPING_OPEN, xpm::clock_16x16);
+    menu_compare_alt_ = menu_edit_->add("Alternate comparation", "", action_wink_comparison(), FL_MENU_DIVIDER, GROUP_CLIPPING_OPEN, xpm::clock_16x16);
     menu_edit_->add("Output properties", "", ca->action_properties(), 0, GROUP_CLIPPING_OPEN, xpm::note_16x16);
 
     menu_tools_.reset(new Menu(menu_, "&Tools"));
@@ -245,7 +245,7 @@ callback_t MainWindow::action_utils_clipping() {
             return;
         }
 
-        std::shared_ptr<Clipping> clip(new Clipping(path.c_str(), false));
+        std::shared_ptr<Clipping> clip(new Clipping(path.c_str(), false, frame_callback_t()));
         if (!clip->good()) {
             show_error("Could not open the clipping project.");
             return;
@@ -326,11 +326,13 @@ void MainWindow::open_video_or_project(const std::string& path) {
 
     std::string extension(".vcutter");
     if (path.substr(path.size() - extension.size()) == extension) {
+        cutter_window_->close();
         if (cutter_window_->clipping_actions()->open(path, false)) {
             enable_controls();
             return;
         }
     } else {
+        cutter_window_->close();
         if (cutter_window_->clipping_actions()->open(path, true)) {
             enable_controls();
             return;
@@ -625,7 +627,7 @@ int main(int argc, char **argv) {
     return result;
 }
 
-#ifdef _WIN32
+#ifdef WIN32
 int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
      return main(__argc, __argv);
 }
diff --git a/src/wnd_tools/encoder_window.cpp b/src/wnd_tools/encoder_window.cpp
index addb175..76d161f 100644
--- a/src/wnd_tools/encoder_window.cpp
+++ b/src/wnd_tools/encoder_window.cpp
@@ -289,7 +289,7 @@ bool EncoderWindow::deserialize(const string_map_t & data) {
             return false;
         }
 
-        clip_.reset(new ClippingRender(&clipping_data));
+        clip_.reset(new ClippingRender(&clipping_data, frame_callback_t()));
 
         if (!clip_->good()) {
             clip_.reset();
@@ -504,7 +504,7 @@ void EncoderWindow::action_convert() {
     std::shared_ptr<ClippingRender> clip = clip_;
 
     if (!clip) {
-        clip.reset(new ClippingRender(edt_path_->value(), true));
+        clip.reset(new ClippingRender(edt_path_->value(), true, frame_callback_t()));
         auto key1 = clip->at(start_frame);
         auto key2 = clip->at(end_frame - 1);
 
diff --git a/tests/test_vcutter/clippings/test_clipping.cpp b/tests/test_vcutter/clippings/test_clipping.cpp
index 0bdccc1..81814fd 100644
--- a/tests/test_vcutter/clippings/test_clipping.cpp
+++ b/tests/test_vcutter/clippings/test_clipping.cpp
@@ -38,7 +38,7 @@ void restore_clipping() {
 class SuiteFixture {
  public:
     SuiteFixture() {
-        clp.reset(new vcutter::Clipping("data/sample_video.webm", true));
+        clp.reset(new vcutter::Clipping("data/sample_video.webm", true, vcutter::frame_callback_t()));
         restore_clipping();
     }
 
@@ -78,7 +78,7 @@ class ClippingTearDown {
 BOOST_FIXTURE_TEST_SUITE(clipping_test_suite, SuiteFixture)
 
 BOOST_AUTO_TEST_CASE(test_clipping_constructors) {
-    vcutter::Clipping clp3("data/it_does_not_exists.mp4", true);
+    vcutter::Clipping clp3("data/it_does_not_exists.mp4", true, vcutter::frame_callback_t());
 
     BOOST_CHECK_EQUAL(clp->good(), true);
     BOOST_CHECK_EQUAL(clp3.good(), false);
@@ -100,17 +100,17 @@ BOOST_AUTO_TEST_CASE(test_clipping_deserialize) {
 
     data["keys"].append(key);
 
-    vcutter::Clipping clp2(&data);
+    vcutter::Clipping clp2(&data, vcutter::frame_callback_t());
 
     BOOST_CHECK_EQUAL(clp2.good(), true);
-    BOOST_CHECK_EQUAL(clp2.w(), 100);
-    BOOST_CHECK_EQUAL(clp2.h(), 200);
-    BOOST_CHECK_EQUAL(clp2.keys().size(), 1);
+    BOOST_CHECK_EQUAL(clp2.w(), 100u);
+    BOOST_CHECK_EQUAL(clp2.h(), 200u);
+    BOOST_CHECK_EQUAL(clp2.keys().size(), 1u);
 }
 
 
 BOOST_AUTO_TEST_CASE(test_clipping_serialize) {
-    BOOST_CHECK_EQUAL(clp->keys().size(), 2);
+    BOOST_CHECK_EQUAL(clp->keys().size(), 2u);
 
     auto data = clp->serialize();
 
@@ -126,7 +126,7 @@ BOOST_AUTO_TEST_CASE(test_clipping_serialize) {
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_buffer_size) {
-    BOOST_CHECK_EQUAL(clp->req_buffer_size(), 80 * 180 * 3);
+    BOOST_CHECK_EQUAL(clp->req_buffer_size(), 80u * 180u * 3u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_get_keys) {
@@ -142,31 +142,31 @@ BOOST_AUTO_TEST_CASE(test_clipping_get_keys) {
     BOOST_CHECK_EQUAL(k3.computed(), false);
     BOOST_CHECK_EQUAL(k4.computed(), true);
 
-    BOOST_CHECK_EQUAL(k0.frame, 119);
+    BOOST_CHECK_EQUAL(k0.frame, 119u);
     BOOST_CHECK_EQUAL(k0.angle(), k1.angle());
     BOOST_CHECK_EQUAL(k0.scale, k1.scale);
     BOOST_CHECK_EQUAL(k0.px, k1.px);
     BOOST_CHECK_EQUAL(k0.py, k1.py);
 
-    BOOST_CHECK_EQUAL(k1.frame, 120);
+    BOOST_CHECK_EQUAL(k1.frame, 120u);
     BOOST_CHECK_EQUAL(k1.angle(), 360);
     BOOST_CHECK_EQUAL(k1.scale, 1);
-    BOOST_CHECK_EQUAL(k1.px, 40);
-    BOOST_CHECK_EQUAL(k1.py, 60);
+    BOOST_CHECK_EQUAL(k1.px, 40u);
+    BOOST_CHECK_EQUAL(k1.py, 60u);
 
-    BOOST_CHECK_EQUAL(k2.frame, 500);
+    BOOST_CHECK_EQUAL(k2.frame, 500u);
     BOOST_CHECK_CLOSE(k2.angle(), 63.3333, 0.1);
     BOOST_CHECK_CLOSE(k2.scale, 0.82407, 0.1);
-    BOOST_CHECK_EQUAL(k2.px, 54);
-    BOOST_CHECK_EQUAL(k2.py, 81);
+    BOOST_CHECK_EQUAL(k2.px, 54u);
+    BOOST_CHECK_EQUAL(k2.py, 81u);
 
-    BOOST_CHECK_EQUAL(k3.frame, 1200);
+    BOOST_CHECK_EQUAL(k3.frame, 1200u);
     BOOST_CHECK_EQUAL(k3.angle(), 180);
     BOOST_CHECK_CLOSE(k3.scale, 0.5, 0.00001);
-    BOOST_CHECK_EQUAL(k3.px, 80);
-    BOOST_CHECK_EQUAL(k3.py, 120);
+    BOOST_CHECK_EQUAL(k3.px, 80u);
+    BOOST_CHECK_EQUAL(k3.py, 120u);
 
-    BOOST_CHECK_EQUAL(k4.frame, 1201);
+    BOOST_CHECK_EQUAL(k4.frame, 1201u);
     BOOST_CHECK_EQUAL(k4.angle(), k3.angle());
     BOOST_CHECK_EQUAL(k4.scale, k3.scale);
     BOOST_CHECK_EQUAL(k4.px, k3.px);
@@ -181,15 +181,15 @@ BOOST_AUTO_TEST_CASE(test_clipping_save_load) {
 
     BOOST_CHECK_EQUAL(clp->saved_path(), temp_path);
 
-    vcutter::Clipping clp2(temp_path, false);
+    vcutter::Clipping clp2(temp_path, false, vcutter::frame_callback_t());
 
     BOOST_CHECK_EQUAL(clp2.saved_path(), temp_path);
     BOOST_CHECK_EQUAL(clp2.video_path(), "data/sample_video.webm");
 
     BOOST_CHECK_EQUAL(clp2.good(), true);
-    BOOST_CHECK_EQUAL(clp2.w(), 80);
-    BOOST_CHECK_EQUAL(clp2.h(), 180);
-    BOOST_CHECK_EQUAL(clp2.keys().size(), 2);
+    BOOST_CHECK_EQUAL(clp2.w(), 80u);
+    BOOST_CHECK_EQUAL(clp2.h(), 180u);
+    BOOST_CHECK_EQUAL(clp2.keys().size(), 2u);
 
     std::remove(temp_path);
 }
@@ -197,14 +197,14 @@ BOOST_AUTO_TEST_CASE(test_clipping_save_load) {
 BOOST_AUTO_TEST_CASE(test_clipping_wh) {
     clp->wh(90, 91);
 
-    BOOST_CHECK_EQUAL(clp->w(), 90);
-    BOOST_CHECK_EQUAL(clp->h(), 91);
+    BOOST_CHECK_EQUAL(clp->w(), 90u);
+    BOOST_CHECK_EQUAL(clp->h(), 91u);
 
     clp->w(80);
     clp->h(180);
 
-    BOOST_CHECK_EQUAL(clp->w(), 80);
-    BOOST_CHECK_EQUAL(clp->h(), 180);
+    BOOST_CHECK_EQUAL(clp->w(), 80u);
+    BOOST_CHECK_EQUAL(clp->h(), 180u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_remove) {
@@ -214,9 +214,9 @@ BOOST_AUTO_TEST_CASE(test_clipping_remove) {
     k1.frame = 120;
 
     clipping.add(k1);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 1);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 1u);
     clipping.remove(120);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 0);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 0u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_define_start) {
@@ -230,23 +230,23 @@ BOOST_AUTO_TEST_CASE(test_clipping_define_start) {
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 10);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 10u);
 
     clipping.define_start(119);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 11);
-    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 119);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 11u);
+    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 119u);
 
     clipping.define_start(120);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 10);
-    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 120);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 10u);
+    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 120u);
 
     clipping.define_start(125);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 5);
-    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 125);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 5u);
+    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 125u);
 
     clipping.define_start(140);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 1);
-    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 140);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 1u);
+    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 140u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_define_end) {
@@ -260,23 +260,23 @@ BOOST_AUTO_TEST_CASE(test_clipping_define_end) {
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 10);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 10u);
 
     clipping.define_end(131);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 11);
-    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 131);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 11u);
+    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 131u);
 
     clipping.define_end(129);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 10);
-    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 129);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 10u);
+    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 129u);
 
     clipping.define_end(124);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 5);
-    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 124);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 5u);
+    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 124u);
 
     clipping.define_end(100);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 1);
-    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 100);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 1u);
+    BOOST_CHECK_EQUAL(clipping.keys().rbegin()->frame, 100u);
 }
 
 
@@ -291,14 +291,14 @@ BOOST_AUTO_TEST_CASE(test_clipping_remove_all) {
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 10);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 10u);
 
     clipping.remove_all(100);
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 1);
-    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 100);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 1u);
+    BOOST_CHECK_EQUAL(clipping.keys().begin()->frame, 100u);
 
     clipping.remove_all();
-    BOOST_CHECK_EQUAL(clipping.keys().size(), 0);
+    BOOST_CHECK_EQUAL(clipping.keys().size(), 0u);
 }
 
 
@@ -309,16 +309,16 @@ BOOST_AUTO_TEST_CASE(test_clipping_first_last_frame) {
     k1.frame = 120;
 
     BOOST_CHECK(clipping.keys().empty());
-    BOOST_CHECK_EQUAL(clipping.first_frame(), 1);
-    BOOST_CHECK_EQUAL(clipping.last_frame(), 10000);
+    BOOST_CHECK_EQUAL(clipping.first_frame(), 1u);
+    BOOST_CHECK_EQUAL(clipping.last_frame(), 10000u);
 
     for (int i = 0; i < 10; ++i) {
         clipping.add(k1);
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.first_frame(), 120);
-    BOOST_CHECK_EQUAL(clipping.last_frame(), 129);
+    BOOST_CHECK_EQUAL(clipping.first_frame(), 120u);
+    BOOST_CHECK_EQUAL(clipping.last_frame(), 129u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_at_index) {
@@ -332,8 +332,8 @@ BOOST_AUTO_TEST_CASE(test_clipping_at_index) {
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.at_index(0).frame, 120);
-    BOOST_CHECK_EQUAL(clipping.at_index(9).frame, 129);
+    BOOST_CHECK_EQUAL(clipping.at_index(0).frame, 120u);
+    BOOST_CHECK_EQUAL(clipping.at_index(9).frame, 129u);
 }
 
 
@@ -360,7 +360,7 @@ BOOST_AUTO_TEST_CASE(test_clipping_version) {
     vcutter::ClippingKey k1;
     k1.frame = 120;
 
-    BOOST_CHECK_EQUAL(clipping.version(), 0);
+    BOOST_CHECK_EQUAL(clipping.version(), 0u);
 
 
     for (int i = 0; i < 10; ++i) {
@@ -368,27 +368,27 @@ BOOST_AUTO_TEST_CASE(test_clipping_version) {
         ++k1.frame;
     }
 
-    BOOST_CHECK_EQUAL(clipping.version(), 10);
+    BOOST_CHECK_EQUAL(clipping.version(), 10u);
 
     clipping.remove(120);
 
-    BOOST_CHECK_EQUAL(clipping.version(), 11);
+    BOOST_CHECK_EQUAL(clipping.version(), 11u);
 
     clipping.define_start(120);
 
-    BOOST_CHECK_EQUAL(clipping.version(), 13);
+    BOOST_CHECK_EQUAL(clipping.version(), 13u);
 
     clipping.define_end(120);
 
-    BOOST_CHECK_EQUAL(clipping.version(), 15);
+    BOOST_CHECK_EQUAL(clipping.version(), 15u);
 
     clipping.remove_all(100);
 
-    BOOST_CHECK_EQUAL(clipping.version(), 17);
+    BOOST_CHECK_EQUAL(clipping.version(), 17u);
 
     clipping.remove_all();
 
-    BOOST_CHECK_EQUAL(clipping.version(), 18);
+    BOOST_CHECK_EQUAL(clipping.version(), 18u);
 }
 
 
@@ -531,8 +531,8 @@ BOOST_AUTO_TEST_CASE(test_interpolation_decrement_position) {
 
     k1 = clipping.at(121);
 
-    BOOST_CHECK_EQUAL(k1.px, 99);
-    BOOST_CHECK_EQUAL(k1.py, 99);
+    BOOST_CHECK_EQUAL(k1.px, 99u);
+    BOOST_CHECK_EQUAL(k1.py, 99u);
 }
 
 
diff --git a/tests/test_vcutter/clippings/test_clipping_key.cpp b/tests/test_vcutter/clippings/test_clipping_key.cpp
index 1e1531c..79f8ae5 100644
--- a/tests/test_vcutter/clippings/test_clipping_key.cpp
+++ b/tests/test_vcutter/clippings/test_clipping_key.cpp
@@ -14,7 +14,7 @@ std::unique_ptr<vcutter::Clipping> clp;
 class SuiteFixture {
  public:
     SuiteFixture() {
-        clp.reset(new vcutter::Clipping("data/sample_video.webm", true));
+        clp.reset(new vcutter::Clipping("data/sample_video.webm", true, vcutter::frame_callback_t()));
         clp->w(clp->player()->info()->w());
         clp->h(clp->player()->info()->h());
     }
@@ -52,15 +52,15 @@ BOOST_AUTO_TEST_CASE(test_clipping_key_constructors) {
 
     BOOST_CHECK_EQUAL(k1.angle(), 0.0);
     BOOST_CHECK_EQUAL(k1.scale, 1.0);
-    BOOST_CHECK_EQUAL(k1.px, 0);
-    BOOST_CHECK_EQUAL(k1.py, 0);
-    BOOST_CHECK_EQUAL(k1.frame, 0);
+    BOOST_CHECK_EQUAL(k1.px, 0u);
+    BOOST_CHECK_EQUAL(k1.py, 0u);
+    BOOST_CHECK_EQUAL(k1.frame, 0u);
 
     BOOST_CHECK_EQUAL(k2.angle(), 360.0);
     BOOST_CHECK_EQUAL(k2.scale, 4.0);
-    BOOST_CHECK_EQUAL(k2.px, 2);
-    BOOST_CHECK_EQUAL(k2.py, 3);
-    BOOST_CHECK_EQUAL(k2.frame, 120);
+    BOOST_CHECK_EQUAL(k2.px, 2u);
+    BOOST_CHECK_EQUAL(k2.py, 3u);
+    BOOST_CHECK_EQUAL(k2.frame, 120u);
 }
 
 BOOST_AUTO_TEST_CASE(test_clipping_key_serialize) {
diff --git a/tests/test_vcutter/clippings/test_conversion.cpp b/tests/test_vcutter/clippings/test_conversion.cpp
index e3b3905..e6fab91 100644
--- a/tests/test_vcutter/clippings/test_conversion.cpp
+++ b/tests/test_vcutter/clippings/test_conversion.cpp
@@ -16,7 +16,7 @@ std::shared_ptr<vcutter::Clipping> clp;
 class TestConversionFixture {
  public:
     TestConversionFixture() {
-        clp.reset(new vcutter::Clipping("data/sample_video.webm", true));
+        clp.reset(new vcutter::Clipping("data/sample_video.webm", true, vcutter::frame_callback_t()));
         BOOST_REQUIRE(clp->good());
         std::remove(kCONVERSION_PATH);
     }
@@ -39,10 +39,10 @@ BOOST_FIXTURE_TEST_CASE(test_convert_from_begin, TestConversionFixture) {
 
     BOOST_CHECK(conversion.convert("mp4-x264", kCONVERSION_PATH, 1000000, 24, true, false, 0));
 
-    vcutter::Clipping clip(kCONVERSION_PATH, true);
+    vcutter::Clipping clip(kCONVERSION_PATH, true, vcutter::frame_callback_t());
 
-    BOOST_CHECK_EQUAL(clip.w(), 80);
-    BOOST_CHECK_EQUAL(clip.h(), 82);
+    BOOST_CHECK_EQUAL(clip.w(), 80u);
+    BOOST_CHECK_EQUAL(clip.h(), 82u);
     BOOST_CHECK_EQUAL(clip.last_frame(), clp->last_frame());
 }
 
@@ -53,10 +53,10 @@ BOOST_FIXTURE_TEST_CASE(test_convert_from_end, TestConversionFixture) {
 
     BOOST_CHECK(conversion.convert("mp4-x264", kCONVERSION_PATH, 1000000, 24, false, false, 0));
 
-    vcutter::Clipping clip(kCONVERSION_PATH, true);
+    vcutter::Clipping clip(kCONVERSION_PATH, true, vcutter::frame_callback_t());
 
-    BOOST_CHECK_EQUAL(clip.w(), 80);
-    BOOST_CHECK_EQUAL(clip.h(), 82);
+    BOOST_CHECK_EQUAL(clip.w(), 80u);
+    BOOST_CHECK_EQUAL(clip.h(), 82u);
     BOOST_CHECK_EQUAL(clip.last_frame(), clp->last_frame());
 }
 
@@ -67,10 +67,10 @@ BOOST_FIXTURE_TEST_CASE(test_convert_append, TestConversionFixture) {
 
     BOOST_CHECK(conversion.convert("mp4-x264", kCONVERSION_PATH, 1000000, 24, true, true, 0));
 
-    vcutter::Clipping clip(kCONVERSION_PATH, true);
+    vcutter::Clipping clip(kCONVERSION_PATH, true, vcutter::frame_callback_t());
 
-    BOOST_CHECK_EQUAL(clip.w(), 80);
-    BOOST_CHECK_EQUAL(clip.h(), 82);
+    BOOST_CHECK_EQUAL(clip.w(), 80u);
+    BOOST_CHECK_EQUAL(clip.h(), 82u);
     BOOST_CHECK_EQUAL(clip.last_frame(), clp->last_frame() * 2 - 2);
 }
 
@@ -85,11 +85,11 @@ BOOST_FIXTURE_TEST_CASE(test_convert_transition_frames, TestConversionFixture) {
 
     BOOST_CHECK(conversion.convert("mp4-x264", kCONVERSION_PATH, 1000000, 24, false, false, 5));
 
-    vcutter::Clipping clip(kCONVERSION_PATH, true);
+    vcutter::Clipping clip(kCONVERSION_PATH, true, vcutter::frame_callback_t());
 
-    BOOST_CHECK_EQUAL(clip.w(), 80);
-    BOOST_CHECK_EQUAL(clip.h(), 82);
-    BOOST_CHECK_EQUAL(clip.last_frame(), 15);
+    BOOST_CHECK_EQUAL(clip.w(), 80u);
+    BOOST_CHECK_EQUAL(clip.h(), 82u);
+    BOOST_CHECK_EQUAL(clip.last_frame(), 15u);
 }
 
 BOOST_AUTO_TEST_SUITE_END()
diff --git a/tests/test_vcutter/common/test_buffers.cpp b/tests/test_vcutter/common/test_buffers.cpp
index 9074a30..97f2345 100644
--- a/tests/test_vcutter/common/test_buffers.cpp
+++ b/tests/test_vcutter/common/test_buffers.cpp
@@ -8,7 +8,7 @@ BOOST_AUTO_TEST_SUITE(buffers_test_suite)
 
 BOOST_AUTO_TEST_CASE(test_buffer_allocation) {
     vcutter::StackBuffer buffer(100, 4);
-    BOOST_CHECK_EQUAL(buffer.count(), 4);
+    BOOST_CHECK_EQUAL(buffer.count(), 4u);
 }
 
 BOOST_AUTO_TEST_CASE(test_buffer_push_pop) {
diff --git a/tests/test_vcutter/common/test_viewport.cpp b/tests/test_vcutter/common/test_viewport.cpp
index 8bb8eaa..ee92ec4 100644
--- a/tests/test_vcutter/common/test_viewport.cpp
+++ b/tests/test_vcutter/common/test_viewport.cpp
@@ -127,26 +127,26 @@ BOOST_AUTO_TEST_CASE(test_viewport_fit) {
 
     uint32_t w = 100, h = 90;
     BOOST_CHECK_EQUAL(vp.fit(&w, &h), 0.125);
-    BOOST_CHECK_EQUAL(w, 800);
-    BOOST_CHECK_EQUAL(h, 720);
+    BOOST_CHECK_EQUAL(w, 800u);
+    BOOST_CHECK_EQUAL(h, 720u);
 
     w = 1280 * 2;
     h = 90;
     BOOST_CHECK_EQUAL(vp.fit(&w, &h), 2);
-    BOOST_CHECK_EQUAL(w, 1280);
-    BOOST_CHECK_EQUAL(h, 45);
+    BOOST_CHECK_EQUAL(w, 1280u);
+    BOOST_CHECK_EQUAL(h, 45u);
 
     w = 1280;
     h = 720 * 2;
     BOOST_CHECK_EQUAL(vp.fit(&w, &h), 2);
-    BOOST_CHECK_EQUAL(w, 640);
-    BOOST_CHECK_EQUAL(h, 720);
+    BOOST_CHECK_EQUAL(w, 640u);
+    BOOST_CHECK_EQUAL(h, 720u);
 
     w = 1290;
     h = 760;
     BOOST_CHECK_CLOSE(vp.fit(&w, &h), 1.055555, 0.1);
-    BOOST_CHECK_EQUAL(w, 1222);
-    BOOST_CHECK_EQUAL(h, 720);
+    BOOST_CHECK_EQUAL(w, 1222u);
+    BOOST_CHECK_EQUAL(h, 720u);
 }
 
 BOOST_AUTO_TEST_SUITE_END()