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 
61  int GetFinished(){
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 
77  int GetProgress(){
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)