[deb_libcec.git] / src / testclient / main.cpp

/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011 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 <cec.h>

#include <cstdio>
#include <fcntl.h>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include "../lib/platform/threads.h"
#include "../lib/util/StdString.h"

using namespace CEC;
using namespace std;

#define CEC_TEST_CLIENT_VERSION 1

#include <cecloader.h>

int        g_cecLogLevel = CEC_LOG_ALL;
int        g_iLogicalAddress = CECDEVICE_PLAYBACKDEVICE1;
ofstream   g_logOutput;
bool       g_bShortLog = false;
CStdString g_strPort;

inline bool HexStrToInt(const std::string& data, uint8_t& value)
{
  int iTmp(0);
  if (sscanf(data.c_str(), "%x", &iTmp) == 1)
  {
    if (iTmp > 256)
      value = 255;
	  else if (iTmp < 0)
      value = 0;
    else
      value = (uint8_t) iTmp;

    return true;
  }

  return false;
}

//get the first word (separated by whitespace) from string data and place that in word
//then remove that word from string data
bool GetWord(string& data, string& word)
{
  stringstream datastream(data);
  string end;

  datastream >> word;
  if (datastream.fail())
  {
    data.clear();
    return false;
  }

  size_t pos = data.find(word) + word.length();

  if (pos >= data.length())
  {
    data.clear();
    return true;
  }

  data = data.substr(pos);

  datastream.clear();
  datastream.str(data);

  datastream >> end;
  if (datastream.fail())
    data.clear();

  return true;
}

void flush_log(ICECAdapter *cecParser)
{
  cec_log_message message;
  while (cecParser && cecParser->GetNextLogMessage(&message))
  {
    if ((message.level & g_cecLogLevel) == message.level)
    {
      CStdString strLevel;
      switch (message.level)
      {
      case CEC_LOG_ERROR:
        strLevel = "ERROR:   ";
        break;
      case CEC_LOG_WARNING:
        strLevel = "WARNING: ";
        break;
      case CEC_LOG_NOTICE:
        strLevel = "NOTICE:  ";
        break;
      case CEC_LOG_TRAFFIC:
        strLevel = "TRAFFIC: ";
        break;
      case CEC_LOG_DEBUG:
        strLevel = "DEBUG:   ";
        break;
      default:
        break;
      }

      CStdString strFullLog;
      strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
      cout << strFullLog.c_str() << endl;

      if (g_logOutput.is_open())
      {
        if (g_bShortLog)
          g_logOutput << message.message << endl;
        else
          g_logOutput << strFullLog.c_str() << endl;
      }
    }
  }
}

void list_devices(ICECAdapter *parser)
{
  cec_adapter *devices = new cec_adapter[10];
  uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
  if (iDevicesFound <= 0)
  {
    cout << "Found devices: NONE" << endl;
  }
  else
  {
    CStdString strLog;
    strLog.Format("Found devices: %d", iDevicesFound);
    cout << strLog.c_str() << endl;
    for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
    {
      CStdString strDevice;
      strDevice.Format("device:        %d\npath:          %s\ncom port:      %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
      cout << endl << strDevice.c_str() << endl;
    }
  }
}

void show_help(const char* strExec)
{
  cout << endl <<
      strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
      endl <<
      "parameters:" << endl <<
      "  -h --help                   Shows this help text" << endl <<
      "  -l --list-devices           List all devices on this system" << endl <<
      "  -la --logical-address {a}   The logical address to use." << endl <<
      "  -f --log-file {file}        Writes all libCEC log message to a file" << endl <<
      "  -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
      "                              and log levels to a file." << endl <<
      "  -d --log-level {level}      Sets the log level. See cectypes.h for values." << endl <<
      "  [COM PORT]                  The com port to connect to. If no COM" << endl <<
      "                              port is given, the client tries to connect to the" << endl <<
      "                              first device that is detected." << endl <<
      endl <<
      "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
      "available commands" << endl;
}

void show_console_help(void)
{
  cout << endl <<
  "================================================================================" << endl <<
  "Available commands:" << endl <<
  endl <<
  "tx {bytes}                transfer bytes over the CEC line." << endl <<
  "txn {bytes}               transfer bytes but don't wait for transmission ACK." << endl <<
  "[tx 40 00 FF 11 22 33]    sends bytes 0x40 0x00 0xFF 0x11 0x22 0x33" << endl <<
  endl <<
  "on {address}              power on the device with the given logical address." << endl <<
  "[on 5]                    power on a connected audio system" << endl <<
  endl <<
  "standby {address}         put the device with the given address in standby mode." << endl <<
  "[standby 0]               powers off the TV" << endl <<
  endl <<
  "la {logical_address}      change the logical address of the CEC adapter." << endl <<
  "[la 4]                    logical address 4" << endl <<
  endl <<
  "pa {physical_address}     change the physical address of the CEC adapter." << endl <<
  "[pa 10 00]                physical address 1.0.0.0" << endl <<
  endl <<
  "osd {addr} {string}       set OSD message on the specified device." << endl <<
  "[osd 0 Test Message]      displays 'Test Message' on the TV" << endl <<
  endl <<
  "ver {addr}                get the CEC version of the specified device." << endl <<
  "[ver 0]                   get the CEC version of the TV" << endl <<
  endl <<
  "ven {addr}                get the vendor ID of the specified device." << endl <<
  "[ven 0]                   get the vendor ID of the TV" << endl <<
  endl <<
  "lang {addr}               get the menu language of the specified device." << endl <<
  "[lang 0]                  get the menu language of the TV" << endl <<
  endl <<
  "pow {addr}                get the power status of the specified device." << endl <<
  "[pow 0]                   get the power status of the TV" << endl <<
  endl <<
  "poll {addr}               poll the specified device." << endl <<
  "[poll 0]                  sends a poll message to the TV" << endl <<
  endl <<
  "[mon] {1|0}               enable or disable CEC bus monitoring." << endl <<
  "[log] {1 - 31}            change the log level. see cectypes.h for values." << endl <<
  "[ping]                    send a ping command to the CEC adapter." << endl <<
  "[bl]                      to let the adapter enter the bootloader, to upgrade" << endl <<
  "                          the flash rom." << endl <<
  "[r]                       reconnect to the CEC adapter." << endl <<
  "[h] or [help]             show this help." << endl <<
  "[q] or [quit]             to quit the CEC test client and switch off all" << endl <<
  "                          connected CEC devices." << endl <<
  "================================================================================" << endl;
}

int main (int argc, char *argv[])
{
  ICECAdapter *parser = LoadLibCec("CECTester");
  if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
  {
#ifdef __WINDOWS__
    cout << "Cannot load libcec.dll" << endl;
#else
    cout << "Cannot load libcec.so" << endl;
#endif
    return 1;
  }
  CStdString strLog;
  strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
  cout << strLog.c_str() << endl;

  //make stdin non-blocking
#ifndef __WINDOWS__
  int flags = fcntl(0, F_GETFL, 0);
  flags |= O_NONBLOCK;
  fcntl(0, F_SETFL, flags);
#endif

  int iArgPtr = 1;
  while (iArgPtr < argc)
  {
    if (argc >= iArgPtr + 1)
    {
      if (!strcmp(argv[iArgPtr], "-f") ||
          !strcmp(argv[iArgPtr], "--log-file") ||
          !strcmp(argv[iArgPtr], "-sf") ||
          !strcmp(argv[iArgPtr], "--short-log-file"))
      {
        if (argc >= iArgPtr + 2)
        {
          g_logOutput.open(argv[iArgPtr + 1]);
          g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
          iArgPtr += 2;
        }
        else
        {
          cout << "== skipped log-file parameter: no file given ==" << endl;
          ++iArgPtr;
        }
      }
      else if (!strcmp(argv[iArgPtr], "-d") ||
          !strcmp(argv[iArgPtr], "--log-level"))
      {
        if (argc >= iArgPtr + 2)
        {
          int iNewLevel = atoi(argv[iArgPtr + 1]);
          if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
          {
            g_cecLogLevel = iNewLevel;
            cout << "log level set to " << argv[iArgPtr + 1] << endl;
          }
          else
          {
            cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
          }
          iArgPtr += 2;
        }
        else
        {
          cout << "== skipped log-level parameter: no level given ==" << endl;
          ++iArgPtr;
        }
      }
      else if (!strcmp(argv[iArgPtr], "-la") ||
               !strcmp(argv[iArgPtr], "--logical-address"))
      {
        if (argc >= iArgPtr + 2)
        {
          int iNewAddress = atoi(argv[iArgPtr + 1]);
          if (iNewAddress >= 0 && iNewAddress <= 15)
          {
            g_iLogicalAddress = iNewAddress;
            cout << "logical address set to " << argv[iArgPtr + 1] << endl;
          }
          else
          {
            cout << "== skipped logical-address parameter: invalid address '" << argv[iArgPtr + 1] << "' ==" << endl;
          }
          iArgPtr += 2;
        }
        else
        {
          cout << "== skipped logical-address parameter: no address given ==" << endl;
          ++iArgPtr;
        }
      }
      else if (!strcmp(argv[iArgPtr], "--list-devices") ||
               !strcmp(argv[iArgPtr], "-l"))
      {
        list_devices(parser);
        UnloadLibCec(parser);
        return 0;
      }
      else if (!strcmp(argv[iArgPtr], "--help") ||
               !strcmp(argv[iArgPtr], "-h"))
      {
        show_help(argv[0]);
        UnloadLibCec(parser);
        return 0;
      }
      else
      {
        g_strPort = argv[iArgPtr++];
      }
    }
  }

  if (g_strPort.IsEmpty())
  {
    cout << "no serial port given. trying autodetect: ";
    cec_adapter devices[10];
    uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
    if (iDevicesFound <= 0)
    {
      cout << "FAILED" << endl;
      UnloadLibCec(parser);
      return 1;
    }
    else
    {
      cout << endl << " path:     " << devices[0].path << endl <<
          " com port: " << devices[0].comm << endl << endl;
      g_strPort = devices[0].comm;
    }
  }

  parser->SetLogicalAddress((cec_logical_address) g_iLogicalAddress);

  if (!parser->Open(g_strPort.c_str()))
  {
    cout << "unable to open the device on port " << g_strPort << endl;
    flush_log(parser);
    UnloadLibCec(parser);
    return 1;
  }

  cout << "cec device opened" << endl;

  parser->PowerOnDevices(CECDEVICE_TV);
  flush_log(parser);

  parser->SetActiveView();
  flush_log(parser);

  bool bContinue(true);
  cout << "waiting for input" << endl;
  while (bContinue)
  {
    flush_log(parser);

    /* just ignore the command buffer and clear it */
    cec_command dummy;
    while (parser && parser->GetNextCommand(&dummy)) {}

    string input;
    getline(cin, input);
    cin.clear();

    if (!input.empty())
    {
      string command;
      if (GetWord(input, command))
      {
        if (command == "tx" || command == "txn")
        {
          string strvalue;
          uint8_t ivalue;
          cec_command bytes;
          bytes.clear();

          while (GetWord(input, strvalue) && HexStrToInt(strvalue, ivalue))
            bytes.push_back(ivalue);

          if (command == "txn")
            bytes.transmit_timeout = 0;

          parser->Transmit(bytes);
        }
        else if (command == "on")
        {
          string strValue;
          uint8_t iValue = 0;
          if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
          {
            parser->PowerOnDevices((cec_logical_address) iValue);
          }
          else
          {
            cout << "invalid destination" << endl;
          }
        }
        else if (command == "standby")
        {
          string strValue;
          uint8_t iValue = 0;
          if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
          {
            parser->StandbyDevices((cec_logical_address) iValue);
          }
          else
          {
            cout << "invalid destination" << endl;
          }
        }
        else if (command == "poll")
        {
          string strValue;
          uint8_t iValue = 0;
          if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
          {
            if (parser->PollDevice((cec_logical_address) iValue))
              cout << "POLL message sent" << endl;
            else
              cout << "POLL message not sent" << endl;
          }
          else
          {
            cout << "invalid destination" << endl;
          }
        }
        else if (command == "la")
        {
          string strvalue;
          if (GetWord(input, strvalue))
          {
            parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
          }
        }
        else if (command == "pa")
        {
          string strB1, strB2;
          uint8_t iB1, iB2;
          if (GetWord(input, strB1) && HexStrToInt(strB1, iB1) &&
              GetWord(input, strB2) && HexStrToInt(strB2, iB2))
          {
            uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
            parser->SetPhysicalAddress(iPhysicalAddress);
          }
        }
        else if (command == "osd")
        {
          bool bFirstWord(false);
          string strAddr, strMessage, strWord;
          uint8_t iAddr;
          if (GetWord(input, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
          {
            while (GetWord(input, strWord))
            {
              if (bFirstWord)
              {
                bFirstWord = false;
                strMessage.append(" ");
              }
              strMessage.append(strWord);
            }
            parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
          }
        }
        else if (command == "ping")
        {
          parser->PingAdapter();
        }
        else if (command == "mon")
        {
          CStdString strEnable;
          if (GetWord(input, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
          {
            parser->SwitchMonitoring(strEnable.Equals("1"));
          }
        }
        else if (command == "bl")
        {
          parser->StartBootloader();
        }
        else if (command == "lang")
        {
          CStdString strDev;
          if (GetWord(input, strDev))
          {
            int iDev = atoi(strDev);
            if (iDev >= 0 && iDev < 15)
            {
              CStdString strLog;
              cec_menu_language language;
              if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
                strLog.Format("menu language '%s'", language.language);
              else
                strLog = "failed!";
              cout << strLog.c_str() << endl;
            }
          }
        }
        else if (command == "ven")
        {
          CStdString strDev;
          if (GetWord(input, strDev))
          {
            int iDev = atoi(strDev);
            if (iDev >= 0 && iDev < 15)
            {
              uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
              CStdString strLog;
              strLog.Format("vendor id: %06x", iVendor);
              cout << strLog.c_str() << endl;
            }
          }
        }
        else if (command == "ver")
        {
          CStdString strDev;
          if (GetWord(input, strDev))
          {
            int iDev = atoi(strDev);
            if (iDev >= 0 && iDev < 15)
            {
              cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
              switch (iVersion)
              {
              case CEC_VERSION_1_2:
                cout << "CEC version 1.2" << endl;
                break;
              case CEC_VERSION_1_2A:
                cout << "CEC version 1.2a" << endl;
                break;
              case CEC_VERSION_1_3:
                cout << "CEC version 1.3" << endl;
                break;
              case CEC_VERSION_1_3A:
                cout << "CEC version 1.3a" << endl;
                break;
              default:
                cout << "unknown CEC version" << endl;
                break;
              }
            }
          }
        }
        else if (command == "pow")
        {
          CStdString strDev;
          if (GetWord(input, strDev))
          {
            int iDev = atoi(strDev);
            if (iDev >= 0 && iDev < 15)
            {
              cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
              switch (iPower)
              {
              case CEC_POWER_STATUS_ON:
                cout << "powered on" << endl;
                break;
              case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
                cout << "on -> standby" << endl;
                break;
              case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
                cout << "standby -> on" << endl;
                break;
              case CEC_POWER_STATUS_STANDBY:
                cout << "standby" << endl;
                break;
              default:
                cout << "unknown power status" << endl;
                break;
              }
            }
          }
        }
        else if (command == "r")
        {
          cout << "closing the connection" << endl;
          parser->Close();
          flush_log(parser);

          cout << "opening a new connection" << endl;
          parser->Open(g_strPort.c_str());
          flush_log(parser);

          cout << "setting active view" << endl;
          parser->SetActiveView();
        }
        else if (command == "h" || command == "help")
        {
          show_console_help();
        }
        else if (command == "q" || command == "quit")
        {
          bContinue = false;
        }
        else if (command == "log")
        {
          CStdString strLevel;
          if (GetWord(input, strLevel))
          {
            int iNewLevel = atoi(strLevel);
            if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
            {
              g_cecLogLevel = iNewLevel;
              cout << "log level changed to " << strLevel.c_str() << endl;
            }
          }
        }
      }
      if (bContinue)
        cout << "waiting for input" << endl;
    }
    CCondition::Sleep(50);
  }

  parser->StandbyDevices(CECDEVICE_BROADCAST);
  parser->Close();
  flush_log(parser);
  UnloadLibCec(parser);

  if (g_logOutput.is_open())
    g_logOutput.close();

  return 0;
}
Commit	Line	Data
abbca718 LOK	1	/*
	2	* This file is part of the libCEC(R) library.
	3	*
	4	* libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited. All rights reserved.
	5	* libCEC(R) is an original work, containing original code.
	6	*
	7	* libCEC(R) is a trademark of Pulse-Eight Limited.
	8	*
	9	* This program is dual-licensed; you can redistribute it and/or modify
	10	* it under the terms of the GNU General Public License as published by
	11	* the Free Software Foundation; either version 2 of the License, or
	12	* (at your option) any later version.
	13	*
	14	* This program is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	* GNU General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU General Public License
	20	* along with this program; if not, write to the Free Software
	21	* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	22	*
	23	*
	24	* Alternatively, you can license this library under a commercial license,
	25	* please contact Pulse-Eight Licensing for more information.
	26	*
	27	* For more information contact:
	28	* Pulse-Eight Licensing <license@pulse-eight.com>
	29	* http://www.pulse-eight.com/
	30	* http://www.pulse-eight.net/
	31	*/
	32
761dcc45	33	#include <cec.h>
acec5f48	34
abbca718 LOK	35	#include <cstdio>
	36	#include <fcntl.h>
	37	#include <iostream>
e6d2161b	38	#include <fstream>
abbca718	39	#include <string>
b9187cc6	40	#include <sstream>
acec5f48 LOK	41	#include "../lib/platform/threads.h"
acec5f48 LOK	42	#include "../lib/util/StdString.h"
abbca718 LOK	43
	44	using namespace CEC;
	45	using namespace std;
	46
d75be19b	47	#define CEC_TEST_CLIENT_VERSION 1
abbca718	48
761dcc45	49	#include <cecloader.h>
8bc45476	50
3d0dca16	51	int g_cecLogLevel = CEC_LOG_ALL;
d6cc5f60	52	int g_iLogicalAddress = CECDEVICE_PLAYBACKDEVICE1;
3d0dca16 LOK	53	ofstream g_logOutput;
	54	bool g_bShortLog = false;
	55	CStdString g_strPort;
b9187cc6	56
8bca69de	57	inline bool HexStrToInt(const std::string& data, uint8_t& value)
b9187cc6	58	{
8bca69de LOK	59	int iTmp(0);
	60	if (sscanf(data.c_str(), "%x", &iTmp) == 1)
	61	{
	62	if (iTmp > 256)
	63	value = 255;
	64	else if (iTmp < 0)
	65	value = 0;
	66	else
	67	value = (uint8_t) iTmp;
b9187cc6	68
8bca69de LOK	69	return true;
	70	}
	71
	72	return false;
	73	}
b9187cc6 LOK	74
	75	//get the first word (separated by whitespace) from string data and place that in word
	76	//then remove that word from string data
	77	bool GetWord(string& data, string& word)
	78	{
	79	stringstream datastream(data);
	80	string end;
	81
	82	datastream >> word;
	83	if (datastream.fail())
	84	{
	85	data.clear();
	86	return false;
	87	}
	88
	89	size_t pos = data.find(word) + word.length();
	90
	91	if (pos >= data.length())
	92	{
	93	data.clear();
	94	return true;
	95	}
	96
	97	data = data.substr(pos);
	98
	99	datastream.clear();
	100	datastream.str(data);
	101
	102	datastream >> end;
	103	if (datastream.fail())
	104	data.clear();
	105
	106	return true;
	107	}
	108
2abe74eb	109	void flush_log(ICECAdapter *cecParser)
abbca718 LOK	110	{
	111	cec_log_message message;
	112	while (cecParser && cecParser->GetNextLogMessage(&message))
	113	{
bdd433cb	114	if ((message.level & g_cecLogLevel) == message.level)
abbca718	115	{
e6d2161b	116	CStdString strLevel;
bdd433cb LOK	117	switch (message.level)
	118	{
	119	case CEC_LOG_ERROR:
e6d2161b	120	strLevel = "ERROR: ";
bdd433cb LOK	121	break;
bdd433cb LOK	122	case CEC_LOG_WARNING:
e6d2161b	123	strLevel = "WARNING: ";
bdd433cb LOK	124	break;
bdd433cb LOK	125	case CEC_LOG_NOTICE:
e6d2161b	126	strLevel = "NOTICE: ";
bdd433cb LOK	127	break;
bdd433cb LOK	128	case CEC_LOG_TRAFFIC:
e6d2161b	129	strLevel = "TRAFFIC: ";
bdd433cb LOK	130	break;
bdd433cb LOK	131	case CEC_LOG_DEBUG:
e6d2161b	132	strLevel = "DEBUG: ";
bdd433cb LOK	133	break;
	134	default:
	135	break;
	136	}
40339852	137
8bc45476 LOK	138	CStdString strFullLog;
	139	strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
	140	cout << strFullLog.c_str() << endl;
e6d2161b LOK	141
e6d2161b LOK	142	if (g_logOutput.is_open())
8bc45476 LOK	143	{
	144	if (g_bShortLog)
	145	g_logOutput << message.message << endl;
	146	else
	147	g_logOutput << strFullLog.c_str() << endl;
	148	}
bdd433cb	149	}
abbca718 LOK	150	}
	151	}
	152
2abe74eb	153	void list_devices(ICECAdapter *parser)
abbca718	154	{
25701fa6 LOK	155	cec_adapter *devices = new cec_adapter[10];
25701fa6 LOK	156	uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
abbca718 LOK	157	if (iDevicesFound <= 0)
abbca718 LOK	158	{
25701fa6	159	cout << "Found devices: NONE" << endl;
abbca718 LOK	160	}
	161	else
	162	{
25701fa6 LOK	163	CStdString strLog;
	164	strLog.Format("Found devices: %d", iDevicesFound);
	165	cout << strLog.c_str() << endl;
	166	for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
abbca718 LOK	167	{
abbca718 LOK	168	CStdString strDevice;
25701fa6	169	strDevice.Format("device: %d\npath: %s\ncom port: %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
abbca718 LOK	170	cout << endl << strDevice.c_str() << endl;
	171	}
	172	}
	173	}
	174
	175	void show_help(const char* strExec)
	176	{
	177	cout << endl <<
	178	strExec << " {-h\|--help\|-l\|--list-devices\|[COM PORT]}" << endl <<
	179	endl <<
	180	"parameters:" << endl <<
8bc45476 LOK	181	" -h --help Shows this help text" << endl <<
8bc45476 LOK	182	" -l --list-devices List all devices on this system" << endl <<
d6cc5f60	183	" -la --logical-address {a} The logical address to use." << endl <<
8bc45476 LOK	184	" -f --log-file {file} Writes all libCEC log message to a file" << endl <<
	185	" -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
	186	" and log levels to a file." << endl <<
606034b6	187	" -d --log-level {level} Sets the log level. See cectypes.h for values." << endl <<
8bc45476 LOK	188	" [COM PORT] The com port to connect to. If no COM" << endl <<
	189	" port is given, the client tries to connect to the" << endl <<
	190	" first device that is detected." << endl <<
825ddb96	191	endl <<
8bc45476 LOK	192	"Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
8bc45476 LOK	193	"available commands" << endl;
825ddb96 LOK	194	}
	195
	196	void show_console_help(void)
	197	{
	198	cout << endl <<
	199	"================================================================================" << endl <<
	200	"Available commands:" << endl <<
	201	endl <<
	202	"tx {bytes} transfer bytes over the CEC line." << endl <<
1f0e9e0f	203	"txn {bytes} transfer bytes but don't wait for transmission ACK." << endl <<
825ddb96 LOK	204	"[tx 40 00 FF 11 22 33] sends bytes 0x40 0x00 0xFF 0x11 0x22 0x33" << endl <<
825ddb96 LOK	205	endl <<
88f45c9b LOK	206	"on {address} power on the device with the given logical address." << endl <<
	207	"[on 5] power on a connected audio system" << endl <<
	208	endl <<
	209	"standby {address} put the device with the given address in standby mode." << endl <<
	210	"[standby 0] powers off the TV" << endl <<
	211	endl <<
825ddb96 LOK	212	"la {logical_address} change the logical address of the CEC adapter." << endl <<
	213	"[la 4] logical address 4" << endl <<
	214	endl <<
a424ebac LOK	215	"pa {physical_address} change the physical address of the CEC adapter." << endl <<
	216	"[pa 10 00] physical address 1.0.0.0" << endl <<
	217	endl <<
1969b140 LOK	218	"osd {addr} {string} set OSD message on the specified device." << endl <<
	219	"[osd 0 Test Message] displays 'Test Message' on the TV" << endl <<
	220	endl <<
6a1c0009 LOK	221	"ver {addr} get the CEC version of the specified device." << endl <<
	222	"[ver 0] get the CEC version of the TV" << endl <<
	223	endl <<
44c74256 LOK	224	"ven {addr} get the vendor ID of the specified device." << endl <<
	225	"[ven 0] get the vendor ID of the TV" << endl <<
	226	endl <<
	227	"lang {addr} get the menu language of the specified device." << endl <<
a3269a0a LOK	228	"[lang 0] get the menu language of the TV" << endl <<
a3269a0a LOK	229	endl <<
e55f3f70 LOK	230	"pow {addr} get the power status of the specified device." << endl <<
	231	"[pow 0] get the power status of the TV" << endl <<
	232	endl <<
57f45e6c LOK	233	"poll {addr} poll the specified device." << endl <<
	234	"[poll 0] sends a poll message to the TV" << endl <<
	235	endl <<
8b7e5ff6	236	"[mon] {1\|0} enable or disable CEC bus monitoring." << endl <<
bdd433cb	237	"[log] {1 - 31} change the log level. see cectypes.h for values." << endl <<
825ddb96	238	"[ping] send a ping command to the CEC adapter." << endl <<
88f45c9b LOK	239	"[bl] to let the adapter enter the bootloader, to upgrade" << endl <<
	240	" the flash rom." << endl <<
	241	"[r] reconnect to the CEC adapter." << endl <<
825ddb96	242	"[h] or [help] show this help." << endl <<
88f45c9b LOK	243	"[q] or [quit] to quit the CEC test client and switch off all" << endl <<
88f45c9b LOK	244	" connected CEC devices." << endl <<
825ddb96	245	"================================================================================" << endl;
abbca718 LOK	246	}
	247
	248	int main (int argc, char *argv[])
	249	{
d54c6c91	250	ICECAdapter *parser = LoadLibCec("CECTester");
d75be19b	251	if (!parser \|\| parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
abbca718	252	{
acec5f48 LOK	253	#ifdef __WINDOWS__
	254	cout << "Cannot load libcec.dll" << endl;
	255	#else
	256	cout << "Cannot load libcec.so" << endl;
	257	#endif
abbca718 LOK	258	return 1;
	259	}
	260	CStdString strLog;
d75be19b	261	strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
abbca718 LOK	262	cout << strLog.c_str() << endl;
	263
	264	//make stdin non-blocking
	265	#ifndef __WINDOWS__
	266	int flags = fcntl(0, F_GETFL, 0);
	267	flags \|= O_NONBLOCK;
	268	fcntl(0, F_SETFL, flags);
	269	#endif
	270
3d0dca16 LOK	271	int iArgPtr = 1;
3d0dca16 LOK	272	while (iArgPtr < argc)
e6d2161b	273	{
3d0dca16	274	if (argc >= iArgPtr + 1)
e6d2161b	275	{
3d0dca16 LOK	276	if (!strcmp(argv[iArgPtr], "-f") \|\|
	277	!strcmp(argv[iArgPtr], "--log-file") \|\|
	278	!strcmp(argv[iArgPtr], "-sf") \|\|
	279	!strcmp(argv[iArgPtr], "--short-log-file"))
	280	{
	281	if (argc >= iArgPtr + 2)
	282	{
	283	g_logOutput.open(argv[iArgPtr + 1]);
	284	g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") \|\| !strcmp(argv[iArgPtr], "--short-log-file"));
	285	iArgPtr += 2;
	286	}
	287	else
	288	{
606034b6 LOK	289	cout << "== skipped log-file parameter: no file given ==" << endl;
	290	++iArgPtr;
	291	}
	292	}
	293	else if (!strcmp(argv[iArgPtr], "-d") \|\|
	294	!strcmp(argv[iArgPtr], "--log-level"))
	295	{
	296	if (argc >= iArgPtr + 2)
	297	{
	298	int iNewLevel = atoi(argv[iArgPtr + 1]);
	299	if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
	300	{
	301	g_cecLogLevel = iNewLevel;
	302	cout << "log level set to " << argv[iArgPtr + 1] << endl;
	303	}
	304	else
	305	{
	306	cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
	307	}
	308	iArgPtr += 2;
	309	}
	310	else
	311	{
	312	cout << "== skipped log-level parameter: no level given ==" << endl;
3d0dca16 LOK	313	++iArgPtr;
	314	}
	315	}
d6cc5f60 LOK	316	else if (!strcmp(argv[iArgPtr], "-la") \|\|
	317	!strcmp(argv[iArgPtr], "--logical-address"))
	318	{
	319	if (argc >= iArgPtr + 2)
	320	{
	321	int iNewAddress = atoi(argv[iArgPtr + 1]);
	322	if (iNewAddress >= 0 && iNewAddress <= 15)
	323	{
	324	g_iLogicalAddress = iNewAddress;
	325	cout << "logical address set to " << argv[iArgPtr + 1] << endl;
	326	}
	327	else
	328	{
	329	cout << "== skipped logical-address parameter: invalid address '" << argv[iArgPtr + 1] << "' ==" << endl;
	330	}
	331	iArgPtr += 2;
	332	}
	333	else
	334	{
	335	cout << "== skipped logical-address parameter: no address given ==" << endl;
	336	++iArgPtr;
	337	}
	338	}
3d0dca16 LOK	339	else if (!strcmp(argv[iArgPtr], "--list-devices") \|\|
	340	!strcmp(argv[iArgPtr], "-l"))
	341	{
	342	list_devices(parser);
	343	UnloadLibCec(parser);
	344	return 0;
	345	}
	346	else if (!strcmp(argv[iArgPtr], "--help") \|\|
	347	!strcmp(argv[iArgPtr], "-h"))
	348	{
	349	show_help(argv[0]);
	350	UnloadLibCec(parser);
	351	return 0;
	352	}
	353	else
	354	{
	355	g_strPort = argv[iArgPtr++];
	356	}
e6d2161b LOK	357	}
	358	}
	359
3d0dca16	360	if (g_strPort.IsEmpty())
abbca718 LOK	361	{
abbca718 LOK	362	cout << "no serial port given. trying autodetect: ";
25701fa6 LOK	363	cec_adapter devices[10];
25701fa6 LOK	364	uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
abbca718 LOK	365	if (iDevicesFound <= 0)
	366	{
	367	cout << "FAILED" << endl;
	368	UnloadLibCec(parser);
	369	return 1;
	370	}
	371	else
	372	{
	373	cout << endl << " path: " << devices[0].path << endl <<
3d0dca16 LOK	374	" com port: " << devices[0].comm << endl << endl;
3d0dca16 LOK	375	g_strPort = devices[0].comm;
abbca718 LOK	376	}
abbca718 LOK	377	}
e6d2161b	378
d6cc5f60 LOK	379	parser->SetLogicalAddress((cec_logical_address) g_iLogicalAddress);
d6cc5f60 LOK	380
3d0dca16	381	if (!parser->Open(g_strPort.c_str()))
abbca718	382	{
3d0dca16	383	cout << "unable to open the device on port " << g_strPort << endl;
abbca718 LOK	384	flush_log(parser);
	385	UnloadLibCec(parser);
	386	return 1;
	387	}
	388
	389	cout << "cec device opened" << endl;
abbca718	390
8829d291	391	parser->PowerOnDevices(CECDEVICE_TV);
abbca718 LOK	392	flush_log(parser);
	393
	394	parser->SetActiveView();
	395	flush_log(parser);
	396
	397	bool bContinue(true);
	398	cout << "waiting for input" << endl;
	399	while (bContinue)
	400	{
	401	flush_log(parser);
	402
b5b53c7d LOK	403	/* just ignore the command buffer and clear it */
	404	cec_command dummy;
	405	while (parser && parser->GetNextCommand(&dummy)) {}
	406
abbca718 LOK	407	string input;
	408	getline(cin, input);
	409	cin.clear();
	410
	411	if (!input.empty())
	412	{
	413	string command;
	414	if (GetWord(input, command))
	415	{
faa6a23b	416	if (command == "tx" \|\| command == "txn")
abbca718 LOK	417	{
abbca718 LOK	418	string strvalue;
8bca69de	419	uint8_t ivalue;
9dee1670	420	cec_command bytes;
25701fa6 LOK	421	bytes.clear();
25701fa6 LOK	422
abbca718	423	while (GetWord(input, strvalue) && HexStrToInt(strvalue, ivalue))
b2da2768	424	bytes.push_back(ivalue);
abbca718	425
8d84e2c0	426	if (command == "txn")
1f0e9e0f	427	bytes.transmit_timeout = 0;
8d84e2c0 LOK	428
8d84e2c0 LOK	429	parser->Transmit(bytes);
abbca718	430	}
88f45c9b LOK	431	else if (command == "on")
	432	{
	433	string strValue;
	434	uint8_t iValue = 0;
	435	if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
	436	{
	437	parser->PowerOnDevices((cec_logical_address) iValue);
	438	}
	439	else
	440	{
	441	cout << "invalid destination" << endl;
	442	}
	443	}
	444	else if (command == "standby")
	445	{
	446	string strValue;
	447	uint8_t iValue = 0;
	448	if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
	449	{
	450	parser->StandbyDevices((cec_logical_address) iValue);
	451	}
	452	else
	453	{
	454	cout << "invalid destination" << endl;
	455	}
	456	}
57f45e6c LOK	457	else if (command == "poll")
	458	{
	459	string strValue;
	460	uint8_t iValue = 0;
	461	if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
	462	{
	463	if (parser->PollDevice((cec_logical_address) iValue))
	464	cout << "POLL message sent" << endl;
	465	else
	466	cout << "POLL message not sent" << endl;
	467	}
	468	else
	469	{
	470	cout << "invalid destination" << endl;
	471	}
	472	}
6dfe9213 LOK	473	else if (command == "la")
	474	{
	475	string strvalue;
6dfe9213 LOK	476	if (GetWord(input, strvalue))
	477	{
	478	parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
abbca718 LOK	479	}
abbca718 LOK	480	}
a424ebac LOK	481	else if (command == "pa")
	482	{
	483	string strB1, strB2;
	484	uint8_t iB1, iB2;
	485	if (GetWord(input, strB1) && HexStrToInt(strB1, iB1) &&
	486	GetWord(input, strB2) && HexStrToInt(strB2, iB2))
	487	{
	488	uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
	489	parser->SetPhysicalAddress(iPhysicalAddress);
	490	}
	491	}
1969b140 LOK	492	else if (command == "osd")
	493	{
	494	bool bFirstWord(false);
	495	string strAddr, strMessage, strWord;
	496	uint8_t iAddr;
	497	if (GetWord(input, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
	498	{
	499	while (GetWord(input, strWord))
	500	{
	501	if (bFirstWord)
	502	{
	503	bFirstWord = false;
	504	strMessage.append(" ");
	505	}
	506	strMessage.append(strWord);
	507	}
	508	parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
	509	}
	510	}
abbca718 LOK	511	else if (command == "ping")
abbca718 LOK	512	{
2abe74eb	513	parser->PingAdapter();
abbca718	514	}
8b7e5ff6 LOK	515	else if (command == "mon")
	516	{
	517	CStdString strEnable;
	518	if (GetWord(input, strEnable) && (strEnable.Equals("0") \|\| strEnable.Equals("1")))
	519	{
	520	parser->SwitchMonitoring(strEnable.Equals("1"));
	521	}
	522	}
abbca718 LOK	523	else if (command == "bl")
	524	{
	525	parser->StartBootloader();
	526	}
a3269a0a LOK	527	else if (command == "lang")
	528	{
	529	CStdString strDev;
	530	if (GetWord(input, strDev))
	531	{
	532	int iDev = atoi(strDev);
	533	if (iDev >= 0 && iDev < 15)
	534	{
	535	CStdString strLog;
	536	cec_menu_language language;
	537	if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
	538	strLog.Format("menu language '%s'", language.language);
	539	else
	540	strLog = "failed!";
	541	cout << strLog.c_str() << endl;
	542	}
	543	}
	544	}
44c74256 LOK	545	else if (command == "ven")
	546	{
	547	CStdString strDev;
	548	if (GetWord(input, strDev))
	549	{
	550	int iDev = atoi(strDev);
	551	if (iDev >= 0 && iDev < 15)
	552	{
	553	uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
	554	CStdString strLog;
	555	strLog.Format("vendor id: %06x", iVendor);
	556	cout << strLog.c_str() << endl;
	557	}
	558	}
	559	}
6a1c0009 LOK	560	else if (command == "ver")
	561	{
	562	CStdString strDev;
	563	if (GetWord(input, strDev))
	564	{
	565	int iDev = atoi(strDev);
	566	if (iDev >= 0 && iDev < 15)
	567	{
	568	cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
	569	switch (iVersion)
	570	{
	571	case CEC_VERSION_1_2:
	572	cout << "CEC version 1.2" << endl;
	573	break;
	574	case CEC_VERSION_1_2A:
	575	cout << "CEC version 1.2a" << endl;
	576	break;
	577	case CEC_VERSION_1_3:
	578	cout << "CEC version 1.3" << endl;
	579	break;
	580	case CEC_VERSION_1_3A:
	581	cout << "CEC version 1.3a" << endl;
	582	break;
	583	default:
	584	cout << "unknown CEC version" << endl;
	585	break;
	586	}
	587	}
	588	}
	589	}
e55f3f70 LOK	590	else if (command == "pow")
	591	{
	592	CStdString strDev;
	593	if (GetWord(input, strDev))
	594	{
	595	int iDev = atoi(strDev);
	596	if (iDev >= 0 && iDev < 15)
	597	{
	598	cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
	599	switch (iPower)
	600	{
	601	case CEC_POWER_STATUS_ON:
	602	cout << "powered on" << endl;
	603	break;
	604	case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
	605	cout << "on -> standby" << endl;
	606	break;
	607	case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
	608	cout << "standby -> on" << endl;
	609	break;
	610	case CEC_POWER_STATUS_STANDBY:
	611	cout << "standby" << endl;
	612	break;
	613	default:
	614	cout << "unknown power status" << endl;
	615	break;
	616	}
	617	}
	618	}
	619	}
12027dbe LOK	620	else if (command == "r")
12027dbe LOK	621	{
25701fa6	622	cout << "closing the connection" << endl;
12027dbe	623	parser->Close();
25701fa6 LOK	624	flush_log(parser);
	625
	626	cout << "opening a new connection" << endl;
3d0dca16	627	parser->Open(g_strPort.c_str());
25701fa6 LOK	628	flush_log(parser);
	629
	630	cout << "setting active view" << endl;
12027dbe LOK	631	parser->SetActiveView();
12027dbe LOK	632	}
825ddb96 LOK	633	else if (command == "h" \|\| command == "help")
	634	{
	635	show_console_help();
	636	}
abbca718 LOK	637	else if (command == "q" \|\| command == "quit")
	638	{
	639	bContinue = false;
	640	}
bdd433cb LOK	641	else if (command == "log")
	642	{
	643	CStdString strLevel;
	644	if (GetWord(input, strLevel))
	645	{
	646	int iNewLevel = atoi(strLevel);
	647	if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
	648	{
	649	g_cecLogLevel = iNewLevel;
	650	cout << "log level changed to " << strLevel.c_str() << endl;
	651	}
	652	}
	653	}
abbca718 LOK	654	}
	655	if (bContinue)
	656	cout << "waiting for input" << endl;
	657	}
	658	CCondition::Sleep(50);
	659	}
	660
2abe74eb	661	parser->StandbyDevices(CECDEVICE_BROADCAST);
5f39c4d8	662	parser->Close();
abbca718 LOK	663	flush_log(parser);
abbca718 LOK	664	UnloadLibCec(parser);
e6d2161b LOK	665
	666	if (g_logOutput.is_open())
	667	g_logOutput.close();
	668
abbca718 LOK	669	return 0;
abbca718 LOK	670	}