Optmize video player (#25)

* Allow to define a frame changed callback

* Use frame changed callback instead of pooling

* Fix preview component's position

* Fix travis CI

* Improve frame changes notifications

* Comment update_buffers calls

* Fix a bug moving mouse after open a video file

.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 .

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)

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() {

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:

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);
 

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() {

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();

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

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_;
 };
 

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();

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()) {

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);

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,19 +33,19 @@ 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);
     }
 }
 
 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()) {

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();

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(){}