ClipProcessingJobs.cpp

Go to the documentation of this file.

 
// Copyright (c) 2008-2019 OpenShot Studios, LLC
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#include "ClipProcessingJobs.h"
 
namespace openshot {
 
// Constructor responsible to choose processing type and apply to clip
ClipProcessingJobs::ClipProcessingJobs(std::string processingType, std::string processInfoJson) :
processingType(processingType), processInfoJson(processInfoJson){
}
 
std::string ClipProcessingJobs::ValidateONNXModel(std::string modelPath){
#ifdef USE_OPENCV
    return CVObjectDetection::ValidateONNXModel(modelPath);
#else
    return "OpenShot was not compiled with OpenCV support.";
#endif
}
 
std::shared_ptr<Frame> ClipProcessingJobs::PreviewObjectMask(std::string processInfoJson, std::shared_ptr<Frame> frame){
#ifdef USE_OPENCV
    ProcessingController controller;
    CVObjectMask objectMask(processInfoJson, controller);
    return objectMask.PreviewSeedMask(frame);
#else
    (void)processInfoJson;
    (void)frame;
    return std::shared_ptr<Frame>();
#endif
}
 
void ClipProcessingJobs::processClip(Clip& clip, std::string json){
    processInfoJson = json;
 
    // Process clip and save processed data
    if(processingType == "Stabilizer"){
        t = std::thread(&ClipProcessingJobs::stabilizeClip, this, std::ref(clip), std::ref(this->processingController));
    }
    if(processingType == "Tracker"){
        t = std::thread(&ClipProcessingJobs::trackClip, this, std::ref(clip), std::ref(this->processingController));
    }
    if(processingType == "ObjectDetection"){
        t = std::thread(&ClipProcessingJobs::detectObjectsClip, this, std::ref(clip), std::ref(this->processingController));
    }
    if(processingType == "ObjectMask"){
        t = std::thread(&ClipProcessingJobs::maskObjectClip, this, std::ref(clip), std::ref(this->processingController));
    }
}
 
// Apply object tracking to clip
void ClipProcessingJobs::trackClip(Clip& clip, ProcessingController& controller){
 
    // Create CVTracker object
    CVTracker tracker(processInfoJson, controller);
    // Start tracking
    tracker.trackClip(clip);
 
    // Thread controller. If effect processing is done, save data
    // Else, kill thread
    if(controller.ShouldStop()){
        controller.SetFinished(true);
        return;
    }
    else{
        // Save stabilization data
        tracker.SaveTrackedData();
        // tells to UI that the processing finished
        controller.SetFinished(true);
    }
 
}
 
// Apply object detection to clip
void ClipProcessingJobs::detectObjectsClip(Clip& clip, ProcessingController& controller){
    // create CVObjectDetection object
    CVObjectDetection objDetector(processInfoJson, controller);
    // Start object detection process
    objDetector.detectObjectsClip(clip);
 
    // Thread controller. If effect processing is done, save data
    // Else, kill thread
    if(controller.ShouldStop()){
        controller.SetFinished(true);
        return;
    }
    else{
        // Save object detection data
        objDetector.SaveObjDetectedData();
        // tells to UI that the processing finished
        controller.SetFinished(true);
    }
}
 
// Apply object segmentation mask to clip
void ClipProcessingJobs::maskObjectClip(Clip& clip, ProcessingController& controller){
    CVObjectMask objectMask(processInfoJson, controller);
    objectMask.maskClip(clip);
 
    if(controller.ShouldStop()){
        controller.SetFinished(true);
        return;
    }
    else{
        objectMask.SaveObjMaskData();
        controller.SetFinished(true);
    }
}
 
void ClipProcessingJobs::stabilizeClip(Clip& clip, ProcessingController& controller){
    // create CVStabilization object
    CVStabilization stabilizer(processInfoJson, controller);
    // Start stabilization process
    stabilizer.stabilizeClip(clip);
 
    // Thread controller. If effect processing is done, save data
    // Else, kill thread
    if(controller.ShouldStop()){
        controller.SetFinished(true);
        return;
    }
    else{
        // Save stabilization data
        stabilizer.SaveStabilizedData();
        // tells to UI that the processing finished
        controller.SetFinished(true);
    }
}
 
// Get processing progress while iterating on the clip
int ClipProcessingJobs::GetProgress(){
 
    return (int)processingController.GetProgress();
}
 
// Check if processing finished
bool ClipProcessingJobs::IsDone(){
 
    if(processingController.GetFinished()){
        t.join();
    }
    return processingController.GetFinished();
}
 
// stop preprocessing before finishing it
void ClipProcessingJobs::CancelProcessing(){
    processingController.CancelProcessing();
}
 
// check if there is an error with the config
bool ClipProcessingJobs::GetError(){
    return processingController.GetError();
}
 
// get the error message
std::string ClipProcessingJobs::GetErrorMessage(){
    return processingController.GetErrorMessage();
}
 
}  // namespace openshot