fixed: 15 and 16 byte frames didn't fit and couldn't be sent

closes #443

src/libcec/adapter/Pulse-Eight/USBCECAdapterCommands.cpp

@@ -69,11 +69,13 @@ cec_datapacket CUSBCECAdapterCommands::RequestSetting(cec_adapter_messagecode ms
 
   CCECAdapterMessage params;
   CCECAdapterMessage *message = m_comm->SendCommand(msgCode, params);
-  if (message && message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED)
+  if (!!message &&
+      (message->state == ADAPTER_MESSAGE_STATE_SENT_ACKED) &&
+      (message->m_rx_len >= 3))
   {
-    retVal = message->response;
-    retVal.Shift(2); // shift out start and msgcode
-    retVal.size -= 1; // remove end
+    // shift out start, msgcode and end
+    memcpy(retVal.data, &message->m_rx_data[2], message->m_rx_len - 3);
+    retVal.size = message->m_rx_len - 3;
   }
 
   SAFE_DELETE(message);

src/libcec/adapter/Pulse-Eight/USBCECAdapterCommunication.cpp

@@ -380,7 +380,7 @@ bool CUSBCECAdapterCommunication::WriteToDevice(CCECAdapterMessage *message)
   }
 
   /* write the message */
-  if (m_port->Write(message->packet.data, message->Size()) != (ssize_t) message->Size())
+  if (m_port->Write(message->m_tx_data, message->m_tx_len) != (ssize_t)message->m_tx_len)
   {
     LIB_CEC->AddLog(CEC_LOG_DEBUG, "error writing command '%s' to serial port '%s': %s", CCECAdapterMessage::ToString(message->Message()), m_port->GetName().c_str(), m_port->GetError().c_str());
     message->state = ADAPTER_MESSAGE_STATE_ERROR;

src/libcec/adapter/Pulse-Eight/USBCECAdapterMessage.cpp

@@ -244,54 +244,48 @@ const char *CCECAdapterMessage::ToString(cec_adapter_messagecode msgCode)
 
 uint8_t CCECAdapterMessage::operator[](uint8_t pos) const
 {
-  return pos < packet.size ? packet[pos] : 0;
+  return (pos < m_tx_len) ? m_tx_data[pos] : 0;
 }
 
 uint8_t CCECAdapterMessage::At(uint8_t pos) const
 {
-  return pos < packet.size ? packet[pos] : 0;
+  return (pos < m_tx_len) ? m_tx_data[pos] : 0;
 }
 
 uint8_t CCECAdapterMessage::Size(void) const
 {
-  return packet.size;
+  return m_tx_len;
 }
 
 bool CCECAdapterMessage::IsEmpty(void) const
 {
-  return packet.IsEmpty();
+  return (m_tx_len == 0);
 }
 
 void CCECAdapterMessage::Clear(void)
 {
-  state               = ADAPTER_MESSAGE_STATE_UNKNOWN;
-  transmit_timeout    = CEC_DEFAULT_TRANSMIT_TIMEOUT;
-  response.Clear();
-  packet.Clear();
-  lineTimeout         = 3;
-  bNextByteIsEscaped  = false;
-  bFireAndForget      = false;
-}
-
-void CCECAdapterMessage::Shift(uint8_t iShiftBy)
-{
-  packet.Shift(iShiftBy);
+  state              = ADAPTER_MESSAGE_STATE_UNKNOWN;
+  transmit_timeout   = CEC_DEFAULT_TRANSMIT_TIMEOUT;
+  lineTimeout        = 3;
+  bNextByteIsEscaped = false;
+  bFireAndForget     = false;
+  m_tx_len         = 0;
+  m_rx_len     = 0;
 }
 
 void CCECAdapterMessage::Append(CCECAdapterMessage &data)
 {
-  Append(data.packet);
-}
-
-void CCECAdapterMessage::Append(cec_datapacket &data)
-{
-  for (uint8_t iPtr = 0; iPtr < data.size; iPtr++)
-    PushBack(data[iPtr]);
+  uint8_t len = data.m_tx_len;
+  if (len + m_tx_len > USBCEC_MAX_MSG_SIZE)
+    len = USBCEC_MAX_MSG_SIZE - m_tx_len;
+  memcpy(&m_tx_data[m_tx_len], data.m_tx_data, len);
+  m_tx_len += len;
 }
 
 void CCECAdapterMessage::PushBack(uint8_t byte)
 {
-  packet.PushBack(byte);
+  if (m_tx_len < USBCEC_MAX_MSG_SIZE)
+    m_tx_data[m_tx_len++] = byte;
 }
 
 void CCECAdapterMessage::PushEscaped(uint8_t byte)
@@ -336,15 +330,15 @@ bool CCECAdapterMessage::PushReceivedByte(uint8_t byte)
 
 cec_adapter_messagecode CCECAdapterMessage::Message(void) const
 {
-  return packet.size >= 2 ?
-      (cec_adapter_messagecode) (packet.At(1) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
+  return (m_tx_len >= 2) ?
+      (cec_adapter_messagecode) (m_tx_data[1] & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
       MSGCODE_NOTHING;
 }
 
 cec_adapter_messagecode CCECAdapterMessage::ResponseTo(void) const
 {
-  return packet.size >= 3 ?
-      (cec_adapter_messagecode) (packet.At(2) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
+  return (m_tx_len >= 3) ?
+      (cec_adapter_messagecode) (m_tx_data[2] & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
       MSGCODE_NOTHING;
 }
 
@@ -370,15 +364,15 @@ bool CCECAdapterMessage::IsTransmission(void) const
 
 bool CCECAdapterMessage::IsEOM(void) const
 {
-  return packet.size >= 2 ?
-      (packet.At(1) & MSGCODE_FRAME_EOM) != 0 :
+  return (m_tx_len >= 2) ?
+      (m_tx_data[1] & MSGCODE_FRAME_EOM) != 0 :
       false;
 }
 
 bool CCECAdapterMessage::IsACK(void) const
 {
-  return packet.size >= 2 ?
-      (packet.At(1) & MSGCODE_FRAME_ACK) != 0 :
+  return (m_tx_len >= 2) ?
+      (m_tx_data[1] & MSGCODE_FRAME_ACK) != 0 :
       false;
 }
 
@@ -418,21 +412,22 @@ bool CCECAdapterMessage::NeedsRetry(void) const
 
 cec_logical_address CCECAdapterMessage::Initiator(void) const
 {
-  return packet.size >= 3 ?
-      (cec_logical_address) (packet.At(2) >> 4) :
+  return (m_tx_len >= 3) ?
+      (cec_logical_address) (m_tx_data[2] >> 4) :
       CECDEVICE_UNKNOWN;
 }
 
 cec_logical_address CCECAdapterMessage::Destination(void) const
 {
-  return packet.size >= 3 ?
-      (cec_logical_address) (packet.At(2) & 0xF) :
+  return (m_tx_len >= 3) ?
+      (cec_logical_address) (m_tx_data[2] & 0xF) :
       CECDEVICE_UNKNOWN;
 }
 
 bool CCECAdapterMessage::HasStartMessage(void) const
 {
-  return packet.size >= 1 && packet.At(0) == MSGSTART;
+  return (m_tx_len >= 1) &&
+      (m_tx_data[0] == MSGSTART);
 }
 
 bool CCECAdapterMessage::PushToCecCommand(cec_command &command) const
@@ -469,7 +464,7 @@ bool CCECAdapterMessage::PushToCecCommand(cec_command &command) const
 
 cec_adapter_messagecode CCECAdapterMessage::Reply(void) const
 {
-  return response.size >= 2 ?
-      (cec_adapter_messagecode) (response.At(1) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
+  return (m_rx_len >= 2) ?
+      (cec_adapter_messagecode) (m_rx_data[1] & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
       MSGCODE_NOTHING;
 }

src/libcec/adapter/Pulse-Eight/USBCECAdapterMessage.h

@@ -95,6 +95,8 @@ namespace CEC
     P8_ADAPTERTYPE_DAUGHTERBOARD,
   } p8_cec_adapter_type;
 
+  #define USBCEC_MAX_MSG_SIZE   (18 * 4)
+
   class CCECAdapterMessage
   {
   public:
@@ -145,24 +147,12 @@ namespace CEC
      */
     void Clear(void);
 
-    /*!
-     * @brief Shift the message by the given number of bytes.
-     * @param iShiftBy The number of bytes to shift.
-     */
-    void Shift(uint8_t iShiftBy);
-
     /*!
      * @brief Append the given message to this message.
      * @param data The message to append.
      */
     void Append(CCECAdapterMessage &data);
 
-    /*!
-     * @brief Append the given datapacket to this message.
-     * @param data The packet to add.
-     */
-    void Append(cec_datapacket &data);
-
     /*!
      * @brief Adds a byte to this message. Does not escape the byte.
      * @param byte The byte to add.
@@ -256,8 +246,10 @@ namespace CEC
      */
     cec_adapter_messagecode Reply(void) const;
 
-    cec_datapacket                        response;             /**< the response to this message */
-    cec_datapacket                        packet;               /**< the actual data */
+    uint8_t                               m_tx_data[USBCEC_MAX_MSG_SIZE];
+    uint8_t                               m_tx_len;
+    uint8_t                               m_rx_data[USBCEC_MAX_MSG_SIZE];
+    uint8_t                               m_rx_len;
     cec_adapter_message_state             state;                /**< the current state of this message */
     int32_t                               transmit_timeout;     /**< the timeout to use when sending this message */
     uint8_t                               lineTimeout;          /**< the default CEC line timeout to use when sending this message */

src/libcec/adapter/Pulse-Eight/USBCECAdapterMessageQueue.cpp

@@ -214,7 +214,8 @@ bool CCECAdapterMessageQueueEntry::MessageReceivedCommandAccepted(const CCECAdap
       if (!m_message->IsTransmission() && m_iPacketsLeft == 0)
       {
         m_message->state = ADAPTER_MESSAGE_STATE_SENT_ACKED;
-        m_message->response = message.packet;
+        memcpy(m_message->m_rx_data, message.m_tx_data, message.m_tx_len);
+        m_message->m_rx_len = message.m_tx_len;
         bSendSignal = true;
       }
       bHandled = true;
@@ -238,7 +239,8 @@ bool CCECAdapterMessageQueueEntry::MessageReceivedTransmitSucceeded(const CCECAd
       m_queue->m_com->m_callback->GetLib()->AddLog(CEC_LOG_DEBUG, "%s - transmit succeeded", m_message->ToString().c_str());
 #endif
       m_message->state = ADAPTER_MESSAGE_STATE_SENT_ACKED;
-      m_message->response = message.packet;
+      memcpy(m_message->m_rx_data, message.m_tx_data, message.m_tx_len);
+      m_message->m_rx_len = message.m_tx_len;
       m_queue->m_com->OnTxAck();
     }
     else
@@ -269,7 +271,8 @@ bool CCECAdapterMessageQueueEntry::MessageReceivedResponse(const CCECAdapterMess
         m_queue->m_com->OnTxError();
     }
 #endif
-    m_message->response = message.packet;
+    memcpy(m_message->m_rx_data, message.m_tx_data, message.m_tx_len);
+    m_message->m_rx_len = message.m_tx_len;
     if (m_message->IsTransmission())
     {
       if (message.Message() == MSGCODE_TRANSMIT_SUCCEEDED)
@@ -417,25 +420,14 @@ void CCECAdapterMessageQueue::MessageReceived(const CCECAdapterMessage &msg)
   }
 }
 
-void CCECAdapterMessageQueue::AddData(uint8_t *data, size_t iLen)
+void CCECAdapterMessageQueue::AddData(uint8_t *data, size_t len)
 {
-  for (size_t iPtr = 0; iPtr < iLen; iPtr++)
+  for (size_t ptr = 0; ptr < len; ++ptr)
   {
-    bool bFullMessage(false);
+    if (m_incomingAdapterMessage->PushReceivedByte(data[ptr]))
     {
-      CLockObject lock(m_mutex);
-      bFullMessage = m_incomingAdapterMessage->PushReceivedByte(data[iPtr]);
-    }
-
-    if (bFullMessage)
-    {
-      /* a full message was received */
-      CCECAdapterMessage newMessage;
-      newMessage.packet = m_incomingAdapterMessage->packet;
-      MessageReceived(newMessage);
-
-      /* clear the current message */
-      CLockObject lock(m_mutex);
+      // a full message was received
+      MessageReceived(*m_incomingAdapterMessage);
       m_incomingAdapterMessage->Clear();
     }
   }