JEtherPix

@@ -16,7 +16,7 @@

 # along with this program. If not, see <http://www.gnu.org/licenses/>.

 VERSION_MAJOR=1

-VERSION_MINOR=2

+VERSION_MINOR=3

 VERSION_REVISION=0

 JAVAC=javac

@@ -1,6 +1,6 @@

 JEtherPix - Java implementation of EtherPix output library

-EtherPix is a large scale display architecure that is driven using UDP/IP.

+EtherPix is a large scale display architecture that is driven using UDP/IP.

 It consists of single pixels that are connected to chains. A number of those

 pixel chains is then connected to a so called distributor module that

 receives data over ethernet and distributes it to the pixel chains.

@@ -12,8 +12,8 @@ are sent for one frame - a single MCUF frame to every distributor.

 The coordinates of the pixels in the MCUF packets do not correspond to pixel

 locations, but to pixel addresses. The y coordinate is the number of the

 output of the distributor and the x coordinate is the number of the pixel

-in the chain. The number of channels is always 3 (RGB) and the maximum value

-is always 255 (8 bit per channel).

+in the chain. The number of channels is always 1 (monochrome)  or 3 (RGB) and

+the maximum value is always 255 (8 bit per channel).

 This library can be used to send the required UDP packets to the EtherPix

 display to make it show images and/or videos.

@@ -169,7 +169,7 @@ class Config

     Pattern pattern;

     Matcher matcher;

     String strDistri, strChannel, strBase, strFactor, strGamma;

-    int dist;

+    int dist, prev_channels;

     Distri distri;

     Mapping mapping = null;

     double base = 0.0, factor = 1.0, gamma = 1.0;

@@ -199,16 +199,24 @@ class Config

       errorExc(String.format("no distributor with number \"%d\"" +

                              " in line %d of config file", dist, m_lineNo));

-    // get channel

-    if (strChannel.equals("red"))

-      mapping = distri.m_mapRed;

-    else if (strChannel.equals("green"))

+    // get channel (and implicitly number of channels)

+    prev_channels = distri.m_channels;

+    if (strChannel.equals("red")) {

+      distri.m_channels = 3;

+      mapping = distri.m_mapRedWhite;

+    } else if (strChannel.equals("green")) {

+      distri.m_channels = 3;

       mapping = distri.m_mapGreen;

-    else if (strChannel.equals("blue"))

+    } else if (strChannel.equals("blue")) {

+      distri.m_channels = 3;

       mapping = distri.m_mapBlue;

-    else

+    } else if (strChannel.equals("white")) {

+      distri.m_channels = 1;

+      mapping = distri.m_mapRedWhite;

+    } else {

       errorExc("invalid channel \"" + strChannel + "\"" +

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

+    }

     // split mapping parameters

     pattern = Pattern.compile("^([-+.eE0-9]+) +([-+.eE0-9]+) +([-+.eE0-9]+)$");

@@ -235,6 +243,11 @@ class Config

     // update mapping parameters

     mapping.set(base, factor, gamma);

+

+    // update message buffer if channel count changed

+    if (distri.m_channels != prev_channels) {

+      distri.allocMsgBuf();

+    }

   }

   /**

@@ -38,10 +38,11 @@ class Constants

   static byte [] mcufHdr    = {  ///< data of MCUF header

     (byte)0x23, (byte)0x54, (byte)0x26, (byte)0x66,

     (byte)0x00, (byte)0x00, (byte)0x00, (byte)0x00,

-    (byte)0x00, (byte)0x03, (byte)0x00, (byte)0xFF

+    (byte)0x00, (byte)0x00, (byte)0x00, (byte)0xFF

   };

   static int mcufOfsOutputsU16  = 4; /**< offset of output count in MCUF data */

   static int mcufOfsPixelsU16   = 6; /**< offset of pixel count in MCUF data */

+  static int mcufOfsChannelsU16 = 8; /**< offset of chan count in MCUF data */

   // fixed settings constants

   static int destIpBase   = 0x0A465000; /**< base IP address of distributors,

@@ -143,13 +143,23 @@ public class Display

               if (rx >= 0 && rx < width && ry >= 0 && ry < height) {

                 // get pixel data and map it

                 src = rx * strideX + ry * strideY + base;

-                distri.m_msgBuf[dest+0] = distri.m_mapRed.m_table[data[src+0] & 0xFF];

+                // monochrome (convert, emphasize green)

+                if (distri.m_channels == 1) {

+                  distri.m_msgBuf[dest] = (byte)(

+                    (distri.m_mapRedWhite.m_table[data[src+0] & 0xFF] +

+                     (distri.m_mapGreen.m_table[data[src+1] & 0xFF] << 1) +

+                     distri.m_mapBlue.m_table[data[src+2] & 0xFF] + 2) >> 2);

+                }

+                // RGB

+                else if (distri.m_channels == 3) {

+                  distri.m_msgBuf[dest+0] = distri.m_mapRedWhite.m_table[data[src+0] & 0xFF];

                   distri.m_msgBuf[dest+1] = distri.m_mapGreen.m_table[data[src+1] & 0xFF];

                   distri.m_msgBuf[dest+2] = distri.m_mapBlue.m_table[data[src+2] & 0xFF];

                 }

+              }

             } // if pixel

-            dest += 3;

+            dest += distri.m_channels;

           } // for pix

         } // for out

@@ -36,9 +36,10 @@ class Distri

     m_distri    = distri;

     m_outputCnt = outputCnt;

     m_pixelCnt  = pixelCnt;

+    m_channels  = 3; // RGB by default

     // allocate default mappings

-    m_mapRed   = new Mapping();

+    m_mapRedWhite = new Mapping();

     m_mapGreen    = new Mapping();

     m_mapBlue     = new Mapping();

@@ -46,13 +47,7 @@ class Distri

     m_pixels = new Pixel [m_outputCnt * m_pixelCnt];

     // allocate and initialize message buffer

-    m_msgBuf = Arrays.copyOf(Constants.mcufHdr,

-                             Constants.mcufHdr.length +

-                             m_outputCnt * m_pixelCnt * 3);

-    m_msgBuf[Constants.mcufOfsOutputsU16 + 0] = (byte)(m_outputCnt >> 8);

-    m_msgBuf[Constants.mcufOfsOutputsU16 + 1] = (byte)m_outputCnt;

-    m_msgBuf[Constants.mcufOfsPixelsU16 + 0]  = (byte)(m_pixelCnt >> 8);

-    m_msgBuf[Constants.mcufOfsPixelsU16 + 1]  = (byte)m_pixelCnt;

+    allocMsgBuf();

   }

   /**

@@ -79,14 +74,31 @@ class Distri

     }

   }

+  /**

+   * @brief allocate and initialize message buffer

+   */

+  void allocMsgBuf()

+  {

+    m_msgBuf = Arrays.copyOf(Constants.mcufHdr,

+                             Constants.mcufHdr.length +

+                             m_outputCnt * m_pixelCnt * m_channels);

+    m_msgBuf[Constants.mcufOfsOutputsU16 + 0] = (byte)(m_outputCnt >> 8);

+    m_msgBuf[Constants.mcufOfsOutputsU16 + 1] = (byte)m_outputCnt;

+    m_msgBuf[Constants.mcufOfsPixelsU16 + 0]  = (byte)(m_pixelCnt >> 8);

+    m_msgBuf[Constants.mcufOfsPixelsU16 + 1]  = (byte)m_pixelCnt;

+    m_msgBuf[Constants.mcufOfsChannelsU16 + 0]  = (byte)(m_channels >> 8);

+    m_msgBuf[Constants.mcufOfsChannelsU16 + 1]  = (byte)m_channels;

+  }

+

   int               m_distri;      ///< number of this distributor

   int               m_outputCnt;   ///< number of outputs

   int               m_pixelCnt;    ///< number pixels connected to every output

   InetSocketAddress [] m_addrs;    /**< network address(es) of distributor,

                                         multiple addresses mean the packets are

                                         sent to each address */

-  Mapping           m_mapRed;    ///< mapping information for red channel

-  Mapping           m_mapGreen;  ///< mapping information for Green channel

+  int               m_channels;    ///< number of channels: 1 (mono)or 3 (RGB)

+  Mapping           m_mapRedWhite; ///< mapping information for red/white chan

+  Mapping           m_mapGreen;    ///< mapping information for green channel

   Mapping           m_mapBlue;     ///< mapping information for blue channel

   Pixel []          m_pixels;      /**< information about pixels of this

                                         distributor,

@@ -29,7 +29,8 @@ distributor 15 = 6,64

 # those lines introduce a mapping between the channel values in the video and the values transmitted to the display

 #  - mapping is done per distributor and applies to all pixels connected to it

-#  - the general format is: mapping <distributor number> (red|green|blue) = <base> <factor> <gamma>

+#  - RGB distributors use red, green and blue, monochrone distributors use white

+#  - the general format is: mapping <distributor number> (red|green|blue|white) = <base> <factor> <gamma>

 #  - the mapping formula is: <display value> := <base> + <factor> * <original value> ^ (1 / <gamma>)

 mapping 0 red = 0.005 0.99 1.0

 mapping 0 green = 0.005 0.99 1.0

@@ -0,0 +1,26 @@

+# EtherPix configuration file

+

+# the address to bind the local socket to

+#  - the EtherPix network 10.70.80.0/16 must be reachable from this address

+bindAddr = 0.0.0.0:0

+

+# the size of the display

+#  - <width>,<height> in pixels

+size = 8,8

+

+# this line adds a new distributor

+#  - the general format is: distributor <distributor number> = <number of outputs>,<number of pixel per output>

+distributor 0 = 6,64

+

+# those lines introduce a mapping between the channel values in the video and the values transmitted to the display

+#  - mapping is done per distributor and applies to all pixels connected to it

+#  - RGB distributors use red, green and blue, monochrone distributors use white

+#  - the general format is: mapping <distributor number> (red|green|blue|white) = <base> <factor> <gamma>

+#  - the mapping formula is: <display value> := <base> + <factor> * <original value> ^ (1 / <gamma>)

+mapping 0 white = 0.0 1.0 1.0

+

+# these lines specify the logical positions of the pixels at an output in movie coordinates

+#  - the general format is: output <distributor number>,<output number> = <pixel x>,<pixel y> ...

+#  - the order of the pixels is the order they are connected in the chain

+output 0,0 = 0,0 1,0 2,0 3,0 4,0 5,0 6,0 7,0 7,1 6,1 5,1 4,1 3,1 2,1 1,1 0,1 0,2 1,2 2,2 3,2 4,2 5,2 6,2 7,2 7,3 6,3 5,3 4,3 3,3 2,3 1,3 0,3 0,4 1,4 2,4 3,4 4,4 5,4 6,4 7,4 7,5 6,5 5,5 4,5 3,5 2,5 1,5 0,5 0,6 1,6 2,6 3,6 4,6 5,6 6,6 7,6 7,7 6,7 5,7 4,7 3,7 2,7 1,7 0,7

+

@@ -14,7 +14,8 @@ distributor 0 = 6,64

 # those lines introduce a mapping between the channel values in the video and the values transmitted to the display

 #  - mapping is done per distributor and applies to all pixels connected to it

-#  - the general format is: mapping <distributor number> (red|green|blue) = <base> <factor> <gamma>

+#  - RGB distributors use red, green and blue, monochrone distributors use white

+#  - the general format is: mapping <distributor number> (red|green|blue|white) = <base> <factor> <gamma>

 #  - the mapping formula is: <display value> := <base> + <factor> * <original value> ^ (1 / <gamma>)

 mapping 0 red = 0.0 1.0 1.0

 mapping 0 green = 0.0 1.0 1.0