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