[deb_libcec.git] / src / lib / adapter / Pulse-Eight / 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 "lib/adapter/AdapterCommunication.h"

namespace CEC
{
  typedef enum cec_adapter_messagecode
  {
    MSGCODE_NOTHING = 0,
    MSGCODE_PING,
    MSGCODE_TIMEOUT_ERROR,
    MSGCODE_HIGH_ERROR,
    MSGCODE_LOW_ERROR,
    MSGCODE_FRAME_START,
    MSGCODE_FRAME_DATA,
    MSGCODE_RECEIVE_FAILED,
    MSGCODE_COMMAND_ACCEPTED,
    MSGCODE_COMMAND_REJECTED,
    MSGCODE_SET_ACK_MASK,
    MSGCODE_TRANSMIT,
    MSGCODE_TRANSMIT_EOM,
    MSGCODE_TRANSMIT_IDLETIME,
    MSGCODE_TRANSMIT_ACK_POLARITY,
    MSGCODE_TRANSMIT_LINE_TIMEOUT,
    MSGCODE_TRANSMIT_SUCCEEDED,
    MSGCODE_TRANSMIT_FAILED_LINE,
    MSGCODE_TRANSMIT_FAILED_ACK,
    MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA,
    MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE,
    MSGCODE_FIRMWARE_VERSION,
    MSGCODE_START_BOOTLOADER,
    MSGCODE_GET_BUILDDATE,
    MSGCODE_SET_CONTROLLED,
    MSGCODE_GET_AUTO_ENABLED,
    MSGCODE_SET_AUTO_ENABLED,
    MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS,
    MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS,
    MSGCODE_GET_LOGICAL_ADDRESS_MASK,
    MSGCODE_SET_LOGICAL_ADDRESS_MASK,
    MSGCODE_GET_PHYSICAL_ADDRESS,
    MSGCODE_SET_PHYSICAL_ADDRESS,
    MSGCODE_GET_DEVICE_TYPE,
    MSGCODE_SET_DEVICE_TYPE,
    MSGCODE_GET_HDMI_VERSION,
    MSGCODE_SET_HDMI_VERSION,
    MSGCODE_GET_OSD_NAME,
    MSGCODE_SET_OSD_NAME,
    MSGCODE_WRITE_EEPROM,
    MSGCODE_GET_ADAPTER_TYPE,
    MSGCODE_FRAME_EOM = 0x80,
    MSGCODE_FRAME_ACK = 0x40,
  } cec_adapter_messagecode;

  typedef enum p8_cec_adapter_type
  {
    P8_ADAPTERTYPE_UNKNOWN = 0,
    P8_ADAPTERTYPE_EXTERNAL,
    P8_ADAPTERTYPE_DAUGHTERBOARD,
  } p8_cec_adapter_type;

  class CCECAdapterMessage
  {
  public:
    /*!
     * @brief Create an empty message.
     */
    CCECAdapterMessage(void);

    /*!
     * @brief Create a message with a command that is to be transmitted over the CEC line.
     * @param command The command to transmit.
     * @param iLineTimeout The line timeout to use when sending this message.
     */
    CCECAdapterMessage(const cec_command &command, uint8_t iLineTimeout = 3);

    /*!
     * @return the message as human readable string.
     */
    std::string ToString(void) const;

    /*!
     * @brief Translate the messagecode into a human readable string.
     * @param msgCode The messagecode to translate.
     * @return The messagecode as string.
     */
    static const char *ToString(cec_adapter_messagecode msgCode);

    /*!
     * @brief Get the byte at the given position.
     * @param pos The position to get.
     * @return The requested byte, or 0 when it's out of range.
     */
    uint8_t At(uint8_t pos) const;
    uint8_t operator[](uint8_t pos) const;

    /*!
     * @return The size of the packet in bytes.
     */
    uint8_t Size(void) const;

    /*!
     * @return True when empty, false otherwise.
     */
    bool IsEmpty(void) const;

    /*!
     * @brief Clear this message and reset everything to the initial values.
     */
    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.
     */
    void PushBack(uint8_t byte);

    /*!
     * @brief Adds a byte to this message and escapes the byte if needed.
     * @param byte The byte to add.
     */
    void PushEscaped(uint8_t byte);

    /*!
     * @brief Adds a byte to this message.
     * @param byte The byte to add.
     * @return True when a full message was received, false otherwise.
     */
    bool PushReceivedByte(uint8_t byte);

    /*!
     * @return The messagecode inside this adapter message, or MSGCODE_NOTHING if there is none.
     */
    cec_adapter_messagecode Message(void) const;

    /*!
     * @return The messagecode (if provided) that this message is responding to
     */
    cec_adapter_messagecode ResponseTo(void) const;

    /*!
     * @return True when this message is a transmission, false otherwise.
     */
    bool IsTranmission(void) const;

    /*!
     * @return True when the EOM bit is set, false otherwise.
     */
    bool IsEOM(void) const;

    /*!
     * @return True when the ACK bit is set, false otherwise.
     */
    bool IsACK(void) const;

    /*!
     * @brief Checks whether the given messagecode is an error message.
     * @param code The code to check.
     * @return True when it's an error, false otherwise.
     */
    static bool MessageCodeIsError(const cec_adapter_messagecode code);

    /*!
     * @return True when this message contains an error code, false otherwise.
     */
    bool IsError(void) const;

    /*!
     * @return True when this message has been replied with an error code, false otherwise.
     */
    bool ReplyIsError(void) const;

    /*!
     * @return True when this message has been replied with an error code and needs to be retried, false otherwise.
     */
    bool NeedsRetry(void) const;

    /*!
     * @return The logical address of the initiator, or CECDEVICE_UNKNOWN if unknown.
     */
    cec_logical_address Initiator(void) const;

    /*!
     * @return The logical address of the destination, or CECDEVICE_UNKNOWN if unknown.
     */
    cec_logical_address Destination(void) const;

    /*!
     * @return True when this message contains a start message, false otherwise.
     */
    bool HasStartMessage(void) const;

    /*!
     * @brief Push this adapter message to the end of the given cec_command.
     * @param command The command to push this message to.
     * @return True when a full CEC message was received, false otherwise.
     */
    bool PushToCecCommand(cec_command &command) const;

    /*!
     * @return The response messagecode.
     */
    cec_adapter_messagecode Reply(void) const;

    cec_datapacket                        response;             /**< the response to this message */
    cec_datapacket                        packet;               /**< the actual data */
    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 */
    bool                                  bFireAndForget;       /**< true to auto delete, don't wait for a response */

  private:
    bool                                  bNextByteIsEscaped;   /**< true when the next byte that is added will be escaped, false otherwise */
  };
}
Commit	Line	Data
	1	#pragma once
	2	/*
	3	* This file is part of the libCEC(R) library.
	4	*
	5	* libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
	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
	34	#include "lib/adapter/AdapterCommunication.h"
	35
	36	namespace CEC
	37	{
	38	typedef enum cec_adapter_messagecode
	39	{
	40	MSGCODE_NOTHING = 0,
	41	MSGCODE_PING,
	42	MSGCODE_TIMEOUT_ERROR,
	43	MSGCODE_HIGH_ERROR,
	44	MSGCODE_LOW_ERROR,
	45	MSGCODE_FRAME_START,
	46	MSGCODE_FRAME_DATA,
	47	MSGCODE_RECEIVE_FAILED,
	48	MSGCODE_COMMAND_ACCEPTED,
	49	MSGCODE_COMMAND_REJECTED,
	50	MSGCODE_SET_ACK_MASK,
	51	MSGCODE_TRANSMIT,
	52	MSGCODE_TRANSMIT_EOM,
	53	MSGCODE_TRANSMIT_IDLETIME,
	54	MSGCODE_TRANSMIT_ACK_POLARITY,
	55	MSGCODE_TRANSMIT_LINE_TIMEOUT,
	56	MSGCODE_TRANSMIT_SUCCEEDED,
	57	MSGCODE_TRANSMIT_FAILED_LINE,
	58	MSGCODE_TRANSMIT_FAILED_ACK,
	59	MSGCODE_TRANSMIT_FAILED_TIMEOUT_DATA,
	60	MSGCODE_TRANSMIT_FAILED_TIMEOUT_LINE,
	61	MSGCODE_FIRMWARE_VERSION,
	62	MSGCODE_START_BOOTLOADER,
	63	MSGCODE_GET_BUILDDATE,
	64	MSGCODE_SET_CONTROLLED,
	65	MSGCODE_GET_AUTO_ENABLED,
	66	MSGCODE_SET_AUTO_ENABLED,
	67	MSGCODE_GET_DEFAULT_LOGICAL_ADDRESS,
	68	MSGCODE_SET_DEFAULT_LOGICAL_ADDRESS,
	69	MSGCODE_GET_LOGICAL_ADDRESS_MASK,
	70	MSGCODE_SET_LOGICAL_ADDRESS_MASK,
	71	MSGCODE_GET_PHYSICAL_ADDRESS,
	72	MSGCODE_SET_PHYSICAL_ADDRESS,
	73	MSGCODE_GET_DEVICE_TYPE,
	74	MSGCODE_SET_DEVICE_TYPE,
	75	MSGCODE_GET_HDMI_VERSION,
	76	MSGCODE_SET_HDMI_VERSION,
	77	MSGCODE_GET_OSD_NAME,
	78	MSGCODE_SET_OSD_NAME,
	79	MSGCODE_WRITE_EEPROM,
	80	MSGCODE_GET_ADAPTER_TYPE,
	81	MSGCODE_FRAME_EOM = 0x80,
	82	MSGCODE_FRAME_ACK = 0x40,
	83	} cec_adapter_messagecode;
	84
	85	typedef enum p8_cec_adapter_type
	86	{
	87	P8_ADAPTERTYPE_UNKNOWN = 0,
	88	P8_ADAPTERTYPE_EXTERNAL,
	89	P8_ADAPTERTYPE_DAUGHTERBOARD,
	90	} p8_cec_adapter_type;
	91
	92	class CCECAdapterMessage
	93	{
	94	public:
	95	/*!
	96	* @brief Create an empty message.
	97	*/
	98	CCECAdapterMessage(void);
	99
	100	/*!
	101	* @brief Create a message with a command that is to be transmitted over the CEC line.
	102	* @param command The command to transmit.
	103	* @param iLineTimeout The line timeout to use when sending this message.
	104	*/
	105	CCECAdapterMessage(const cec_command &command, uint8_t iLineTimeout = 3);
	106
	107	/*!
	108	* @return the message as human readable string.
	109	*/
	110	std::string ToString(void) const;
	111
	112	/*!
	113	* @brief Translate the messagecode into a human readable string.
	114	* @param msgCode The messagecode to translate.
	115	* @return The messagecode as string.
	116	*/
	117	static const char *ToString(cec_adapter_messagecode msgCode);
	118
	119	/*!
	120	* @brief Get the byte at the given position.
	121	* @param pos The position to get.
	122	* @return The requested byte, or 0 when it's out of range.
	123	*/
	124	uint8_t At(uint8_t pos) const;
	125	uint8_t operator[](uint8_t pos) const;
	126
	127	/*!
	128	* @return The size of the packet in bytes.
	129	*/
	130	uint8_t Size(void) const;
	131
	132	/*!
	133	* @return True when empty, false otherwise.
	134	*/
	135	bool IsEmpty(void) const;
	136
	137	/*!
	138	* @brief Clear this message and reset everything to the initial values.
	139	*/
	140	void Clear(void);
	141
	142	/*!
	143	* @brief Shift the message by the given number of bytes.
	144	* @param iShiftBy The number of bytes to shift.
	145	*/
	146	void Shift(uint8_t iShiftBy);
	147
	148	/*!
	149	* @brief Append the given message to this message.
	150	* @param data The message to append.
	151	*/
	152	void Append(CCECAdapterMessage &data);
	153
	154	/*!
	155	* @brief Append the given datapacket to this message.
	156	* @param data The packet to add.
	157	*/
	158	void Append(cec_datapacket &data);
	159
	160	/*!
	161	* @brief Adds a byte to this message. Does not escape the byte.
	162	* @param byte The byte to add.
	163	*/
	164	void PushBack(uint8_t byte);
	165
	166	/*!
	167	* @brief Adds a byte to this message and escapes the byte if needed.
	168	* @param byte The byte to add.
	169	*/
	170	void PushEscaped(uint8_t byte);
	171
	172	/*!
	173	* @brief Adds a byte to this message.
	174	* @param byte The byte to add.
	175	* @return True when a full message was received, false otherwise.
	176	*/
	177	bool PushReceivedByte(uint8_t byte);
	178
	179	/*!
	180	* @return The messagecode inside this adapter message, or MSGCODE_NOTHING if there is none.
	181	*/
	182	cec_adapter_messagecode Message(void) const;
	183
	184	/*!
	185	* @return The messagecode (if provided) that this message is responding to
	186	*/
	187	cec_adapter_messagecode ResponseTo(void) const;
	188
	189	/*!
	190	* @return True when this message is a transmission, false otherwise.
	191	*/
	192	bool IsTranmission(void) const;
	193
	194	/*!
	195	* @return True when the EOM bit is set, false otherwise.
	196	*/
	197	bool IsEOM(void) const;
	198
	199	/*!
	200	* @return True when the ACK bit is set, false otherwise.
	201	*/
	202	bool IsACK(void) const;
	203
	204	/*!
	205	* @brief Checks whether the given messagecode is an error message.
	206	* @param code The code to check.
	207	* @return True when it's an error, false otherwise.
	208	*/
	209	static bool MessageCodeIsError(const cec_adapter_messagecode code);
	210
	211	/*!
	212	* @return True when this message contains an error code, false otherwise.
	213	*/
	214	bool IsError(void) const;
	215
	216	/*!
	217	* @return True when this message has been replied with an error code, false otherwise.
	218	*/
	219	bool ReplyIsError(void) const;
	220
	221	/*!
	222	* @return True when this message has been replied with an error code and needs to be retried, false otherwise.
	223	*/
	224	bool NeedsRetry(void) const;
	225
	226	/*!
	227	* @return The logical address of the initiator, or CECDEVICE_UNKNOWN if unknown.
	228	*/
	229	cec_logical_address Initiator(void) const;
	230
	231	/*!
	232	* @return The logical address of the destination, or CECDEVICE_UNKNOWN if unknown.
	233	*/
	234	cec_logical_address Destination(void) const;
	235
	236	/*!
	237	* @return True when this message contains a start message, false otherwise.
	238	*/
	239	bool HasStartMessage(void) const;
	240
	241	/*!
	242	* @brief Push this adapter message to the end of the given cec_command.
	243	* @param command The command to push this message to.
	244	* @return True when a full CEC message was received, false otherwise.
	245	*/
	246	bool PushToCecCommand(cec_command &command) const;
	247
	248	/*!
	249	* @return The response messagecode.
	250	*/
	251	cec_adapter_messagecode Reply(void) const;
	252
	253	cec_datapacket response; /*< the response to this message /
	254	cec_datapacket packet; /*< the actual data /
	255	cec_adapter_message_state state; /*< the current state of this message /
	256	int32_t transmit_timeout; /*< the timeout to use when sending this message /
	257	uint8_t lineTimeout; /*< the default CEC line timeout to use when sending this message /
	258	bool bFireAndForget; /*< true to auto delete, don't wait for a response /
	259
	260	private:
	261	bool bNextByteIsEscaped; /*< true when the next byte that is added will be escaped, false otherwise /
	262	};
	263	}