JEtherPix

1) /* JFlexiPix - Java implementation of FlexiPix output library
2)  *

3)  * Copyright 2010-2011 Stefan Schuermans <stefan schuermans info>

4)  *
5)  * This program is free software: you can redistribute it and/or modify
6)  * it under the terms of the GNU General Public License as published by
7)  * the Free Software Foundation, version 3 of the License.
8)  *
9)  *
10)  * This program is distributed in the hope that it will be useful,
11)  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12)  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13)  * GNU General Public License for more details.
14)  *
15)  * You should have received a copy of the GNU Lesser General Public License
16)  * along with this program. If not, see <http://www.gnu.org/licenses/>.
17)  */
18) 
19) package org.blinkenarea.JFlexiPix;
20) 
21) import java.io.*;

22) import java.net.*;

23) import java.util.*;
24) import java.util.regex.*;
25) 
26) /// configuration parser
27) class Config
28) {
29)   /**
30)    * @brief constructor
31)    * @param[in] display display to configure
32)    * @param[in] messageIf message interface to report messages to or null
33)    */
34)   Config(Display display, MessageIf messageIf)
35)   {
36)     // save constructor parameters
37)     m_display   = display;
38)     m_messageIf = messageIf;
39) 
40)     // compile regular expression patterns
41) 
42)     // empty lines: "   # comment"
43)     m_patternEmpty = Pattern.compile("^" + "\\s*" + "(?:#.*)?" + "$");
44) 
45)     // extract setting and value from "   setting   =   value   # comment"
46)     m_patternLine = Pattern.compile("^" +
47)                                     "\\s*" +
48)                                     "([^\\s=#](?:[^=#]*[^\\s=#])?)" +
49)                                     "\\s*=\\s*" +
50)                                     "([^\\s=#](?:[^=#]*[^\\s=#])?)" +
51)                                     "\\s*" + 
52)                                     "(?:#.*)?" +
53)                                     "$");
54)   }
55) 
56)   /**
57)    * @brief process distributor from config file
58)    *
59)    * @param[in] settingPart2 second half of setting to process
60)    * @param[in] value value of setting
61)    */
62)   void procDistri(String settingPart2, String value)
63)     throws Exception
64)   {

65)     int dist, out, pix;
66)     Pixel px;
67) 
68)     // get distributor number
69)     try {
70)       dist = Integer.parseInt(settingPart2);
71)     } catch (NumberFormatException e) {
72)       dist = Constants.distriMaxCnt; // force error in next line
73)     }
74)     if (dist >= Constants.distriMaxCnt)

75)       errorExc("invalid distributor number \"" + settingPart2 + "\"" +
76)                String.format(" in line %d of config file", m_lineNo));

77) 
78)     // get number of outputs and pixels
79)     px = PixelParser.parsePixel(value); // abuse for "outputs,pixels"
80)     if (px == null)

81)       errorExc("invalid distributor size \"" + value + "\"" +
82)                String.format(" in line %d of config file", m_lineNo));

83)     out = px.m_x;
84)     if (out >= Constants.outputMaxCnt)

85)       errorExc(String.format("invalid number of outputs \"%d\"" +
86)                              " in line %d of config file", out, m_lineNo));

87)     pix = px.m_y;
88)     if (pix >= Constants.pixelMaxCnt)

89)       errorExc(String.format("invalid number of pixels \"%d\"" +
90)                              " in line %d of config file", pix, m_lineNo));

91) 
92)     // check if distributor is already present
93)     if (m_display.m_distris[dist] != null)

94)       errorExc(String.format("duplicate definition of distributor \"%d\"" +
95)                              " in line %d of config file", dist, m_lineNo));

96) 
97)     // create new distributor
98)     m_display.m_distris[dist] = new Distri(dist, out, pix);
99) 
100)     // count distributors

101)     m_display.m_distriCnt++;

102)   }
103) 

104)   /**
105)    * @brief process distributor address from config file
106)    *
107)    * @param[in] settingPart2 second half of setting to process
108)    * @param[in] value value of setting
109)    */
110)   void procDistriAddr(String settingPart2, String value)
111)     throws Exception
112)   {
113)     int dist;
114)     Distri distri;
115)     InetSocketAddress addr;
116) 
117)     // get distributor number
118)     try {
119)       dist = Integer.parseInt(settingPart2);
120)     } catch (NumberFormatException e) {
121)       dist = Constants.distriMaxCnt; // force error in next line
122)     }
123)     if (dist >= Constants.distriMaxCnt)
124)       errorExc(String.format("invalid distributor number \"%d\"" +
125)                              " in line %d of config file", dist, m_lineNo));
126) 
127)     // get distributor
128)     distri = m_display.m_distris[dist];
129)     if (distri == null)
130)       errorExc(String.format("no distributor with number \"%d\"" +
131)                              " in line %d of config file", dist, m_lineNo));
132) 
133)     // get address
134)     addr = AddrParser.parseAddr(value);
135)     if (addr == null) {
136)       errorExc("invalid addess \"" + value +
137)                "\" for distributor with number \"%u\"" +
138)                String.format(" in line %d of config file", m_lineNo));
139)     }
140)     distri.m_addr = addr;
141)   }
142) 

143)   /**
144)    * @brief process mapping from config file
145)    *
146)    * @param[in] settingPart2 second half of setting to process
147)    * @param[in] value value of setting
148)    */
149)   void procMapping(String settingPart2, String value)
150)     throws Exception
151)   {

152)     Pattern pattern;
153)     Matcher matcher;
154)     String strDistri, strChannel, strBase, strFactor, strGamma;
155)     int dist;
156)     Distri distri;
157)     Mapping mapping = null;
158)     double base = 0.0, factor = 1.0, gamma = 1.0;
159) 
160)     // split setting part 2 into distributor and channel
161)     pattern = Pattern.compile("^([0-9]+) +([a-z]+)$");
162)     matcher = pattern.matcher(settingPart2);
163)     if (!matcher.find())

164)       errorExc("invalid mapping specifier \"" + settingPart2 + "\"" +
165)                String.format(" in line %d of config file", m_lineNo));

166)     strDistri  = matcher.group(1);
167)     strChannel = matcher.group(2);
168) 
169)     // get distributor number
170)     try {
171)       dist = Integer.parseInt(strDistri);
172)     } catch (NumberFormatException e) {
173)       dist = Constants.distriMaxCnt; // force error in next line
174)     }
175)     if (dist >= Constants.distriMaxCnt)

176)       errorExc("invalid distributor number \"" + strDistri + "\"" +
177)                String.format(" in line %d of config file", m_lineNo));

178) 
179)     // get distributor
180)     distri = m_display.m_distris[dist];
181)     if (distri == null)

182)       errorExc(String.format("no distributor with number \"%d\"" +
183)                              " in line %d of config file", dist, m_lineNo));

184) 
185)     // get channel
186)     if (strChannel.equals("red"))
187)       mapping = distri.m_mapRed;
188)     else if (strChannel.equals("green"))
189)       mapping = distri.m_mapGreen;
190)     else if (strChannel.equals("blue"))
191)       mapping = distri.m_mapBlue;
192)     else

193)       errorExc("invalid channel \"" + strChannel + "\"" +
194)                String.format(" in line %d of config file", m_lineNo));

195) 
196)     // split mapping parameters
197)     pattern = Pattern.compile("^([-+.eE0-9]+) +([-+.eE0-9]+) +([-+.eE0-9]+)$");
198)     matcher = pattern.matcher(value);
199)     if (!matcher.find())

200)       errorExc("invalid mapping parameters \"" + value + "\"" +
201)                String.format(" in line %d of config file", m_lineNo));

202)     strBase   = matcher.group(1);
203)     strFactor = matcher.group(2);
204)     strGamma  = matcher.group(3);
205) 
206)     // parse mapping parameters
207)     try {
208)       base   = Double.parseDouble(strBase);
209)       factor = Double.parseDouble(strFactor);
210)       gamma  = Double.parseDouble(strGamma);
211)     } catch (NumberFormatException e) {

212)       errorExc("invalid mapping parameters \"" + value + "\"" +
213)                String.format(" in line %d of config file", m_lineNo), e);

214)     }
215)     if (gamma <= 0.0)

216)       errorExc(String.format("invalid gamma value \"%f\"" +
217)                              " in line %d of config file", gamma, m_lineNo));

218) 
219)     // update mapping parameters
220)     mapping.set(base, factor, gamma);

221)   }
222) 
223)   /**
224)    * @brief process pixel from config file
225)    *
226)    * @param[in] txtPixel text of pixel to process

227)    * @param[in] distri distributor

228)    * @param[in] dist number of distributor
229)    * @param[in] out number of output
230)    * @param[in] pix number of pixel

231)    * @param return if parsing was successful

232)    */

233)   boolean procPixel(String txtPixel, Distri distri, int dist, int out, int pix)

234)   {

235)     Pixel pixel;
236)     int idx;
237) 
238)     // get coordinates of pixel
239)     pixel = PixelParser.parsePixel(txtPixel);
240)     if (pixel == null) {
241)       error("invalid pixel \"" + txtPixel + "\"" +
242)             String.format(" in line %d of config file", m_lineNo));
243)       return false;
244)     }
245) 
246)     // check pixel number
247)     if (pix >= Constants.pixelMaxCnt || pix >= distri.m_pixelCnt) {
248)       error(String.format("too many pixels (more than %d)" +
249)                           " in line %d of config file",
250)                           distri.m_pixelCnt, m_lineNo));
251)       return false;
252)     }
253) 
254)     // check that pixel is not yet set
255)     idx = out * distri.m_pixelCnt + pix;
256)     if (distri.m_pixels[idx] != null) {
257)       error(String.format("pixel %d of output %d of distributor %d" +
258)                           " already set to pixel %d,%d" +
259)                           " in line %d of config file",
260)                           pix, out, dist, distri.m_pixels[idx].m_x,
261)                           distri.m_pixels[idx].m_y, m_lineNo));
262)       return false;
263)     }
264) 
265)     // create pixel
266)     distri.m_pixels[idx] = pixel;
267) 
268)     // count pixels in total
269)     m_display.m_pixelCnt++;
270) 
271)     return true;

272)   }
273) 
274)   /**
275)    * @brief process output from config file
276)    *
277)    * @param[in] settingPart2 second half of setting to process
278)    * @param[in] value value of setting
279)    */
280)   void procOutput(String settingPart2, String value)
281)     throws Exception
282)   {

283)     Pixel px;
284)     int dist, out, pix;
285)     Distri distri;
286)     String [] pixels;
287)     boolean err;
288) 
289)     // get number of distributor and output
290)     px = PixelParser.parsePixel(settingPart2); // abuse for "dist,out"
291)     if (px == null)
292)       errorExc("invalid output specifier \"" + settingPart2 + "\"" +
293)                String.format(" in line %d of config file", m_lineNo));
294)     dist = px.m_x;
295)     if (dist >= Constants.distriMaxCnt)
296)       errorExc(String.format("invalid distributor number \"%d\"" +
297)                              " in line %d of config file", dist, m_lineNo));
298)     out = px.m_y;
299)     if (out >= Constants.outputMaxCnt)
300)       errorExc(String.format("invalid output number \"%d\"" +
301)                              " in line %d of config file", out, m_lineNo));
302) 
303)     // get distributor
304)     distri = m_display.m_distris[dist];
305)     if (distri == null)
306)       errorExc(String.format("no distributor with number \"%d\"" +
307)                              " in line %d of config file", dist, m_lineNo));
308) 
309)     // check output number
310)     if (out >= distri.m_outputCnt)
311)       errorExc(String.format("no output with output number \"%d\"" +
312)                              " in line %d of config file", out, m_lineNo));
313) 
314)     // count outputs
315)     m_display.m_outputCnt++;
316) 
317)     // process pixels
318)     pixels = value.split("\\s+");
319)     err = false;
320)     for (pix = 0; pix < pixels.length; ++pix)
321)       if (!procPixel(pixels[pix], distri, dist, out, pix))
322)         err = true;
323)     if (err)
324)       errorExc(String.format("invalid pixels in line %d of config file",
325)                              m_lineNo));

326)   }
327) 
328)   /**
329)    * @brief process setting from config file
330)    *
331)    * @param[in] setting setting to process
332)    * @param[in] value value of setting
333)    */
334)   void procSetting(String setting, String value)
335)     throws Exception
336)   {

337)     InetSocketAddress addr;
338)     Pixel pix;

339) 

340)     // replace all whitespace in setting with spaces
341)     setting = setting.replace('\t', ' ').replace('\r', ' ')
342)                      .replace('\n', ' ').replace('\f', ' ');
343) 
344)     // bind address of UDP output
345)     if (setting.equals("bindAddr")) {
346)       addr = AddrParser.parseAddr(value);
347)       if (addr == null) {

348)         errorExc("invalid addess \"" + value + "\" for \"" + setting +
349)                  String.format(" in line %d of config file", m_lineNo));

350)       }
351)       info("bind address: " + addr.toString());
352)       m_display.m_bindAddr = addr;
353)       return;
354)     }
355) 
356)     // size of display
357)     if (setting.equals("size")) {
358)       pix = PixelParser.parsePixel(value);
359)       if (pix == null || pix.m_x <= 0 || pix.m_y <= 0) {

360)         errorExc("invalid value \"" + value + "\" for \"" + setting +
361)                  String.format(" in line %d of config file", m_lineNo));

362)       }
363)       m_display.m_size = pix;
364)       return;
365)     }
366) 
367)     // distributor
368)     if (setting.startsWith("distributor ")) {
369)       procDistri(setting.substring(12), value);
370)       return;
371)     }
372) 

373)     // distributor address
374)     if (setting.startsWith("distributorAddr ")) {
375)       procDistriAddr(setting.substring(16), value);
376)       return;
377)     }
378) 

379)     // mapping
380)     if (setting.startsWith("mapping ")) {
381)       procMapping(setting.substring(8), value);
382)       return;
383)     }
384) 
385)     // distributor
386)     if (setting.startsWith("output ")) {
387)       procOutput(setting.substring(7), value);
388)       return;
389)     }
390) 
391)     // unknown setting

392)     warning("unknown setting \"" + setting + "\"" +

393)             String.format(" in line %d of config file", m_lineNo) +
394)             ", ignored");

395)   }
396) 
397)   /**
398)    * @brief process line from config file
399)    *
400)    * @param[in] line line to process
401)    */
402)   void procLine(String line)
403)     throws Exception
404)   {
405)     Matcher matcher;
406)     String setting, value;
407) 
408)     // ignore empty lines: "   # comment"
409)     matcher = m_patternEmpty.matcher(line);
410)     if (matcher.find())
411)       return;
412) 
413)     // extract setting and value from "   setting   =   value   # comment"
414)     matcher = m_patternLine.matcher(line);
415)     if (!matcher.find()) {
416)       // line cannot be parsed
417)       if (m_messageIf != null)
418)         m_messageIf.message(MsgType.Warn,
419)                             String.format("invalid line %d in config file," +

420)                                           " ignored", m_lineNo));

421)       return;
422)     }
423)     setting = matcher.group(1);
424)     value   = matcher.group(2);
425) 
426)     // process setting
427)     procSetting(setting, value);
428)   }
429) 
430)   /**
431)    * @brief process config file
432)    *
433)    * @param[in] configFileName name of config file to read
434)    */
435)   void procFile(String configFileName)
436)     throws Exception
437)   {

438)     FileReader fr = null;
439)     BufferedReader br = null;

440)     String line;
441) 
442)     // check file name

443)     if (configFileName.length() == 0)

444)       errorExc("no config file specified");

445) 

446)     info("using config file \"" + configFileName + "\"");

447) 
448)     // open file
449)     try {
450)       fr = new FileReader(configFileName);
451)       br = new BufferedReader(fr);
452)     } catch (FileNotFoundException e) {

453)       errorExc("cannot open config file \"" + configFileName +
454)                "\" for reading", e);

455)     }
456) 
457)     // read lines and process them
458)     m_lineNo = 1;
459)     while ((line = br.readLine()) != null) {
460)       procLine(line);
461)       ++m_lineNo;
462)     }
463) 
464)     // close file
465)     br.close();
466)     fr.close();
467) 

468)     info(String.format("%dx%d input format, ", m_display.m_size.m_x,
469)                                                m_display.m_size.m_y) +
470)          String.format("%d distributors, ",    m_display.m_distriCnt ) +
471)          String.format("%d outputs, ",         m_display.m_outputCnt ) +

472)          String.format("%d pixels",            m_display.m_pixelCnt));

473)   }
474) 
475)   /**

476)    * @brief report error message

477)    * @param[in] txt error text
478)    */
479)   private void error(String txt)
480)   {
481)     if (m_messageIf != null)
482)       m_messageIf.message(MsgType.Err, txt + "\n");

483)   }
484) 
485)   /**
486)    * @brief report error message and throw exception
487)    * @param[in] txt error text
488)    */
489)   private void errorExc(String txt)
490)     throws Exception
491)   {
492)     error(txt);

493)     throw new Exception(txt);
494)   }
495) 
496)   /**
497)    * @brief report error message and throw exception
498)    * @param[in] txt error text
499)    * @param[in] e reason for error
500)    */

501)   private void errorExc(String txt, Exception e)

502)     throws Exception
503)   {

504)     error(txt + ": " + e.getMessage());

505)     throw new Exception(txt, e);
506)   }
507) 
508)   /**
509)    * @brief report warning message
510)    * @param[in] txt warning text
511)    */
512)   private void warning(String txt)
513)   {
514)     if (m_messageIf != null)
515)       m_messageIf.message(MsgType.Warn, txt + "\n");
516)   }
517) 
518)   /**
519)    * @brief report information message
520)    * @param[in] txt information text
521)    */
522)   private void info(String txt)
523)   {

524)     if (m_messageIf != null)

525)       m_messageIf.message(MsgType.Info, txt + "\n");