Fix protocol incompatibility introduced in 6e0070c.

Also: Assert that endianness is little or big, don't use a Boost macro name.

Author: tstenner

src/data_receiver.cpp

@@ -171,7 +171,7 @@ void data_receiver::data_thread() {
 					server_stream << "LSL:streamfeed/" << proposed_protocol_version << " "
 								  << conn_.current_uid() << "\r\n";
 					// transmit request parameters
-					server_stream << "Native-Byte-Order: " << BOOST_BYTE_ORDER << "\r\n";
+					server_stream << "Native-Byte-Order: " << LSL_BYTE_ORDER << "\r\n";
 					server_stream << "Endian-Performance: "
 								  << std::floor(measure_endian_performance()) << "\r\n";
 					server_stream << "Has-IEEE754-Floats: "
@@ -228,7 +228,7 @@ void data_receiver::data_thread() {
 							// get the header information
 							if (type == "byte-order") {
 								use_byte_order = std::stoi(rest);
-								if (use_byte_order == 2134 && BOOST_BYTE_ORDER != 2134 &&
+								if (use_byte_order == 2134 && LSL_BYTE_ORDER != 2134 &&
 									format_sizes[conn_.type_info().channel_format()] >= 8)
 									throw std::runtime_error(
 										"The byte order conversion requested by the other party is "

src/sample.cpp

@@ -136,13 +136,13 @@ void load_raw(std::streambuf &sb, void *address, std::size_t count) {
 template <typename T> T load_value(std::streambuf &sb, int use_byte_order) {
 	T tmp;
 	load_raw(sb, &tmp, sizeof(T));
-	if (sizeof(T) > 1 && use_byte_order != BOOST_BYTE_ORDER) endian_reverse_inplace(tmp);
+	if (sizeof(T) > 1 && use_byte_order != LSL_BYTE_ORDER) endian_reverse_inplace(tmp);
 	return tmp;
 }
 
 /// Save a value to a stream buffer with correct endian treatment.
 template <typename T> void save_value(std::streambuf &sb, T v, int use_byte_order) {
-	if (use_byte_order != BOOST_BYTE_ORDER) endian_reverse_inplace(v);
+	if (use_byte_order != LSL_BYTE_ORDER) endian_reverse_inplace(v);
 	save_raw(sb, &v, sizeof(T));
 }
 
@@ -181,7 +181,7 @@ void sample::save_streambuf(
 		}
 	} else {
 		// write numeric data in binary
-		if (use_byte_order == BOOST_BYTE_ORDER || format_sizes[format_] == 1) {
+		if (use_byte_order == LSL_BYTE_ORDER || format_sizes[format_] == 1) {
 			save_raw(sb, &data_, datasize());
 		} else {
 			memcpy(scratchpad, &data_, datasize());
@@ -227,7 +227,7 @@ void sample::load_streambuf(
 	} else {
 		// read numeric channel data
 		load_raw(sb, &data_, datasize());
-		if (use_byte_order != BOOST_BYTE_ORDER && format_sizes[format_] > 1) convert_endian(&data_);
+		if (use_byte_order != LSL_BYTE_ORDER && format_sizes[format_] > 1) convert_endian(&data_);
 		if (suppress_subnormals && format_float[format_]) {
 			if (format_ == cft_float32) {
 				for (uint32_t *p = (uint32_t *)&data_, *e = p + num_channels_; p < e; p++)

src/sample.h

@@ -12,8 +12,10 @@
 #include <string>
 #include <type_traits>
 
-const int BOOST_BYTE_ORDER =
-	lslboost::endian::order::native == lslboost::endian::order::little ? 4321 : 1234;
+// Determine target byte order / endianness
+using byteorder = lslboost::endian::order;
+static_assert(byteorder::native == byteorder::little || byteorder::native == byteorder::big, "Unsupported byteorder");
+const int LSL_BYTE_ORDER = (byteorder::native == byteorder::little) ? 1234 : 4321;
 
 // Boost.Endian has no functions to reverse floats, so we pretend they're ints of the same size.
 template <typename T> inline void endian_reverse_inplace(T &t) {

src/tcp_server.cpp

@@ -123,7 +123,7 @@ class client_session : public std::enable_shared_from_this<client_session> {
 	int data_protocol_version_{100};
 	/// byte order to use (0=portable, 1234=little endian, 4321=big endian, 2134=PDP endian,
 	/// unsupported)
-	int use_byte_order_{BOOST_BYTE_ORDER};
+	int use_byte_order_{LSL_BYTE_ORDER};
 	/// our chunk granularity
 	int chunk_granularity_{0};
 	/// maximum number of samples buffered
@@ -425,20 +425,20 @@ void client_session::handle_read_feedparams(
 				data_protocol_version_ = 100;
 			if (data_protocol_version_ >= 110) {
 				// decide on the byte order if conflicting
-				if (BOOST_BYTE_ORDER != client_byte_order) {
+				if (LSL_BYTE_ORDER != client_byte_order) {
 					if (client_byte_order == 2134 && client_value_size >= 8) {
 						// since we have no implementation for this byte order conversion let
 						// the client do it
-						use_byte_order_ = BOOST_BYTE_ORDER;
+						use_byte_order_ = LSL_BYTE_ORDER;
 					} else {
 						// let the faster party perform the endian conversion
 						use_byte_order_ = (client_value_size <= 1 || (measure_endian_performance() >
 																		 client_endian_performance))
 											  ? client_byte_order
-											  : BOOST_BYTE_ORDER;
+											  : LSL_BYTE_ORDER;
 					}
 				} else
-					use_byte_order_ = BOOST_BYTE_ORDER;
+					use_byte_order_ = LSL_BYTE_ORDER;
 				// determine if subnormal suppression needs to be enabled
 				client_suppress_subnormals =
 					(format_subnormal[format] && !client_supports_subnormals);