force network byte order for dmdserver

Author: mkalkbrenner

include/DMDUtil/DMD.h

@@ -122,6 +122,42 @@ class DMDUTILAPI DMD
     uint8_t b;
     uint16_t width;
     uint16_t height;
+
+    void convertToHostByteOrder()
+    {
+      mode = static_cast<Mode>(ntohl(static_cast<uint32_t>(mode)));
+      layout = static_cast<AlphaNumericLayout>(ntohl(static_cast<uint32_t>(layout)));
+      depth = ntohl(depth);
+      for (size_t i = 0; i < 256 * 64; i++)
+      {
+        segData[i] = ntohs(segData[i]);
+      }
+      for (size_t i = 0; i < 128; i++)
+      {
+        segData2[i] = ntohs(segData2[i]);
+      }
+      width = ntohs(width);
+      height = ntohs(height);
+    }
+
+    Update toNetworkByteOrder() const
+    {
+      Update copy = *this;
+      copy.mode = static_cast<Mode>(htonl(static_cast<uint32_t>(mode)));
+      copy.layout = static_cast<AlphaNumericLayout>(htonl(static_cast<uint32_t>(layout)));
+      copy.depth = htonl(depth);
+      for (size_t i = 0; i < 256 * 64; i++)
+      {
+        copy.segData[i] = htons(segData[i]);
+      }
+      for (size_t i = 0; i < 128; i++)
+      {
+        copy.segData2[i] = htons(segData2[i]);
+      }
+      copy.width = htons(width);
+      copy.height = htons(height);
+      return copy;
+    }
   };
 
   struct StreamHeader
@@ -134,6 +170,28 @@ class DMDUTILAPI DMD
     uint8_t buffered = 0;          // 0 => unbuffered, 1 => buffered
     uint8_t disconnectOthers = 0;  // 0 => no, 1 => yes
     uint32_t length = 0;
+
+    void convertToHostByteOrder()
+    {
+      version = ntohs(version);
+      mode = static_cast<Mode>(ntohl(static_cast<uint32_t>(mode)));
+      width = ntohs(width);
+      height = ntohs(height);
+      length = ntohl(length);
+      buffered = ntohs(buffered);
+      disconnectOthers = ntohs(disconnectOthers);
+    }
+
+    void convertToNetworkByteOrder()
+    {
+      version = htons(version);
+      mode = static_cast<Mode>(htonl(static_cast<uint32_t>(mode)));
+      width = htons(width);
+      height = htons(height);
+      length = htonl(length);
+      buffered = htons(buffered);
+      disconnectOthers = htons(disconnectOthers);
+    }
   };
 
   struct PathsHeader
@@ -142,6 +200,10 @@ class DMDUTILAPI DMD
     char name[DMDUTIL_MAX_NAME_SIZE] = {0};
     char altColorPath[DMDUTIL_MAX_PATH_SIZE] = {0};
     char pupVideosPath[DMDUTIL_MAX_PATH_SIZE] = {0};
+
+    void convertToHostByteOrder() {}
+
+    void convertToNetworkByteOrder() {}
   };
 #pragma pack(pop)  // Reset to default packing
 

src/DMD.cpp

@@ -396,13 +396,16 @@ void DMD::QueueUpdate(const std::shared_ptr<Update> dmdUpdate, bool buffered)
           StreamHeader streamHeader;
           streamHeader.buffered = (uint8_t)buffered;
           streamHeader.disconnectOthers = (uint8_t)m_dmdServerDisconnectOthers;
+          streamHeader.convertToNetworkByteOrder();
           m_pDMDServerConnector->Write(&streamHeader, sizeof(StreamHeader));
           PathsHeader pathsHeader;
           strcpy(pathsHeader.name, m_romName);
           strcpy(pathsHeader.altColorPath, m_altColorPath);
           strcpy(pathsHeader.pupVideosPath, m_pupVideosPath);
+          pathsHeader.convertToNetworkByteOrder();
           m_pDMDServerConnector->Write(&pathsHeader, sizeof(PathsHeader));
-          m_pDMDServerConnector->Write(dmdUpdate.get(), sizeof(Update));
+          Update dmdUpdateNetwork = dmdUpdate->toNetworkByteOrder();
+          m_pDMDServerConnector->Write(&dmdUpdateNetwork, sizeof(Update));
 
           if (streamHeader.disconnectOthers != 0) m_dmdServerDisconnectOthers = false;
         }

src/dmdServer.cpp

@@ -94,9 +94,8 @@ void run(sockpp::tcp_socket sock, uint32_t threadId)
 
     if (n == sizeof(DMDUtil::DMD::StreamHeader))
     {
-      // At the moment the server only listens on localhost.
-      // Therefore, we don't have to take care about litte vs. big endian and can use memcpy.
       memcpy(pStreamHeader, buffer, n);
+      pStreamHeader->convertToHostByteOrder();
       if (strcmp(pStreamHeader->header, "DMDStream") == 0 && pStreamHeader->version == 1)
       {
         if (opt_verbose)
@@ -124,6 +123,7 @@ void run(sockpp::tcp_socket sock, uint32_t threadId)
             {
               DMDUtil::DMD::PathsHeader pathsHeader;
               memcpy(&pathsHeader, buffer, n);
+              pathsHeader.convertToHostByteOrder();
 
               if (strcmp(pathsHeader.header, "Paths") == 0 &&
                   (n = sock.read_n(buffer, sizeof(DMDUtil::DMD::Update))) == sizeof(DMDUtil::DMD::Update) &&
@@ -135,6 +135,7 @@ void run(sockpp::tcp_socket sock, uint32_t threadId)
                                pathsHeader.name, pathsHeader.altColorPath, pathsHeader.pupVideosPath);
                 auto data = std::make_shared<DMDUtil::DMD::Update>();
                 memcpy(data.get(), buffer, n);
+                data->convertToHostByteOrder();
 
                 if (data->width <= DMDSERVER_MAX_WIDTH && data->height <= DMDSERVER_MAX_HEIGHT)
                 {
@@ -165,9 +166,13 @@ void run(sockpp::tcp_socket sock, uint32_t threadId)
                 threadId == currentThreadId && pStreamHeader->width <= DMDSERVER_MAX_WIDTH &&
                 pStreamHeader->height <= DMDSERVER_MAX_HEIGHT)
             {
-              // At the moment the server only listens on localhost.
-              // Therefore, we don't have to take care about litte vs. big endian and can use the buffer as uint16_t as
-              // it is.
+              uint16_t* pixelData = (uint16_t*)buffer;
+              size_t pixelCount = pStreamHeader->length / sizeof(uint16_t);
+              for (size_t i = 0; i < pixelCount; i++)
+              {
+                pixelData[i] = ntohs(pixelData[i]);
+              }
+
               pDmd->UpdateRGB16Data((uint16_t*)buffer, pStreamHeader->width, pStreamHeader->height,
                                     pStreamHeader->buffered == 1);
             }