src/testclient/main.cpp

   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
  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/threads.h"
  42 #include "../lib/util/StdString.h"
  43
  44 using namespace CEC;
  45 using namespace std;
  46
  47 #define CEC_TEST_CLIENT_VERSION 1
  48
  49 #include <cecloader.h>
  50
  51 int        g_cecLogLevel = CEC_LOG_ALL;
  52 ofstream   g_logOutput;
  53 bool       g_bShortLog = false;
  54 CStdString g_strPort;
  55
  56 inline bool HexStrToInt(const std::string& data, uint8_t& value)
  57 {
  58   int iTmp(0);
  59   if (sscanf(data.c_str(), "%x", &iTmp) == 1)
  60   {
  61     if (iTmp > 256)
  62       value = 255;
  63           else if (iTmp < 0)
  64       value = 0;
  65     else
  66       value = (uint8_t) iTmp;
  67
  68     return true;
  69   }
  70
  71   return false;
  72 }
  73
  74 //get the first word (separated by whitespace) from string data and place that in word
  75 //then remove that word from string data
  76 bool GetWord(string& data, string& word)
  77 {
  78   stringstream datastream(data);
  79   string end;
  80
  81   datastream >> word;
  82   if (datastream.fail())
  83   {
  84     data.clear();
  85     return false;
  86   }
  87
  88   size_t pos = data.find(word) + word.length();
  89
  90   if (pos >= data.length())
  91   {
  92     data.clear();
  93     return true;
  94   }
  95
  96   data = data.substr(pos);
  97
  98   datastream.clear();
  99   datastream.str(data);
 100
 101   datastream >> end;
 102   if (datastream.fail())
 103     data.clear();
 104
 105   return true;
 106 }
 107
 108 void FlushLog(ICECAdapter *cecParser)
 109 {
 110   cec_log_message message;
 111   while (cecParser && cecParser->GetNextLogMessage(&message))
 112   {
 113     if ((message.level & g_cecLogLevel) == message.level)
 114     {
 115       CStdString strLevel;
 116       switch (message.level)
 117       {
 118       case CEC_LOG_ERROR:
 119         strLevel = "ERROR:   ";
 120         break;
 121       case CEC_LOG_WARNING:
 122         strLevel = "WARNING: ";
 123         break;
 124       case CEC_LOG_NOTICE:
 125         strLevel = "NOTICE:  ";
 126         break;
 127       case CEC_LOG_TRAFFIC:
 128         strLevel = "TRAFFIC: ";
 129         break;
 130       case CEC_LOG_DEBUG:
 131         strLevel = "DEBUG:   ";
 132         break;
 133       default:
 134         break;
 135       }
 136
 137       CStdString strFullLog;
 138       strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
 139       cout << strFullLog.c_str() << endl;
 140
 141       if (g_logOutput.is_open())
 142       {
 143         if (g_bShortLog)
 144           g_logOutput << message.message << endl;
 145         else
 146           g_logOutput << strFullLog.c_str() << endl;
 147       }
 148     }
 149   }
 150 }
 151
 152 void ListDevices(ICECAdapter *parser)
 153 {
 154   cec_adapter *devices = new cec_adapter[10];
 155   uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
 156   if (iDevicesFound <= 0)
 157   {
 158     cout << "Found devices: NONE" << endl;
 159   }
 160   else
 161   {
 162     CStdString strLog;
 163     strLog.Format("Found devices: %d", iDevicesFound);
 164     cout << strLog.c_str() << endl;
 165     for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
 166     {
 167       CStdString strDevice;
 168       strDevice.Format("device:        %d\npath:          %s\ncom port:      %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
 169       cout << endl << strDevice.c_str() << endl;
 170     }
 171   }
 172 }
 173
 174 void ShowHelpCommandLine(const char* strExec)
 175 {
 176   cout << endl <<
 177       strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
 178       endl <<
 179       "parameters:" << endl <<
 180       "  -h --help                   Shows this help text" << endl <<
 181       "  -l --list-devices           List all devices on this system" << endl <<
 182       "  -t --type {p|r|t|a}         The device type to use. More than one is possible." << endl <<
 183       "  -p --port {int}             The HDMI port to use as active source." << endl <<
 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 <<
 187       "  -d --log-level {level}      Sets the log level. See cectypes.h for values." << endl <<
 188       "  -s --single-command         Execute a single command and exit. Does not power" << endl <<
 189       "                              on devices on startup and power them off on exit." << endl <<
 190       "  [COM PORT]                  The com port to connect to. If no COM" << endl <<
 191       "                              port is given, the client tries to connect to the" << endl <<
 192       "                              first device that is detected." << endl <<
 193       endl <<
 194       "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
 195       "available commands" << endl;
 196 }
 197
 198 ICECAdapter *CreateParser(cec_device_type_list typeList)
 199 {
 200   ICECAdapter *parser = LibCecInit("CECTester", typeList);
 201   if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
 202   {
 203   #ifdef __WINDOWS__
 204     cout << "Cannot load libcec.dll" << endl;
 205   #else
 206     cout << "Cannot load libcec.so" << endl;
 207   #endif
 208     return NULL;
 209   }
 210
 211   CStdString strLog;
 212   strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
 213   cout << strLog.c_str() << endl;
 214
 215   return parser;
 216 }
 217
 218 void ShowHelpConsole(void)
 219 {
 220   cout << endl <<
 221   "================================================================================" << endl <<
 222   "Available commands:" << endl <<
 223   endl <<
 224   "[tx] {bytes}              transfer bytes over the CEC line." << endl <<
 225   "[txn] {bytes}             transfer bytes but don't wait for transmission ACK." << endl <<
 226   "[on] {address}            power on the device with the given logical address." << endl <<
 227   "[standby] {address}       put the device with the given address in standby mode." << endl <<
 228   "[la] {logical address}    change the logical address of the CEC adapter." << endl <<
 229   "[p] {port number}         change the HDMI port number of the CEC adapter." << endl <<
 230   "[pa] {physical address}   change the physical address of the CEC adapter." << endl <<
 231   "[osd] {addr} {string}     set OSD message on the specified device." << endl <<
 232   "[ver] {addr}              get the CEC version of the specified device." << endl <<
 233   "[ven] {addr}              get the vendor ID of the specified device." << endl <<
 234   "[lang] {addr}             get the menu language of the specified device." << endl <<
 235   "[pow] {addr}              get the power status of the specified device." << endl <<
 236   "[poll] {addr}             poll the specified device." << endl <<
 237   "[lad]                     lists active devices on the bus" << endl <<
 238   "[ad] {addr}               checks whether the specified device is active." << endl <<
 239   "[at] {type}               checks whether the specified device type is active." << endl <<
 240   "[volup]                   send a volume up command to the amp if present" << endl <<
 241   "[voldown]                 send a volume down command to the amp if present" << endl <<
 242   "[mute]                    send a mute/unmute command to the amp if present" << endl <<
 243   "[mon] {1|0}               enable or disable CEC bus monitoring." << endl <<
 244   "[log] {1 - 31}            change the log level. see cectypes.h for values." << endl <<
 245   "[ping]                    send a ping command to the CEC adapter." << endl <<
 246   "[bl]                      to let the adapter enter the bootloader, to upgrade" << endl <<
 247   "                          the flash rom." << endl <<
 248   "[r]                       reconnect to the CEC adapter." << endl <<
 249   "[h] or [help]             show this help." << endl <<
 250   "[q] or [quit]             to quit the CEC test client and switch off all" << endl <<
 251   "                          connected CEC devices." << endl <<
 252   "================================================================================" << endl;
 253 }
 254
 255 int main (int argc, char *argv[])
 256 {
 257   int8_t iHDMIPort(-1);
 258   cec_device_type_list typeList;
 259   typeList.clear();
 260
 261   int iArgPtr = 1;
 262   bool bSingleCommand(false);
 263   while (iArgPtr < argc)
 264   {
 265     if (argc >= iArgPtr + 1)
 266     {
 267       if (!strcmp(argv[iArgPtr], "-f") ||
 268           !strcmp(argv[iArgPtr], "--log-file") ||
 269           !strcmp(argv[iArgPtr], "-sf") ||
 270           !strcmp(argv[iArgPtr], "--short-log-file"))
 271       {
 272         if (argc >= iArgPtr + 2)
 273         {
 274           g_logOutput.open(argv[iArgPtr + 1]);
 275           g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
 276           iArgPtr += 2;
 277         }
 278         else
 279         {
 280           cout << "== skipped log-file parameter: no file given ==" << endl;
 281           ++iArgPtr;
 282         }
 283       }
 284       else if (!strcmp(argv[iArgPtr], "-d") ||
 285           !strcmp(argv[iArgPtr], "--log-level"))
 286       {
 287         if (argc >= iArgPtr + 2)
 288         {
 289           int iNewLevel = atoi(argv[iArgPtr + 1]);
 290           if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 291           {
 292             g_cecLogLevel = iNewLevel;
 293             if (!bSingleCommand)
 294               cout << "log level set to " << argv[iArgPtr + 1] << endl;
 295           }
 296           else
 297           {
 298             cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
 299           }
 300           iArgPtr += 2;
 301         }
 302         else
 303         {
 304           cout << "== skipped log-level parameter: no level given ==" << endl;
 305           ++iArgPtr;
 306         }
 307       }
 308       else if (!strcmp(argv[iArgPtr], "-t") ||
 309                !strcmp(argv[iArgPtr], "--type"))
 310       {
 311         if (argc >= iArgPtr + 2)
 312         {
 313           if (!strcmp(argv[iArgPtr + 1], "p"))
 314           {
 315             if (!bSingleCommand)
 316               cout << "== using device type 'playback device'" << endl;
 317             typeList.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
 318           }
 319           else if (!strcmp(argv[iArgPtr + 1], "r"))
 320           {
 321             if (!bSingleCommand)
 322               cout << "== using device type 'recording device'" << endl;
 323             typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
 324           }
 325           else if (!strcmp(argv[iArgPtr + 1], "t"))
 326           {
 327             if (!bSingleCommand)
 328               cout << "== using device type 'tuner'" << endl;
 329             typeList.add(CEC_DEVICE_TYPE_TUNER);
 330           }
 331           else if (!strcmp(argv[iArgPtr + 1], "a"))
 332           {
 333             if (!bSingleCommand)
 334               cout << "== using device type 'audio system'" << endl;
 335             typeList.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM);
 336           }
 337           else
 338           {
 339             cout << "== skipped invalid device type '" << argv[iArgPtr + 1] << "'" << endl;
 340           }
 341           ++iArgPtr;
 342         }
 343         ++iArgPtr;
 344       }
 345       else if (!strcmp(argv[iArgPtr], "--list-devices") ||
 346                !strcmp(argv[iArgPtr], "-l"))
 347       {
 348         ICECAdapter *parser = CreateParser(typeList);
 349         if (parser)
 350         {
 351           ListDevices(parser);
 352           UnloadLibCec(parser);
 353         }
 354         return 0;
 355       }
 356       else if (!strcmp(argv[iArgPtr], "--single-command") ||
 357           !strcmp(argv[iArgPtr], "-s"))
 358       {
 359         bSingleCommand = true;
 360         ++iArgPtr;
 361       }
 362       else if (!strcmp(argv[iArgPtr], "--help") ||
 363                !strcmp(argv[iArgPtr], "-h"))
 364       {
 365         ShowHelpCommandLine(argv[0]);
 366         return 0;
 367       }
 368       else if (!strcmp(argv[iArgPtr], "-p") ||
 369                !strcmp(argv[iArgPtr], "--port"))
 370       {
 371         if (argc >= iArgPtr + 2)
 372         {
 373           iHDMIPort= atoi(argv[iArgPtr + 1]);
 374           cout << "using HDMI port '" << iHDMIPort << "'" << endl;
 375           ++iArgPtr;
 376         }
 377         ++iArgPtr;
 378       }
 379       else
 380       {
 381         g_strPort = argv[iArgPtr++];
 382       }
 383     }
 384   }
 385
 386   if (typeList.IsEmpty())
 387   {
 388     if (!bSingleCommand)
 389       cout << "No device type given. Using 'recording device'" << endl;
 390     typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
 391   }
 392
 393   ICECAdapter *parser = LibCecInit("CECTester", typeList);
 394   if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
 395   {
 396 #ifdef __WINDOWS__
 397     cout << "Cannot load libcec.dll" << endl;
 398 #else
 399     cout << "Cannot load libcec.so" << endl;
 400 #endif
 401     return 1;
 402   }
 403
 404   if (!bSingleCommand)
 405   {
 406     CStdString strLog;
 407     strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
 408     cout << strLog.c_str() << endl;
 409
 410     //make stdin non-blocking
 411   #ifndef __WINDOWS__
 412     int flags = fcntl(0, F_GETFL, 0);
 413     flags |= O_NONBLOCK;
 414     fcntl(0, F_SETFL, flags);
 415   #endif
 416   }
 417
 418   if (g_strPort.IsEmpty())
 419   {
 420     if (!bSingleCommand)
 421       cout << "no serial port given. trying autodetect: ";
 422     cec_adapter devices[10];
 423     uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
 424     if (iDevicesFound <= 0)
 425     {
 426       if (bSingleCommand)
 427         cout << "autodetect ";
 428       cout << "FAILED" << endl;
 429       UnloadLibCec(parser);
 430       return 1;
 431     }
 432     else
 433     {
 434       if (!bSingleCommand)
 435       {
 436         cout << endl << " path:     " << devices[0].path << endl <<
 437             " com port: " << devices[0].comm << endl << endl;
 438       }
 439       g_strPort = devices[0].comm;
 440     }
 441   }
 442
 443   if (iHDMIPort > 0)
 444   {
 445     parser->SetHDMIPort((uint8_t)iHDMIPort);
 446     FlushLog(parser);
 447   }
 448
 449   cout << "scanning the CEC bus..." << endl;
 450
 451   if (!parser->Open(g_strPort.c_str()))
 452   {
 453     cout << "unable to open the device on port " << g_strPort << endl;
 454     FlushLog(parser);
 455     UnloadLibCec(parser);
 456     return 1;
 457   }
 458
 459   if (!bSingleCommand)
 460   {
 461     cout << "cec device opened" << endl;
 462
 463     parser->PowerOnDevices(CECDEVICE_TV);
 464     FlushLog(parser);
 465
 466     parser->SetActiveSource();
 467     FlushLog(parser);
 468
 469     cout << "waiting for input" << endl;
 470   }
 471
 472   bool bContinue(true);
 473   while (bContinue)
 474   {
 475     if (bSingleCommand)
 476       bContinue = false;
 477
 478     FlushLog(parser);
 479
 480     /* just ignore the command buffer and clear it */
 481     cec_command dummy;
 482     while (parser && parser->GetNextCommand(&dummy)) {}
 483
 484     string input;
 485     getline(cin, input);
 486     cin.clear();
 487
 488     if (!input.empty())
 489     {
 490       string command;
 491       if (GetWord(input, command))
 492       {
 493         if (command == "tx" || command == "txn")
 494         {
 495           string strvalue;
 496           uint8_t ivalue;
 497           cec_command bytes;
 498           bytes.Clear();
 499
 500           while (GetWord(input, strvalue) && HexStrToInt(strvalue, ivalue))
 501             bytes.PushBack(ivalue);
 502
 503           if (command == "txn")
 504             bytes.transmit_timeout = 0;
 505
 506           parser->Transmit(bytes);
 507         }
 508         else if (command == "on")
 509         {
 510           string strValue;
 511           uint8_t iValue = 0;
 512           if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 513           {
 514             parser->PowerOnDevices((cec_logical_address) iValue);
 515           }
 516           else
 517           {
 518             cout << "invalid destination" << endl;
 519           }
 520         }
 521         else if (command == "standby")
 522         {
 523           string strValue;
 524           uint8_t iValue = 0;
 525           if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 526           {
 527             parser->StandbyDevices((cec_logical_address) iValue);
 528           }
 529           else
 530           {
 531             cout << "invalid destination" << endl;
 532           }
 533         }
 534         else if (command == "poll")
 535         {
 536           string strValue;
 537           uint8_t iValue = 0;
 538           if (GetWord(input, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
 539           {
 540             if (parser->PollDevice((cec_logical_address) iValue))
 541               cout << "POLL message sent" << endl;
 542             else
 543               cout << "POLL message not sent" << endl;
 544           }
 545           else
 546           {
 547             cout << "invalid destination" << endl;
 548           }
 549         }
 550         else if (command == "la")
 551         {
 552           string strvalue;
 553           if (GetWord(input, strvalue))
 554           {
 555             parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
 556           }
 557         }
 558         else if (command == "p")
 559         {
 560           string strvalue;
 561           if (GetWord(input, strvalue))
 562           {
 563             parser->SetHDMIPort(atoi(strvalue.c_str()));
 564           }
 565         }
 566         else if (command == "pa")
 567         {
 568           string strB1, strB2;
 569           uint8_t iB1, iB2;
 570           if (GetWord(input, strB1) && HexStrToInt(strB1, iB1) &&
 571               GetWord(input, strB2) && HexStrToInt(strB2, iB2))
 572           {
 573             uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
 574             parser->SetPhysicalAddress(iPhysicalAddress);
 575           }
 576         }
 577         else if (command == "osd")
 578         {
 579           bool bFirstWord(false);
 580           string strAddr, strMessage, strWord;
 581           uint8_t iAddr;
 582           if (GetWord(input, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
 583           {
 584             while (GetWord(input, strWord))
 585             {
 586               if (bFirstWord)
 587               {
 588                 bFirstWord = false;
 589                 strMessage.append(" ");
 590               }
 591               strMessage.append(strWord);
 592             }
 593             parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
 594           }
 595         }
 596         else if (command == "ping")
 597         {
 598           parser->PingAdapter();
 599         }
 600         else if (command == "volup")
 601         {
 602           parser->VolumeUp();
 603         }
 604         else if (command == "voldown")
 605         {
 606           parser->VolumeDown();
 607         }
 608         else if (command == "mute")
 609         {
 610           parser->MuteAudio();
 611         }
 612         else if (command == "mon")
 613         {
 614           CStdString strEnable;
 615           if (GetWord(input, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
 616           {
 617             parser->SwitchMonitoring(strEnable.Equals("1"));
 618           }
 619         }
 620         else if (command == "bl")
 621         {
 622           parser->StartBootloader();
 623         }
 624         else if (command == "lang")
 625         {
 626           CStdString strDev;
 627           if (GetWord(input, strDev))
 628           {
 629             int iDev = atoi(strDev);
 630             if (iDev >= 0 && iDev < 15)
 631             {
 632               CStdString strLog;
 633               cec_menu_language language;
 634               if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
 635                 strLog.Format("menu language '%s'", language.language);
 636               else
 637                 strLog = "failed!";
 638               cout << strLog.c_str() << endl;
 639             }
 640           }
 641         }
 642         else if (command == "ven")
 643         {
 644           CStdString strDev;
 645           if (GetWord(input, strDev))
 646           {
 647             int iDev = atoi(strDev);
 648             if (iDev >= 0 && iDev < 15)
 649             {
 650               uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
 651               CStdString strLog;
 652               strLog.Format("vendor id: %06x", iVendor);
 653               cout << strLog.c_str() << endl;
 654             }
 655           }
 656         }
 657         else if (command == "ver")
 658         {
 659           CStdString strDev;
 660           if (GetWord(input, 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               switch (iVersion)
 667               {
 668               case CEC_VERSION_1_2:
 669                 cout << "CEC version 1.2" << endl;
 670                 break;
 671               case CEC_VERSION_1_2A:
 672                 cout << "CEC version 1.2a" << endl;
 673                 break;
 674               case CEC_VERSION_1_3:
 675                 cout << "CEC version 1.3" << endl;
 676                 break;
 677               case CEC_VERSION_1_3A:
 678                 cout << "CEC version 1.3a" << endl;
 679                 break;
 680               default:
 681                 cout << "unknown CEC version" << endl;
 682                 break;
 683               }
 684             }
 685           }
 686         }
 687         else if (command == "pow")
 688         {
 689           CStdString strDev;
 690           if (GetWord(input, strDev))
 691           {
 692             int iDev = atoi(strDev);
 693             if (iDev >= 0 && iDev < 15)
 694             {
 695               cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
 696               switch (iPower)
 697               {
 698               case CEC_POWER_STATUS_ON:
 699                 cout << "powered on" << endl;
 700                 break;
 701               case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
 702                 cout << "on -> standby" << endl;
 703                 break;
 704               case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
 705                 cout << "standby -> on" << endl;
 706                 break;
 707               case CEC_POWER_STATUS_STANDBY:
 708                 cout << "standby" << endl;
 709                 break;
 710               default:
 711                 cout << "unknown power status" << endl;
 712                 break;
 713               }
 714             }
 715           }
 716         }
 717         else if (command == "lad")
 718         {
 719           cout << "listing active devices:" << endl;
 720           cec_logical_addresses addresses = parser->GetActiveDevices();
 721           for (unsigned iPtr = 0; iPtr < 16; iPtr++)
 722             if (addresses[iPtr])
 723               cout << "logical address " << iPtr << endl;
 724         }
 725         else if (command == "ad")
 726         {
 727           CStdString strDev;
 728           if (GetWord(input, strDev))
 729           {
 730             int iDev = atoi(strDev);
 731             if (iDev >= 0 && iDev < 15)
 732               cout << "logical address " << iDev << " is " << (parser->IsActiveDevice((cec_logical_address)iDev) ? "active" : "not active") << endl;
 733           }
 734         }
 735         else if (command == "at")
 736         {
 737           CStdString strType;
 738           if (GetWord(input, strType))
 739           {
 740             cec_device_type type = CEC_DEVICE_TYPE_TV;
 741             if (strType.Equals("a"))
 742               type = CEC_DEVICE_TYPE_AUDIO_SYSTEM;
 743             else if (strType.Equals("p"))
 744               type = CEC_DEVICE_TYPE_PLAYBACK_DEVICE;
 745             else if (strType.Equals("r"))
 746               type = CEC_DEVICE_TYPE_RECORDING_DEVICE;
 747             else if (strType.Equals("t"))
 748               type = CEC_DEVICE_TYPE_TUNER;
 749             cout << "device " << type << " is " << (parser->IsActiveDeviceType(type) ? "active" : "not active") << endl;
 750           }
 751         }
 752         else if (command == "r")
 753         {
 754           cout << "closing the connection" << endl;
 755           parser->Close();
 756           FlushLog(parser);
 757
 758           cout << "opening a new connection" << endl;
 759           parser->Open(g_strPort.c_str());
 760           FlushLog(parser);
 761
 762           cout << "setting active source" << endl;
 763           parser->SetActiveSource();
 764         }
 765         else if (command == "h" || command == "help")
 766         {
 767           ShowHelpConsole();
 768         }
 769         else if (command == "q" || command == "quit")
 770         {
 771           bContinue = false;
 772         }
 773         else if (command == "log")
 774         {
 775           CStdString strLevel;
 776           if (GetWord(input, strLevel))
 777           {
 778             int iNewLevel = atoi(strLevel);
 779             if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
 780             {
 781               g_cecLogLevel = iNewLevel;
 782               cout << "log level changed to " << strLevel.c_str() << endl;
 783             }
 784           }
 785         }
 786       }
 787       if (bContinue)
 788         cout << "waiting for input" << endl;
 789     }
 790
 791     if (bContinue)
 792       CCondition::Sleep(50);
 793   }
 794
 795   if (!bSingleCommand)
 796     parser->StandbyDevices(CECDEVICE_BROADCAST);
 797
 798   parser->Close();
 799   FlushLog(parser);
 800   UnloadLibCec(parser);
 801
 802   if (g_logOutput.is_open())
 803     g_logOutput.close();
 804
 805   return 0;
 806 }