Argus Camera Sample
Argus Camera Sample
 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-2019, 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_APERTURE_MOTOR_STEP = "apertureMotorStep";
55 static const char *ELEMENT_APERTURE_MOTOR_SPEED = "apertureMotorSpeed";
56 static const char *ELEMENT_CAPTURE_YUV_FORMAT = "captureYuvFormat";
57 static const char *ELEMENT_AE_ANTIBANDING_MODE = "aeAntibandingMode";
58 static const char *ELEMENT_AE_LOCK = "aeLock";
59 static const char *ELEMENT_AWB_LOCK = "awbLock";
60 static const char *ELEMENT_AWB_MODE = "awbMode";
61 static const char *ELEMENT_EXPOSURE_COMPENSATION = "exposureCompensation";
62 static const char *ELEMENT_ISP_DIGITAL_GAIN_RANGE = "ispDigitalGainRange";
63 static const char *ELEMENT_DENOISE_MODE = "denoiseMode";
64 static const char *ELEMENT_STILL_FILE_TYPE = "stillFileType";
65 static const char *ELEMENT_VIDEO_FORMAT = "videoFormat";
66 static const char *ELEMENT_VIDEO_FILE_TYPE = "videoFileType";
67 static const char *ELEMENT_VIDEO_BIT_RATE = "videoBitRate";
68 static const char *ELEMENT_OUTPUT_SIZE = "outputSize";
69 static const char *ELEMENT_OUTPUT_PATH = "outputPath";
70 static const char *ELEMENT_DE_FOG_ENABLE = "deFogEnable";
71 static const char *ELEMENT_DE_FOG_AMOUNT = "deFogAmount";
72 static const char *ELEMENT_DE_FOG_QUALITY = "deFogQaulity";
73 
74 static void XMLCALL xmlHandleData(void *parser, const char *s, int len)
75 {
76  XML_Parser p = (XML_Parser)parser;
77  std::string *data = reinterpret_cast<std::string*>(XML_GetUserData(p));
78 
79  data->append(s, len);
80 }
81 
82 static void XMLCALL xmlStartElement(void *parser, const char *name, const char **atts)
83 {
84  XML_Parser p = (XML_Parser)parser;
85 
86  if (strcmp(name, "argusconfig") == 0)
87  {
88  const char **curAtt = atts;
89 
90  while (*curAtt != NULL)
91  {
92  const char *attribute = curAtt[0];
93  const char *value = curAtt[1];
94 
95  if (strcmp(attribute, "version") == 0)
96  {
97  if (strcmp(value, VERSION) != 0)
98  {
99  ORIGINATE_ERROR_FAIL("Unsupported version '%s' expected version '%s'",
100  value, VERSION);
101  }
102  }
103  else
104  ORIGINATE_ERROR_FAIL("Found unexpected attribute '%s'", attribute);
105  curAtt += 2;
106  }
107  }
108 
109  XML_SetCharacterDataHandler(p, xmlHandleData);
110 
111  return;
112 
113 fail:
114  XML_StopParser(p, XML_FALSE);
115 }
116 
117 /**
118  * Check if an element matches the value name, if this is the case set the value to 'dataStr'
119  * @param [in] elementName current element
120  * @param [in] dataStr data for that element
121  * @param [in] valueName value name
122  * @param [in] value value to update with dataStr if there is a match
123  * @param [out] match set if there was a match
124  */
125 template<typename T> static bool checkValue(const char *elementName, const char *dataStr,
126  const char *valueName, Value<T> &value, bool *match)
127 {
128  if (strcmp(elementName, valueName) == 0)
129  {
130  PROPAGATE_ERROR(value.setFromString(dataStr));
131  *match = true;
132  }
133 
134  return true;
135 }
136 
137 static void XMLCALL xmlEndElement(void *parser, const char *name)
138 {
139  Dispatcher &dispatcher = Dispatcher::getInstance();
140  XML_Parser p = (XML_Parser)parser;
141  std::string *data = reinterpret_cast<std::string*>(XML_GetUserData(p));
142 
143  if (strcmp(name, ELEMENT_DEVICE_INDEX) == 0)
144  {
145  PROPAGATE_ERROR_FAIL(dispatcher.m_deviceIndex.setFromString(data->c_str()));
146  }
147  else if (strcmp(name, ELEMENT_VERBOSE) == 0)
148  {
149  PROPAGATE_ERROR_FAIL(dispatcher.m_verbose.setFromString(data->c_str()));
150  }
151  else if (strcmp(name, ELEMENT_KPI) == 0)
152  {
153  PROPAGATE_ERROR_FAIL(dispatcher.m_kpi.setFromString(data->c_str()));
154  }
155  else if (strcmp(name, ELEMENT_EXPOSURE_TIME_RANGE) == 0)
156  {
157  PROPAGATE_ERROR_FAIL(dispatcher.m_exposureTimeRange.setFromString(data->c_str()));
158  }
159  else if (strcmp(name, ELEMENT_GAIN_RANGE) == 0)
160  {
161  PROPAGATE_ERROR_FAIL(dispatcher.m_gainRange.setFromString(data->c_str()));
162  }
163  else if (strcmp(name, ELEMENT_SENSOR_MODE_INDEX) == 0)
164  {
165  PROPAGATE_ERROR_FAIL(dispatcher.m_sensorModeIndex.setFromString(data->c_str()));
166  }
167  else if (strcmp(name, ELEMENT_FRAME_RATE) == 0)
168  {
169  PROPAGATE_ERROR_FAIL(dispatcher.m_frameRate.setFromString(data->c_str()));
170  }
171  else if (strcmp(name, ELEMENT_FOCUS_POSITION) == 0)
172  {
173  PROPAGATE_ERROR_FAIL(dispatcher.m_focusPosition.setFromString(data->c_str()));
174  }
175  else if (strcmp(name, ELEMENT_APERTURE_MOTOR_STEP) == 0)
176  {
177  PROPAGATE_ERROR_FAIL(dispatcher.m_apertureMotorStep.setFromString(data->c_str()));
178  }
179  else if (strcmp(name, ELEMENT_APERTURE_MOTOR_SPEED) == 0)
180  {
181  PROPAGATE_ERROR_FAIL(dispatcher.m_apertureMotorSpeed.setFromString(data->c_str()));
182  }
183  else if (strcmp(name, ELEMENT_CAPTURE_YUV_FORMAT) == 0)
184  {
185  PROPAGATE_ERROR_FAIL(dispatcher.m_captureYuvFormat.setFromString(data->c_str()));
186  }
187  else if (strcmp(name, ELEMENT_DENOISE_MODE) == 0)
188  {
189  PROPAGATE_ERROR_FAIL(dispatcher.m_denoiseMode.setFromString(data->c_str()));
190  }
191  else if (strcmp(name, ELEMENT_AE_ANTIBANDING_MODE) == 0)
192  {
193  PROPAGATE_ERROR_FAIL(dispatcher.m_aeAntibandingMode.setFromString(data->c_str()));
194  }
195  else if (strcmp(name, ELEMENT_AE_LOCK) == 0)
196  {
197  PROPAGATE_ERROR_FAIL(dispatcher.m_aeLock.setFromString(data->c_str()));
198  }
199  else if (strcmp(name, ELEMENT_AWB_LOCK) == 0)
200  {
201  PROPAGATE_ERROR_FAIL(dispatcher.m_awbLock.setFromString(data->c_str()));
202  }
203  else if (strcmp(name, ELEMENT_AWB_MODE) == 0)
204  {
205  PROPAGATE_ERROR_FAIL(dispatcher.m_awbMode.setFromString(data->c_str()));
206  }
207  else if (strcmp(name, ELEMENT_EXPOSURE_COMPENSATION) == 0)
208  {
209  PROPAGATE_ERROR_FAIL(dispatcher.m_exposureCompensation.setFromString(data->c_str()));
210  }
211  else if (strcmp(name, ELEMENT_ISP_DIGITAL_GAIN_RANGE) == 0)
212  {
213  PROPAGATE_ERROR_FAIL(dispatcher.m_ispDigitalGainRange.setFromString(data->c_str()));
214  }
215  else if (strcmp(name, ELEMENT_STILL_FILE_TYPE) == 0)
216  {
217  PROPAGATE_ERROR_FAIL(dispatcher.m_stillFileType.setFromString(data->c_str()));
218  }
219  else if (strcmp(name, ELEMENT_VIDEO_FORMAT) == 0)
220  {
221  PROPAGATE_ERROR_FAIL(dispatcher.m_videoFormat.setFromString(data->c_str()));
222  }
223  else if (strcmp(name, ELEMENT_VIDEO_FILE_TYPE) == 0)
224  {
225  PROPAGATE_ERROR_FAIL(dispatcher.m_videoFileType.setFromString(data->c_str()));
226  }
227  else if (strcmp(name, ELEMENT_VIDEO_BIT_RATE) == 0)
228  {
229  PROPAGATE_ERROR_FAIL(dispatcher.m_videoBitRate.setFromString(data->c_str()));
230  }
231  else if (strcmp(name, ELEMENT_OUTPUT_SIZE) == 0)
232  {
233  PROPAGATE_ERROR_FAIL(dispatcher.m_outputSize.setFromString(data->c_str()));
234  }
235  else if (strcmp(name, ELEMENT_OUTPUT_PATH) == 0)
236  {
237  PROPAGATE_ERROR_FAIL(dispatcher.m_outputPath.set(*data));
238  }
239  else if (strcmp(name, ELEMENT_DE_FOG_ENABLE) == 0)
240  {
241  PROPAGATE_ERROR_FAIL(dispatcher.m_deFogEnable.setFromString(data->c_str()));
242  }
243  else if (strcmp(name, ELEMENT_DE_FOG_AMOUNT) == 0)
244  {
245  PROPAGATE_ERROR_FAIL(dispatcher.m_deFogAmount.setFromString(data->c_str()));
246  }
247  else if (strcmp(name, ELEMENT_DE_FOG_QUALITY) == 0)
248  {
249  PROPAGATE_ERROR_FAIL(dispatcher.m_deFogQuality.setFromString(data->c_str()));
250  }
251  else if (strcmp(name, "argusconfig") == 0)
252  {
253  }
254  else
255  {
256  ORIGINATE_ERROR_FAIL("Unhandled element '%s'.", name);
257  }
258 
259  XML_SetCharacterDataHandler(p, NULL);
260  data->clear();
261 
262  return;
263 
264 fail:
265  XML_StopParser(p, XML_FALSE);
266 }
267 
268 bool loadConfig(const char *configFile)
269 {
270  if (configFile == NULL)
271  ORIGINATE_ERROR("'configFile' is NULL");
272 
273  FILE *xmlFile;
274  bool success = true;
275  long ftellResult;
276  size_t fileSize;
277  UniquePointer<char> fileData;
278  XML_Parser parser = NULL;
279  std::string data;
280 
281  // open the file
282  xmlFile = fopen(configFile, "rb");
283  if (xmlFile == NULL)
284  ORIGINATE_ERROR_FAIL("Failed to open file %s", configFile);
285 
286  // get file size
287  if (fseek(xmlFile, 0, SEEK_END) != 0)
288  ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
289 
290  ftellResult = ftell(xmlFile);
291  if (ftellResult == -1)
292  ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
293  if (ftellResult == 0)
294  ORIGINATE_ERROR_FAIL("Empty file %s", configFile);
295 
296  fileSize = ftellResult;
297 
298  if (fseek(xmlFile, 0, SEEK_SET) != 0)
299  ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
300 
301  // allocate buffer
302  fileData.reset(new char[fileSize + 1]);
303  if (!fileData)
304  ORIGINATE_ERROR_FAIL("Out of memory");
305 
306  // read from file to buffer
307  if (fread(fileData.get(), fileSize, 1, xmlFile) != 1)
308  ORIGINATE_ERROR_FAIL("Failed to read buffer file %s", configFile);
309  // terminate string
310  fileData.get()[fileSize] = 0;
311 
312  // create XML parser
313  parser = XML_ParserCreate(NULL);
314  if (parser == NULL)
315  ORIGINATE_ERROR_FAIL("Failed to create parser");
316 
317  XML_UseParserAsHandlerArg(parser);
318  // the user data is a string, the XML data handler appens to this, the end element handler
319  // then uses it to set the values
320  XML_SetUserData(parser, &data);
321  XML_SetElementHandler(parser, xmlStartElement, xmlEndElement);
322 
323  // start parsing
324  if (XML_Parse(parser, fileData.get(), (int)fileSize, 1) == XML_STATUS_ERROR)
325  {
326  // on failure print the line and column number and the line in which the error occured
327  const XML_Size lineNumber = XML_GetCurrentLineNumber(parser);
328  const XML_Size columnNumber = XML_GetCurrentColumnNumber(parser);
329  const XML_Index byteIndex = XML_GetCurrentByteIndex(parser);
330 
331  std::string line;
332 
333  if ((byteIndex >= 0) && (static_cast<size_t>(byteIndex) < fileSize))
334  {
335  // find line start
336  size_t lineStart = static_cast<size_t>(byteIndex);
337  while ((lineStart > 0) && (fileData.get()[lineStart] != '\n'))
338  --lineStart;
339  // point after new line
340  if (fileData.get()[lineStart] == '\n')
341  ++lineStart;
342 
343  // find line end
344  size_t lineEnd = static_cast<size_t>(lineStart);
345  while ((lineEnd < fileSize) && (fileData.get()[lineEnd] != '\n'))
346  ++lineEnd;
347 
348  line.append(&fileData.get()[lineStart], lineEnd - lineStart);
349  }
350  else
351  {
352  line += "-";
353  }
354 
355  ORIGINATE_ERROR_FAIL("%s at line %lu:%lu:\n%s",
356  XML_ErrorString(XML_GetErrorCode(parser)),
357  lineNumber, columnNumber, line.c_str());
358  }
359 
360  goto succeeded;
361 
362 fail:
363  success = false;
364 
365 succeeded:
366  if (parser != 0)
367  XML_ParserFree(parser);
368  if (xmlFile != NULL)
369  fclose(xmlFile);
370 
371  return success;
372 }
373 
374 // write an string to XML
375 static void writeValue(std::ofstream &stream, const char *name, const std::string& string)
376 {
377  stream << " <" << name << ">" << string << "</" << name << ">" << std::endl;
378 }
379 
380 // write an value to XML
381 template<typename T> static void writeValue(std::ofstream &stream, const char *name,
382  const Value<T> &value)
383 {
384  writeValue(stream, name, value.toString());
385 }
386 
387 bool saveConfig(const char *configFile)
388 {
389  if (configFile == NULL)
390  ORIGINATE_ERROR("'configFile' is NULL");
391 
392  Dispatcher &dispatcher = Dispatcher::getInstance();
393 
394  // open the stream
395  std::ofstream stream(configFile, std::ofstream::out);
396  if (!stream.is_open())
397  ORIGINATE_ERROR("Failed to open file '%s' for saving.", configFile);
398 
399  // header
400  stream << "<?xml version='1.0' encoding='utf-8'?>" << std::endl;
401  stream << "<argusconfig version='" << VERSION << "'>" << std::endl;
402 
403  // write the value
404  writeValue(stream, ELEMENT_DEVICE_INDEX, dispatcher.m_deviceIndex);
405  writeValue(stream, ELEMENT_VERBOSE, dispatcher.m_verbose);
406  writeValue(stream, ELEMENT_KPI, dispatcher.m_kpi);
407  writeValue(stream, ELEMENT_EXPOSURE_TIME_RANGE, dispatcher.m_exposureTimeRange);
408  writeValue(stream, ELEMENT_GAIN_RANGE, dispatcher.m_gainRange);
409  writeValue(stream, ELEMENT_SENSOR_MODE_INDEX, dispatcher.m_sensorModeIndex);
410  writeValue(stream, ELEMENT_FRAME_RATE, dispatcher.m_frameRate);
411  writeValue(stream, ELEMENT_FOCUS_POSITION, dispatcher.m_focusPosition);
412  writeValue(stream, ELEMENT_APERTURE_MOTOR_STEP, dispatcher.m_apertureMotorStep);
413  writeValue(stream, ELEMENT_APERTURE_MOTOR_SPEED, dispatcher.m_apertureMotorSpeed);
414  writeValue(stream, ELEMENT_CAPTURE_YUV_FORMAT, dispatcher.m_captureYuvFormat);
415  writeValue(stream, ELEMENT_DENOISE_MODE, dispatcher.m_denoiseMode);
416  writeValue(stream, ELEMENT_AE_ANTIBANDING_MODE, dispatcher.m_aeAntibandingMode);
417  writeValue(stream, ELEMENT_AE_LOCK, dispatcher.m_aeLock);
418  writeValue(stream, ELEMENT_AWB_LOCK, dispatcher.m_awbLock);
419  writeValue(stream, ELEMENT_AWB_MODE, dispatcher.m_awbMode);
420  writeValue(stream, ELEMENT_EXPOSURE_COMPENSATION, dispatcher.m_exposureCompensation);
421  writeValue(stream, ELEMENT_ISP_DIGITAL_GAIN_RANGE, dispatcher.m_ispDigitalGainRange);
422  writeValue(stream, ELEMENT_STILL_FILE_TYPE, dispatcher.m_stillFileType);
423  writeValue(stream, ELEMENT_VIDEO_FORMAT, dispatcher.m_videoFormat);
424  writeValue(stream, ELEMENT_VIDEO_FILE_TYPE, dispatcher.m_videoFileType);
425  writeValue(stream, ELEMENT_VIDEO_BIT_RATE, dispatcher.m_videoBitRate);
426  writeValue(stream, ELEMENT_OUTPUT_SIZE, dispatcher.m_outputSize);
427  writeValue(stream, ELEMENT_OUTPUT_PATH, dispatcher.m_outputPath.get());
428  writeValue(stream, ELEMENT_DE_FOG_ENABLE, dispatcher.m_deFogEnable);
429  writeValue(stream, ELEMENT_DE_FOG_AMOUNT, dispatcher.m_deFogAmount);
430  writeValue(stream, ELEMENT_DE_FOG_QUALITY, dispatcher.m_deFogQuality);
431 
432  // footer
433  stream << "</argusconfig>" << std::endl;
434 
435  stream.close();
436 
437  return true;
438 }
439 
440 }; // namespace ArgusSamples