[deb_libcec.git] / src / lib / adapter / USBCECAdapterMessage.h

#pragma once
/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited.  All rights reserved.
 * libCEC(R) is an original work, containing original code.
 *
 * libCEC(R) is a trademark of Pulse-Eight Limited.
 *
 * This program is dual-licensed; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * Alternatively, you can license this library under a commercial license,
 * please contact Pulse-Eight Licensing for more information.
 *
 * For more information contact:
 * Pulse-Eight Licensing       <license@pulse-eight.com>
 *     http://www.pulse-eight.com/
 *     http://www.pulse-eight.net/
 */

#include "../platform/util/StdString.h"

namespace CEC
{
  class CCECAdapterMessage
  {
  public:
    CCECAdapterMessage(void) :
        event(false)
    {
      Clear();
    }

    CCECAdapterMessage(const cec_command &command)
    {
      Clear();

      //set ack polarity to high when transmitting to the broadcast address
      //set ack polarity low when transmitting to any other address
      PushBack(MSGSTART);
      PushEscaped(MSGCODE_TRANSMIT_ACK_POLARITY);
      if (command.destination == CECDEVICE_BROADCAST)
        PushEscaped(CEC_TRUE);
      else
        PushEscaped(CEC_FALSE);
      PushBack(MSGEND);

      // add source and destination
      PushBack(MSGSTART);
      PushEscaped(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
      PushBack(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
      PushBack(MSGEND);

      // add opcode
      if (command.opcode_set == 1)
      {
        PushBack(MSGSTART);
        PushEscaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
        PushBack((uint8_t) command.opcode);
        PushBack(MSGEND);

        // add parameters
        for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
        {
          PushBack(MSGSTART);

          if (iPtr == command.parameters.size - 1)
            PushEscaped( MSGCODE_TRANSMIT_EOM);
          else
            PushEscaped(MSGCODE_TRANSMIT);

          PushEscaped(command.parameters[iPtr]);

          PushBack(MSGEND);
        }
      }

      // set timeout
      transmit_timeout = command.transmit_timeout;
      //TODO
    }

    CCECAdapterMessage &operator=(const CCECAdapterMessage &msg)
    {
      packet = msg.packet;
      state  = msg.state;
      return *this;
    }

    CStdString ToString(void) const
    {
      CStdString strMsg;
      if (Size() == 0)
      {
        strMsg = "empty message";
      }
      else
      {
        strMsg = ToString(Message());

        switch (Message())
        {
        case MSGCODE_TIMEOUT_ERROR:
        case MSGCODE_HIGH_ERROR:
        case MSGCODE_LOW_ERROR:
          {
            uint32_t iLine = (Size() >= 3) ? (At(1) << 8) | At(2) : 0;
            uint32_t iTime = (Size() >= 7) ? (At(3) << 24) | (At(4) << 16) | (At(5) << 8) | At(6) : 0;
            strMsg.AppendFormat(" line:%u", iLine);
            strMsg.AppendFormat(" time:%u", iTime);
          }
          break;
        case MSGCODE_FRAME_START:
          if (Size() >= 2)
            strMsg.AppendFormat(" initiator:%1x destination:%1x ack:%s %s", Initiator(), Destination(), IsACK() ? "high" : "low", IsEOM() ? "eom" : "");
          break;
        case MSGCODE_FRAME_DATA:
          if (Size() >= 2)
            strMsg.AppendFormat(" %02x %s", At(1), IsEOM() ? "eom" : "");
          break;
        default:
          break;
        }
      }

      return strMsg;
    }

    static const char *ToString(cec_adapter_messagecode msgCode)
    {
      switch (msgCode)
      {
      case MSGCODE_NOTHING:
        return "NOTHING";
      case MSGCODE_PING:
        return "PING";
      case MSGCODE_TIMEOUT_ERROR:
        return "TIMEOUT";
      case MSGCODE_HIGH_ERROR:
        return "HIGH_ERROR";
      case MSGCODE_LOW_ERROR:
        return "LOW_ERROR";
      case MSGCODE_FRAME_START:
        return "FRAME_START";
      case MSGCODE_FRAME_DATA:
        return "FRAME_DATA";
      case MSGCODE_RECEIVE_FAILED:
        return "RECEIVE_FAILED";
      case MSGCODE_COMMAND_ACCEPTED:
        return "COMMAND_ACCEPTED";
      case MSGCODE_COMMAND_REJECTED:
        return "COMMAND_REJECTED";
      case MSGCODE_SET_ACK_MASK:
        return "SET_ACK_MASK";
      case MSGCODE_TRANSMIT:
        return "TRANSMIT";
      case MSGCODE_TRANSMIT_EOM:
        return "TRANSMIT_EOM";
      case MSGCODE_TRANSMIT_IDLETIME:
        return "TRANSMIT_IDLETIME";
      case MSGCODE_TRANSMIT_ACK_POLARITY:
        return "TRANSMIT_ACK_POLARITY";
      case MSGCODE_TRANSMIT_LINE_TIMEOUT:
        return "TRANSMIT_LINE_TIMEOUT";
      case MSGCODE_TRANSMIT_SUCCEEDED:
        return "TRANSMIT_SUCCEEDED";
      case MSGCODE_TRANSMIT_FAILED_LINE:
        return "TRANSMIT_FAILED_LINE";
      case MSGCODE_TRANSMIT_FAILED_ACK:
        return "TRANSMIT_FAILED_ACK";
      case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
        return "TRANSMIT_FAILED_TIMEOUT_DATA";
      case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
        return "TRANSMIT_FAILED_TIMEOUT_LINE";
      case MSGCODE_FIRMWARE_VERSION:
        return "FIRMWARE_VERSION";
      case MSGCODE_START_BOOTLOADER:
        return "START_BOOTLOADER";
      case MSGCODE_FRAME_EOM:
        return "FRAME_EOM";
      case MSGCODE_FRAME_ACK:
        return "FRAME_ACK";
      case MSGCODE_SET_POWERSTATE:
        return "SET_POWERSTATE";
      case MSGCODE_SET_CONTROLLED:
        return "SET_CONTROLLED";
      case MSGCODE_GET_AUTO_ENABLED:
        return "GET_AUTO_ENABLED";
      case MSGCODE_SET_AUTO_ENABLED:
        return "SET_AUTO_ENABLED";
      case MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS:
        return "GET_DEFAULT_LOGICAL_ADDRESS";
      case MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS:
        return "SET_DEFAULT_LOGICAL_ADDRESS";
      case MSGCODE_GET_LOGICAL_ADDRESS_MASK:
        return "GET_LOGICAL_ADDRESS_MASK";
      case MSGCODE_SET_LOGICAL_ADDRESS_MASK:
        return "SET_LOGICAL_ADDRESS_MASK";
      case MSGCODE_GET_PHYSICAL_ADDRESS:
        return "GET_PHYSICAL_ADDRESS";
      case MSGCODE_SET_PHYSICAL_ADDRESS:
        return "SET_PHYSICAL_ADDRESS";
      case MSGCODE_GET_DEVICE_TYPE:
        return "GET_DEVICE_TYPE";
      case MSGCODE_SET_DEVICE_TYPE:
        return "SET_DEVICE_TYPE";
      case MSGCODE_GET_HDMI_VERSION:
        return "GET_HDMI_VERSION";
      case MSGCODE_SET_HDMI_VERSION:
        return "SET_HDMI_VERSION";
      case MSGCODE_GET_OSD_NAME:
        return "GET_OSD_NAME";
      case MSGCODE_SET_OSD_NAME:
        return "SET_OSD_NAME";
      case MSGCODE_WRITE_EEPROM:
        return "WRITE_EEPROM";
      }

      return "unknown";
    }

    uint8_t operator[](uint8_t pos) const
    {
      return packet[pos];
    }

    uint8_t At(uint8_t pos) const
    {
      return packet[pos];
    }

    uint8_t Size(void) const
    {
      return packet.size;
    }

    bool IsEmpty(void) const
    {
      return packet.IsEmpty();
    }

    void Clear(void)
    {
      state               = ADAPTER_MESSAGE_STATE_UNKNOWN;
      transmit_timeout    = CEC_DEFAULT_TRANSMIT_TIMEOUT;
      packet.Clear();
      maxTries            = CEC_DEFAULT_TRANSMIT_RETRIES + 1;
      tries               = 0;
      reply               = MSGCODE_NOTHING;
      isTransmission      = true;
      expectControllerAck = true;
      lineTimeout         = 3;
      retryTimeout        = 3;
    }

    void Shift(uint8_t iShiftBy)
    {
      packet.Shift(iShiftBy);
    }

    void Append(CCECAdapterMessage &data)
    {
      Append(data.packet);
    }

    void Append(cec_datapacket &data)
    {
      for (uint8_t iPtr = 0; iPtr < data.size; iPtr++)
        PushBack(data[iPtr]);
    }

    void PushBack(uint8_t add)
    {
      packet.PushBack(add);
    }

    void PushEscaped(uint8_t byte)
    {
      if (byte >= MSGESC)
      {
        PushBack(MSGESC);
        PushBack(byte - ESCOFFSET);
      }
      else
      {
        PushBack(byte);
      }
    }

    cec_adapter_messagecode Message(void) const
    {
      return packet.size >= 1 ?
          (cec_adapter_messagecode) (packet.At(0) & ~(MSGCODE_FRAME_EOM | MSGCODE_FRAME_ACK)) :
          MSGCODE_NOTHING;
    }

    bool IsEOM(void) const
    {
      return packet.size >= 1 ?
          (packet.At(0) & MSGCODE_FRAME_EOM) != 0 :
          false;
    }

    bool IsACK(void) const
    {
      return packet.size >= 1 ?
          (packet.At(0) & MSGCODE_FRAME_ACK) != 0 :
          false;
    }

    bool IsError(void) const
    {
      cec_adapter_messagecode code = Message();
      return (code == MSGCODE_HIGH_ERROR ||
              code == MSGCODE_LOW_ERROR ||
              code == MSGCODE_RECEIVE_FAILED ||
              code == MSGCODE_COMMAND_REJECTED ||
              code == MSGCODE_TRANSMIT_LINE_TIMEOUT ||
              code == MSGCODE_TRANSMIT_FAILED_LINE ||
              code == MSGCODE_TRANSMIT_FAILED_ACK ||
              code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
              code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE);
    }

    bool NeedsRetry(void) const
    {
      return reply == MSGCODE_NOTHING ||
             reply == MSGCODE_RECEIVE_FAILED ||
             reply == MSGCODE_TIMEOUT_ERROR ||
             reply == MSGCODE_TRANSMIT_FAILED_LINE ||
             reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA ||
             reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE ||
             reply == MSGCODE_TRANSMIT_LINE_TIMEOUT;
    }

    cec_logical_address Initiator(void) const
    {
      return packet.size >= 2 ?
          (cec_logical_address) (packet.At(1) >> 4) :
          CECDEVICE_UNKNOWN;
    }

    cec_logical_address Destination(void) const
    {
      return packet.size >= 2 ?
          (cec_logical_address) (packet.At(1) & 0xF) :
          CECDEVICE_UNKNOWN;
    }

    uint8_t                               maxTries;
    uint8_t                               tries;
    cec_adapter_messagecode               reply;
    cec_datapacket                        packet;
    cec_adapter_message_state             state;
    int32_t                               transmit_timeout;
    bool                                  isTransmission;
    bool                                  expectControllerAck;
    uint8_t                               lineTimeout;
    uint8_t                               retryTimeout;
    PLATFORM::CEvent                      event;
  };
}
Commit	Line	Data
ef7696f5 LOK	1	#pragma once
	2	/*
	3	* This file is part of the libCEC(R) library.
	4	*
b492c10e	5	* libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
ef7696f5 LOK	6	* libCEC(R) is an original work, containing original code.
	7	*
	8	* libCEC(R) is a trademark of Pulse-Eight Limited.
	9	*
	10	* This program is dual-licensed; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software
	22	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23	*
	24	*
	25	* Alternatively, you can license this library under a commercial license,
	26	* please contact Pulse-Eight Licensing for more information.
	27	*
	28	* For more information contact:
	29	* Pulse-Eight Licensing <license@pulse-eight.com>
	30	* http://www.pulse-eight.com/
	31	* http://www.pulse-eight.net/
	32	*/
	33
24048d57	34	#include "../platform/util/StdString.h"
ba65909d	35
ef7696f5 LOK	36	namespace CEC
ef7696f5 LOK	37	{
ef7696f5 LOK	38	class CCECAdapterMessage
	39	{
	40	public:
de49d80b LOK	41	CCECAdapterMessage(void) :
de49d80b LOK	42	event(false)
ef7696f5 LOK	43	{
	44	Clear();
	45	}
	46
	47	CCECAdapterMessage(const cec_command &command)
	48	{
	49	Clear();
	50
	51	//set ack polarity to high when transmitting to the broadcast address
	52	//set ack polarity low when transmitting to any other address
	53	PushBack(MSGSTART);
	54	PushEscaped(MSGCODE_TRANSMIT_ACK_POLARITY);
	55	if (command.destination == CECDEVICE_BROADCAST)
	56	PushEscaped(CEC_TRUE);
	57	else
	58	PushEscaped(CEC_FALSE);
	59	PushBack(MSGEND);
	60
	61	// add source and destination
	62	PushBack(MSGSTART);
	63	PushEscaped(command.opcode_set == 0 ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
	64	PushBack(((uint8_t)command.initiator << 4) + (uint8_t)command.destination);
	65	PushBack(MSGEND);
	66
	67	// add opcode
	68	if (command.opcode_set == 1)
	69	{
	70	PushBack(MSGSTART);
	71	PushEscaped(command.parameters.IsEmpty() ? (uint8_t)MSGCODE_TRANSMIT_EOM : (uint8_t)MSGCODE_TRANSMIT);
	72	PushBack((uint8_t) command.opcode);
	73	PushBack(MSGEND);
	74
	75	// add parameters
	76	for (int8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
	77	{
	78	PushBack(MSGSTART);
	79
	80	if (iPtr == command.parameters.size - 1)
	81	PushEscaped( MSGCODE_TRANSMIT_EOM);
	82	else
	83	PushEscaped(MSGCODE_TRANSMIT);
	84
	85	PushEscaped(command.parameters[iPtr]);
	86
	87	PushBack(MSGEND);
	88	}
	89	}
	90
	91	// set timeout
	92	transmit_timeout = command.transmit_timeout;
5dcf9f25	93	//TODO
ef7696f5 LOK	94	}
	95
	96	CCECAdapterMessage &operator=(const CCECAdapterMessage &msg)
	97	{
	98	packet = msg.packet;
	99	state = msg.state;
	100	return *this;
	101	}
	102
	103	CStdString ToString(void) const
	104	{
	105	CStdString strMsg;
	106	if (Size() == 0)
	107	{
	108	strMsg = "empty message";
	109	}
	110	else
	111	{
7a87e02e	112	strMsg = ToString(Message());
ef7696f5 LOK	113
	114	switch (Message())
	115	{
	116	case MSGCODE_TIMEOUT_ERROR:
	117	case MSGCODE_HIGH_ERROR:
	118	case MSGCODE_LOW_ERROR:
	119	{
	120	uint32_t iLine = (Size() >= 3) ? (At(1) << 8) \| At(2) : 0;
	121	uint32_t iTime = (Size() >= 7) ? (At(3) << 24) \| (At(4) << 16) \| (At(5) << 8) \| At(6) : 0;
	122	strMsg.AppendFormat(" line:%u", iLine);
	123	strMsg.AppendFormat(" time:%u", iTime);
	124	}
	125	break;
	126	case MSGCODE_FRAME_START:
	127	if (Size() >= 2)
	128	strMsg.AppendFormat(" initiator:%1x destination:%1x ack:%s %s", Initiator(), Destination(), IsACK() ? "high" : "low", IsEOM() ? "eom" : "");
	129	break;
	130	case MSGCODE_FRAME_DATA:
	131	if (Size() >= 2)
	132	strMsg.AppendFormat(" %02x %s", At(1), IsEOM() ? "eom" : "");
	133	break;
	134	default:
	135	break;
	136	}
	137	}
	138
	139	return strMsg;
	140	}
	141
7a87e02e	142	static const char *ToString(cec_adapter_messagecode msgCode)
ef7696f5	143	{
7a87e02e	144	switch (msgCode)
ef7696f5 LOK	145	{
ef7696f5 LOK	146	case MSGCODE_NOTHING:
7a87e02e	147	return "NOTHING";
ef7696f5	148	case MSGCODE_PING:
7a87e02e	149	return "PING";
ef7696f5	150	case MSGCODE_TIMEOUT_ERROR:
7a87e02e	151	return "TIMEOUT";
ef7696f5	152	case MSGCODE_HIGH_ERROR:
7a87e02e	153	return "HIGH_ERROR";
ef7696f5	154	case MSGCODE_LOW_ERROR:
7a87e02e	155	return "LOW_ERROR";
ef7696f5	156	case MSGCODE_FRAME_START:
7a87e02e	157	return "FRAME_START";
ef7696f5	158	case MSGCODE_FRAME_DATA:
7a87e02e	159	return "FRAME_DATA";
ef7696f5	160	case MSGCODE_RECEIVE_FAILED:
7a87e02e	161	return "RECEIVE_FAILED";
ef7696f5	162	case MSGCODE_COMMAND_ACCEPTED:
7a87e02e	163	return "COMMAND_ACCEPTED";
ef7696f5	164	case MSGCODE_COMMAND_REJECTED:
7a87e02e	165	return "COMMAND_REJECTED";
ef7696f5	166	case MSGCODE_SET_ACK_MASK:
7a87e02e	167	return "SET_ACK_MASK";
ef7696f5	168	case MSGCODE_TRANSMIT:
7a87e02e	169	return "TRANSMIT";
ef7696f5	170	case MSGCODE_TRANSMIT_EOM:
7a87e02e	171	return "TRANSMIT_EOM";
ef7696f5	172	case MSGCODE_TRANSMIT_IDLETIME:
7a87e02e	173	return "TRANSMIT_IDLETIME";
ef7696f5	174	case MSGCODE_TRANSMIT_ACK_POLARITY:
7a87e02e	175	return "TRANSMIT_ACK_POLARITY";
ef7696f5	176	case MSGCODE_TRANSMIT_LINE_TIMEOUT:
7a87e02e	177	return "TRANSMIT_LINE_TIMEOUT";
ef7696f5	178	case MSGCODE_TRANSMIT_SUCCEEDED:
7a87e02e	179	return "TRANSMIT_SUCCEEDED";
ef7696f5	180	case MSGCODE_TRANSMIT_FAILED_LINE:
7a87e02e	181	return "TRANSMIT_FAILED_LINE";
ef7696f5	182	case MSGCODE_TRANSMIT_FAILED_ACK:
7a87e02e	183	return "TRANSMIT_FAILED_ACK";
ef7696f5	184	case MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA:
7a87e02e	185	return "TRANSMIT_FAILED_TIMEOUT_DATA";
ef7696f5	186	case MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE:
7a87e02e	187	return "TRANSMIT_FAILED_TIMEOUT_LINE";
ef7696f5	188	case MSGCODE_FIRMWARE_VERSION:
7a87e02e	189	return "FIRMWARE_VERSION";
ef7696f5	190	case MSGCODE_START_BOOTLOADER:
7a87e02e	191	return "START_BOOTLOADER";
ef7696f5	192	case MSGCODE_FRAME_EOM:
7a87e02e	193	return "FRAME_EOM";
ef7696f5	194	case MSGCODE_FRAME_ACK:
7a87e02e	195	return "FRAME_ACK";
dd4efb6d	196	case MSGCODE_SET_POWERSTATE:
7a87e02e	197	return "SET_POWERSTATE";
dd4efb6d	198	case MSGCODE_SET_CONTROLLED:
7a87e02e	199	return "SET_CONTROLLED";
da59dc5f	200	case MSGCODE_GET_AUTO_ENABLED:
7a87e02e	201	return "GET_AUTO_ENABLED";
da59dc5f	202	case MSGCODE_SET_AUTO_ENABLED:
7a87e02e	203	return "SET_AUTO_ENABLED";
da59dc5f	204	case MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS:
7a87e02e	205	return "GET_DEFAULT_LOGICAL_ADDRESS";
da59dc5f	206	case MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS:
7a87e02e	207	return "SET_DEFAULT_LOGICAL_ADDRESS";
da59dc5f	208	case MSGCODE_GET_LOGICAL_ADDRESS_MASK:
7a87e02e	209	return "GET_LOGICAL_ADDRESS_MASK";
da59dc5f	210	case MSGCODE_SET_LOGICAL_ADDRESS_MASK:
7a87e02e	211	return "SET_LOGICAL_ADDRESS_MASK";
da59dc5f	212	case MSGCODE_GET_PHYSICAL_ADDRESS:
7a87e02e	213	return "GET_PHYSICAL_ADDRESS";
da59dc5f	214	case MSGCODE_SET_PHYSICAL_ADDRESS:
7a87e02e	215	return "SET_PHYSICAL_ADDRESS";
da59dc5f	216	case MSGCODE_GET_DEVICE_TYPE:
7a87e02e	217	return "GET_DEVICE_TYPE";
da59dc5f	218	case MSGCODE_SET_DEVICE_TYPE:
7a87e02e	219	return "SET_DEVICE_TYPE";
da59dc5f	220	case MSGCODE_GET_HDMI_VERSION:
7a87e02e	221	return "GET_HDMI_VERSION";
da59dc5f	222	case MSGCODE_SET_HDMI_VERSION:
7a87e02e	223	return "SET_HDMI_VERSION";
da59dc5f	224	case MSGCODE_GET_OSD_NAME:
7a87e02e	225	return "GET_OSD_NAME";
da59dc5f	226	case MSGCODE_SET_OSD_NAME:
7a87e02e	227	return "SET_OSD_NAME";
da59dc5f	228	case MSGCODE_WRITE_EEPROM:
7a87e02e	229	return "WRITE_EEPROM";
ef7696f5 LOK	230	}
ef7696f5 LOK	231
7a87e02e	232	return "unknown";
ef7696f5 LOK	233	}
	234
	235	uint8_t operator[](uint8_t pos) const
	236	{
	237	return packet[pos];
	238	}
	239
	240	uint8_t At(uint8_t pos) const
	241	{
	242	return packet[pos];
	243	}
	244
	245	uint8_t Size(void) const
	246	{
	247	return packet.size;
	248	}
	249
	250	bool IsEmpty(void) const
	251	{
	252	return packet.IsEmpty();
	253	}
	254
	255	void Clear(void)
	256	{
71c4a2f5	257	state = ADAPTER_MESSAGE_STATE_UNKNOWN;
c71891a3	258	transmit_timeout = CEC_DEFAULT_TRANSMIT_TIMEOUT;
ef7696f5	259	packet.Clear();
71c4a2f5 LOK	260	maxTries = CEC_DEFAULT_TRANSMIT_RETRIES + 1;
	261	tries = 0;
	262	reply = MSGCODE_NOTHING;
	263	isTransmission = true;
	264	expectControllerAck = true;
7bb4ed43 LOK	265	lineTimeout = 3;
7bb4ed43 LOK	266	retryTimeout = 3;
ef7696f5 LOK	267	}
	268
	269	void Shift(uint8_t iShiftBy)
	270	{
	271	packet.Shift(iShiftBy);
	272	}
	273
c9c282a4 LOK	274	void Append(CCECAdapterMessage &data)
	275	{
	276	Append(data.packet);
	277	}
	278
	279	void Append(cec_datapacket &data)
	280	{
	281	for (uint8_t iPtr = 0; iPtr < data.size; iPtr++)
	282	PushBack(data[iPtr]);
	283	}
	284
ef7696f5 LOK	285	void PushBack(uint8_t add)
	286	{
	287	packet.PushBack(add);
	288	}
	289
	290	void PushEscaped(uint8_t byte)
	291	{
	292	if (byte >= MSGESC)
	293	{
	294	PushBack(MSGESC);
	295	PushBack(byte - ESCOFFSET);
	296	}
	297	else
	298	{
	299	PushBack(byte);
	300	}
	301	}
	302
	303	cec_adapter_messagecode Message(void) const
	304	{
	305	return packet.size >= 1 ?
	306	(cec_adapter_messagecode) (packet.At(0) & ~(MSGCODE_FRAME_EOM \| MSGCODE_FRAME_ACK)) :
	307	MSGCODE_NOTHING;
	308	}
	309
	310	bool IsEOM(void) const
	311	{
	312	return packet.size >= 1 ?
	313	(packet.At(0) & MSGCODE_FRAME_EOM) != 0 :
	314	false;
	315	}
	316
	317	bool IsACK(void) const
	318	{
	319	return packet.size >= 1 ?
	320	(packet.At(0) & MSGCODE_FRAME_ACK) != 0 :
	321	false;
	322	}
	323
	324	bool IsError(void) const
	325	{
	326	cec_adapter_messagecode code = Message();
	327	return (code == MSGCODE_HIGH_ERROR \|\|
	328	code == MSGCODE_LOW_ERROR \|\|
	329	code == MSGCODE_RECEIVE_FAILED \|\|
	330	code == MSGCODE_COMMAND_REJECTED \|\|
	331	code == MSGCODE_TRANSMIT_LINE_TIMEOUT \|\|
	332	code == MSGCODE_TRANSMIT_FAILED_LINE \|\|
	333	code == MSGCODE_TRANSMIT_FAILED_ACK \|\|
	334	code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA \|\|
	335	code == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE);
	336	}
	337
	338	bool NeedsRetry(void) const
	339	{
	340	return reply == MSGCODE_NOTHING \|\|
	341	reply == MSGCODE_RECEIVE_FAILED \|\|
	342	reply == MSGCODE_TIMEOUT_ERROR \|\|
	343	reply == MSGCODE_TRANSMIT_FAILED_LINE \|\|
	344	reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA \|\|
	345	reply == MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE \|\|
	346	reply == MSGCODE_TRANSMIT_LINE_TIMEOUT;
	347	}
	348
349	cec_logical_address Initiator(void) const
350	{
351	return packet.size >= 2 ?
352	(cec_logical_address) (packet.At(1) >> 4) :
353	CECDEVICE_UNKNOWN;
354	}
355
356	cec_logical_address Destination(void) const
357	{
358	return packet.size >= 2 ?
359	(cec_logical_address) (packet.At(1) & 0xF) :
360	CECDEVICE_UNKNOWN;
361	}
362
960f33c6 LOK	363	uint8_t maxTries;
	364	uint8_t tries;
	365	cec_adapter_messagecode reply;
	366	cec_datapacket packet;
	367	cec_adapter_message_state state;
	368	int32_t transmit_timeout;
	369	bool isTransmission;
	370	bool expectControllerAck;
	371	uint8_t lineTimeout;
	372	uint8_t retryTimeout;
	373	PLATFORM::CEvent event;
ef7696f5 LOK	374	};
ef7696f5 LOK	375	}