src/testclient/main.cpp

   1 /*
   2  * This file is part of the libCEC(R) library.
   3  *
   4  * libCEC(R) is Copyright (C) 2011-2012 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
  33 #include <cec.h>
  34
  35 #include <cstdio>
  36 #include <fcntl.h>
  37 #include <iostream>
  38 #include <fstream>
  39 #include <string>
  40 #include <sstream>
  41 #include "../lib/platform/os.h"
  42 #include "../lib/implementations/CECCommandHandler.h"
  43
  44 using namespace CEC;
  45 using namespace std;
  46 using namespace PLATFORM;
  47
  48 #define CEC_TEST_CLIENT_VERSION 1
  49
  50 #include <cecloader.h>
  51
  52 int                  g_cecLogLevel(CEC_LOG_ALL);
  53 ofstream             g_logOutput;
  54 bool                 g_bShortLog(false);
  55 CStdString           g_strPort;
  56 uint8_t              g_iHDMIPort(CEC_DEFAULT_HDMI_PORT);
  57 cec_logical_address  g_iBaseDevice((cec_logical_address)CEC_DEFAULT_BASE_DEVICE);
  58 cec_device_type_list g_typeList;
  59 bool                 g_bSingleCommand(false);
  60 bool                 g_bExit(false);
  61 bool                 g_bHardExit(false);
  62 CMutex               g_outputMutex;
  63 ICECCallbacks        g_callbacks;
  64
  65 inline void PrintToStdOut(const char *strFormat, ...)
  66 {
  67   CStdString strLog;
  68
  69   va_list argList;
  70   va_start(argList, strFormat);
  71   strLog.FormatV(strFormat, argList);
  72   va_end(argList);
  73
  74   CLockObject lock(g_outputMutex);
  75   cout << strLog << endl;
  76 }
  77
  78 inline bool HexStrToInt(const std::string& data, uint8_t& value)
  79 {
  80   int iTmp(0);
  81   if (sscanf(data.c_str(), "%x", &iTmp) == 1)
  82   {
  83     if (iTmp > 256)
  84       value = 255;
  85           else if (iTmp < 0)
  86       value = 0;
  87     else
  88       value = (uint8_t) iTmp;
  89
  90     return true;
  91   }
  92
  93   return false;
  94 }
  95
  96 //get the first word (separated by whitespace) from string data and place that in word
  97 //then remove that word from string data
  98 bool GetWord(string& data, string& word)
  99 {
 100   stringstream datastream(data);
 101   string end;
 102
 103   datastream >> word;
 104   if (datastream.fail())
 105   {
 106     data.clear();
 107     return false;
 108   }
 109
 110   size_t pos = data.find(word) + word.length();
 111
 112   if (pos >= data.length())
 113   {
 114     data.clear();
 115     return true;
 116   }
 117
 118   data = data.substr(pos);
 119
 120   datastream.clear();
 121   datastream.str(data);
 122
 123   datastream >> end;
 124   if (datastream.fail())
 125     data.clear();
 126
 127   return true;
 128 }
 129
 130 int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message)
 131 {
 132   if ((message.level & g_cecLogLevel) == message.level)
 133   {
 134     CStdString strLevel;
 135     switch (message.level)
 136     {
 137     case CEC_LOG_ERROR:
 138       strLevel = "ERROR:   ";
 139       break;
 140     case CEC_LOG_WARNING:
 141       strLevel = "WARNING: ";
 142       break;
 143     case CEC_LOG_NOTICE:
 144       strLevel = "NOTICE:  ";
 145       break;
 146     case CEC_LOG_TRAFFIC:
 147       strLevel = "TRAFFIC: ";
 148       break;
 149     case CEC_LOG_DEBUG:
 150       strLevel = "DEBUG:   ";
 151       break;
 152     default:
 153       break;
 154     }
 155
 156     CStdString strFullLog;
 157     strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
 158     PrintToStdOut(strFullLog.c_str());
 159
 160     if (g_logOutput.is_open())
 161     {
 162       if (g_bShortLog)
 163         g_logOutput << message.message << endl;
 164       else
 165         g_logOutput << strFullLog.c_str() << endl;
 166     }
 167   }
 168
 169   return 0;
 170 }
 171
 172 int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &UNUSED(key))
 173 {
 174   return 0;
 175 }
 176
 177 int CecCommand(void *UNUSED(cbParam), const cec_command &UNUSED(command))
 178 {
 179   return 0;
 180 }
 181
 182 void EnableCallbacks(ICECAdapter *adapter)
 183 {
 184   g_callbacks.CBCecLogMessage = &CecLogMessage;
 185   g_callbacks.CBCecKeyPress   = &CecKeyPress;
 186   g_callbacks.CBCecCommand    = &CecCommand;
 187   adapter->EnableCallbacks(NULL, &g_callbacks);
 188 }
 189
 190 void ListDevices(ICECAdapter *parser)
 191 {
 192   cec_adapter *devices = new cec_adapter[10];
 193   uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
 194   if (iDevicesFound <= 0)
 195   {
 196     PrintToStdOut("Found devices: NONE");
 197   }
 198   else
 199   {
 200     PrintToStdOut("Found devices: %d", iDevicesFound);
 201     for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
 202       PrintToStdOut("device:        %d\npath:          %s\ncom port:      %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
 203   }
 204 }
 205
 206 void ShowHelpCommandLine(const char* strExec)
 207 {
 208   CLockObject lock(g_outputMutex);
 209   cout << endl <<
 210       strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
 211       endl <<
 212       "parameters:" << endl <<
 213       "  -h --help                   Shows this help text" << endl <<
 214       "  -l --list-devices           List all devices on this system" << endl <<
 215       "  -t --type {p|r|t|a}         The device type to use. More than one is possible." << endl <<
 216       "  -p --port {int}             The HDMI port to use as active source." << endl <<
 217       "  -b --base {int}             The logical address of the device to with this " << endl <<
 218       "                              adapter is connected." << endl <<
 219       "  -f --log-file {file}        Writes all libCEC log message to a file" << endl <<
 220       "  -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
 221       "                              and log levels to a file." << endl <<
 222       "  -d --log-level {level}      Sets the log level. See cectypes.h for values." << endl <<
 223       "  -s --single-command         Execute a single command and exit. Does not power" << endl <<
 224       "                              on devices on startup and power them off on exit." << endl <<
 225       "  [COM PORT]                  The com port to connect to. If no COM" << endl <<
 226       "                              port is given, the client tries to connect to the" << endl <<
 227       "                              first device that is detected." << endl <<
 228       endl <<
 229       "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
 230       "available commands" << endl;
 231 }
 232
 233 ICECAdapter *CreateParser(cec_device_type_list typeList)
 234 {
 235   ICECAdapter *parser = LibCecInit("CECTester", typeList);
 236   if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
 237   {
 238   #ifdef __WINDOWS__
 239     PrintToStdOut("Cannot load libcec.dll");
 240   #else
 241     PrintToStdOut("Cannot load libcec.so");
 242   #endif
 243     return NULL;
 244   }
 245
 246   PrintToStdOut("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
 247
 248   return parser;
 249 }
 250
 251 void ShowHelpConsole(void)
 252 {
 253   CLockObject lock(g_outputMutex);
 254   cout << endl <<
 255   "================================================================================" << endl <<
 256   "Available commands:" << endl <<
 257   endl <<
 258   "[tx] {bytes}              transfer bytes over the CEC line." << endl <<
 259   "[txn] {bytes}             transfer bytes but don't wait for transmission ACK." << endl <<
 260   "[on] {address}            power on the device with the given logical address." << endl <<
 261   "[standby] {address}       put the device with the given address in standby mode." << endl <<
 262   "[la] {logical address}    change the logical address of the CEC adapter." << endl <<
 263   "[p] {device} {port}       change the HDMI port number of the CEC adapter." << endl <<
 264   "[pa] {physical address}   change the physical address of the CEC adapter." << endl <<
 265   "[as]                      make the CEC adapter the active source." << endl <<
 266   "[osd] {addr} {string}     set OSD message on the specified device." << endl <<
 267   "[ver] {addr}              get the CEC version of the specified device." << endl <<
 268   "[ven] {addr}              get the vendor ID of the specified device." << endl <<
 269   "[lang] {addr}             get the menu language of the specified device." << endl <<
 270   "[pow] {addr}              get the power status of the specified device." << endl <<
 271   "[name] {addr}             get the OSD name of the specified device." << endl <<
 272   "[poll] {addr}             poll the specified device." << endl <<
 273   "[lad]                     lists active devices on the bus" << endl <<
 274   "[ad] {addr}               checks whether the specified device is active." << endl <<
 275   "[at] {type}               checks whether the specified device type is active." << endl <<
 276   "[volup]                   send a volume up command to the amp if present" << endl <<
 277   "[voldown]                 send a volume down command to the amp if present" << endl <<
 278   "[mute]                    send a mute/unmute command to the amp if present" << endl <<
 279   "[scan]                    scan the CEC bus and display device info" << endl <<
 280   "[mon] {1|0}               enable or disable CEC bus monitoring." << endl <<
 281   "[log] {1 - 31}            change the log level. see cectypes.h for values." << endl <<
 282   "[ping]                    send a ping command to the CEC adapter." << endl <<
 283   "[bl]                      to let the adapter enter the bootloader, to upgrade" << endl <<
 284   "                          the flash rom." << endl <<
 285   "[r]                       reconnect to the CEC adapter." << endl <<
 286   "[h] or [help]             show this help." << endl <<
 287   "[q] or [quit]             to quit the CEC test client and switch off all" << endl <<
 288   "                          connected CEC devices." << endl <<
 289   "================================================================================" << endl;
 290 }
 291
 292 bool ProcessCommandTX(ICECAdapter *parser, const string &command, string &arguments)
 293 {
 294   if (command == "tx" || command == "txn")
 295   {
 296     string strvalue;
 297     uint8_t ivalue;
 298     cec_command bytes;
 299     bytes.Clear();
 300
 301     while (GetWord(arguments, strvalue) && HexStrToInt(strvalue, ivalue))
 302       bytes.PushBack(ivalue);
 303
 304     if (command == "txn")
 305       bytes.transmit_timeout = 0;
 306
 307     parser->Transmit(bytes);
 308
 309     return true;
 310   }
 311
 312   return false;
 313 }
 314
 315 bool ProcessCommandON(ICECAdapter *parser, const string &command, string &arguments)
 316 {
 317   if (command == "on")
 318   {
 319     string strValue;
 320     uint8_t iValue = 0;
 321     if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 322     {
 323       parser->PowerOnDevices((cec_logical_address) iValue);
 324       return true;
 325     }
 326     else
 327     {
 328       PrintToStdOut("invalid destination");
 329     }
 330   }
 331
 332   return false;
 333 }
 334
 335 bool ProcessCommandSTANDBY(ICECAdapter *parser, const string &command, string &arguments)
 336 {
 337   if (command == "standby")
 338   {
 339     string strValue;
 340     uint8_t iValue = 0;
 341     if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 342     {
 343       parser->StandbyDevices((cec_logical_address) iValue);
 344       return true;
 345     }
 346     else
 347     {
 348       PrintToStdOut("invalid destination");
 349     }
 350   }
 351
 352   return false;
 353 }
 354
 355 bool ProcessCommandPOLL(ICECAdapter *parser, const string &command, string &arguments)
 356 {
 357   if (command == "poll")
 358   {
 359     string strValue;
 360     uint8_t iValue = 0;
 361     if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 362     {
 363       if (parser->PollDevice((cec_logical_address) iValue))
 364         PrintToStdOut("POLL message sent");
 365       else
 366         PrintToStdOut("POLL message not sent");
 367       return true;
 368     }
 369     else
 370     {
 371       PrintToStdOut("invalid destination");
 372     }
 373   }
 374
 375   return false;
 376 }
 377
 378 bool ProcessCommandLA(ICECAdapter *parser, const string &command, string &arguments)
 379 {
 380   if (command == "la")
 381   {
 382     string strvalue;
 383     if (GetWord(arguments, strvalue))
 384     {
 385       parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
 386       return true;
 387     }
 388   }
 389
 390   return false;
 391 }
 392
 393 bool ProcessCommandP(ICECAdapter *parser, const string &command, string &arguments)
 394 {
 395   if (command == "p")
 396   {
 397     string strPort, strDevice;
 398     if (GetWord(arguments, strDevice) && GetWord(arguments, strPort))
 399     {
 400       parser->SetHDMIPort((cec_logical_address)atoi(strDevice.c_str()), (uint8_t)atoi(strPort.c_str()));
 401       return true;
 402     }
 403   }
 404
 405   return false;
 406 }
 407
 408 bool ProcessCommandPA(ICECAdapter *parser, const string &command, string &arguments)
 409 {
 410   if (command == "pa")
 411   {
 412     string strB1, strB2;
 413     uint8_t iB1, iB2;
 414     if (GetWord(arguments, strB1) && HexStrToInt(strB1, iB1) &&
 415         GetWord(arguments, strB2) && HexStrToInt(strB2, iB2))
 416     {
 417       uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
 418       parser->SetPhysicalAddress(iPhysicalAddress);
 419       return true;
 420     }
 421   }
 422
 423   return false;
 424 }
 425
 426 bool ProcessCommandOSD(ICECAdapter *parser, const string &command, string &arguments)
 427 {
 428   if (command == "osd")
 429   {
 430     bool bFirstWord(false);
 431     string strAddr, strMessage, strWord;
 432     uint8_t iAddr;
 433     if (GetWord(arguments, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
 434     {
 435       while (GetWord(arguments, strWord))
 436       {
 437         if (bFirstWord)
 438         {
 439           bFirstWord = false;
 440           strMessage.append(" ");
 441         }
 442         strMessage.append(strWord);
 443       }
 444       parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
 445       return true;
 446     }
 447   }
 448
 449   return false;
 450 }
 451
 452 bool ProcessCommandAS(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 453 {
 454   if (command == "as")
 455   {
 456     parser->SetActiveView();
 457     return true;
 458   }
 459
 460   return false;
 461 }
 462
 463
 464 bool ProcessCommandPING(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 465 {
 466   if (command == "ping")
 467   {
 468     parser->PingAdapter();
 469     return true;
 470   }
 471
 472   return false;
 473 }
 474
 475 bool ProcessCommandVOLUP(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 476 {
 477   if (command == "volup")
 478   {
 479     PrintToStdOut("volume up: %2X", parser->VolumeUp());
 480     return true;
 481   }
 482
 483   return false;
 484 }
 485
 486 bool ProcessCommandVOLDOWN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 487 {
 488   if (command == "voldown")
 489   {
 490     PrintToStdOut("volume down: %2X", parser->VolumeDown());
 491     return true;
 492   }
 493
 494   return false;
 495 }
 496
 497 bool ProcessCommandMUTE(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 498 {
 499   if (command == "mute")
 500   {
 501     PrintToStdOut("mute: %2X", parser->MuteAudio());
 502     return true;
 503   }
 504
 505   return false;
 506 }
 507
 508 bool ProcessCommandMON(ICECAdapter *parser, const string &command, string &arguments)
 509 {
 510   if (command == "mon")
 511   {
 512     CStdString strEnable;
 513     if (GetWord(arguments, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
 514     {
 515       parser->SwitchMonitoring(strEnable.Equals("1"));
 516       return true;
 517     }
 518   }
 519
 520   return false;
 521 }
 522
 523 bool ProcessCommandBL(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 524 {
 525   if (command == "bl")
 526   {
 527     if (parser->StartBootloader())
 528     {
 529       PrintToStdOut("entered bootloader mode. exiting cec-client");
 530       g_bExit = true;
 531       g_bHardExit = true;
 532     }
 533     return true;
 534   }
 535
 536   return false;
 537 }
 538
 539 bool ProcessCommandLANG(ICECAdapter *parser, const string &command, string &arguments)
 540 {
 541   if (command == "lang")
 542   {
 543     CStdString strDev;
 544     if (GetWord(arguments, strDev))
 545     {
 546       int iDev = atoi(strDev);
 547       if (iDev >= 0 && iDev < 15)
 548       {
 549         CStdString strLog;
 550         cec_menu_language language;
 551         if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
 552           strLog.Format("menu language '%s'", language.language);
 553         else
 554           strLog = "failed!";
 555         PrintToStdOut(strLog);
 556         return true;
 557       }
 558     }
 559   }
 560
 561   return false;
 562 }
 563
 564 bool ProcessCommandVEN(ICECAdapter *parser, const string &command, string &arguments)
 565 {
 566   if (command == "ven")
 567   {
 568     CStdString strDev;
 569     if (GetWord(arguments, strDev))
 570     {
 571       int iDev = atoi(strDev);
 572       if (iDev >= 0 && iDev < 15)
 573       {
 574         uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
 575         PrintToStdOut("vendor id: %06x", iVendor);
 576         return true;
 577       }
 578     }
 579   }
 580
 581   return false;
 582 }
 583
 584 bool ProcessCommandVER(ICECAdapter *parser, const string &command, string &arguments)
 585 {
 586   if (command == "ver")
 587   {
 588     CStdString strDev;
 589     if (GetWord(arguments, strDev))
 590     {
 591       int iDev = atoi(strDev);
 592       if (iDev >= 0 && iDev < 15)
 593       {
 594         cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
 595         PrintToStdOut("CEC version %s", parser->ToString(iVersion));
 596         return true;
 597       }
 598     }
 599   }
 600
 601   return false;
 602 }
 603
 604 bool ProcessCommandPOW(ICECAdapter *parser, const string &command, string &arguments)
 605 {
 606   if (command == "pow")
 607   {
 608     CStdString strDev;
 609     if (GetWord(arguments, strDev))
 610     {
 611       int iDev = atoi(strDev);
 612       if (iDev >= 0 && iDev < 15)
 613       {
 614         cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
 615         PrintToStdOut("power status: %s", parser->ToString(iPower));
 616         return true;
 617       }
 618     }
 619   }
 620
 621   return false;
 622 }
 623
 624 bool ProcessCommandNAME(ICECAdapter *parser, const string &command, string &arguments)
 625 {
 626   if (command == "name")
 627   {
 628     CStdString strDev;
 629     if (GetWord(arguments, strDev))
 630     {
 631       int iDev = atoi(strDev);
 632       if (iDev >= 0 && iDev < 15)
 633       {
 634         cec_osd_name name = parser->GetDeviceOSDName((cec_logical_address)iDev);
 635         PrintToStdOut("OSD name of device %d is '%s'", iDev, name.name);
 636       }
 637       return true;
 638     }
 639   }
 640
 641   return false;
 642 }
 643
 644 bool ProcessCommandLAD(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 645 {
 646   if (command == "lad")
 647   {
 648     PrintToStdOut("listing active devices:");
 649     cec_logical_addresses addresses = parser->GetActiveDevices();
 650     for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
 651       if (addresses[iPtr])
 652       {
 653         PrintToStdOut("logical address %X", (int)iPtr);
 654       }
 655     return true;
 656   }
 657
 658   return false;
 659 }
 660
 661 bool ProcessCommandAD(ICECAdapter *parser, const string &command, string &arguments)
 662 {
 663   if (command == "ad")
 664   {
 665     CStdString strDev;
 666     if (GetWord(arguments, strDev))
 667     {
 668       int iDev = atoi(strDev);
 669       if (iDev >= 0 && iDev < 15)
 670         PrintToStdOut("logical address %X is %s", iDev, (parser->IsActiveDevice((cec_logical_address)iDev) ? "active" : "not active"));
 671     }
 672   }
 673
 674   return false;
 675 }
 676
 677 bool ProcessCommandAT(ICECAdapter *parser, const string &command, string &arguments)
 678 {
 679   if (command == "at")
 680   {
 681     CStdString strType;
 682     if (GetWord(arguments, strType))
 683     {
 684       cec_device_type type = CEC_DEVICE_TYPE_TV;
 685       if (strType.Equals("a"))
 686         type = CEC_DEVICE_TYPE_AUDIO_SYSTEM;
 687       else if (strType.Equals("p"))
 688         type = CEC_DEVICE_TYPE_PLAYBACK_DEVICE;
 689       else if (strType.Equals("r"))
 690         type = CEC_DEVICE_TYPE_RECORDING_DEVICE;
 691       else if (strType.Equals("t"))
 692         type = CEC_DEVICE_TYPE_TUNER;
 693
 694       PrintToStdOut("device %d is %s", type, (parser->IsActiveDeviceType(type) ? "active" : "not active"));
 695       return true;
 696     }
 697   }
 698
 699   return false;
 700 }
 701
 702 bool ProcessCommandR(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 703 {
 704   if (command == "r")
 705   {
 706     PrintToStdOut("closing the connection");
 707     parser->Close();
 708
 709     PrintToStdOut("opening a new connection");
 710     parser->Open(g_strPort.c_str());
 711
 712     PrintToStdOut("setting active source");
 713     parser->SetActiveSource();
 714     return true;
 715   }
 716
 717   return false;
 718 }
 719
 720 bool ProcessCommandH(ICECAdapter * UNUSED(parser), const string &command, string & UNUSED(arguments))
 721 {
 722   if (command == "h" || command == "help")
 723   {
 724     ShowHelpConsole();
 725     return true;
 726   }
 727
 728   return false;
 729 }
 730
 731 bool ProcessCommandLOG(ICECAdapter * UNUSED(parser), const string &command, string &arguments)
 732 {
 733   if (command == "log")
 734   {
 735     CStdString strLevel;
 736     if (GetWord(arguments, strLevel))
 737     {
 738       int iNewLevel = atoi(strLevel);
 739       if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 740       {
 741         g_cecLogLevel = iNewLevel;
 742
 743         PrintToStdOut("log level changed to %s", strLevel.c_str());
 744         return true;
 745       }
 746     }
 747   }
 748
 749   return false;
 750 }
 751
 752 bool ProcessCommandSCAN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
 753 {
 754   if (command == "scan")
 755   {
 756     PrintToStdOut("CEC bus information");
 757     PrintToStdOut("===================");
 758     cec_logical_addresses addresses = parser->GetActiveDevices();
 759     for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
 760     {
 761       if (addresses[iPtr])
 762       {
 763         CStdString strLog;
 764         uint64_t iVendorId        = parser->GetDeviceVendorId((cec_logical_address)iPtr);
 765         bool     bActive          = parser->IsActiveSource((cec_logical_address)iPtr);
 766         uint16_t iPhysicalAddress = parser->GetDevicePhysicalAddress((cec_logical_address)iPtr);
 767         cec_version iCecVersion   = parser->GetDeviceCecVersion((cec_logical_address)iPtr);
 768         cec_power_status power    = parser->GetDevicePowerStatus((cec_logical_address)iPtr);
 769         cec_osd_name osdName      = parser->GetDeviceOSDName((cec_logical_address)iPtr);
 770         CStdString strAddr;
 771         strAddr.Format("%04x", iPhysicalAddress);
 772         cec_menu_language lang;
 773         lang.device = CECDEVICE_UNKNOWN;
 774         parser->GetDeviceMenuLanguage((cec_logical_address)iPtr, &lang);
 775
 776         strLog.AppendFormat("device #%X: %s\n", (int)iPtr, parser->ToString((cec_logical_address)iPtr));
 777         strLog.AppendFormat("address:       %s\n", strAddr.c_str());
 778         strLog.AppendFormat("active source: %s\n", (bActive ? "yes" : "no"));
 779         strLog.AppendFormat("vendor:        %s\n", parser->ToString((cec_vendor_id)iVendorId));
 780         strLog.AppendFormat("osd string:    %s\n", osdName.name);
 781         strLog.AppendFormat("CEC version:   %s\n", parser->ToString(iCecVersion));
 782         strLog.AppendFormat("power status:  %s\n", parser->ToString(power));
 783         if ((uint8_t)lang.device == iPtr)
 784           strLog.AppendFormat("language:      %s\n", lang.language);
 785         strLog.append("\n");
 786         PrintToStdOut(strLog);
 787       }
 788     }
 789     return true;
 790   }
 791
 792   return false;
 793 }
 794
 795 bool ProcessConsoleCommand(ICECAdapter *parser, string &input)
 796 {
 797   if (!input.empty())
 798   {
 799     string command;
 800     if (GetWord(input, command))
 801     {
 802       if (command == "q" || command == "quit")
 803         return false;
 804
 805       ProcessCommandTX(parser, command, input) ||
 806       ProcessCommandON(parser, command, input) ||
 807       ProcessCommandSTANDBY(parser, command, input) ||
 808       ProcessCommandPOLL(parser, command, input) ||
 809       ProcessCommandLA(parser, command, input) ||
 810       ProcessCommandP(parser, command, input) ||
 811       ProcessCommandPA(parser, command, input) ||
 812       ProcessCommandAS(parser, command, input) ||
 813       ProcessCommandOSD(parser, command, input) ||
 814       ProcessCommandPING(parser, command, input) ||
 815       ProcessCommandVOLUP(parser, command, input) ||
 816       ProcessCommandVOLDOWN(parser, command, input) ||
 817       ProcessCommandMUTE(parser, command, input) ||
 818       ProcessCommandMON(parser, command, input) ||
 819       ProcessCommandBL(parser, command, input) ||
 820       ProcessCommandLANG(parser, command, input) ||
 821       ProcessCommandVEN(parser, command, input) ||
 822       ProcessCommandVER(parser, command, input) ||
 823       ProcessCommandPOW(parser, command, input) ||
 824       ProcessCommandNAME(parser, command, input) ||
 825       ProcessCommandLAD(parser, command, input) ||
 826       ProcessCommandAD(parser, command, input) ||
 827       ProcessCommandAT(parser, command, input) ||
 828       ProcessCommandR(parser, command, input) ||
 829       ProcessCommandH(parser, command, input) ||
 830       ProcessCommandLOG(parser, command, input) ||
 831       ProcessCommandSCAN(parser, command, input);
 832     }
 833   }
 834   return true;
 835 }
 836
 837 bool ProcessCommandLineArguments(int argc, char *argv[])
 838 {
 839   bool bReturn(true);
 840   int iArgPtr = 1;
 841   while (iArgPtr < argc && bReturn)
 842   {
 843     if (argc >= iArgPtr + 1)
 844     {
 845       if (!strcmp(argv[iArgPtr], "-f") ||
 846           !strcmp(argv[iArgPtr], "--log-file") ||
 847           !strcmp(argv[iArgPtr], "-sf") ||
 848           !strcmp(argv[iArgPtr], "--short-log-file"))
 849       {
 850         if (argc >= iArgPtr + 2)
 851         {
 852           g_logOutput.open(argv[iArgPtr + 1]);
 853           g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
 854           iArgPtr += 2;
 855         }
 856         else
 857         {
 858           cout << "== skipped log-file parameter: no file given ==" << endl;
 859           ++iArgPtr;
 860         }
 861       }
 862       else if (!strcmp(argv[iArgPtr], "-d") ||
 863           !strcmp(argv[iArgPtr], "--log-level"))
 864       {
 865         if (argc >= iArgPtr + 2)
 866         {
 867           int iNewLevel = atoi(argv[iArgPtr + 1]);
 868           if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 869           {
 870             g_cecLogLevel = iNewLevel;
 871             if (!g_bSingleCommand)
 872               cout << "log level set to " << argv[iArgPtr + 1] << endl;
 873           }
 874           else
 875           {
 876             cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
 877           }
 878           iArgPtr += 2;
 879         }
 880         else
 881         {
 882           cout << "== skipped log-level parameter: no level given ==" << endl;
 883           ++iArgPtr;
 884         }
 885       }
 886       else if (!strcmp(argv[iArgPtr], "-t") ||
 887                !strcmp(argv[iArgPtr], "--type"))
 888       {
 889         if (argc >= iArgPtr + 2)
 890         {
 891           if (!strcmp(argv[iArgPtr + 1], "p"))
 892           {
 893             if (!g_bSingleCommand)
 894               cout << "== using device type 'playback device'" << endl;
 895             g_typeList.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
 896           }
 897           else if (!strcmp(argv[iArgPtr + 1], "r"))
 898           {
 899             if (!g_bSingleCommand)
 900               cout << "== using device type 'recording device'" << endl;
 901             g_typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
 902           }
 903           else if (!strcmp(argv[iArgPtr + 1], "t"))
 904           {
 905             if (!g_bSingleCommand)
 906               cout << "== using device type 'tuner'" << endl;
 907             g_typeList.add(CEC_DEVICE_TYPE_TUNER);
 908           }
 909           else if (!strcmp(argv[iArgPtr + 1], "a"))
 910           {
 911             if (!g_bSingleCommand)
 912               cout << "== using device type 'audio system'" << endl;
 913             g_typeList.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM);
 914           }
 915           else
 916           {
 917             cout << "== skipped invalid device type '" << argv[iArgPtr + 1] << "'" << endl;
 918           }
 919           ++iArgPtr;
 920         }
 921         ++iArgPtr;
 922       }
 923       else if (!strcmp(argv[iArgPtr], "--list-devices") ||
 924                !strcmp(argv[iArgPtr], "-l"))
 925       {
 926         ICECAdapter *parser = CreateParser(g_typeList);
 927         if (parser)
 928         {
 929           ListDevices(parser);
 930           UnloadLibCec(parser);
 931           parser = NULL;
 932         }
 933         bReturn = false;
 934       }
 935       else if (!strcmp(argv[iArgPtr], "--single-command") ||
 936           !strcmp(argv[iArgPtr], "-s"))
 937       {
 938         g_bSingleCommand = true;
 939         ++iArgPtr;
 940       }
 941       else if (!strcmp(argv[iArgPtr], "--help") ||
 942                !strcmp(argv[iArgPtr], "-h"))
 943       {
 944         ShowHelpCommandLine(argv[0]);
 945         return 0;
 946       }
 947       else if (!strcmp(argv[iArgPtr], "-b") ||
 948                !strcmp(argv[iArgPtr], "--base"))
 949       {
 950         if (argc >= iArgPtr + 2)
 951         {
 952           g_iBaseDevice = (cec_logical_address)atoi(argv[iArgPtr + 1]);
 953           cout << "using base device '" << (int)g_iBaseDevice << "'" << endl;
 954           ++iArgPtr;
 955         }
 956         ++iArgPtr;
 957       }
 958       else if (!strcmp(argv[iArgPtr], "-p") ||
 959                !strcmp(argv[iArgPtr], "--port"))
 960       {
 961         if (argc >= iArgPtr + 2)
 962         {
 963           g_iHDMIPort = (int8_t)atoi(argv[iArgPtr + 1]);
 964           cout << "using HDMI port '" << (int)g_iHDMIPort << "'" << endl;
 965           ++iArgPtr;
 966         }
 967         ++iArgPtr;
 968       }
 969       else
 970       {
 971         g_strPort = argv[iArgPtr++];
 972       }
 973     }
 974   }
 975
 976   return bReturn;
 977 }
 978
 979 int main (int argc, char *argv[])
 980 {
 981   g_typeList.clear();
 982
 983   if (!ProcessCommandLineArguments(argc, argv))
 984     return 0;
 985
 986   if (g_typeList.IsEmpty())
 987   {
 988     if (!g_bSingleCommand)
 989       cout << "No device type given. Using 'recording device'" << endl;
 990     g_typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
 991   }
 992
 993   ICECAdapter *parser = LibCecInit("CECTester", g_typeList);
 994   if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
 995   {
 996 #ifdef __WINDOWS__
 997     cout << "Cannot load libcec.dll" << endl;
 998 #else
 999     cout << "Cannot load libcec.so" << endl;
1000 #endif
1001
1002     if (parser)
1003       UnloadLibCec(parser);
1004
1005     return 1;
1006   }
1007
1008   if (!g_bSingleCommand)
1009   {
1010     CStdString strLog;
1011     strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
1012     cout << strLog.c_str() << endl;
1013
1014     //make stdin non-blocking
1015   #ifndef __WINDOWS__
1016     int flags = fcntl(0, F_GETFL, 0);
1017     flags |= O_NONBLOCK;
1018     fcntl(0, F_SETFL, flags);
1019   #endif
1020   }
1021
1022   if (g_strPort.IsEmpty())
1023   {
1024     if (!g_bSingleCommand)
1025       cout << "no serial port given. trying autodetect: ";
1026     cec_adapter devices[10];
1027     uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
1028     if (iDevicesFound <= 0)
1029     {
1030       if (g_bSingleCommand)
1031         cout << "autodetect ";
1032       cout << "FAILED" << endl;
1033       UnloadLibCec(parser);
1034       return 1;
1035     }
1036     else
1037     {
1038       if (!g_bSingleCommand)
1039       {
1040         cout << endl << " path:     " << devices[0].path << endl <<
1041             " com port: " << devices[0].comm << endl << endl;
1042       }
1043       g_strPort = devices[0].comm;
1044     }
1045   }
1046
1047   EnableCallbacks(parser);
1048
1049   parser->SetHDMIPort(g_iBaseDevice, g_iHDMIPort);
1050   PrintToStdOut("opening a connection to the CEC adapter...");
1051
1052   if (!parser->Open(g_strPort.c_str()))
1053   {
1054     PrintToStdOut("unable to open the device on port %s", g_strPort.c_str());
1055     UnloadLibCec(parser);
1056     return 1;
1057   }
1058
1059   if (!g_bSingleCommand)
1060   {
1061     PrintToStdOut("cec device opened");
1062
1063     parser->PowerOnDevices(CECDEVICE_TV);
1064     parser->SetActiveSource();
1065
1066     PrintToStdOut("waiting for input");
1067   }
1068
1069   while (!g_bExit && !g_bHardExit)
1070   {
1071     string input;
1072     getline(cin, input);
1073     cin.clear();
1074
1075     if (ProcessConsoleCommand(parser, input) && !g_bSingleCommand && !g_bExit && !g_bHardExit)
1076     {
1077       if (!input.empty())
1078         PrintToStdOut("waiting for input");
1079     }
1080     else
1081       g_bExit = true;
1082
1083     if (!g_bExit && !g_bHardExit)
1084       CCondition::Sleep(50);
1085   }
1086
1087   if (!g_bSingleCommand && !g_bHardExit)
1088     parser->StandbyDevices(CECDEVICE_BROADCAST);
1089
1090   parser->Close();
1091   UnloadLibCec(parser);
1092
1093   if (g_logOutput.is_open())
1094     g_logOutput.close();
1095
1096   return 0;
1097 }