- Change output json structure.

- Update CMakeLists.txt.
- Upgrade dependencies.

Author: shincurry

.gitignore

@@ -1,3 +1,6 @@
+# Custom
+cmake-build-debug
+
 # Compiled Object files
 *.slo
 *.lo

CMakeLists.txt

@@ -1,19 +1,13 @@
-cmake_minimum_required(VERSION 3.6)
-project(animeloop_cli)
+cmake_minimum_required(VERSION 3.5)
+project(animeloop-cli)
+
+find_package(PkgConfig REQUIRED)
 
 add_subdirectory(${PROJECT_SOURCE_DIR}/cxxopts)
-add_subdirectory(${PROJECT_SOURCE_DIR}/jsoncpp)
 
 include_directories(${PROJECT_SOURCE_DIR}/cxxopts/include)
-include_directories(${PROJECT_SOURCE_DIR}/jsoncpp/include/json)
-
-find_package( OpenSSL 1.0.0 REQUIRED )
-
-
-find_package( OpenCV 3.2.0 REQUIRED )
-
+include_directories(${PROJECT_SOURCE_DIR}/jsoncpp/dist/json)
 
-find_package(Boost 1.63.0 REQUIRED)
 
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
 
@@ -28,11 +22,27 @@ set(SOURCE_FILES
     animeloop-cli/models.cpp
     animeloop-cli/models.hpp
     animeloop-cli/utils.cpp
-    animeloop-cli/utils.hpp)
+    animeloop-cli/utils.hpp
+    jsoncpp/dist/jsoncpp.cpp)
+
+add_executable(animeloop-cli ${SOURCE_FILES})
+
+# OpenCV
+find_package( OpenCV 3.2 REQUIRED )
+target_link_libraries( animeloop-cli ${OpenCV_LIBS} )
+
+# Boost
+find_package(Boost COMPONENTS filesystem date_time system REQUIRED)
+target_link_libraries( animeloop-cli ${Boost_LIBRARIES} )
+
+# Search OpenSSL
+pkg_search_module(OPENSSL REQUIRED openssl)
 
-add_executable(animeloop_cli ${SOURCE_FILES})
+if( OPENSSL_FOUND )
+    include_directories(${OPENSSL_INCLUDE_DIRS})
+    message(STATUS "Using OpenSSL ${OPENSSL_VERSION}")
+else()
+    # Error; with REQUIRED, pkg_search_module() will throw an error by it's own
+endif()
 
-target_link_libraries(${EXECUTABLE_NAME} ${OpenSSL_LIBS})
-target_link_libraries(${EXECUTABLE_NAME} ${OpenCV_LIBS})
-set(Boost_USE_STATIC_LIBS ON)
-target_link_libraries(${EXECUTABLE_NAME} ${Boost_LIBS})
+target_link_libraries( animeloop-cli ${OPENSSL_LIBRARIES})

README.md

@@ -1,34 +1,103 @@
 # animeloop-cli
 Anime loop video command line tool.
 
+
+
 ### Installation
 
-#### Git Submodules Init
+#### Modules Init
 
-```Shell
-$ git submodule init
-$ git submodule update
+``` Shell
+git submodule init
+git submodule update
+```
+
+
+#### Dependencies
+
+##### macOS
+
+``` Shell
+# OpenCV
+brew tap homebrew/science
+brew install opencv3 --with-contrib --with-ffmpeg --c++11
+
+# Boost
+brew install boost
+```
+
+##### Linux
+
+``` Shell
+# OpenCV
+sudo apt-get -y install libopencv-dev build-essential cmake git libgtk2.0-dev pkg-config python-dev python-numpy libdc1394-22 libdc1394-22-dev libjpeg-dev libpng12-dev libjasper-dev libavcodec-dev libavformat-dev libswscale-dev libgstreamer0.10-dev libgstreamer-plugins-base0.10-dev libv4l-dev libtbb-dev libqt4-dev libfaac-dev libmp3lame-dev libopencore-amrnb-dev libopencore-amrwb-dev libtheora-dev libvorbis-dev libxvidcore-dev x264 v4l-utils unzip
+
+mkdir opencv
+cd opencv
+
+wget https://github.com/Itseez/opencv/archive/3.2.0.zip -O opencv-3.2.0.zip
+unzip opencv-3.2.0.zip
+cd opencv-3.2.0
+
+mkdir build
+cd build
+cmake -D CMAKE_BUILD_TYPE=RELEASE -D CMAKE_INSTALL_PREFIX=/usr/local -D WITH_TBB=ON -D WITH_V4L=ON -D WITH_QT=ON -D WITH_OPENGL=ON ..
+
+make -j $(nproc)
+sudo make install
+
+sudo /bin/bash -c 'echo "/usr/local/lib" > /etc/ld.so.conf.d/opencv.conf'
+sudo ldconfig
+
+## uninstall opencv
+sudo apt-get remove opencv
+
+# Boost
+sudo apt-get install libboost-all-dev
 ```
 
-#### macOS 
+#### Compile & Build 
+
+##### Xcode
+
+Open `animeloop-cli.xcodeproj` and run it.
 
-Just run in Xcode.
+(if you compile opencv source code by yourself, you maybe need edit `Linked Frameworks and Libraries` settings in Xcode project.)
 
-#### Cross-Platform
+##### cmake
 
-CMake is not available currently.
+``` Shell
+cd animeloop-cli
+mkdir build
+cd build
+cmake ..
+make
+(make install)
+```
 
 ## Usage
 
 ```Shell
-$ animeloop -i ~/your-video-file -o ~/Downloads/ --max-duration 4 --min-duration 1.0
-```
 
-## Dependencies
 
-* Boost
-* OpenCV 3
+animeloop [OPTION...]
+
+  -h, --help              Show animeloop help
+  -v, --version           Show animeloop version
+  -i, --input arg         Input video file path
+  -o, --output arg        Output video directory path (default:
+                          <current dir>)
+      --episode arg       Episode name of the source video (default:
+                          <filename>)
+      --series arg        Series name of the source video  (default:
+                          <filename>)
+      --min-duration arg  Minimum duration (second) of loop video (default:
+                          0.8)
+      --max-duration arg  Maximum duration (second) of loop video (default:
+                          4.0)
+      --cover             Output loop video cover image.
 
-## Thanks
 
-* cxxopts
+# Example
+animeloop -i ~/your-video-file -o ~/Downloads/ --max-duration 4 --min-duration 1.0
+```

animeloop-cli/loop_video.cpp

@@ -23,11 +23,12 @@ using namespace cv;
 using namespace al;
 
 
-al::LoopVideo::LoopVideo(std::string title, std::string input, std::string output) {
+al::LoopVideo::LoopVideo(std::string series, std::string episode, std::string input, std::string output) {
 
     this->md5 = al::md5_of_file(input);
 
-    this->title = title;
+    this->series = series;
+    this->episode = episode;
 
     this->filename = path(input).stem().string();
 
@@ -90,7 +91,9 @@ void al::LoopVideo::generate(const LoopDurations durations) {
     VideoInfo info = get_info(this->input_path.string());
 
     Json::Value videos_json;
-    videos_json["title"] = this->title;
+    videos_json["series"] = this->series;
+    videos_json["episode"] = this->episode;
+
     videos_json["animeloop_ver"] = kVersion;
 
     Json::Value source_json;
@@ -146,20 +149,22 @@ void al::LoopVideo::generate(const LoopDurations durations) {
         // Save video info json file.
         Json::Value video_json;
 
-        video_json["video_filename"] = video_filename;
-        video_json["cover_filename"] = cover_filename;
+        Json::Value files_json;
+        files_json["mp4_1080p"] = video_filename;
+        files_json["jpg_1080p"] = cover_filename;
+        video_json["files"] = files_json;
 
         video_json["duration"] = video_duration;
 
         Json::Value frame_json;
-        frame_json["start"] = to_string(start_frame);
+        frame_json["begin"] = to_string(start_frame);
         frame_json["end"] = to_string(end_frame);
         video_json["frame"] = frame_json;
 
-        Json::Value time_json;
-        time_json["start"] = al::time_string(start_frame / info.fps);
-        time_json["end"] = al::time_string(end_frame / info.fps);
-        video_json["time"] = time_json;
+        Json::Value period_json;
+        period_json["begin"] = al::time_string(start_frame / info.fps);
+        period_json["end"] = al::time_string(end_frame / info.fps);
+        video_json["period"] = period_json;
 
         auto md5 = al::md5_of_file(video_filepath);
         video_json["md5"] = md5;

animeloop-cli/loop_video.hpp

@@ -16,13 +16,14 @@
 #include <boost/filesystem.hpp>
 
 namespace al {
-    const std::string kVersion = "1.3.0";
+    const std::string kVersion = "1.3.1";
 
     class LoopVideo {
     public:
         // infomation
         std::string filename;
-        std::string title;
+        std::string series;
+        std::string episode;
 
         // I/O path
         boost::filesystem::path input_path;
@@ -49,7 +50,7 @@ namespace al {
         LoopDurations filtered_durations;
         FrameVector frames;
 
-        LoopVideo(std::string title, std::string input, std::string output);
+        LoopVideo(std::string series, std::string episode, std::string input, std::string output);
         cv::CascadeClassifier face_cascade;
 
         void init();

animeloop-cli/main.cpp

@@ -12,39 +12,52 @@
 #include "cxxopts.hpp"
 #include "loop_video.hpp"
 
+using namespace std;
+using namespace boost::filesystem;
+using namespace cxxopts;
+
 int main(int argc, char * argv[]) {
 
-    auto rpath = boost::filesystem::path(argv[0]).parent_path();
+    auto rpath = path(argv[0]).parent_path();
     double min_duration, max_duration;
 
     try {
         cxxopts::Options options("animeloop", "anime loop video generator.");
 
-        std::string input, output, title;
+        string input, output, episode, series;
 
         options.add_options()
         ("h,help", "Show animeloop help")
         ("v,version", "Show animeloop version")
-        ("title", "Title of the source video", cxxopts::value<std::string>(title))
-        ("i,input", "Input video file path", cxxopts::value<std::string>(input))
-        ("o,output", "Output video directory path", cxxopts::value<std::string>(output)->default_value(rpath.string()))
-        ("min-duration", "Minimum duration (second) of loop video", cxxopts::value<double>(min_duration)->default_value("0.8"))
-        ("max-duration", "Maximum duration (second) of loop video", cxxopts::value<double>(max_duration)->default_value("4.0"))
+        ("i,input", "Input video file path", value<string>(input))
+        ("o,output", "Output video directory path", value<string>(output)->default_value(rpath.string()))
+        ("episode", "Episode name of the source video (default: <filename>)", value<string>(episode))
+        ("series", "Series name of the source video  (default: <filename>)", value<string>(series))
+        ("min-duration", "Minimum duration (second) of loop video", value<double>(min_duration)->default_value("0.8"))
+        ("max-duration", "Maximum duration (second) of loop video", value<double>(max_duration)->default_value("4.0"))
         ("cover", "Output loop video cover image.")
         ;
 
         options.parse(argc, argv);
 
         if (options.count("version")) {
-            std::cout << "version: " << al::kVersion << std::endl;
+            cout << "version: " << al::kVersion << endl;
         }
 
         if (options.count("help")) {
-            std::cout << options.help() << std::endl;
+            cout << options.help() << endl;
         }
 
-        if (options.count("input") && options.count("title")) {
-            al::LoopVideo loop_video(title, input, output);
+        if (options.count("input")) {
+            if (episode == "") {
+                episode = path(input).stem().string();
+            }
+
+            if (series == "") {
+                series = path(input).stem().string();
+            }
+            
+            al::LoopVideo loop_video(series, episode, input, output);
             loop_video.kMinduration = min_duration;
             loop_video.kMaxduration = max_duration;
 
@@ -60,8 +73,8 @@ int main(int argc, char * argv[]) {
         }
 
 
-    } catch (const cxxopts::OptionException& e) {
-        std::cout << "error parsing options: " << e.what() << std::endl;
+    } catch (const OptionException& e) {
+        cout << "error parsing options: " << e.what() << endl;
         exit(1);
     }