Argus Camera Sample Argus Camera Sample

- Main Page
- Related Pages
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
XMLConfig.cpp
Go to the documentation of this file.
1 /*
2 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without
5 * modification, are permitted provided that the following conditions
6 * are met:
7 * * Redistributions of source code must retain the above copyright
8 * notice, this list of conditions and the following disclaimer.
9 * * Redistributions in binary form must reproduce the above copyright
10 * notice, this list of conditions and the following disclaimer in the
11 * documentation and/or other materials provided with the distribution.
12 * * Neither the name of NVIDIA CORPORATION nor the names of its
13 * contributors may be used to endorse or promote products derived
14 * from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
17 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
20 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 #include <string>
30 #include <fstream>
31 #include <stdio.h>
32
33 #include <expat.h>
34
35 #include "XMLConfig.h"
36 #include "Dispatcher.h"
37 #include "UniquePointer.h"
38
39 namespace ArgusSamples
40 {
41
42 // XML version
43 static const char *VERSION = "1.0";
44
45 // element names
46 static const char *ELEMENT_DEVICE_INDEX = "deviceIndex";
47 static const char *ELEMENT_VERBOSE = "verbose";
48 static const char *ELEMENT_KPI = "kpi";
49 static const char *ELEMENT_EXPOSURE_TIME_RANGE = "exposureTimeRange";
50 static const char *ELEMENT_GAIN_RANGE = "gainRange";
51 static const char *ELEMENT_SENSOR_MODE_INDEX = "sensorModeIndex";
52 static const char *ELEMENT_FRAME_RATE = "frameRate";
53 static const char *ELEMENT_FOCUS_POSITION = "focusPosition";
54 static const char *ELEMENT_AE_ANTIBANDING_MODE = "aeAntibandingMode";
55 static const char *ELEMENT_AE_LOCK = "aeLock";
56 static const char *ELEMENT_AWB_LOCK = "awbLock";
57 static const char *ELEMENT_AWB_MODE = "awbMode";
58 static const char *ELEMENT_EXPOSURE_COMPENSATION = "exposureCompensation";
59 static const char *ELEMENT_DENOISE_MODE = "denoiseMode";
60 static const char *ELEMENT_VSTAB_MODE = "vstabMode";
61 static const char *ELEMENT_VIDEO_FORMAT = "videoFormat";
62 static const char *ELEMENT_VIDEO_FILE_TYPE = "videoFileType";
63 static const char *ELEMENT_VIDEO_BIT_RATE = "videoBitRate";
64 static const char *ELEMENT_OUTPUT_SIZE = "outputSize";
65 static const char *ELEMENT_OUTPUT_PATH = "outputPath";
66 static const char *ELEMENT_DE_FOG_ENABLE = "deFogEnable";
67 static const char *ELEMENT_DE_FOG_AMOUNT = "deFogAmount";
68 static const char *ELEMENT_DE_FOG_QUALITY = "deFogQaulity";
69
70 static void XMLCALL xmlHandleData(void *parser, const char *s, int len)
71 {
72 XML_Parser p = (XML_Parser)parser;
73 std::string *data = reinterpret_cast<std::string*>(XML_GetUserData(p));
74
75 data->append(s, len);
76 }
77
78 static void XMLCALL xmlStartElement(void *parser, const char *name, const char **atts)
79 {
80 XML_Parser p = (XML_Parser)parser;
81
82 if (strcmp(name, "argusconfig") == 0)
83 {
84 const char **curAtt = atts;
85
86 while (*curAtt != NULL)
87 {
88 const char *attribute = curAtt[0];
89 const char *value = curAtt[1];
90
91 if (strcmp(attribute, "version") == 0)
92 {
93 if (strcmp(value, VERSION) != 0)
94 {
95 ORIGINATE_ERROR_FAIL("Unsupported version '%s' expected version '%s'",
96 value, VERSION);
97 }
98 }
99 else
100 ORIGINATE_ERROR_FAIL("Found unexpected attribute '%s'", attribute);
101 curAtt += 2;
102 }
103 }
104
105 XML_SetCharacterDataHandler(p, xmlHandleData);
106
107 return;
108
109 fail:
110 XML_StopParser(p, XML_FALSE);
111 }
112
113 /**
114 * Check if an element matches the value name, if this is the case set the value to 'dataStr'
115 * @param [in] elementName current element
116 * @param [in] dataStr data for that element
117 * @param [in] valueName value name
118 * @param [in] value value to update with dataStr if there is a match
119 * @param [out] match set if there was a match
120 */
121 template<typename T> static bool checkValue(const char *elementName, const char *dataStr,
122 const char *valueName, Value<T> &value, bool *match)
123 {
124 if (strcmp(elementName, valueName) == 0)
125 {
126 PROPAGATE_ERROR(value.setFromString(dataStr));
127 *match = true;
128 }
129
130 return true;
131 }
132
133 static void XMLCALL xmlEndElement(void *parser, const char *name)
134 {
135 Dispatcher &dispatcher = Dispatcher::getInstance();
136 XML_Parser p = (XML_Parser)parser;
137 std::string *data = reinterpret_cast<std::string*>(XML_GetUserData(p));
138
139 if (strcmp(name, ELEMENT_DEVICE_INDEX) == 0)
140 {
141 PROPAGATE_ERROR_FAIL(dispatcher.m_deviceIndex.setFromString(data->c_str()));
142 }
143 else if (strcmp(name, ELEMENT_VERBOSE) == 0)
144 {
145 PROPAGATE_ERROR_FAIL(dispatcher.m_verbose.setFromString(data->c_str()));
146 }
147 else if (strcmp(name, ELEMENT_KPI) == 0)
148 {
149 PROPAGATE_ERROR_FAIL(dispatcher.m_kpi.setFromString(data->c_str()));
150 }
151 else if (strcmp(name, ELEMENT_EXPOSURE_TIME_RANGE) == 0)
152 {
153 PROPAGATE_ERROR_FAIL(dispatcher.m_exposureTimeRange.setFromString(data->c_str()));
154 }
155 else if (strcmp(name, ELEMENT_GAIN_RANGE) == 0)
156 {
157 PROPAGATE_ERROR_FAIL(dispatcher.m_gainRange.setFromString(data->c_str()));
158 }
159 else if (strcmp(name, ELEMENT_SENSOR_MODE_INDEX) == 0)
160 {
161 PROPAGATE_ERROR_FAIL(dispatcher.m_sensorModeIndex.setFromString(data->c_str()));
162 }
163 else if (strcmp(name, ELEMENT_FRAME_RATE) == 0)
164 {
165 PROPAGATE_ERROR_FAIL(dispatcher.m_frameRate.setFromString(data->c_str()));
166 }
167 else if (strcmp(name, ELEMENT_FOCUS_POSITION) == 0)
168 {
169 PROPAGATE_ERROR_FAIL(dispatcher.m_focusPosition.setFromString(data->c_str()));
170 }
171 else if (strcmp(name, ELEMENT_DENOISE_MODE) == 0)
172 {
173 PROPAGATE_ERROR_FAIL(dispatcher.m_denoiseMode.setFromString(data->c_str()));
174 }
175 else if (strcmp(name, ELEMENT_VSTAB_MODE) == 0)
176 {
177 PROPAGATE_ERROR_FAIL(dispatcher.m_vstabMode.setFromString(data->c_str()));
178 }
179 else if (strcmp(name, ELEMENT_AE_ANTIBANDING_MODE) == 0)
180 {
181 PROPAGATE_ERROR_FAIL(dispatcher.m_aeAntibandingMode.setFromString(data->c_str()));
182 }
183 else if (strcmp(name, ELEMENT_AE_LOCK) == 0)
184 {
185 PROPAGATE_ERROR_FAIL(dispatcher.m_aeLock.setFromString(data->c_str()));
186 }
187 else if (strcmp(name, ELEMENT_AWB_LOCK) == 0)
188 {
189 PROPAGATE_ERROR_FAIL(dispatcher.m_awbLock.setFromString(data->c_str()));
190 }
191 else if (strcmp(name, ELEMENT_AWB_MODE) == 0)
192 {
193 PROPAGATE_ERROR_FAIL(dispatcher.m_awbMode.setFromString(data->c_str()));
194 }
195 else if (strcmp(name, ELEMENT_EXPOSURE_COMPENSATION) == 0)
196 {
197 PROPAGATE_ERROR_FAIL(dispatcher.m_exposureCompensation.setFromString(data->c_str()));
198 }
199 else if (strcmp(name, ELEMENT_VIDEO_FORMAT) == 0)
200 {
201 PROPAGATE_ERROR_FAIL(dispatcher.m_videoFormat.setFromString(data->c_str()));
202 }
203 else if (strcmp(name, ELEMENT_VIDEO_FILE_TYPE) == 0)
204 {
205 PROPAGATE_ERROR_FAIL(dispatcher.m_videoFileType.setFromString(data->c_str()));
206 }
207 else if (strcmp(name, ELEMENT_VIDEO_BIT_RATE) == 0)
208 {
209 PROPAGATE_ERROR_FAIL(dispatcher.m_videoBitRate.setFromString(data->c_str()));
210 }
211 else if (strcmp(name, ELEMENT_OUTPUT_SIZE) == 0)
212 {
213 PROPAGATE_ERROR_FAIL(dispatcher.m_outputSize.setFromString(data->c_str()));
214 }
215 else if (strcmp(name, ELEMENT_OUTPUT_PATH) == 0)
216 {
217 PROPAGATE_ERROR_FAIL(dispatcher.m_outputPath.set(*data));
218 }
219 else if (strcmp(name, ELEMENT_DE_FOG_ENABLE) == 0)
220 {
221 PROPAGATE_ERROR_FAIL(dispatcher.m_deFogEnable.setFromString(data->c_str()));
222 }
223 else if (strcmp(name, ELEMENT_DE_FOG_AMOUNT) == 0)
224 {
225 PROPAGATE_ERROR_FAIL(dispatcher.m_deFogAmount.setFromString(data->c_str()));
226 }
227 else if (strcmp(name, ELEMENT_DE_FOG_QUALITY) == 0)
228 {
229 PROPAGATE_ERROR_FAIL(dispatcher.m_deFogQuality.setFromString(data->c_str()));
230 }
231 else if (strcmp(name, "argusconfig") == 0)
232 {
233 }
234 else
235 {
236 ORIGINATE_ERROR_FAIL("Unhandled element '%s'.", name);
237 }
238
239 XML_SetCharacterDataHandler(p, NULL);
240 data->clear();
241
242 return;
243
244 fail:
245 XML_StopParser(p, XML_FALSE);
246 }
247
248 bool loadConfig(const char *configFile)
249 {
250 if (configFile == NULL)
251 ORIGINATE_ERROR("'configFile' is NULL");
252
253 FILE *xmlFile;
254 bool success = true;
255 long ftellResult;
256 size_t fileSize;
257 UniquePointer<char> fileData;
258 XML_Parser parser = NULL;
259 std::string data;
260
261 // open the file
262 xmlFile = fopen(configFile, "rb");
263 if (xmlFile == NULL)
264 ORIGINATE_ERROR_FAIL("Failed to open file %s", configFile);
265
266 // get file size
267 if (fseek(xmlFile, 0, SEEK_END) != 0)
268 ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
269
270 ftellResult = ftell(xmlFile);
271 if (ftellResult == -1)
272 ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
273 if (ftellResult == 0)
274 ORIGINATE_ERROR_FAIL("Empty file %s", configFile);
275
276 fileSize = ftellResult;
277
278 if (fseek(xmlFile, 0, SEEK_SET) != 0)
279 ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
280
281 // allocate buffer
282 fileData.reset(new char[fileSize + 1]);
283 if (!fileData)
284 ORIGINATE_ERROR_FAIL("Out of memory");
285
286 // read from file to buffer
287 if (fread(fileData.get(), fileSize, 1, xmlFile) != 1)
288 ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
289 // terminate string
290 fileData.get()[fileSize] = 0;
291
292 // create XML parser
293 parser = XML_ParserCreate(NULL);
294 if (parser == NULL)
295 ORIGINATE_ERROR("Failed to create parser");
296
297 XML_UseParserAsHandlerArg(parser);
298 // the user data is a string, the XML data handler appens to this, the end element handler
299 // then uses it to set the values
300 XML_SetUserData(parser, &data);
301 XML_SetElementHandler(parser, xmlStartElement, xmlEndElement);
302
303 // start parsing
304 if (XML_Parse(parser, fileData.get(), (int)fileSize, 1) == XML_STATUS_ERROR)
305 {
306 // on failure print the line and column number and the line in which the error occured
307 const XML_Size lineNumber = XML_GetCurrentLineNumber(parser);
308 const XML_Size columnNumber = XML_GetCurrentColumnNumber(parser);
309 const XML_Index byteIndex = XML_GetCurrentByteIndex(parser);
310
311 std::string line;
312
313 if ((byteIndex >= 0) && (static_cast<size_t>(byteIndex) < fileSize))
314 {
315 // find line start
316 size_t lineStart = static_cast<size_t>(byteIndex);
317 while ((lineStart > 0) && (fileData.get()[lineStart] != '\n'))
318 --lineStart;
319 // point after new line
320 if (fileData.get()[lineStart] == '\n')
321 ++lineStart;
322
323 // find line end
324 size_t lineEnd = static_cast<size_t>(lineStart);
325 while ((lineEnd < fileSize) && (fileData.get()[lineEnd] != '\n'))
326 ++lineEnd;
327
328 line.append(&fileData.get()[lineStart], lineEnd - lineStart);
329 }
330 else
331 {
332 line += "-";
333 }
334
335 ORIGINATE_ERROR_FAIL("%s at line %lu:%lu:\n%s",
336 XML_ErrorString(XML_GetErrorCode(parser)),
337 lineNumber, columnNumber, line.c_str());
338 }
339
340 goto succeeded;
341
342 fail:
343 success = false;
344
345 succeeded:
346 if (parser != 0)
347 XML_ParserFree(parser);
348 if (xmlFile != NULL)
349 fclose(xmlFile);
350
351 return success;
352 }
353
354 // write an string to XML
355 static void writeValue(std::ofstream &stream, const char *name, const std::string& string)
356 {
357 stream << " <" << name << ">" << string << "</" << name << ">" << std::endl;
358 }
359
360 // write an value to XML
361 template<typename T> static void writeValue(std::ofstream &stream, const char *name,
362 const Value<T> &value)
363 {
364 writeValue(stream, name, value.toString());
365 }
366
367 bool saveConfig(const char *configFile)
368 {
369 if (configFile == NULL)
370 ORIGINATE_ERROR("'configFile' is NULL");
371
372 Dispatcher &dispatcher = Dispatcher::getInstance();
373
374 // open the stream
375 std::ofstream stream(configFile, std::ofstream::out);
376 if (!stream.is_open())
377 ORIGINATE_ERROR("Failed to open file '%s' for saving.", configFile);
378
379 // header
380 stream << "<?xml version='1.0' encoding='utf-8'?>" << std::endl;
381 stream << "<argusconfig version='" << VERSION << "'>" << std::endl;
382
383 // write the value
384 writeValue(stream, ELEMENT_DEVICE_INDEX, dispatcher.m_deviceIndex);
385 writeValue(stream, ELEMENT_VERBOSE, dispatcher.m_verbose);
386 writeValue(stream, ELEMENT_KPI, dispatcher.m_kpi);
387 writeValue(stream, ELEMENT_EXPOSURE_TIME_RANGE, dispatcher.m_exposureTimeRange);
388 writeValue(stream, ELEMENT_GAIN_RANGE, dispatcher.m_gainRange);
389 writeValue(stream, ELEMENT_SENSOR_MODE_INDEX, dispatcher.m_sensorModeIndex);
390 writeValue(stream, ELEMENT_FRAME_RATE, dispatcher.m_frameRate);
391 writeValue(stream, ELEMENT_FOCUS_POSITION, dispatcher.m_focusPosition);
392 writeValue(stream, ELEMENT_DENOISE_MODE, dispatcher.m_denoiseMode);
393 writeValue(stream, ELEMENT_VSTAB_MODE, dispatcher.m_vstabMode);
394 writeValue(stream, ELEMENT_AE_ANTIBANDING_MODE, dispatcher.m_aeAntibandingMode);
395 writeValue(stream, ELEMENT_AE_LOCK, dispatcher.m_aeLock);
396 writeValue(stream, ELEMENT_AWB_LOCK, dispatcher.m_awbLock);
397 writeValue(stream, ELEMENT_AWB_MODE, dispatcher.m_awbMode);
398 writeValue(stream, ELEMENT_EXPOSURE_COMPENSATION, dispatcher.m_exposureCompensation);
399 writeValue(stream, ELEMENT_VIDEO_FORMAT, dispatcher.m_videoFormat);
400 writeValue(stream, ELEMENT_VIDEO_FILE_TYPE, dispatcher.m_videoFileType);
401 writeValue(stream, ELEMENT_VIDEO_BIT_RATE, dispatcher.m_videoBitRate);
402 writeValue(stream, ELEMENT_OUTPUT_SIZE, dispatcher.m_outputSize);
403 writeValue(stream, ELEMENT_OUTPUT_PATH, dispatcher.m_outputPath.get());
404 writeValue(stream, ELEMENT_DE_FOG_ENABLE, dispatcher.m_deFogEnable);
405 writeValue(stream, ELEMENT_DE_FOG_AMOUNT, dispatcher.m_deFogAmount);
406 writeValue(stream, ELEMENT_DE_FOG_QUALITY, dispatcher.m_deFogQuality);
407
408 // footer
409 stream << "</argusconfig>" << std::endl;
410
411 stream.close();
412
413 return true;
414 }
415
416 }; // namespace ArgusSamples