2 * This file is part of the libCEC(R) library.
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
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.
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.
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.
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
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/
33 #include "../../include/cec.h"
41 #include "../lib/platform/os.h"
42 #include "../lib/implementations/CECCommandHandler.h"
46 using namespace PLATFORM
;
48 #include <cecloader.h>
50 ICECCallbacks g_callbacks
;
51 libcec_configuration g_config
;
52 int g_cecLogLevel(CEC_LOG_ALL
);
54 bool g_bShortLog(false);
56 bool g_bSingleCommand(false);
58 bool g_bHardExit(false);
61 inline void PrintToStdOut(const char *strFormat
, ...)
66 va_start(argList
, strFormat
);
67 strLog
.FormatV(strFormat
, argList
);
70 CLockObject
lock(g_outputMutex
);
71 cout
<< strLog
<< endl
;
74 inline bool HexStrToInt(const std::string
& data
, uint8_t& value
)
77 if (sscanf(data
.c_str(), "%x", &iTmp
) == 1)
84 value
= (uint8_t) iTmp
;
92 //get the first word (separated by whitespace) from string data and place that in word
93 //then remove that word from string data
94 bool GetWord(string
& data
, string
& word
)
96 stringstream
datastream(data
);
100 if (datastream
.fail())
106 size_t pos
= data
.find(word
) + word
.length();
108 if (pos
>= data
.length())
114 data
= data
.substr(pos
);
117 datastream
.str(data
);
120 if (datastream
.fail())
126 int CecLogMessage(void *UNUSED(cbParam
), const cec_log_message
&message
)
128 if ((message
.level
& g_cecLogLevel
) == message
.level
)
131 switch (message
.level
)
134 strLevel
= "ERROR: ";
136 case CEC_LOG_WARNING
:
137 strLevel
= "WARNING: ";
140 strLevel
= "NOTICE: ";
142 case CEC_LOG_TRAFFIC
:
143 strLevel
= "TRAFFIC: ";
146 strLevel
= "DEBUG: ";
152 CStdString strFullLog
;
153 strFullLog
.Format("%s[%16lld]\t%s", strLevel
.c_str(), message
.time
, message
.message
);
154 PrintToStdOut(strFullLog
.c_str());
156 if (g_logOutput
.is_open())
159 g_logOutput
<< message
.message
<< endl
;
161 g_logOutput
<< strFullLog
.c_str() << endl
;
168 int CecKeyPress(void *UNUSED(cbParam
), const cec_keypress
&UNUSED(key
))
173 int CecCommand(void *UNUSED(cbParam
), const cec_command
&UNUSED(command
))
178 int CecAlert(void *UNUSED(cbParam
), const libcec_alert type
, const libcec_parameter
&UNUSED(param
))
182 case CEC_ALERT_CONNECTION_LOST
:
183 PrintToStdOut("Connection lost - exiting\n");
192 void ListDevices(ICECAdapter
*parser
)
194 cec_adapter
*devices
= new cec_adapter
[10];
195 int8_t iDevicesFound
= parser
->FindAdapters(devices
, 10, NULL
);
196 if (iDevicesFound
<= 0)
198 PrintToStdOut("Found devices: NONE");
202 CStdString strDeviceInfo
;
203 strDeviceInfo
.Format("Found devices: %d\n\n", iDevicesFound
);
205 for (int8_t iDevicePtr
= 0; iDevicePtr
< iDevicesFound
; iDevicePtr
++)
207 strDeviceInfo
.AppendFormat("device: %d\ncom port: %s\n", iDevicePtr
+ 1, devices
[iDevicePtr
].comm
);
208 libcec_configuration config
;
211 if (!parser
->GetDeviceInformation(devices
[iDevicePtr
].comm
, &config
))
212 PrintToStdOut("WARNING: unable to open the device on port %s", devices
[iDevicePtr
].comm
);
215 strDeviceInfo
.AppendFormat("firmware version: %d\n", config
.iFirmwareVersion
);
217 if (config
.iFirmwareBuildDate
!= CEC_DEFAULT_FIRMWARE_BUILD_DATE
)
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");
225 strDeviceInfo
.append("\n");
227 PrintToStdOut(strDeviceInfo
.c_str());
231 void ShowHelpCommandLine(const char* strExec
)
233 CLockObject
lock(g_outputMutex
);
235 strExec
<< " {-h|--help|-l|--list-devices|[COM PORT]}" << 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 " [COM PORT] The com port to connect to. If no COM" << endl
<<
253 " port is given, the client tries to connect to the" << endl
<<
254 " first device that is detected." << endl
<<
256 "Type 'h' or 'help' and press enter after starting the client to display all " << endl
<<
257 "available commands" << endl
;
260 void ShowHelpConsole(void)
262 CLockObject
lock(g_outputMutex
);
264 "================================================================================" << endl
<<
265 "Available commands:" << endl
<<
267 "[tx] {bytes} transfer bytes over the CEC line." << endl
<<
268 "[txn] {bytes} transfer bytes but don't wait for transmission ACK." << endl
<<
269 "[on] {address} power on the device with the given logical address." << endl
<<
270 "[standby] {address} put the device with the given address in standby mode." << endl
<<
271 "[la] {logical address} change the logical address of the CEC adapter." << endl
<<
272 "[p] {device} {port} change the HDMI port number of the CEC adapter." << endl
<<
273 "[pa] {physical address} change the physical address of the CEC adapter." << endl
<<
274 "[as] make the CEC adapter the active source." << endl
<<
275 "[osd] {addr} {string} set OSD message on the specified device." << endl
<<
276 "[ver] {addr} get the CEC version of the specified device." << endl
<<
277 "[ven] {addr} get the vendor ID of the specified device." << endl
<<
278 "[lang] {addr} get the menu language of the specified device." << endl
<<
279 "[pow] {addr} get the power status of the specified device." << endl
<<
280 "[name] {addr} get the OSD name of the specified device." << endl
<<
281 "[poll] {addr} poll the specified device." << endl
<<
282 "[lad] lists active devices on the bus" << endl
<<
283 "[ad] {addr} checks whether the specified device is active." << endl
<<
284 "[at] {type} checks whether the specified device type is active." << endl
<<
285 "[sp] {addr} makes the specified physical address active." << endl
<<
286 "[spl] {addr} makes the specified logical address active." << endl
<<
287 "[volup] send a volume up command to the amp if present" << endl
<<
288 "[voldown] send a volume down command to the amp if present" << endl
<<
289 "[mute] send a mute/unmute command to the amp if present" << endl
<<
290 "[self] show the list of addresses controlled by libCEC" << endl
<<
291 "[scan] scan the CEC bus and display device info" << endl
<<
292 "[mon] {1|0} enable or disable CEC bus monitoring." << endl
<<
293 "[log] {1 - 31} change the log level. see cectypes.h for values." << endl
<<
294 "[ping] send a ping command to the CEC adapter." << endl
<<
295 "[bl] to let the adapter enter the bootloader, to upgrade" << endl
<<
296 " the flash rom." << endl
<<
297 "[r] reconnect to the CEC adapter." << endl
<<
298 "[h] or [help] show this help." << endl
<<
299 "[q] or [quit] to quit the CEC test client and switch off all" << endl
<<
300 " connected CEC devices." << endl
<<
301 "================================================================================" << endl
;
304 bool ProcessCommandSELF(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
306 if (command
== "self")
308 cec_logical_addresses addr
= parser
->GetLogicalAddresses();
309 CStdString strOut
= "Addresses controlled by libCEC: ";
311 for (uint8_t iPtr
= 0; iPtr
<= 15; iPtr
++)
315 strOut
.AppendFormat((bFirst
? "%d%s" : ", %d%s"), iPtr
, parser
->IsActiveSource((cec_logical_address
)iPtr
) ? "*" : "");
319 PrintToStdOut(strOut
.c_str());
326 bool ProcessCommandSP(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
332 if (GetWord(arguments
, strAddress
))
334 sscanf(strAddress
.c_str(), "%x", &iAddress
);
335 if (iAddress
>= 0 && iAddress
<= CEC_INVALID_PHYSICAL_ADDRESS
)
336 parser
->SetStreamPath((uint16_t)iAddress
);
344 bool ProcessCommandSPL(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
346 if (command
== "spl")
349 cec_logical_address iAddress
;
350 if (GetWord(arguments
, strAddress
))
352 iAddress
= (cec_logical_address
)atoi(strAddress
.c_str());
353 if (iAddress
>= CECDEVICE_TV
&& iAddress
< CECDEVICE_BROADCAST
)
354 parser
->SetStreamPath(iAddress
);
362 bool ProcessCommandTX(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
364 if (command
== "tx" || command
== "txn")
371 while (GetWord(arguments
, strvalue
) && HexStrToInt(strvalue
, ivalue
))
372 bytes
.PushBack(ivalue
);
374 if (command
== "txn")
375 bytes
.transmit_timeout
= 0;
377 parser
->Transmit(bytes
);
385 bool ProcessCommandON(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
391 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
393 parser
->PowerOnDevices((cec_logical_address
) iValue
);
398 PrintToStdOut("invalid destination");
405 bool ProcessCommandSTANDBY(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
407 if (command
== "standby")
411 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
413 parser
->StandbyDevices((cec_logical_address
) iValue
);
418 PrintToStdOut("invalid destination");
425 bool ProcessCommandPOLL(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
427 if (command
== "poll")
431 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
433 if (parser
->PollDevice((cec_logical_address
) iValue
))
434 PrintToStdOut("POLL message sent");
436 PrintToStdOut("POLL message not sent");
441 PrintToStdOut("invalid destination");
448 bool ProcessCommandLA(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
453 if (GetWord(arguments
, strvalue
))
455 parser
->SetLogicalAddress((cec_logical_address
) atoi(strvalue
.c_str()));
463 bool ProcessCommandP(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
467 string strPort
, strDevice
;
468 if (GetWord(arguments
, strDevice
) && GetWord(arguments
, strPort
))
470 parser
->SetHDMIPort((cec_logical_address
)atoi(strDevice
.c_str()), (uint8_t)atoi(strPort
.c_str()));
478 bool ProcessCommandPA(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
484 if (GetWord(arguments
, strB1
) && HexStrToInt(strB1
, iB1
) &&
485 GetWord(arguments
, strB2
) && HexStrToInt(strB2
, iB2
))
487 uint16_t iPhysicalAddress
= ((uint16_t)iB1
<< 8) + iB2
;
488 parser
->SetPhysicalAddress(iPhysicalAddress
);
496 bool ProcessCommandOSD(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
498 if (command
== "osd")
500 bool bFirstWord(false);
501 string strAddr
, strMessage
, strWord
;
503 if (GetWord(arguments
, strAddr
) && HexStrToInt(strAddr
, iAddr
) && iAddr
< 0xF)
505 while (GetWord(arguments
, strWord
))
510 strMessage
.append(" ");
512 strMessage
.append(strWord
);
514 parser
->SetOSDString((cec_logical_address
) iAddr
, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME
, strMessage
.c_str());
522 bool ProcessCommandAS(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
526 parser
->SetActiveSource();
534 bool ProcessCommandPING(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
536 if (command
== "ping")
538 parser
->PingAdapter();
545 bool ProcessCommandVOLUP(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
547 if (command
== "volup")
549 PrintToStdOut("volume up: %2X", parser
->VolumeUp());
556 bool ProcessCommandVOLDOWN(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
558 if (command
== "voldown")
560 PrintToStdOut("volume down: %2X", parser
->VolumeDown());
567 bool ProcessCommandMUTE(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
569 if (command
== "mute")
571 PrintToStdOut("mute: %2X", parser
->MuteAudio());
578 bool ProcessCommandMON(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
580 if (command
== "mon")
582 CStdString strEnable
;
583 if (GetWord(arguments
, strEnable
) && (strEnable
.Equals("0") || strEnable
.Equals("1")))
585 parser
->SwitchMonitoring(strEnable
.Equals("1"));
593 bool ProcessCommandBL(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
597 if (parser
->StartBootloader())
599 PrintToStdOut("entered bootloader mode. exiting cec-client");
609 bool ProcessCommandLANG(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
611 if (command
== "lang")
614 if (GetWord(arguments
, strDev
))
616 int iDev
= atoi(strDev
);
617 if (iDev
>= 0 && iDev
< 15)
620 cec_menu_language language
;
621 if (parser
->GetDeviceMenuLanguage((cec_logical_address
) iDev
, &language
))
622 strLog
.Format("menu language '%s'", language
.language
);
625 PrintToStdOut(strLog
);
634 bool ProcessCommandVEN(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
636 if (command
== "ven")
639 if (GetWord(arguments
, strDev
))
641 int iDev
= atoi(strDev
);
642 if (iDev
>= 0 && iDev
< 15)
644 uint64_t iVendor
= parser
->GetDeviceVendorId((cec_logical_address
) iDev
);
645 PrintToStdOut("vendor id: %06x", iVendor
);
654 bool ProcessCommandVER(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
656 if (command
== "ver")
659 if (GetWord(arguments
, strDev
))
661 int iDev
= atoi(strDev
);
662 if (iDev
>= 0 && iDev
< 15)
664 cec_version iVersion
= parser
->GetDeviceCecVersion((cec_logical_address
) iDev
);
665 PrintToStdOut("CEC version %s", parser
->ToString(iVersion
));
674 bool ProcessCommandPOW(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
676 if (command
== "pow")
679 if (GetWord(arguments
, strDev
))
681 int iDev
= atoi(strDev
);
682 if (iDev
>= 0 && iDev
< 15)
684 cec_power_status iPower
= parser
->GetDevicePowerStatus((cec_logical_address
) iDev
);
685 PrintToStdOut("power status: %s", parser
->ToString(iPower
));
694 bool ProcessCommandNAME(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
696 if (command
== "name")
699 if (GetWord(arguments
, strDev
))
701 int iDev
= atoi(strDev
);
702 if (iDev
>= 0 && iDev
< 15)
704 cec_osd_name name
= parser
->GetDeviceOSDName((cec_logical_address
)iDev
);
705 PrintToStdOut("OSD name of device %d is '%s'", iDev
, name
.name
);
714 bool ProcessCommandLAD(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
716 if (command
== "lad")
718 PrintToStdOut("listing active devices:");
719 cec_logical_addresses addresses
= parser
->GetActiveDevices();
720 for (uint8_t iPtr
= 0; iPtr
<= 11; iPtr
++)
723 PrintToStdOut("logical address %X", (int)iPtr
);
731 bool ProcessCommandAD(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
736 if (GetWord(arguments
, strDev
))
738 int iDev
= atoi(strDev
);
739 if (iDev
>= 0 && iDev
< 15)
740 PrintToStdOut("logical address %X is %s", iDev
, (parser
->IsActiveDevice((cec_logical_address
)iDev
) ? "active" : "not active"));
747 bool ProcessCommandAT(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
752 if (GetWord(arguments
, strType
))
754 cec_device_type type
= CEC_DEVICE_TYPE_TV
;
755 if (strType
.Equals("a"))
756 type
= CEC_DEVICE_TYPE_AUDIO_SYSTEM
;
757 else if (strType
.Equals("p"))
758 type
= CEC_DEVICE_TYPE_PLAYBACK_DEVICE
;
759 else if (strType
.Equals("r"))
760 type
= CEC_DEVICE_TYPE_RECORDING_DEVICE
;
761 else if (strType
.Equals("t"))
762 type
= CEC_DEVICE_TYPE_TUNER
;
764 PrintToStdOut("device %d is %s", type
, (parser
->IsActiveDeviceType(type
) ? "active" : "not active"));
772 bool ProcessCommandR(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
776 PrintToStdOut("closing the connection");
779 PrintToStdOut("opening a new connection");
780 parser
->Open(g_strPort
.c_str());
782 PrintToStdOut("setting active source");
783 parser
->SetActiveSource();
790 bool ProcessCommandH(ICECAdapter
* UNUSED(parser
), const string
&command
, string
& UNUSED(arguments
))
792 if (command
== "h" || command
== "help")
801 bool ProcessCommandLOG(ICECAdapter
* UNUSED(parser
), const string
&command
, string
&arguments
)
803 if (command
== "log")
806 if (GetWord(arguments
, strLevel
))
808 int iNewLevel
= atoi(strLevel
);
809 if (iNewLevel
>= CEC_LOG_ERROR
&& iNewLevel
<= CEC_LOG_ALL
)
811 g_cecLogLevel
= iNewLevel
;
813 PrintToStdOut("log level changed to %s", strLevel
.c_str());
822 bool ProcessCommandSCAN(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
824 if (command
== "scan")
827 PrintToStdOut("requesting CEC bus information ...");
829 strLog
.append("CEC bus information\n===================\n");
830 cec_logical_addresses addresses
= parser
->GetActiveDevices();
831 for (uint8_t iPtr
= 0; iPtr
< 16; iPtr
++)
835 uint64_t iVendorId
= parser
->GetDeviceVendorId((cec_logical_address
)iPtr
);
836 bool bActive
= parser
->IsActiveSource((cec_logical_address
)iPtr
);
837 uint16_t iPhysicalAddress
= parser
->GetDevicePhysicalAddress((cec_logical_address
)iPtr
);
838 cec_version iCecVersion
= parser
->GetDeviceCecVersion((cec_logical_address
)iPtr
);
839 cec_power_status power
= parser
->GetDevicePowerStatus((cec_logical_address
)iPtr
);
840 cec_osd_name osdName
= parser
->GetDeviceOSDName((cec_logical_address
)iPtr
);
842 strAddr
.Format("%04x", iPhysicalAddress
);
843 cec_menu_language lang
;
844 lang
.device
= CECDEVICE_UNKNOWN
;
845 parser
->GetDeviceMenuLanguage((cec_logical_address
)iPtr
, &lang
);
847 strLog
.AppendFormat("device #%X: %s\n", (int)iPtr
, parser
->ToString((cec_logical_address
)iPtr
));
848 strLog
.AppendFormat("address: %s\n", strAddr
.c_str());
849 strLog
.AppendFormat("active source: %s\n", (bActive
? "yes" : "no"));
850 strLog
.AppendFormat("vendor: %s\n", parser
->ToString((cec_vendor_id
)iVendorId
));
851 strLog
.AppendFormat("osd string: %s\n", osdName
.name
);
852 strLog
.AppendFormat("CEC version: %s\n", parser
->ToString(iCecVersion
));
853 strLog
.AppendFormat("power status: %s\n", parser
->ToString(power
));
854 if ((uint8_t)lang
.device
== iPtr
)
855 strLog
.AppendFormat("language: %s\n", lang
.language
);
856 strLog
.append("\n\n");
860 cec_logical_address activeSource
= parser
->GetActiveSource();
861 strLog
.AppendFormat("currently active source: %s (%d)", parser
->ToString(activeSource
), (int)activeSource
);
863 PrintToStdOut(strLog
);
870 bool ProcessConsoleCommand(ICECAdapter
*parser
, string
&input
)
875 if (GetWord(input
, command
))
877 if (command
== "q" || command
== "quit")
880 ProcessCommandTX(parser
, command
, input
) ||
881 ProcessCommandON(parser
, command
, input
) ||
882 ProcessCommandSTANDBY(parser
, command
, input
) ||
883 ProcessCommandPOLL(parser
, command
, input
) ||
884 ProcessCommandLA(parser
, command
, input
) ||
885 ProcessCommandP(parser
, command
, input
) ||
886 ProcessCommandPA(parser
, command
, input
) ||
887 ProcessCommandAS(parser
, command
, input
) ||
888 ProcessCommandOSD(parser
, command
, input
) ||
889 ProcessCommandPING(parser
, command
, input
) ||
890 ProcessCommandVOLUP(parser
, command
, input
) ||
891 ProcessCommandVOLDOWN(parser
, command
, input
) ||
892 ProcessCommandMUTE(parser
, command
, input
) ||
893 ProcessCommandMON(parser
, command
, input
) ||
894 ProcessCommandBL(parser
, command
, input
) ||
895 ProcessCommandLANG(parser
, command
, input
) ||
896 ProcessCommandVEN(parser
, command
, input
) ||
897 ProcessCommandVER(parser
, command
, input
) ||
898 ProcessCommandPOW(parser
, command
, input
) ||
899 ProcessCommandNAME(parser
, command
, input
) ||
900 ProcessCommandLAD(parser
, command
, input
) ||
901 ProcessCommandAD(parser
, command
, input
) ||
902 ProcessCommandAT(parser
, command
, input
) ||
903 ProcessCommandR(parser
, command
, input
) ||
904 ProcessCommandH(parser
, command
, input
) ||
905 ProcessCommandLOG(parser
, command
, input
) ||
906 ProcessCommandSCAN(parser
, command
, input
) ||
907 ProcessCommandSP(parser
, command
, input
) ||
908 ProcessCommandSPL(parser
, command
, input
) ||
909 ProcessCommandSELF(parser
, command
, input
);
915 bool ProcessCommandLineArguments(int argc
, char *argv
[])
919 while (iArgPtr
< argc
&& bReturn
)
921 if (argc
>= iArgPtr
+ 1)
923 if (!strcmp(argv
[iArgPtr
], "-f") ||
924 !strcmp(argv
[iArgPtr
], "--log-file") ||
925 !strcmp(argv
[iArgPtr
], "-sf") ||
926 !strcmp(argv
[iArgPtr
], "--short-log-file"))
928 if (argc
>= iArgPtr
+ 2)
930 g_logOutput
.open(argv
[iArgPtr
+ 1]);
931 g_bShortLog
= (!strcmp(argv
[iArgPtr
], "-sf") || !strcmp(argv
[iArgPtr
], "--short-log-file"));
936 cout
<< "== skipped log-file parameter: no file given ==" << endl
;
940 else if (!strcmp(argv
[iArgPtr
], "-d") ||
941 !strcmp(argv
[iArgPtr
], "--log-level"))
943 if (argc
>= iArgPtr
+ 2)
945 int iNewLevel
= atoi(argv
[iArgPtr
+ 1]);
946 if (iNewLevel
>= CEC_LOG_ERROR
&& iNewLevel
<= CEC_LOG_ALL
)
948 g_cecLogLevel
= iNewLevel
;
949 if (!g_bSingleCommand
)
950 cout
<< "log level set to " << argv
[iArgPtr
+ 1] << endl
;
954 cout
<< "== skipped log-level parameter: invalid level '" << argv
[iArgPtr
+ 1] << "' ==" << endl
;
960 cout
<< "== skipped log-level parameter: no level given ==" << endl
;
964 else if (!strcmp(argv
[iArgPtr
], "-t") ||
965 !strcmp(argv
[iArgPtr
], "--type"))
967 if (argc
>= iArgPtr
+ 2)
969 if (!strcmp(argv
[iArgPtr
+ 1], "p"))
971 if (!g_bSingleCommand
)
972 cout
<< "== using device type 'playback device'" << endl
;
973 g_config
.deviceTypes
.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE
);
975 else if (!strcmp(argv
[iArgPtr
+ 1], "r"))
977 if (!g_bSingleCommand
)
978 cout
<< "== using device type 'recording device'" << endl
;
979 g_config
.deviceTypes
.add(CEC_DEVICE_TYPE_RECORDING_DEVICE
);
981 else if (!strcmp(argv
[iArgPtr
+ 1], "t"))
983 if (!g_bSingleCommand
)
984 cout
<< "== using device type 'tuner'" << endl
;
985 g_config
.deviceTypes
.add(CEC_DEVICE_TYPE_TUNER
);
987 else if (!strcmp(argv
[iArgPtr
+ 1], "a"))
989 if (!g_bSingleCommand
)
990 cout
<< "== using device type 'audio system'" << endl
;
991 g_config
.deviceTypes
.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM
);
995 cout
<< "== skipped invalid device type '" << argv
[iArgPtr
+ 1] << "'" << endl
;
1001 else if (!strcmp(argv
[iArgPtr
], "--list-devices") ||
1002 !strcmp(argv
[iArgPtr
], "-l"))
1004 ICECAdapter
*parser
= LibCecInitialise(&g_config
);
1007 ListDevices(parser
);
1008 UnloadLibCec(parser
);
1013 else if (!strcmp(argv
[iArgPtr
], "--bootloader"))
1018 else if (!strcmp(argv
[iArgPtr
], "--single-command") ||
1019 !strcmp(argv
[iArgPtr
], "-s"))
1021 g_bSingleCommand
= true;
1024 else if (!strcmp(argv
[iArgPtr
], "--help") ||
1025 !strcmp(argv
[iArgPtr
], "-h"))
1027 ShowHelpCommandLine(argv
[0]);
1030 else if (!strcmp(argv
[iArgPtr
], "-b") ||
1031 !strcmp(argv
[iArgPtr
], "--base"))
1033 if (argc
>= iArgPtr
+ 2)
1035 g_config
.baseDevice
= (cec_logical_address
)atoi(argv
[iArgPtr
+ 1]);
1036 cout
<< "using base device '" << (int)g_config
.baseDevice
<< "'" << endl
;
1041 else if (!strcmp(argv
[iArgPtr
], "-p") ||
1042 !strcmp(argv
[iArgPtr
], "--port"))
1044 if (argc
>= iArgPtr
+ 2)
1046 uint8_t hdmiport
= (int8_t)atoi(argv
[iArgPtr
+ 1]);
1051 g_config
.iHDMIPort
= hdmiport
;
1052 cout
<< "using HDMI port '" << (int)g_config
.iHDMIPort
<< "'" << endl
;
1057 else if (!strcmp(argv
[iArgPtr
], "-r") ||
1058 !strcmp(argv
[iArgPtr
], "--rom"))
1060 cout
<< "using settings from EEPROM" << endl
;
1061 g_config
.bGetSettingsFromROM
= 1;
1064 else if (!strcmp(argv
[iArgPtr
], "-o") ||
1065 !strcmp(argv
[iArgPtr
], "--osd-name"))
1067 if (argc
>= iArgPtr
+ 2)
1069 snprintf(g_config
.strDeviceName
, 13, "%s", argv
[iArgPtr
+ 1]);
1070 cout
<< "using osd name " << g_config
.strDeviceName
<< endl
;
1077 g_strPort
= argv
[iArgPtr
++];
1085 int main (int argc
, char *argv
[])
1088 snprintf(g_config
.strDeviceName
, 13, "CECTester");
1089 g_config
.clientVersion
= CEC_CLIENT_VERSION_1_6_2
;
1090 g_config
.bActivateSource
= 0;
1091 g_callbacks
.CBCecLogMessage
= &CecLogMessage
;
1092 g_callbacks
.CBCecKeyPress
= &CecKeyPress
;
1093 g_callbacks
.CBCecCommand
= &CecCommand
;
1094 g_callbacks
.CBCecAlert
= &CecAlert
;
1095 g_config
.callbacks
= &g_callbacks
;
1097 if (!ProcessCommandLineArguments(argc
, argv
))
1100 if (g_config
.deviceTypes
.IsEmpty())
1102 if (!g_bSingleCommand
)
1103 cout
<< "No device type given. Using 'recording device'" << endl
;
1104 g_config
.deviceTypes
.add(CEC_DEVICE_TYPE_RECORDING_DEVICE
);
1107 ICECAdapter
*parser
= LibCecInitialise(&g_config
);
1111 cout
<< "Cannot load libcec.dll" << endl
;
1113 cout
<< "Cannot load libcec.so" << endl
;
1117 UnloadLibCec(parser
);
1122 if (!g_bSingleCommand
)
1125 strLog
.Format("CEC Parser created - libCEC version %s", parser
->ToString((cec_server_version
)g_config
.serverVersion
));
1126 cout
<< strLog
.c_str() << endl
;
1128 //make stdin non-blocking
1130 int flags
= fcntl(0, F_GETFL
, 0);
1131 flags
|= O_NONBLOCK
;
1132 fcntl(0, F_SETFL
, flags
);
1136 if (g_strPort
.IsEmpty())
1138 if (!g_bSingleCommand
)
1139 cout
<< "no serial port given. trying autodetect: ";
1140 cec_adapter devices
[10];
1141 uint8_t iDevicesFound
= parser
->FindAdapters(devices
, 10, NULL
);
1142 if (iDevicesFound
<= 0)
1144 if (g_bSingleCommand
)
1145 cout
<< "autodetect ";
1146 cout
<< "FAILED" << endl
;
1147 UnloadLibCec(parser
);
1152 if (!g_bSingleCommand
)
1154 cout
<< endl
<< " path: " << devices
[0].path
<< endl
<<
1155 " com port: " << devices
[0].comm
<< endl
<< endl
;
1157 g_strPort
= devices
[0].comm
;
1161 PrintToStdOut("opening a connection to the CEC adapter...");
1163 if (!parser
->Open(g_strPort
.c_str()))
1165 PrintToStdOut("unable to open the device on port %s", g_strPort
.c_str());
1166 UnloadLibCec(parser
);
1170 if (!g_bSingleCommand
)
1171 PrintToStdOut("waiting for input");
1173 while (!g_bExit
&& !g_bHardExit
)
1176 getline(cin
, input
);
1179 if (ProcessConsoleCommand(parser
, input
) && !g_bSingleCommand
&& !g_bExit
&& !g_bHardExit
)
1182 PrintToStdOut("waiting for input");
1187 if (!g_bExit
&& !g_bHardExit
)
1192 UnloadLibCec(parser
);
1194 if (g_logOutput
.is_open())
1195 g_logOutput
.close();