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