2 * This file is part of the libCEC(R) library.
4 * libCEC(R) is Copyright (C) 2011 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/
41 #include "../lib/platform/os.h"
42 #include "../lib/implementations/CECCommandHandler.h"
46 using namespace PLATFORM
;
48 #define CEC_TEST_CLIENT_VERSION 1
50 #include <cecloader.h>
52 int g_cecLogLevel(CEC_LOG_ALL
);
54 bool g_bShortLog(false);
56 uint8_t g_iHDMIPort(CEC_DEFAULT_HDMI_PORT
);
57 cec_logical_address
g_iBaseDevice((cec_logical_address
)CEC_DEFAULT_BASE_DEVICE
);
58 cec_device_type_list g_typeList
;
59 bool g_bSingleCommand(false);
61 bool g_bHardExit(false);
63 ICECCallbacks g_callbacks
;
65 inline void PrintToStdOut(const char *strOut
)
67 CLockObject
lock(g_outputMutex
);
68 cout
<< strOut
<< endl
;
71 inline void PrintToStdOut(const CStdString
&strOut
)
73 PrintToStdOut(strOut
.c_str());
76 inline bool HexStrToInt(const std::string
& data
, uint8_t& value
)
79 if (sscanf(data
.c_str(), "%x", &iTmp
) == 1)
86 value
= (uint8_t) iTmp
;
94 //get the first word (separated by whitespace) from string data and place that in word
95 //then remove that word from string data
96 bool GetWord(string
& data
, string
& word
)
98 stringstream
datastream(data
);
102 if (datastream
.fail())
108 size_t pos
= data
.find(word
) + word
.length();
110 if (pos
>= data
.length())
116 data
= data
.substr(pos
);
119 datastream
.str(data
);
122 if (datastream
.fail())
128 int CecLogMessage(void *UNUSED(cbParam
), const cec_log_message
&message
)
130 if ((message
.level
& g_cecLogLevel
) == message
.level
)
133 switch (message
.level
)
136 strLevel
= "ERROR: ";
138 case CEC_LOG_WARNING
:
139 strLevel
= "WARNING: ";
142 strLevel
= "NOTICE: ";
144 case CEC_LOG_TRAFFIC
:
145 strLevel
= "TRAFFIC: ";
148 strLevel
= "DEBUG: ";
154 CStdString strFullLog
;
155 strFullLog
.Format("%s[%16lld]\t%s", strLevel
.c_str(), message
.time
, message
.message
);
156 PrintToStdOut(strFullLog
);
158 if (g_logOutput
.is_open())
161 g_logOutput
<< message
.message
<< endl
;
163 g_logOutput
<< strFullLog
.c_str() << endl
;
170 int CecKeyPress(void *UNUSED(cbParam
), const cec_keypress
&UNUSED(key
))
175 int CecCommand(void *UNUSED(cbParam
), const cec_command
&UNUSED(command
))
180 void EnableCallbacks(ICECAdapter
*adapter
)
182 g_callbacks
.CBCecLogMessage
= &CecLogMessage
;
183 g_callbacks
.CBCecKeyPress
= &CecKeyPress
;
184 g_callbacks
.CBCecCommand
= &CecCommand
;
185 adapter
->EnableCallbacks(NULL
, &g_callbacks
);
188 void ListDevices(ICECAdapter
*parser
)
190 cec_adapter
*devices
= new cec_adapter
[10];
191 uint8_t iDevicesFound
= parser
->FindAdapters(devices
, 10, NULL
);
192 if (iDevicesFound
<= 0)
194 PrintToStdOut("Found devices: NONE");
199 strLog
.Format("Found devices: %d", iDevicesFound
);
200 PrintToStdOut(strLog
);
201 for (unsigned int iDevicePtr
= 0; iDevicePtr
< iDevicesFound
; iDevicePtr
++)
203 CStdString strDevice
;
204 strDevice
.Format("device: %d\npath: %s\ncom port: %s", iDevicePtr
+ 1, devices
[iDevicePtr
].path
, devices
[iDevicePtr
].comm
);
205 PrintToStdOut(strDevice
);
210 void ShowHelpCommandLine(const char* strExec
)
212 CLockObject
lock(g_outputMutex
);
214 strExec
<< " {-h|--help|-l|--list-devices|[COM PORT]}" << endl
<<
216 "parameters:" << endl
<<
217 " -h --help Shows this help text" << endl
<<
218 " -l --list-devices List all devices on this system" << endl
<<
219 " -t --type {p|r|t|a} The device type to use. More than one is possible." << endl
<<
220 " -p --port {int} The HDMI port to use as active source." << endl
<<
221 " -b --base {int} The logical address of the device to with this " << endl
<<
222 " adapter is connected." << endl
<<
223 " -f --log-file {file} Writes all libCEC log message to a file" << endl
<<
224 " -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl
<<
225 " and log levels to a file." << endl
<<
226 " -d --log-level {level} Sets the log level. See cectypes.h for values." << endl
<<
227 " -s --single-command Execute a single command and exit. Does not power" << endl
<<
228 " on devices on startup and power them off on exit." << endl
<<
229 " [COM PORT] The com port to connect to. If no COM" << endl
<<
230 " port is given, the client tries to connect to the" << endl
<<
231 " first device that is detected." << endl
<<
233 "Type 'h' or 'help' and press enter after starting the client to display all " << endl
<<
234 "available commands" << endl
;
237 ICECAdapter
*CreateParser(cec_device_type_list typeList
)
239 ICECAdapter
*parser
= LibCecInit("CECTester", typeList
);
240 if (!parser
|| parser
->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION
)
243 PrintToStdOut("Cannot load libcec.dll");
245 PrintToStdOut("Cannot load libcec.so");
251 strLog
.Format("CEC Parser created - libcec version %d.%d", parser
->GetLibVersionMajor(), parser
->GetLibVersionMinor());
252 PrintToStdOut(strLog
.c_str());
257 void ShowHelpConsole(void)
259 CLockObject
lock(g_outputMutex
);
261 "================================================================================" << endl
<<
262 "Available commands:" << endl
<<
264 "[tx] {bytes} transfer bytes over the CEC line." << endl
<<
265 "[txn] {bytes} transfer bytes but don't wait for transmission ACK." << endl
<<
266 "[on] {address} power on the device with the given logical address." << endl
<<
267 "[standby] {address} put the device with the given address in standby mode." << endl
<<
268 "[la] {logical address} change the logical address of the CEC adapter." << endl
<<
269 "[p] {device} {port} change the HDMI port number of the CEC adapter." << endl
<<
270 "[pa] {physical address} change the physical address of the CEC adapter." << endl
<<
271 "[as] make the CEC adapter the active source." << endl
<<
272 "[osd] {addr} {string} set OSD message on the specified device." << endl
<<
273 "[ver] {addr} get the CEC version of the specified device." << endl
<<
274 "[ven] {addr} get the vendor ID of the specified device." << endl
<<
275 "[lang] {addr} get the menu language of the specified device." << endl
<<
276 "[pow] {addr} get the power status of the specified device." << endl
<<
277 "[name] {addr} get the OSD name of the specified device." << endl
<<
278 "[poll] {addr} poll the specified device." << endl
<<
279 "[lad] lists active devices on the bus" << endl
<<
280 "[ad] {addr} checks whether the specified device is active." << endl
<<
281 "[at] {type} checks whether the specified device type is active." << endl
<<
282 "[volup] send a volume up command to the amp if present" << endl
<<
283 "[voldown] send a volume down command to the amp if present" << endl
<<
284 "[mute] send a mute/unmute command to the amp if present" << endl
<<
285 "[scan] scan the CEC bus and display device info" << endl
<<
286 "[mon] {1|0} enable or disable CEC bus monitoring." << endl
<<
287 "[log] {1 - 31} change the log level. see cectypes.h for values." << endl
<<
288 "[ping] send a ping command to the CEC adapter." << endl
<<
289 "[bl] to let the adapter enter the bootloader, to upgrade" << endl
<<
290 " the flash rom." << endl
<<
291 "[r] reconnect to the CEC adapter." << endl
<<
292 "[h] or [help] show this help." << endl
<<
293 "[q] or [quit] to quit the CEC test client and switch off all" << endl
<<
294 " connected CEC devices." << endl
<<
295 "================================================================================" << endl
;
298 bool ProcessCommandTX(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
300 if (command
== "tx" || command
== "txn")
307 while (GetWord(arguments
, strvalue
) && HexStrToInt(strvalue
, ivalue
))
308 bytes
.PushBack(ivalue
);
310 if (command
== "txn")
311 bytes
.transmit_timeout
= 0;
313 parser
->Transmit(bytes
);
321 bool ProcessCommandON(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
327 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
329 parser
->PowerOnDevices((cec_logical_address
) iValue
);
334 PrintToStdOut("invalid destination");
341 bool ProcessCommandSTANDBY(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
343 if (command
== "standby")
347 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
349 parser
->StandbyDevices((cec_logical_address
) iValue
);
354 PrintToStdOut("invalid destination");
361 bool ProcessCommandPOLL(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
363 if (command
== "poll")
367 if (GetWord(arguments
, strValue
) && HexStrToInt(strValue
, iValue
) && iValue
<= 0xF)
369 if (parser
->PollDevice((cec_logical_address
) iValue
))
370 PrintToStdOut("POLL message sent");
372 PrintToStdOut("POLL message not sent");
377 PrintToStdOut("invalid destination");
384 bool ProcessCommandLA(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
389 if (GetWord(arguments
, strvalue
))
391 parser
->SetLogicalAddress((cec_logical_address
) atoi(strvalue
.c_str()));
399 bool ProcessCommandP(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
403 string strPort
, strDevice
;
404 if (GetWord(arguments
, strDevice
) && GetWord(arguments
, strPort
))
406 parser
->SetHDMIPort((cec_logical_address
)atoi(strDevice
.c_str()), (uint8_t)atoi(strPort
.c_str()));
414 bool ProcessCommandPA(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
420 if (GetWord(arguments
, strB1
) && HexStrToInt(strB1
, iB1
) &&
421 GetWord(arguments
, strB2
) && HexStrToInt(strB2
, iB2
))
423 uint16_t iPhysicalAddress
= ((uint16_t)iB1
<< 8) + iB2
;
424 parser
->SetPhysicalAddress(iPhysicalAddress
);
432 bool ProcessCommandOSD(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
434 if (command
== "osd")
436 bool bFirstWord(false);
437 string strAddr
, strMessage
, strWord
;
439 if (GetWord(arguments
, strAddr
) && HexStrToInt(strAddr
, iAddr
) && iAddr
< 0xF)
441 while (GetWord(arguments
, strWord
))
446 strMessage
.append(" ");
448 strMessage
.append(strWord
);
450 parser
->SetOSDString((cec_logical_address
) iAddr
, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME
, strMessage
.c_str());
458 bool ProcessCommandAS(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
462 parser
->SetActiveView();
470 bool ProcessCommandPING(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
472 if (command
== "ping")
474 parser
->PingAdapter();
481 bool ProcessCommandVOLUP(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
483 if (command
== "volup")
486 strLog
.Format("volume up: %2X", parser
->VolumeUp());
487 PrintToStdOut(strLog
);
494 bool ProcessCommandVOLDOWN(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
496 if (command
== "voldown")
499 strLog
.Format("volume down: %2X", parser
->VolumeDown());
500 PrintToStdOut(strLog
);
507 bool ProcessCommandMUTE(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
509 if (command
== "mute")
512 strLog
.Format("mute: %2X", parser
->MuteAudio());
513 PrintToStdOut(strLog
);
520 bool ProcessCommandMON(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
522 if (command
== "mon")
524 CStdString strEnable
;
525 if (GetWord(arguments
, strEnable
) && (strEnable
.Equals("0") || strEnable
.Equals("1")))
527 parser
->SwitchMonitoring(strEnable
.Equals("1"));
535 bool ProcessCommandBL(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
539 if (parser
->StartBootloader())
541 PrintToStdOut("entered bootloader mode. exiting cec-client");
551 bool ProcessCommandLANG(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
553 if (command
== "lang")
556 if (GetWord(arguments
, strDev
))
558 int iDev
= atoi(strDev
);
559 if (iDev
>= 0 && iDev
< 15)
562 cec_menu_language language
;
563 if (parser
->GetDeviceMenuLanguage((cec_logical_address
) iDev
, &language
))
564 strLog
.Format("menu language '%s'", language
.language
);
567 PrintToStdOut(strLog
);
576 bool ProcessCommandVEN(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
578 if (command
== "ven")
581 if (GetWord(arguments
, strDev
))
583 int iDev
= atoi(strDev
);
584 if (iDev
>= 0 && iDev
< 15)
586 uint64_t iVendor
= parser
->GetDeviceVendorId((cec_logical_address
) iDev
);
588 strLog
.Format("vendor id: %06x", iVendor
);
589 PrintToStdOut(strLog
);
598 bool ProcessCommandVER(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
600 if (command
== "ver")
603 if (GetWord(arguments
, strDev
))
605 int iDev
= atoi(strDev
);
606 if (iDev
>= 0 && iDev
< 15)
608 cec_version iVersion
= parser
->GetDeviceCecVersion((cec_logical_address
) iDev
);
610 strLog
.Format("CEC version %s", parser
->ToString(iVersion
));
611 PrintToStdOut(strLog
);
620 bool ProcessCommandPOW(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
622 if (command
== "pow")
625 if (GetWord(arguments
, strDev
))
627 int iDev
= atoi(strDev
);
628 if (iDev
>= 0 && iDev
< 15)
630 cec_power_status iPower
= parser
->GetDevicePowerStatus((cec_logical_address
) iDev
);
632 strLog
.Format("power status: %s", parser
->ToString(iPower
));
633 PrintToStdOut(strLog
);
642 bool ProcessCommandNAME(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
644 if (command
== "name")
647 if (GetWord(arguments
, strDev
))
649 int iDev
= atoi(strDev
);
650 if (iDev
>= 0 && iDev
< 15)
652 cec_osd_name name
= parser
->GetDeviceOSDName((cec_logical_address
)iDev
);
654 strLog
.Format("OSD name of device %d is '%s'", iDev
, name
.name
);
655 PrintToStdOut(strLog
);
664 bool ProcessCommandLAD(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
666 if (command
== "lad")
669 PrintToStdOut("listing active devices:");
670 cec_logical_addresses addresses
= parser
->GetActiveDevices();
671 for (uint8_t iPtr
= 0; iPtr
<= 11; iPtr
++)
674 strLog
.Format("logical address %X", (int)iPtr
);
675 PrintToStdOut(strLog
);
683 bool ProcessCommandAD(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
688 if (GetWord(arguments
, strDev
))
690 int iDev
= atoi(strDev
);
691 if (iDev
>= 0 && iDev
< 15)
694 strLog
.Format("logical address %X is %s", iDev
, (parser
->IsActiveDevice((cec_logical_address
)iDev
) ? "active" : "not active"));
695 PrintToStdOut(strLog
);
703 bool ProcessCommandAT(ICECAdapter
*parser
, const string
&command
, string
&arguments
)
708 if (GetWord(arguments
, strType
))
710 cec_device_type type
= CEC_DEVICE_TYPE_TV
;
711 if (strType
.Equals("a"))
712 type
= CEC_DEVICE_TYPE_AUDIO_SYSTEM
;
713 else if (strType
.Equals("p"))
714 type
= CEC_DEVICE_TYPE_PLAYBACK_DEVICE
;
715 else if (strType
.Equals("r"))
716 type
= CEC_DEVICE_TYPE_RECORDING_DEVICE
;
717 else if (strType
.Equals("t"))
718 type
= CEC_DEVICE_TYPE_TUNER
;
720 strLog
.Format("device %d is %s", type
, (parser
->IsActiveDeviceType(type
) ? "active" : "not active"));
721 PrintToStdOut(strLog
);
729 bool ProcessCommandR(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
733 PrintToStdOut("closing the connection");
736 PrintToStdOut("opening a new connection");
737 parser
->Open(g_strPort
.c_str());
739 PrintToStdOut("setting active source");
740 parser
->SetActiveSource();
747 bool ProcessCommandH(ICECAdapter
* UNUSED(parser
), const string
&command
, string
& UNUSED(arguments
))
749 if (command
== "h" || command
== "help")
758 bool ProcessCommandLOG(ICECAdapter
* UNUSED(parser
), const string
&command
, string
&arguments
)
760 if (command
== "log")
763 if (GetWord(arguments
, strLevel
))
765 int iNewLevel
= atoi(strLevel
);
766 if (iNewLevel
>= CEC_LOG_ERROR
&& iNewLevel
<= CEC_LOG_ALL
)
768 g_cecLogLevel
= iNewLevel
;
770 strLog
.Format("log level changed to %s", strLevel
.c_str());
771 PrintToStdOut(strLog
);
780 bool ProcessCommandSCAN(ICECAdapter
*parser
, const string
&command
, string
& UNUSED(arguments
))
782 if (command
== "scan")
784 PrintToStdOut("CEC bus information");
785 PrintToStdOut("===================");
786 cec_logical_addresses addresses
= parser
->GetActiveDevices();
787 for (uint8_t iPtr
= 0; iPtr
< 16; iPtr
++)
792 uint64_t iVendorId
= parser
->GetDeviceVendorId((cec_logical_address
)iPtr
);
793 bool bActive
= parser
->IsActiveSource((cec_logical_address
)iPtr
);
794 uint16_t iPhysicalAddress
= parser
->GetDevicePhysicalAddress((cec_logical_address
)iPtr
);
795 cec_version iCecVersion
= parser
->GetDeviceCecVersion((cec_logical_address
)iPtr
);
796 cec_power_status power
= parser
->GetDevicePowerStatus((cec_logical_address
)iPtr
);
797 cec_osd_name osdName
= parser
->GetDeviceOSDName((cec_logical_address
)iPtr
);
799 strAddr
.Format("%04x", iPhysicalAddress
);
800 cec_menu_language lang
;
801 lang
.device
= CECDEVICE_UNKNOWN
;
802 parser
->GetDeviceMenuLanguage((cec_logical_address
)iPtr
, &lang
);
804 strLog
.AppendFormat("device #%X: %s\n", (int)iPtr
, parser
->ToString((cec_logical_address
)iPtr
));
805 strLog
.AppendFormat("address: %s\n", strAddr
.c_str());
806 strLog
.AppendFormat("active source: %s\n", (bActive
? "yes" : "no"));
807 strLog
.AppendFormat("vendor: %s\n", parser
->ToString((cec_vendor_id
)iVendorId
));
808 strLog
.AppendFormat("osd string: %s\n", osdName
.name
);
809 strLog
.AppendFormat("CEC version: %s\n", parser
->ToString(iCecVersion
));
810 strLog
.AppendFormat("power status: %s\n", parser
->ToString(power
));
811 if ((uint8_t)lang
.device
== iPtr
)
812 strLog
.AppendFormat("language: %s\n", lang
.language
);
814 PrintToStdOut(strLog
);
823 bool ProcessConsoleCommand(ICECAdapter
*parser
, string
&input
)
828 if (GetWord(input
, command
))
830 if (command
== "q" || command
== "quit")
833 ProcessCommandTX(parser
, command
, input
) ||
834 ProcessCommandON(parser
, command
, input
) ||
835 ProcessCommandSTANDBY(parser
, command
, input
) ||
836 ProcessCommandPOLL(parser
, command
, input
) ||
837 ProcessCommandLA(parser
, command
, input
) ||
838 ProcessCommandP(parser
, command
, input
) ||
839 ProcessCommandPA(parser
, command
, input
) ||
840 ProcessCommandAS(parser
, command
, input
) ||
841 ProcessCommandOSD(parser
, command
, input
) ||
842 ProcessCommandPING(parser
, command
, input
) ||
843 ProcessCommandVOLUP(parser
, command
, input
) ||
844 ProcessCommandVOLDOWN(parser
, command
, input
) ||
845 ProcessCommandMUTE(parser
, command
, input
) ||
846 ProcessCommandMON(parser
, command
, input
) ||
847 ProcessCommandBL(parser
, command
, input
) ||
848 ProcessCommandLANG(parser
, command
, input
) ||
849 ProcessCommandVEN(parser
, command
, input
) ||
850 ProcessCommandVER(parser
, command
, input
) ||
851 ProcessCommandPOW(parser
, command
, input
) ||
852 ProcessCommandNAME(parser
, command
, input
) ||
853 ProcessCommandLAD(parser
, command
, input
) ||
854 ProcessCommandAD(parser
, command
, input
) ||
855 ProcessCommandAT(parser
, command
, input
) ||
856 ProcessCommandR(parser
, command
, input
) ||
857 ProcessCommandH(parser
, command
, input
) ||
858 ProcessCommandLOG(parser
, command
, input
) ||
859 ProcessCommandSCAN(parser
, command
, input
);
865 bool ProcessCommandLineArguments(int argc
, char *argv
[])
869 while (iArgPtr
< argc
&& bReturn
)
871 if (argc
>= iArgPtr
+ 1)
873 if (!strcmp(argv
[iArgPtr
], "-f") ||
874 !strcmp(argv
[iArgPtr
], "--log-file") ||
875 !strcmp(argv
[iArgPtr
], "-sf") ||
876 !strcmp(argv
[iArgPtr
], "--short-log-file"))
878 if (argc
>= iArgPtr
+ 2)
880 g_logOutput
.open(argv
[iArgPtr
+ 1]);
881 g_bShortLog
= (!strcmp(argv
[iArgPtr
], "-sf") || !strcmp(argv
[iArgPtr
], "--short-log-file"));
886 cout
<< "== skipped log-file parameter: no file given ==" << endl
;
890 else if (!strcmp(argv
[iArgPtr
], "-d") ||
891 !strcmp(argv
[iArgPtr
], "--log-level"))
893 if (argc
>= iArgPtr
+ 2)
895 int iNewLevel
= atoi(argv
[iArgPtr
+ 1]);
896 if (iNewLevel
>= CEC_LOG_ERROR
&& iNewLevel
<= CEC_LOG_ALL
)
898 g_cecLogLevel
= iNewLevel
;
899 if (!g_bSingleCommand
)
900 cout
<< "log level set to " << argv
[iArgPtr
+ 1] << endl
;
904 cout
<< "== skipped log-level parameter: invalid level '" << argv
[iArgPtr
+ 1] << "' ==" << endl
;
910 cout
<< "== skipped log-level parameter: no level given ==" << endl
;
914 else if (!strcmp(argv
[iArgPtr
], "-t") ||
915 !strcmp(argv
[iArgPtr
], "--type"))
917 if (argc
>= iArgPtr
+ 2)
919 if (!strcmp(argv
[iArgPtr
+ 1], "p"))
921 if (!g_bSingleCommand
)
922 cout
<< "== using device type 'playback device'" << endl
;
923 g_typeList
.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE
);
925 else if (!strcmp(argv
[iArgPtr
+ 1], "r"))
927 if (!g_bSingleCommand
)
928 cout
<< "== using device type 'recording device'" << endl
;
929 g_typeList
.add(CEC_DEVICE_TYPE_RECORDING_DEVICE
);
931 else if (!strcmp(argv
[iArgPtr
+ 1], "t"))
933 if (!g_bSingleCommand
)
934 cout
<< "== using device type 'tuner'" << endl
;
935 g_typeList
.add(CEC_DEVICE_TYPE_TUNER
);
937 else if (!strcmp(argv
[iArgPtr
+ 1], "a"))
939 if (!g_bSingleCommand
)
940 cout
<< "== using device type 'audio system'" << endl
;
941 g_typeList
.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM
);
945 cout
<< "== skipped invalid device type '" << argv
[iArgPtr
+ 1] << "'" << endl
;
951 else if (!strcmp(argv
[iArgPtr
], "--list-devices") ||
952 !strcmp(argv
[iArgPtr
], "-l"))
954 ICECAdapter
*parser
= CreateParser(g_typeList
);
958 UnloadLibCec(parser
);
963 else if (!strcmp(argv
[iArgPtr
], "--single-command") ||
964 !strcmp(argv
[iArgPtr
], "-s"))
966 g_bSingleCommand
= true;
969 else if (!strcmp(argv
[iArgPtr
], "--help") ||
970 !strcmp(argv
[iArgPtr
], "-h"))
972 ShowHelpCommandLine(argv
[0]);
975 else if (!strcmp(argv
[iArgPtr
], "-b") ||
976 !strcmp(argv
[iArgPtr
], "--base"))
978 if (argc
>= iArgPtr
+ 2)
980 g_iBaseDevice
= (cec_logical_address
)atoi(argv
[iArgPtr
+ 1]);
981 cout
<< "using base device '" << (int)g_iBaseDevice
<< "'" << endl
;
986 else if (!strcmp(argv
[iArgPtr
], "-p") ||
987 !strcmp(argv
[iArgPtr
], "--port"))
989 if (argc
>= iArgPtr
+ 2)
991 g_iHDMIPort
= (int8_t)atoi(argv
[iArgPtr
+ 1]);
992 cout
<< "using HDMI port '" << (int)g_iHDMIPort
<< "'" << endl
;
999 g_strPort
= argv
[iArgPtr
++];
1007 int main (int argc
, char *argv
[])
1011 if (!ProcessCommandLineArguments(argc
, argv
))
1014 if (g_typeList
.IsEmpty())
1016 if (!g_bSingleCommand
)
1017 cout
<< "No device type given. Using 'recording device'" << endl
;
1018 g_typeList
.add(CEC_DEVICE_TYPE_RECORDING_DEVICE
);
1021 ICECAdapter
*parser
= LibCecInit("CECTester", g_typeList
);
1022 if (!parser
|| parser
->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION
)
1025 cout
<< "Cannot load libcec.dll" << endl
;
1027 cout
<< "Cannot load libcec.so" << endl
;
1031 UnloadLibCec(parser
);
1036 if (!g_bSingleCommand
)
1039 strLog
.Format("CEC Parser created - libcec version %d.%d", parser
->GetLibVersionMajor(), parser
->GetLibVersionMinor());
1040 cout
<< strLog
.c_str() << endl
;
1042 //make stdin non-blocking
1044 int flags
= fcntl(0, F_GETFL
, 0);
1045 flags
|= O_NONBLOCK
;
1046 fcntl(0, F_SETFL
, flags
);
1050 if (g_strPort
.IsEmpty())
1052 if (!g_bSingleCommand
)
1053 cout
<< "no serial port given. trying autodetect: ";
1054 cec_adapter devices
[10];
1055 uint8_t iDevicesFound
= parser
->FindAdapters(devices
, 10, NULL
);
1056 if (iDevicesFound
<= 0)
1058 if (g_bSingleCommand
)
1059 cout
<< "autodetect ";
1060 cout
<< "FAILED" << endl
;
1061 UnloadLibCec(parser
);
1066 if (!g_bSingleCommand
)
1068 cout
<< endl
<< " path: " << devices
[0].path
<< endl
<<
1069 " com port: " << devices
[0].comm
<< endl
<< endl
;
1071 g_strPort
= devices
[0].comm
;
1075 EnableCallbacks(parser
);
1077 parser
->SetHDMIPort(g_iBaseDevice
, g_iHDMIPort
);
1078 PrintToStdOut("opening a connection to the CEC adapter...");
1080 if (!parser
->Open(g_strPort
.c_str()))
1083 strLog
.Format("unable to open the device on port %s", g_strPort
.c_str());
1084 PrintToStdOut(strLog
);
1085 UnloadLibCec(parser
);
1089 if (!g_bSingleCommand
)
1091 PrintToStdOut("cec device opened");
1093 parser
->PowerOnDevices(CECDEVICE_TV
);
1094 parser
->SetActiveSource();
1096 PrintToStdOut("waiting for input");
1099 while (!g_bExit
&& !g_bHardExit
)
1102 getline(cin
, input
);
1105 if (ProcessConsoleCommand(parser
, input
) && !g_bSingleCommand
&& !g_bExit
&& !g_bHardExit
)
1108 PrintToStdOut("waiting for input");
1113 if (!g_bExit
&& !g_bHardExit
)
1114 CCondition::Sleep(50);
1117 if (!g_bSingleCommand
&& !g_bHardExit
)
1118 parser
->StandbyDevices(CECDEVICE_BROADCAST
);
1121 UnloadLibCec(parser
);
1123 if (g_logOutput
.is_open())
1124 g_logOutput
.close();