OpenShot Library | libopenshot 0.2.7
ProcessingController.h
Go to the documentation of this file.
1/**
2 * @file
3 * @brief This is a message class for thread safe comunication between ClipProcessingJobs and OpenCV classes
4 * @author Jonathan Thomas <jonathan@openshot.org>
5 * @author Brenno Caldato <brenno.caldato@outlook.com>
6 *
7 * @ref License
8 */
9
10/* LICENSE
11 *
12 * Copyright (c) 2008-2019 OpenShot Studios, LLC
13 * <http://www.openshotstudios.com/>. This file is part of
14 * OpenShot Library (libopenshot), an open-source project dedicated to
15 * delivering high quality video editing and animation solutions to the
16 * world. For more information visit <http://www.openshot.org/>.
17 *
18 * OpenShot Library (libopenshot) is free software: you can redistribute it
19 * and/or modify it under the terms of the GNU Lesser General Public License
20 * as published by the Free Software Foundation, either version 3 of the
21 * License, or (at your option) any later version.
22 *
23 * OpenShot Library (libopenshot) is distributed in the hope that it will be
24 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 * GNU Lesser General Public License for more details.
27 *
28 * You should have received a copy of the GNU Lesser General Public License
29 * along with OpenShot Library. If not, see <http://www.gnu.org/licenses/>.
30 */
31
32#ifndef OPENSHOT_PROCESSINGCONTROLLER_H
33#define OPENSHOT_PROCESSINGCONTROLLER_H
34
35#include <iostream>
36#include <thread>
37#include <mutex>
38
39
41 private:
42 uint processingProgress;
43 bool processingFinished;
44 bool stopProcessing;
45 bool error = true;
46 std::string error_message;
47
48 std::mutex mtxProgress;
49 std::mutex mtxFinished;
50 std::mutex mtxStop;
51 std::mutex mtxerror;
52
53 public:
54
56 processingProgress = 0;
57 stopProcessing = false;
58 processingFinished = false;
59 }
60
62 std::lock_guard<std::mutex> lck (mtxFinished);
63 bool f = processingFinished;
64 return f;
65 }
66
67 void SetFinished(bool f){
68 std::lock_guard<std::mutex> lck (mtxFinished);
69 processingFinished = f;
70 }
71
72 void SetProgress(uint p){
73 std::lock_guard<std::mutex> lck (mtxProgress);
74 processingProgress = p;
75 }
76
78 std::lock_guard<std::mutex> lck (mtxProgress);
79 uint p = processingProgress;
80 return p;
81 }
82
84 std::lock_guard<std::mutex> lck (mtxStop);
85 stopProcessing = true;
86 }
87
88 bool ShouldStop(){
89 std::lock_guard<std::mutex> lck (mtxStop);
90 bool s = stopProcessing;
91 return s;
92 }
93
94 void SetError(bool err, std::string message){
95 std::lock_guard<std::mutex> lck (mtxerror);
96 error = err;
97 error_message = message;
98 }
99
100 bool GetError(){
101 std::lock_guard<std::mutex> lck (mtxerror);
102 bool e = error;
103 return e;
104 }
105
106 std::string GetErrorMessage(){
107 std::lock_guard<std::mutex> lck (mtxerror);
108 std::string message = error_message;
109 return message;
110 }
111
112};
113
114#endif
void SetError(bool err, std::string message)