repositories / deb_libcec.git / blob
? search:


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