-
Notifications
You must be signed in to change notification settings - Fork 2
/
ipiped.vala
246 lines (227 loc) · 8.82 KB
/
ipiped.vala
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
/**
* ipiped/src/ipiped.vala
*
* Ipipe class - framework for controlling and configuring ipipe using D-Bus messages
*
* Copyright(c) 2010, RidgeRun
* All rights reserved.
*/
using Posix,V4l2,ImpPrev,dm365aew;
#if (RRAEW)
using rraew;
#endif
[DBus(name = "com.ridgerun.ipiped.IpipeInterface", signals = "Error")]
public class Ipipe:GLib.Object {
/* Private data */
/** Flag to enable/disable debug information */
private static bool debug = false;
/** Flag to indicate if the previewer is initialized*/
private static bool initialized = false;
private string sensor = "";
private string video_processor = "";
public AbstcVideoProcessor video_processor_abstract;
public AbstcSensor sensor_abstract;
public signal void Error(string err_message);
#if (RRAEW)
/** Thread for aew*/
unowned Thread<void*> thread;
/** Flag to indicate if the aew thread is running*/
bool aew_running = false;
/** Indicates if we can close the execution thread wihtout failing **/
bool clean_close = false;
/** Pointer to aew structure*/
void *rraew = null;
/** Time between aew iterations*/
int wait_time=0;
#endif
/**
* Create a new instance of a Ipipe daemon
*/
public Ipipe(string _sensor, string _video_processor, AbstcVideoProcessor _video_processor_abstract,
AbstcSensor _sensor_abstract){
/* Initialize private variables */
initialized = false;
sensor =_sensor;
video_processor=_video_processor;
video_processor_abstract=_video_processor_abstract;
sensor_abstract=_sensor_abstract;
this.debug = false;
}
/**
* Destroy a instance of Ipipe
*/
~Ipipe(){
/* Destroy the ipipe instance */
}
/**
* Debug
* Enable/Disable the debug information in all the functions
* @param enable if true print debug information
*/
public void enable_debug(bool enable) throws IOError{
this.debug = enable;
video_processor_abstract.debug = true;
sensor_abstract.debug = true;
}
/**
* Ping
* Show to the ipipe-client that an instance of the ipiped daemon is
* alive
*/
public bool ping() throws IOError{
return true;
}
public string get_sensor() throws IOError{
return sensor;
}
public string get_video_processor() throws IOError{
return video_processor;
}
#if (RRAEW)
private void* aew_thread_func(){
try {
while (aew_running) {
Thread.usleep(wait_time);
if (run_rraew(rraew)<0){
clean_close = false;
close_aew();
}
}
}catch(IOError e) {
Posix.stderr.printf("Fail to execute:%s\n", e.message);
}
return null;
}
/**
* AEW Algorithm initialization
* Uses the parameters given by the user to configure the aew library,
* sets the functions to access the sensor and the dm365 interface
* (vpfe ipipe). Creates an aew structure and a thread for the aew loop
* @param wb string that chooses the auto white balance algorithm,
* can be "G" for gray world or "W" for white balance or "N" to do not
* apply an auto white balance.
* @param ae string that chooses the auto exposure algorithm, can be
* "EC" for electronic centric or "N" to do not apply an auto exposure.
* @param g string that chooses the gain type, can be "S" for sensor
* gain or "D" for digital gain.
* @param meter string that chooses the metering system for the auto
* exposure algorithm, can be "S" for spot or "P" for partial or "C" for
* electronic centric or "SG" for segmented image or "A" for average.
* @param time it is the time between aew algorithms iterations
* @param fps is the minimum allowed frame rate
* @param segment_factor a percentage of the maximun image divisions
*/
public int init_aew(string wb, string ae, string g, string meter,
int time, int fps, int segment_factor, int width, int height,
int center_percentage) throws IOError
{
/** File descriptors information*/
FileDescriptors fd = FileDescriptors();
wait_time = time;
WhiteBalanceAlgo wb_algo;
ExposureAlgo ae_algo;
GainType gain_type;
MeteringType meter_type;
Sensor sensor = Sensor();
Interface interf = Interface();
if(aew_running) {
Posix.stderr.printf("The AEW algorithm is alreadty being " +
"executed. Please finish the current session\n by using " +
"close-aew. Then you will be able to start a new one\n");
return -1;
}
if (time > 1000000) {
Posix.stderr.printf("\nIpiped:Wait time is greater than the maximum\n");
return -1;
}
if ((segment_factor > 100)|| (segment_factor) < 1) {
Posix.stderr.printf("\nIpiped:Segmentation factor must be between 1 and 100\n");
return -1;
}
/* Define the gain module to be used*/
if (g == "S")
gain_type = GainType.SENSOR;
else if (g == "D")
gain_type = GainType.DIGITAL;
else {
Posix.stderr.printf("\nIpiped:Invalid gain type\n");
return -1;
}
/* Define the ae algorithm*/
if (ae == "EC")
ae_algo = ExposureAlgo.EC;
else if(ae == "N")
ae_algo = ExposureAlgo.NONE;
else {
Posix.stderr.printf("\nIpiped:Invalid auto exposure algorithm\n");
return -1;
}
/* Define the awb algorithm*/
if (wb == "W")
wb_algo = WhiteBalanceAlgo.WHITE_PATCH;
else if (wb == "W2")
wb_algo = WhiteBalanceAlgo.WHITE_PATCH_2;
else if (wb == "G")
wb_algo = WhiteBalanceAlgo.GRAY_WORLD;
else if (wb == "N")
wb_algo = WhiteBalanceAlgo.NONE;
else{
Posix.stderr.printf("\nIpiped:Invalid white-balance algorithm\n");
return -1;
}
/* Define the metering method*/
if (meter == "P")
meter_type = MeteringType.PARTIAL_AREA;
else if (meter == "C")
meter_type = MeteringType.CENTER_WEIGHTED;
else if (meter == "A")
meter_type = MeteringType.AVERAGE;
else if (meter == "SG"){
meter_type = MeteringType.SEGMENT;
}else{
Posix.stderr.printf("\nIpiped:Invalid metering type\n");
return -1;
}
/* Sensor information */
sensor_abstract.get_sensor_data(&sensor);
if (!video_processor_abstract.get_video_processor_data(&interf)) {
Posix.stderr.printf ("Can't get video processor data\n");
return -1;
}
fd.previewer_fd = video_processor_abstract.previewer_fd;
fd.owner_previewer_fd = video_processor_abstract.owner_previewer_fd;
fd.aew_fd = video_processor_abstract.aew_fd;
fd.owner_aew_fd = video_processor_abstract.owner_aew_fd;
fd.capture_fd = sensor_abstract.capture_fd;
fd.owner_capture_fd = sensor_abstract.owner_capture_fd;
rraew = create_rraew(wb_algo, ae_algo, meter_type,
width, height, fps, segment_factor, center_percentage, gain_type,
&fd, &sensor, &interf);
aew_running = true;
clean_close = true;
if (!Thread.supported ()) {
error ("Cannot run without thread support");
}
try {
thread = Thread.create<void*>(aew_thread_func, true);
} catch (ThreadError e) {
return -1;
}
return 0;
}
/**
* End AEW Algorithm, disable AEW engine
*/
public void close_aew() throws IOError{
aew_running = false;
if(clean_close) {
thread.join();
clean_close = false;
}
if (rraew != null){
destroy_rraew(rraew);
rraew = null;
}
}
#endif
}