A2B: Add A2BMessage transmit support

communication/encoder.cpp

@@ -8,6 +8,8 @@
 #include "icsneo/communication/message/ethphymessage.h"
 #include "icsneo/communication/packet/i2cpacket.h"
 #include "icsneo/communication/message/i2cmessage.h"
+#include "icsneo/communication/packet/a2bpacket.h"
+
 
 using namespace icsneo;
 
@@ -70,6 +72,18 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 					// packets to the device. This function just encodes them back to back into `result`
 					return HardwareISO9141Packet::EncodeFromMessage(*isomsg, result, report, packetizer);
 				} // End of Network::Type::ISO9141
+				case Network::Type::A2B: {
+					auto a2bmsg = std::dynamic_pointer_cast<A2BMessage>(message);
+					if(!a2bmsg) {
+						report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+						return false;
+					}
+					buffer = &result;
+					if(!HardwareA2BPacket::EncodeFromMessage(*a2bmsg, result, report)) {
+						return false;
+					}
+					break;
+				} // End of Network::Type::A2B
 				case Network::Type::I2C: {
 					auto i2cmsg = std::dynamic_pointer_cast<I2CMessage>(message);
 					if(!i2cmsg) {
@@ -81,7 +95,7 @@ bool Encoder::encode(const Packetizer& packetizer, std::vector<uint8_t>& result,
 						return false;
 					}
 					break;
-				}
+				} // End of Network::Type::I2C
 				default:
 					report(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error);
 					return false;

communication/message/callback/streamoutput/a2bwavoutput.cpp

@@ -70,11 +70,11 @@ bool A2BWAVOutput::writeSamples(const std::shared_ptr<A2BMessage>& msg, A2BMessa
 	uint8_t numChannels = msg->getNumChannels();
 
 	uint8_t channel = 0;
-	uint32_t sampleIndex = 0;
+	uint32_t frame = 0;
 	uint8_t bitDepth = msg->getBitDepth();
 
 	while(true) {
-		auto sample = msg->getSample(dir, channel, sampleIndex);
+		auto sample = msg->getSample(dir, channel, frame);
 
 		if(!sample) {
 			if(channel == 0) {
@@ -90,7 +90,7 @@ bool A2BWAVOutput::writeSamples(const std::shared_ptr<A2BMessage>& msg, A2BMessa
 
 		channel = (channel + 1) % numChannels;
 		if(channel == 0) {
-			sampleIndex++;
+			frame++;
 		}
 	}
 

communication/packet/a2bpacket.cpp

@@ -1,13 +1,15 @@
 #include "icsneo/communication/packet/a2bpacket.h"
-#include "icsneo/communication/message/a2bmessage.h"
 #include <cstring>
 
-using namespace icsneo;
 
-std::shared_ptr<Message> HardwareA2BPacket::DecodeToMessage(const std::vector<uint8_t> &bytestream) {
-	
-	constexpr uint8_t coreMiniMessageHeaderSize = 28;
-	
+namespace icsneo {
+
+const size_t HardwareA2BPacket::coreMiniMessageHeaderSize = 28;
+const size_t HardwareA2BPacket::a2bMessageMaxLength = (size_t)HardwareA2BPacket::coreMiniMessageHeaderSize + 1024;
+const size_t HardwareA2BPacket::a2bHeaderSize = 6;
+
+std::shared_ptr<Message> HardwareA2BPacket::DecodeToMessage(const std::vector<uint8_t>& bytestream) {
+
 	if(bytestream.size() < coreMiniMessageHeaderSize)
 	{
 		return nullptr;
@@ -31,9 +33,14 @@ std::shared_ptr<Message> HardwareA2BPacket::DecodeToMessage(const std::vector<ui
 	uint8_t bytesPerChannel = data->header.channelSize16 ? 2 : 4;
 	uint8_t numChannels = data->header.channelNum;
 	uint8_t bitDepth = data->header.channelSize16 ? A2BPCM_L16 : A2BPCM_L24;
-	bool monitor = data->header.monitor;
 
-	std::shared_ptr<A2BMessage> msg = std::make_shared<A2BMessage>(bitDepth, bytesPerChannel, numChannels, monitor);
+	std::shared_ptr<A2BMessage> msg = std::make_shared<A2BMessage>(bitDepth, bytesPerChannel, numChannels);
+	msg->channelSize16 = data->header.channelSize16;
+	msg->monitor = data->header.monitor;
+	msg->txmsg = data->header.txmsg;
+	msg->errIndicator = data->header.errIndicator;
+	msg->syncFrame = data->header.syncFrame;
+	msg->rfu2 = data->header.rfu2;
 
 	const uint8_t *bytes = bytestream.data();
 	bytes+=coreMiniMessageHeaderSize;
@@ -58,3 +65,99 @@ std::shared_ptr<Message> HardwareA2BPacket::DecodeToMessage(const std::vector<ui
 
 	return msg;
 }
+
+bool HardwareA2BPacket::EncodeFromMessage(const A2BMessage& message, std::vector<uint8_t>& bytestream, const device_eventhandler_t& report) {
+
+	if(message.getBytesPerSample() != 2 && message.getBytesPerSample() != 4) {
+		report(APIEvent::Type::MessageFormattingError, APIEvent::Severity::Error);
+		return false;
+	}
+
+	size_t sampleBytes = message.getNumSamples() * static_cast<size_t>(message.getBytesPerSample());
+	size_t totalSize = coreMiniMessageHeaderSize + sampleBytes;
+
+	if(totalSize > a2bMessageMaxLength) {
+		report(APIEvent::Type::MessageMaxLengthExceeded, APIEvent::Severity::Error);
+		return false;
+	}
+
+	bytestream.reserve(totalSize);
+
+	bytestream.push_back(message.getNumChannels());
+	bytestream.push_back(message.channelSize16 ? 1 : 0);
+	
+	uint8_t a2b2Bits = 0;
+	
+	if(message.monitor) {
+		a2b2Bits = a2b2Bits | 1;
+	}
+
+	if(message.txmsg) {
+		a2b2Bits = a2b2Bits | (1 << 1);
+	}
+
+	if(message.errIndicator) {
+		a2b2Bits = a2b2Bits | (1 << 2);
+	}
+
+	if(message.syncFrame) {
+		a2b2Bits = a2b2Bits | (1 << 3);
+	}
+
+	bytestream.push_back(a2b2Bits);
+	bytestream.push_back(0);
+	bytestream.push_back(static_cast<uint8_t>(message.rfu2));
+	bytestream.push_back(static_cast<uint8_t>(message.rfu2 >> 8));
+
+	for(size_t i = 0; i < (coreMiniMessageHeaderSize - a2bHeaderSize); i++)
+		bytestream.push_back(0);
+
+	uint8_t numChannels = message.getNumChannels();
+
+	uint8_t channel = 0;
+	uint32_t frame = 0;
+
+	auto writeSample = [&](A2BPCMSample&& sample) {
+		for(uint32_t i = 0; i < static_cast<uint32_t>(message.getBytesPerSample()); i++) {
+			bytestream.push_back(static_cast<uint8_t>((sample >> (i*8))));
+		}
+	};
+
+	while(true) {
+		auto dsSample = message.getSample(A2BMessage::A2BDirection::DownStream, channel, frame);
+		auto usSample = message.getSample(A2BMessage::A2BDirection::UpStream, channel, frame);
+
+
+		// Check if getSample failed for both downstream and upstream
+		if(!dsSample && !usSample) {
+
+			if(channel != 0) {
+				//Incomplete frame, the frame we are currently on does not contain all channel samples
+				report(APIEvent::Type::A2BMessageIncompleteFrame, APIEvent::Severity::Error);
+				return false;
+			}
+			// Since no samples have been written for the current frame yet and there are no more
+			// samples in both upstream and downstream, we can break and end parsing.
+			break;
+		}
+		// Since the first case failed, at least one of the streams still has samples.
+		// This case checks to see if the other stream does not have a sample.
+		else if(!dsSample || !usSample) {
+			// Report an error since we must have a one to one correspondence between upstream
+			// and downstream.
+			report(APIEvent::Type::A2BMessageIncompleteFrame, APIEvent::Severity::Error);
+			return false;
+		}
+		
+		writeSample(std::move(dsSample.value()));
+		writeSample(std::move(usSample.value()));
+
+		channel = (channel + 1) % numChannels;
+		if(channel == 0) 
+			frame++;
+	}
+
+	return true;
+}
+
+}