Merge remote branch 'libcec-public/master'
[deb_libcec.git] / src / testclient / main.cpp
... / ...
CommitLineData
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
44using namespace CEC;
45using namespace std;
46using namespace PLATFORM;
47
48#include <cecloader.h>
49
50ICECCallbacks g_callbacks;
51libcec_configuration g_config;
52int g_cecLogLevel(CEC_LOG_ALL);
53ofstream g_logOutput;
54bool g_bShortLog(false);
55CStdString g_strPort;
56bool g_bSingleCommand(false);
57bool g_bExit(false);
58bool g_bHardExit(false);
59CMutex g_outputMutex;
60
61inline 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
74inline 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
94bool 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
126int 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
168int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &UNUSED(key))
169{
170 return 0;
171}
172
173int CecCommand(void *UNUSED(cbParam), const cec_command &UNUSED(command))
174{
175 return 0;
176}
177
178int 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
192void 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
231void 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
261void 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
305bool 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
327bool 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
345bool 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
363bool 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
386bool 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
406bool 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
426bool 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
449bool 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
464bool 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
479bool 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
497bool 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
523bool 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
535bool 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
546bool 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
557bool 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
568bool 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
579bool 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
594bool 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
610bool 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
635bool 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
655bool 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
675bool 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
695bool 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
715bool 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
732bool 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
748bool 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
773bool 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
791bool 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
802bool 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
823bool 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
871bool 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
916bool 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
1093int 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}