Reduce time-consuming - use ffmpeg resize video.

shincurry · shincurry · commit e02d22bd54ab · 2017-07-16T00:57:05.000+08:00
diff --git a/README.md b/README.md
@@ -24,6 +24,9 @@ brew install opencv3 --with-contrib --with-ffmpeg --c++11
 
 # Boost
 brew install boost
+
+# FFmpeg
+brew install ffmpeg
 ```
 
 ##### Linux
@@ -57,6 +60,11 @@ sudo apt-get install libboost-all-dev
 
 # OpenSSL
 sudo apt-get install libssl-dev
+
+# FFmpeg
+# unofficial ppa
+sudo add-apt-repository ppa:jonathonf/ffmpeg-3
+sudo apt update && sudo apt install ffmpeg
 ```
 
 #### Compile & Build 
diff --git a/animeloop-cli.xcodeproj/project.pbxproj b/animeloop-cli.xcodeproj/project.pbxproj
@@ -365,6 +365,7 @@
 		88537EA11E4C501900385BCB /* Debug */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
 				HEADER_SEARCH_PATHS = /usr/local/include;
 				LIBRARY_SEARCH_PATHS = (
@@ -381,6 +382,7 @@
 		88537EA21E4C501900385BCB /* Release */ = {
 			isa = XCBuildConfiguration;
 			buildSettings = {
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
 				CLANG_WARN_DOCUMENTATION_COMMENTS = NO;
 				HEADER_SEARCH_PATHS = /usr/local/include;
 				LIBRARY_SEARCH_PATHS = (
diff --git a/animeloop-cli/loop_video.cpp b/animeloop-cli/loop_video.cpp
@@ -12,10 +12,7 @@
 #include "filter.hpp"
 
 #include "json.h"
-#include <boost/filesystem.hpp>
-#include <locale>
-#include <numeric>
-#include <string>
+#include <sys/wait.h>
 
 using namespace std;
 using namespace boost::filesystem;
@@ -47,13 +44,10 @@ al::LoopVideo::LoopVideo(std::string series, std::string episode, std::string in
     if (!exists(this->caches_path)) {
         create_directories(this->caches_path);
     }
-    
-//    this->face_cascade_filename = "./lbpcascade_animeface.xml";
-//    face_cascade.load(this->face_cascade_filename.string());
 }
 
 void al::LoopVideo::init() {
-    resize_video(this->input_path.string(), this->resized_video_filename.string(), cv::Size(this->kResizedWidth, this->kResizedHeight));
+    resize_video(this->input_path, this->resized_video_filename, cv::Size(this->kResizedWidth, this->kResizedHeight));
     get_frames(this->resized_video_filename.string(), this->frames);
     get_hash_strings(this->resized_video_filename.string(), "dHash", this->dhash_strings, this->dhash_filename.string());
     get_hash_strings(this->resized_video_filename.string(), "pHash", this->phash_strings, this->phash_filename.string());
@@ -86,6 +80,18 @@ void al::LoopVideo::print(LoopDurations durations) {
     }
 }
 
+int fork_gen_cover(string video_filepath, string cover_filepath) {
+    int pid = fork();
+    if(pid != 0) {
+        /* We're in the parent process, return the child's pid. */
+        return pid;
+    }
+    /* Otherwise, we're in the child process, so let's exec curl. */
+    execlp("ffmpeg", "ffmpeg", "-loglevel", "panic", "-i", video_filepath.c_str(), "-vframes", "1", "-f", "image2", cover_filepath.c_str(), NULL);
+
+    exit(100);
+}
+
 void al::LoopVideo::generate(const LoopDurations durations) {
     VideoInfo info = get_info(this->input_path.string());
     
@@ -124,27 +130,37 @@ void al::LoopVideo::generate(const LoopDurations durations) {
             cv::Mat image;
             long frame = start_frame;
             while (capture.read(image)) {
-                if (cover_enabled && frame == start_frame) {
-                    cv::imwrite(cover_filepath, image);
-                } else if (frame > end_frame) {
+                // Exclude the last frame.
+                if (frame >= end_frame) {
                     break;
                 }
-                
+
                 writer.write(image);
                 frame++;
             }
             writer.release();
         }
-        
+        capture.release();
+
         if (cover_enabled && !exists(cover_filepath)) {
-            capture.set(CV_CAP_PROP_POS_FRAMES, start_frame);
-            cv::Mat image;
-            capture.read(image);
-            cv::imwrite(cover_filepath, image);
+            int cpid = fork_gen_cover(video_filepath, cover_filepath);
+            if(cpid == -1) {
+                /* Failed to fork */
+                cerr << "Fork failed" << endl;
+                throw;
+            }
+
+            /* Optionally, wait for the child to exit and get
+               the exit status. */
+            int status;
+            waitpid(cpid, &status, 0);
+            if(! WIFEXITED(status)) {
+                cerr << "The child was killed or segfaulted or something." << endl;
+            }
+
+            status = WEXITSTATUS(status);
         }
-        capture.release();
 
-        
         // Save video info json file.
         Json::Value video_json;
         
diff --git a/animeloop-cli/loop_video.hpp b/animeloop-cli/loop_video.hpp
@@ -16,7 +16,7 @@
 #include <boost/filesystem.hpp>
 
 namespace al {
-    const std::string kVersion = "1.3.1";
+    const std::string kVersion = "1.3.2";
 
     class LoopVideo {
     public:
diff --git a/animeloop-cli/utils.cpp b/animeloop-cli/utils.cpp
@@ -12,11 +12,11 @@
 #include "json.h"
 #include <boost/filesystem.hpp>
 #include <boost/date_time/posix_time/posix_time.hpp>
-#include <boost/date_time/posix_time/posix_time_io.hpp>
-#include <locale>
+#include <boost/regex.hpp>
 #include <openssl/md5.h>
-#include <fstream>
 #include <numeric>
+#include <sys/wait.h>
+
 
 using namespace std;
 using namespace boost::filesystem;
@@ -42,37 +42,85 @@ VideoInfo al::get_info(std::string filename) {
 }
 
 
+int fork_resize_video(path input, path temp_filename, Size size) {
+    int pid = fork();
+    if(pid != 0) {
+        /* We're in the parent process, return the child's pid. */
+        return pid;
+    }
+    /* Otherwise, we're in the child process, so let's exec curl. */
+    execlp("ffmpeg", "ffmpeg", "-loglevel", "panic", "-i", input.string().c_str(), "-s", (to_string(size.width) + "x" + to_string(size.height)).c_str(), "-an", temp_filename.string().c_str(), NULL);
+
+    exit(100);
+}
+
+void al::resize_video(path input, path output, Size size) {
+    path temp_output = output.parent_path().append("temp");
+    path temp_filename = path(temp_output).append(output.filename().string());
+    if (!exists(temp_output)) {
+        create_directories(temp_output);
+    } else {
+        if (exists(temp_filename)) {
+            remove(temp_filename);
+        }
+    }
 
-void al::resize_video(string file, string output, Size size) {
     auto if_exists = exists(output);
     
     if (!if_exists) {
-        // Calculate hash string per frame.
-        std::cout << "Resizing video... 0%" << std::endl;
-        VideoCapture capture;
-        capture.open(file);
-        
-        VideoInfo info = get_info(capture);
+        if (system("which ffmpeg") == 0) {
+            cout << "Resizing video..." << endl;
+
+            int cpid = fork_resize_video(input, temp_filename, size);
+            if(cpid == -1) {
+                /* Failed to fork */
+                cerr << "Fork failed" << endl;
+                throw;
+            }
 
-        VideoWriter writer(output, CV_FOURCC('H', '2', '6', '4'), info.fps, size);
+            /* Optionally, wait for the child to exit and get
+               the exit status. */
+            int status;
+            waitpid(cpid, &status, 0);
+            if(! WIFEXITED(status)) {
+                cerr << "The child was killed or segfaulted or something\n" << endl;
+            }
 
-        
-        int percent = 0;
-        int count = 0, total = info.frame_count;
-        cv::Mat image;
-        while (capture.read(image)) {
-            if (count / double(total) * 100 > percent) {
-                percent++;
-                std::cout << "Resizing video... " << percent << "%" << std::endl;
+            status = WEXITSTATUS(status);
+
+
+            cout << "done." << endl;
+
+        } else {
+            // Calculate hash string per frame.
+            cout << "Resizing video... 0%" << endl;
+            VideoCapture capture;
+            capture.open(input.string());
+
+            VideoInfo info = get_info(capture);
+
+            VideoWriter writer(temp_filename.string(), CV_FOURCC('H', '2', '6', '4'), info.fps, size);
+
+
+            int percent = 0;
+            int count = 0, total = info.frame_count;
+            cv::Mat image;
+            while (capture.read(image)) {
+                if (count / double(total) * 100 > percent) {
+                    percent++;
+                    std::cout << "Resizing video... " << percent << "%" << std::endl;
+                }
+                cv::resize(image, image, size);
+                writer.write(image);
+                image.release();
+                count++;
             }
-            cv::resize(image, image, size);
-            writer.write(image);
-            image.release();
-            count++;
+
+            writer.release();
+            capture.release();
         }
-        
-        writer.release();
-        capture.release();
+
+        system(("mv " + temp_filename.string() + " " + output.string()).c_str());
     }
 }
 
@@ -91,19 +139,27 @@ bool al::get_frames(string file, FrameVector &frames) {
     return true;
 }
 
-bool al::get_hash_strings(string file, string type, HashVector &hash_strings, string hash_file) {
-    
+void al::get_hash_strings(path filename, string type, HashVector &hash_strings, path hash_file) {
+    path temp_path = hash_file.parent_path().append("temp");
+    path temp_filename = path(temp_path).append(hash_file.filename().string());
+
+    if (!exists(temp_path)) {
+        create_directories(temp_path);
+    } else {
+        if (exists(temp_filename)) {
+            remove(temp_filename);
+        }
+    }
+
     auto if_exists = exists(hash_file);
     VideoCapture capture;
     if (if_exists) {
         // Read video frames hash string from file.
         std::cout << "Restore " << type << " value from file..." << std::endl;
         
-        std::ifstream input_file(hash_file);
+        std::ifstream input_file(hash_file.string());
         HashVector hashs;
-        
-        int count;
-        count = 0;
+
         while (input_file) {
             string line;
             getline(input_file, line);
@@ -112,15 +168,13 @@ bool al::get_hash_strings(string file, string type, HashVector &hash_strings, st
         input_file.close();
         
         hash_strings = hashs;
-        return true;
     } else {
         // Calculate hash string per frame.
         VideoCapture capture;
-        capture.open(file);
+        capture.open(filename.string());
         VideoInfo info = get_info(capture);
         HashVector hashs;
-        
-        
+
         cout << "Calculating " << type << " value... 0%" << endl;
         int percent = 0;
         int count = 0, total = info.frame_count;
@@ -139,13 +193,13 @@ bool al::get_hash_strings(string file, string type, HashVector &hash_strings, st
         hash_strings = hashs;
         
         cout << "Save " << type << " value into file..." << endl;
-        std::ofstream output_file(hash_file);
+        std::ofstream output_file(temp_filename.string());
         ostream_iterator<string> output_iterator(output_file, "\n");
         std::copy(hashs.begin(), hashs.end(), output_iterator);
         output_file.close();
-        return true;
+
+        system(("mv " + temp_filename.string() + " " + hash_file.string()).c_str());
     }
-    return false;
 }
 
 
diff --git a/animeloop-cli/utils.hpp b/animeloop-cli/utils.hpp
@@ -14,37 +14,41 @@
 #include <iostream>
 #include <string>
 #include <opencv2/opencv.hpp>
+#include <boost/filesystem/path.hpp>
 
 
 namespace al {
     VideoInfo get_info(std::string filename);
+
     VideoInfo get_info(cv::VideoCapture &capture);
-    
+
     /**
      Resize a video and write into a new file.
 
      @param file intput path of origin video file
      @param output output path of resized video file
      @param size resizing size
      */
-    void resize_video(std::string file, std::string output, cv::Size size);
+    void resize_video(boost::filesystem::path input, boost::filesystem::path output, cv::Size size);
 
     bool get_frames(std::string file, FrameVector &frames);
 
-    bool get_hash_strings(std::string file, std::string type, al::HashVector &hash_strings, std::string hash_file);
-    
+    void get_hash_strings(boost::filesystem::path filename, std::string type, al::HashVector &hash_strings,
+                          boost::filesystem::path hash_file);
+
     double get_variance(std::vector<int> distances);
+
     double get_mean(cv::Mat image);
-    
-    
+
+
     /**
      Convert seconds value to a time string.
 
      @param seconds seconds value
      @return Time string
      */
     std::string time_string(double seconds);
-    
+
     /**
      Generate the MD5 checksum of a file.
 
