cec: make sure we're not trying to unlock the mutex too many times
[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 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 <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
44 using namespace CEC;
45 using namespace std;
46 using namespace PLATFORM;
47
48 #define CEC_TEST_CLIENT_VERSION 1
49
50 #include <cecloader.h>
51
52 int g_cecLogLevel(CEC_LOG_ALL);
53 ofstream g_logOutput;
54 bool g_bShortLog(false);
55 CStdString g_strPort;
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);
60 CMutex g_outputMutex;
61 ICECCallbacks g_callbacks;
62
63 inline void PrintToStdOut(const char *strOut)
64 {
65 CLockObject lock(g_outputMutex);
66 cout << strOut << endl;
67 }
68
69 inline void PrintToStdOut(const CStdString &strOut)
70 {
71 PrintToStdOut(strOut.c_str());
72 }
73
74 inline 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
94 bool 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
126 int 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);
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
168 int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &UNUSED(key))
169 {
170 return 0;
171 }
172
173 int CecCommand(void *UNUSED(cbParam), const cec_command &UNUSED(command))
174 {
175 return 0;
176 }
177
178 void EnableCallbacks(ICECAdapter *adapter)
179 {
180 g_callbacks.CBCecLogMessage = &CecLogMessage;
181 g_callbacks.CBCecKeyPress = &CecKeyPress;
182 g_callbacks.CBCecCommand = &CecCommand;
183 adapter->EnableCallbacks(NULL, &g_callbacks);
184 }
185
186 void ListDevices(ICECAdapter *parser)
187 {
188 cec_adapter *devices = new cec_adapter[10];
189 uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
190 if (iDevicesFound <= 0)
191 {
192 PrintToStdOut("Found devices: NONE");
193 }
194 else
195 {
196 CStdString strLog;
197 strLog.Format("Found devices: %d", iDevicesFound);
198 PrintToStdOut(strLog);
199 for (unsigned int iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
200 {
201 CStdString strDevice;
202 strDevice.Format("device: %d\npath: %s\ncom port: %s", iDevicePtr + 1, devices[iDevicePtr].path, devices[iDevicePtr].comm);
203 PrintToStdOut(strDevice);
204 }
205 }
206 }
207
208 void ShowHelpCommandLine(const char* strExec)
209 {
210 CLockObject lock(g_outputMutex);
211 cout << endl <<
212 strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
213 endl <<
214 "parameters:" << endl <<
215 " -h --help Shows this help text" << endl <<
216 " -l --list-devices List all devices on this system" << endl <<
217 " -t --type {p|r|t|a} The device type to use. More than one is possible." << endl <<
218 " -p --port {int} The HDMI port to use as active source." << endl <<
219 " -b --base {int} The logical address of the device to with this " << endl <<
220 " adapter is connected." << endl <<
221 " -f --log-file {file} Writes all libCEC log message to a file" << endl <<
222 " -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
223 " and log levels to a file." << endl <<
224 " -d --log-level {level} Sets the log level. See cectypes.h for values." << endl <<
225 " -s --single-command Execute a single command and exit. Does not power" << endl <<
226 " on devices on startup and power them off on exit." << endl <<
227 " [COM PORT] The com port to connect to. If no COM" << endl <<
228 " port is given, the client tries to connect to the" << endl <<
229 " first device that is detected." << endl <<
230 endl <<
231 "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
232 "available commands" << endl;
233 }
234
235 ICECAdapter *CreateParser(cec_device_type_list typeList)
236 {
237 ICECAdapter *parser = LibCecInit("CECTester", typeList);
238 if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
239 {
240 #ifdef __WINDOWS__
241 PrintToStdOut("Cannot load libcec.dll");
242 #else
243 PrintToStdOut("Cannot load libcec.so");
244 #endif
245 return NULL;
246 }
247
248 CStdString strLog;
249 strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
250 PrintToStdOut(strLog.c_str());
251
252 return parser;
253 }
254
255 void ShowHelpConsole(void)
256 {
257 CLockObject lock(g_outputMutex);
258 cout << endl <<
259 "================================================================================" << endl <<
260 "Available commands:" << endl <<
261 endl <<
262 "[tx] {bytes} transfer bytes over the CEC line." << endl <<
263 "[txn] {bytes} transfer bytes but don't wait for transmission ACK." << endl <<
264 "[on] {address} power on the device with the given logical address." << endl <<
265 "[standby] {address} put the device with the given address in standby mode." << endl <<
266 "[la] {logical address} change the logical address of the CEC adapter." << endl <<
267 "[p] {device} {port} change the HDMI port number of the CEC adapter." << endl <<
268 "[pa] {physical address} change the physical address of the CEC adapter." << endl <<
269 "[as] make the CEC adapter the active source." << endl <<
270 "[osd] {addr} {string} set OSD message on the specified device." << endl <<
271 "[ver] {addr} get the CEC version of the specified device." << endl <<
272 "[ven] {addr} get the vendor ID of the specified device." << endl <<
273 "[lang] {addr} get the menu language of the specified device." << endl <<
274 "[pow] {addr} get the power status of the specified device." << endl <<
275 "[name] {addr} get the OSD name of the specified device." << endl <<
276 "[poll] {addr} poll the specified device." << endl <<
277 "[lad] lists active devices on the bus" << endl <<
278 "[ad] {addr} checks whether the specified device is active." << endl <<
279 "[at] {type} checks whether the specified device type is active." << endl <<
280 "[volup] send a volume up command to the amp if present" << endl <<
281 "[voldown] send a volume down command to the amp if present" << endl <<
282 "[mute] send a mute/unmute command to the amp if present" << endl <<
283 "[scan] scan the CEC bus and display device info" << endl <<
284 "[mon] {1|0} enable or disable CEC bus monitoring." << endl <<
285 "[log] {1 - 31} change the log level. see cectypes.h for values." << endl <<
286 "[ping] send a ping command to the CEC adapter." << endl <<
287 "[bl] to let the adapter enter the bootloader, to upgrade" << endl <<
288 " the flash rom." << endl <<
289 "[r] reconnect to the CEC adapter." << endl <<
290 "[h] or [help] show this help." << endl <<
291 "[q] or [quit] to quit the CEC test client and switch off all" << endl <<
292 " connected CEC devices." << endl <<
293 "================================================================================" << endl;
294 }
295
296 bool ProcessCommandTX(ICECAdapter *parser, const string &command, string &arguments)
297 {
298 if (command == "tx" || command == "txn")
299 {
300 string strvalue;
301 uint8_t ivalue;
302 cec_command bytes;
303 bytes.Clear();
304
305 while (GetWord(arguments, strvalue) && HexStrToInt(strvalue, ivalue))
306 bytes.PushBack(ivalue);
307
308 if (command == "txn")
309 bytes.transmit_timeout = 0;
310
311 parser->Transmit(bytes);
312
313 return true;
314 }
315
316 return false;
317 }
318
319 bool ProcessCommandON(ICECAdapter *parser, const string &command, string &arguments)
320 {
321 if (command == "on")
322 {
323 string strValue;
324 uint8_t iValue = 0;
325 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
326 {
327 parser->PowerOnDevices((cec_logical_address) iValue);
328 return true;
329 }
330 else
331 {
332 PrintToStdOut("invalid destination");
333 }
334 }
335
336 return false;
337 }
338
339 bool ProcessCommandSTANDBY(ICECAdapter *parser, const string &command, string &arguments)
340 {
341 if (command == "standby")
342 {
343 string strValue;
344 uint8_t iValue = 0;
345 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
346 {
347 parser->StandbyDevices((cec_logical_address) iValue);
348 return true;
349 }
350 else
351 {
352 PrintToStdOut("invalid destination");
353 }
354 }
355
356 return false;
357 }
358
359 bool ProcessCommandPOLL(ICECAdapter *parser, const string &command, string &arguments)
360 {
361 if (command == "poll")
362 {
363 string strValue;
364 uint8_t iValue = 0;
365 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
366 {
367 if (parser->PollDevice((cec_logical_address) iValue))
368 PrintToStdOut("POLL message sent");
369 else
370 PrintToStdOut("POLL message not sent");
371 return true;
372 }
373 else
374 {
375 PrintToStdOut("invalid destination");
376 }
377 }
378
379 return false;
380 }
381
382 bool ProcessCommandLA(ICECAdapter *parser, const string &command, string &arguments)
383 {
384 if (command == "la")
385 {
386 string strvalue;
387 if (GetWord(arguments, strvalue))
388 {
389 parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
390 return true;
391 }
392 }
393
394 return false;
395 }
396
397 bool ProcessCommandP(ICECAdapter *parser, const string &command, string &arguments)
398 {
399 if (command == "p")
400 {
401 string strPort, strDevice;
402 if (GetWord(arguments, strDevice) && GetWord(arguments, strPort))
403 {
404 parser->SetHDMIPort((cec_logical_address)atoi(strDevice.c_str()), (uint8_t)atoi(strPort.c_str()));
405 return true;
406 }
407 }
408
409 return false;
410 }
411
412 bool ProcessCommandPA(ICECAdapter *parser, const string &command, string &arguments)
413 {
414 if (command == "pa")
415 {
416 string strB1, strB2;
417 uint8_t iB1, iB2;
418 if (GetWord(arguments, strB1) && HexStrToInt(strB1, iB1) &&
419 GetWord(arguments, strB2) && HexStrToInt(strB2, iB2))
420 {
421 uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
422 parser->SetPhysicalAddress(iPhysicalAddress);
423 return true;
424 }
425 }
426
427 return false;
428 }
429
430 bool ProcessCommandOSD(ICECAdapter *parser, const string &command, string &arguments)
431 {
432 if (command == "osd")
433 {
434 bool bFirstWord(false);
435 string strAddr, strMessage, strWord;
436 uint8_t iAddr;
437 if (GetWord(arguments, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
438 {
439 while (GetWord(arguments, strWord))
440 {
441 if (bFirstWord)
442 {
443 bFirstWord = false;
444 strMessage.append(" ");
445 }
446 strMessage.append(strWord);
447 }
448 parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
449 return true;
450 }
451 }
452
453 return false;
454 }
455
456 bool ProcessCommandAS(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
457 {
458 if (command == "as")
459 {
460 parser->SetActiveView();
461 return true;
462 }
463
464 return false;
465 }
466
467
468 bool ProcessCommandPING(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
469 {
470 if (command == "ping")
471 {
472 parser->PingAdapter();
473 return true;
474 }
475
476 return false;
477 }
478
479 bool ProcessCommandVOLUP(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
480 {
481 if (command == "volup")
482 {
483 CStdString strLog;
484 strLog.Format("volume up: %2X", parser->VolumeUp());
485 PrintToStdOut(strLog);
486 return true;
487 }
488
489 return false;
490 }
491
492 bool ProcessCommandVOLDOWN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
493 {
494 if (command == "voldown")
495 {
496 CStdString strLog;
497 strLog.Format("volume down: %2X", parser->VolumeDown());
498 PrintToStdOut(strLog);
499 return true;
500 }
501
502 return false;
503 }
504
505 bool ProcessCommandMUTE(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
506 {
507 if (command == "mute")
508 {
509 CStdString strLog;
510 strLog.Format("mute: %2X", parser->MuteAudio());
511 PrintToStdOut(strLog);
512 return true;
513 }
514
515 return false;
516 }
517
518 bool ProcessCommandMON(ICECAdapter *parser, const string &command, string &arguments)
519 {
520 if (command == "mon")
521 {
522 CStdString strEnable;
523 if (GetWord(arguments, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
524 {
525 parser->SwitchMonitoring(strEnable.Equals("1"));
526 return true;
527 }
528 }
529
530 return false;
531 }
532
533 bool ProcessCommandBL(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
534 {
535 if (command == "bl")
536 {
537 parser->StartBootloader();
538 return true;
539 }
540
541 return false;
542 }
543
544 bool ProcessCommandLANG(ICECAdapter *parser, const string &command, string &arguments)
545 {
546 if (command == "lang")
547 {
548 CStdString strDev;
549 if (GetWord(arguments, strDev))
550 {
551 int iDev = atoi(strDev);
552 if (iDev >= 0 && iDev < 15)
553 {
554 CStdString strLog;
555 cec_menu_language language;
556 if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
557 strLog.Format("menu language '%s'", language.language);
558 else
559 strLog = "failed!";
560 PrintToStdOut(strLog);
561 return true;
562 }
563 }
564 }
565
566 return false;
567 }
568
569 bool ProcessCommandVEN(ICECAdapter *parser, const string &command, string &arguments)
570 {
571 if (command == "ven")
572 {
573 CStdString strDev;
574 if (GetWord(arguments, strDev))
575 {
576 int iDev = atoi(strDev);
577 if (iDev >= 0 && iDev < 15)
578 {
579 uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
580 CStdString strLog;
581 strLog.Format("vendor id: %06x", iVendor);
582 PrintToStdOut(strLog);
583 return true;
584 }
585 }
586 }
587
588 return false;
589 }
590
591 bool ProcessCommandVER(ICECAdapter *parser, const string &command, string &arguments)
592 {
593 if (command == "ver")
594 {
595 CStdString strDev;
596 if (GetWord(arguments, strDev))
597 {
598 int iDev = atoi(strDev);
599 if (iDev >= 0 && iDev < 15)
600 {
601 cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
602 CStdString strLog;
603 strLog.Format("CEC version %s", parser->ToString(iVersion));
604 PrintToStdOut(strLog);
605 return true;
606 }
607 }
608 }
609
610 return false;
611 }
612
613 bool ProcessCommandPOW(ICECAdapter *parser, const string &command, string &arguments)
614 {
615 if (command == "pow")
616 {
617 CStdString strDev;
618 if (GetWord(arguments, strDev))
619 {
620 int iDev = atoi(strDev);
621 if (iDev >= 0 && iDev < 15)
622 {
623 cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
624 CStdString strLog;
625 strLog.Format("power status: %s", parser->ToString(iPower));
626 PrintToStdOut(strLog);
627 return true;
628 }
629 }
630 }
631
632 return false;
633 }
634
635 bool ProcessCommandNAME(ICECAdapter *parser, const string &command, string &arguments)
636 {
637 if (command == "name")
638 {
639 CStdString strDev;
640 if (GetWord(arguments, strDev))
641 {
642 int iDev = atoi(strDev);
643 if (iDev >= 0 && iDev < 15)
644 {
645 cec_osd_name name = parser->GetDeviceOSDName((cec_logical_address)iDev);
646 CStdString strLog;
647 strLog.Format("OSD name of device %d is '%s'", iDev, name.name);
648 PrintToStdOut(strLog);
649 }
650 return true;
651 }
652 }
653
654 return false;
655 }
656
657 bool ProcessCommandLAD(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
658 {
659 if (command == "lad")
660 {
661 CStdString strLog;
662 PrintToStdOut("listing active devices:");
663 cec_logical_addresses addresses = parser->GetActiveDevices();
664 for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
665 if (addresses[iPtr])
666 {
667 strLog.Format("logical address %X", (int)iPtr);
668 PrintToStdOut(strLog);
669 }
670 return true;
671 }
672
673 return false;
674 }
675
676 bool ProcessCommandAD(ICECAdapter *parser, const string &command, string &arguments)
677 {
678 if (command == "ad")
679 {
680 CStdString strDev;
681 if (GetWord(arguments, strDev))
682 {
683 int iDev = atoi(strDev);
684 if (iDev >= 0 && iDev < 15)
685 {
686 CStdString strLog;
687 strLog.Format("logical address %X is %s", iDev, (parser->IsActiveDevice((cec_logical_address)iDev) ? "active" : "not active"));
688 PrintToStdOut(strLog);
689 }
690 }
691 }
692
693 return false;
694 }
695
696 bool ProcessCommandAT(ICECAdapter *parser, const string &command, string &arguments)
697 {
698 if (command == "at")
699 {
700 CStdString strType;
701 if (GetWord(arguments, strType))
702 {
703 cec_device_type type = CEC_DEVICE_TYPE_TV;
704 if (strType.Equals("a"))
705 type = CEC_DEVICE_TYPE_AUDIO_SYSTEM;
706 else if (strType.Equals("p"))
707 type = CEC_DEVICE_TYPE_PLAYBACK_DEVICE;
708 else if (strType.Equals("r"))
709 type = CEC_DEVICE_TYPE_RECORDING_DEVICE;
710 else if (strType.Equals("t"))
711 type = CEC_DEVICE_TYPE_TUNER;
712 CStdString strLog;
713 strLog.Format("device %d is %s", type, (parser->IsActiveDeviceType(type) ? "active" : "not active"));
714 PrintToStdOut(strLog);
715 return true;
716 }
717 }
718
719 return false;
720 }
721
722 bool ProcessCommandR(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
723 {
724 if (command == "r")
725 {
726 PrintToStdOut("closing the connection");
727 parser->Close();
728
729 PrintToStdOut("opening a new connection");
730 parser->Open(g_strPort.c_str());
731
732 PrintToStdOut("setting active source");
733 parser->SetActiveSource();
734 return true;
735 }
736
737 return false;
738 }
739
740 bool ProcessCommandH(ICECAdapter * UNUSED(parser), const string &command, string & UNUSED(arguments))
741 {
742 if (command == "h" || command == "help")
743 {
744 ShowHelpConsole();
745 return true;
746 }
747
748 return false;
749 }
750
751 bool ProcessCommandLOG(ICECAdapter * UNUSED(parser), const string &command, string &arguments)
752 {
753 if (command == "log")
754 {
755 CStdString strLevel;
756 if (GetWord(arguments, strLevel))
757 {
758 int iNewLevel = atoi(strLevel);
759 if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
760 {
761 g_cecLogLevel = iNewLevel;
762 CStdString strLog;
763 strLog.Format("log level changed to %s", strLevel.c_str());
764 PrintToStdOut(strLog);
765 return true;
766 }
767 }
768 }
769
770 return false;
771 }
772
773 bool ProcessCommandSCAN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
774 {
775 if (command == "scan")
776 {
777 PrintToStdOut("CEC bus information");
778 PrintToStdOut("===================");
779 cec_logical_addresses addresses = parser->GetActiveDevices();
780 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
781 {
782 if (addresses[iPtr])
783 {
784 CStdString strLog;
785 uint64_t iVendorId = parser->GetDeviceVendorId((cec_logical_address)iPtr);
786 bool bActive = parser->IsActiveSource((cec_logical_address)iPtr);
787 uint16_t iPhysicalAddress = parser->GetDevicePhysicalAddress((cec_logical_address)iPtr);
788 cec_version iCecVersion = parser->GetDeviceCecVersion((cec_logical_address)iPtr);
789 cec_power_status power = parser->GetDevicePowerStatus((cec_logical_address)iPtr);
790 cec_osd_name osdName = parser->GetDeviceOSDName((cec_logical_address)iPtr);
791 CStdString strAddr;
792 strAddr.Format("%04x", iPhysicalAddress);
793 cec_menu_language lang;
794 lang.device = CECDEVICE_UNKNOWN;
795 parser->GetDeviceMenuLanguage((cec_logical_address)iPtr, &lang);
796
797 strLog.AppendFormat("device #%X: %s\n", (int)iPtr, parser->ToString((cec_logical_address)iPtr));
798 strLog.AppendFormat("address: %s\n", strAddr.c_str());
799 strLog.AppendFormat("active source: %s\n", (bActive ? "yes" : "no"));
800 strLog.AppendFormat("vendor: %s\n", parser->ToString((cec_vendor_id)iVendorId));
801 strLog.AppendFormat("osd string: %s\n", osdName.name);
802 strLog.AppendFormat("CEC version: %s\n", parser->ToString(iCecVersion));
803 strLog.AppendFormat("power status: %s\n", parser->ToString(power));
804 if ((uint8_t)lang.device == iPtr)
805 strLog.AppendFormat("language: %s\n", lang.language);
806 strLog.append("\n");
807 PrintToStdOut(strLog);
808 }
809 }
810 return true;
811 }
812
813 return false;
814 }
815
816 bool ProcessConsoleCommand(ICECAdapter *parser, string &input)
817 {
818 if (!input.empty())
819 {
820 string command;
821 if (GetWord(input, command))
822 {
823 if (command == "q" || command == "quit")
824 return false;
825
826 ProcessCommandTX(parser, command, input) ||
827 ProcessCommandON(parser, command, input) ||
828 ProcessCommandSTANDBY(parser, command, input) ||
829 ProcessCommandPOLL(parser, command, input) ||
830 ProcessCommandLA(parser, command, input) ||
831 ProcessCommandP(parser, command, input) ||
832 ProcessCommandPA(parser, command, input) ||
833 ProcessCommandAS(parser, command, input) ||
834 ProcessCommandOSD(parser, command, input) ||
835 ProcessCommandPING(parser, command, input) ||
836 ProcessCommandVOLUP(parser, command, input) ||
837 ProcessCommandVOLDOWN(parser, command, input) ||
838 ProcessCommandMUTE(parser, command, input) ||
839 ProcessCommandMON(parser, command, input) ||
840 ProcessCommandBL(parser, command, input) ||
841 ProcessCommandLANG(parser, command, input) ||
842 ProcessCommandVEN(parser, command, input) ||
843 ProcessCommandVER(parser, command, input) ||
844 ProcessCommandPOW(parser, command, input) ||
845 ProcessCommandNAME(parser, command, input) ||
846 ProcessCommandLAD(parser, command, input) ||
847 ProcessCommandAD(parser, command, input) ||
848 ProcessCommandAT(parser, command, input) ||
849 ProcessCommandR(parser, command, input) ||
850 ProcessCommandH(parser, command, input) ||
851 ProcessCommandLOG(parser, command, input) ||
852 ProcessCommandSCAN(parser, command, input);
853 }
854 }
855 return true;
856 }
857
858 bool ProcessCommandLineArguments(int argc, char *argv[])
859 {
860 bool bReturn(true);
861 int iArgPtr = 1;
862 while (iArgPtr < argc && bReturn)
863 {
864 if (argc >= iArgPtr + 1)
865 {
866 if (!strcmp(argv[iArgPtr], "-f") ||
867 !strcmp(argv[iArgPtr], "--log-file") ||
868 !strcmp(argv[iArgPtr], "-sf") ||
869 !strcmp(argv[iArgPtr], "--short-log-file"))
870 {
871 if (argc >= iArgPtr + 2)
872 {
873 g_logOutput.open(argv[iArgPtr + 1]);
874 g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
875 iArgPtr += 2;
876 }
877 else
878 {
879 cout << "== skipped log-file parameter: no file given ==" << endl;
880 ++iArgPtr;
881 }
882 }
883 else if (!strcmp(argv[iArgPtr], "-d") ||
884 !strcmp(argv[iArgPtr], "--log-level"))
885 {
886 if (argc >= iArgPtr + 2)
887 {
888 int iNewLevel = atoi(argv[iArgPtr + 1]);
889 if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
890 {
891 g_cecLogLevel = iNewLevel;
892 if (!g_bSingleCommand)
893 cout << "log level set to " << argv[iArgPtr + 1] << endl;
894 }
895 else
896 {
897 cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
898 }
899 iArgPtr += 2;
900 }
901 else
902 {
903 cout << "== skipped log-level parameter: no level given ==" << endl;
904 ++iArgPtr;
905 }
906 }
907 else if (!strcmp(argv[iArgPtr], "-t") ||
908 !strcmp(argv[iArgPtr], "--type"))
909 {
910 if (argc >= iArgPtr + 2)
911 {
912 if (!strcmp(argv[iArgPtr + 1], "p"))
913 {
914 if (!g_bSingleCommand)
915 cout << "== using device type 'playback device'" << endl;
916 g_typeList.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
917 }
918 else if (!strcmp(argv[iArgPtr + 1], "r"))
919 {
920 if (!g_bSingleCommand)
921 cout << "== using device type 'recording device'" << endl;
922 g_typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
923 }
924 else if (!strcmp(argv[iArgPtr + 1], "t"))
925 {
926 if (!g_bSingleCommand)
927 cout << "== using device type 'tuner'" << endl;
928 g_typeList.add(CEC_DEVICE_TYPE_TUNER);
929 }
930 else if (!strcmp(argv[iArgPtr + 1], "a"))
931 {
932 if (!g_bSingleCommand)
933 cout << "== using device type 'audio system'" << endl;
934 g_typeList.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM);
935 }
936 else
937 {
938 cout << "== skipped invalid device type '" << argv[iArgPtr + 1] << "'" << endl;
939 }
940 ++iArgPtr;
941 }
942 ++iArgPtr;
943 }
944 else if (!strcmp(argv[iArgPtr], "--list-devices") ||
945 !strcmp(argv[iArgPtr], "-l"))
946 {
947 ICECAdapter *parser = CreateParser(g_typeList);
948 if (parser)
949 {
950 ListDevices(parser);
951 UnloadLibCec(parser);
952 parser = NULL;
953 }
954 bReturn = false;
955 }
956 else if (!strcmp(argv[iArgPtr], "--single-command") ||
957 !strcmp(argv[iArgPtr], "-s"))
958 {
959 g_bSingleCommand = true;
960 ++iArgPtr;
961 }
962 else if (!strcmp(argv[iArgPtr], "--help") ||
963 !strcmp(argv[iArgPtr], "-h"))
964 {
965 ShowHelpCommandLine(argv[0]);
966 return 0;
967 }
968 else if (!strcmp(argv[iArgPtr], "-b") ||
969 !strcmp(argv[iArgPtr], "--base"))
970 {
971 if (argc >= iArgPtr + 2)
972 {
973 g_iBaseDevice = (cec_logical_address)atoi(argv[iArgPtr + 1]);
974 cout << "using base device '" << (int)g_iBaseDevice << "'" << endl;
975 ++iArgPtr;
976 }
977 ++iArgPtr;
978 }
979 else if (!strcmp(argv[iArgPtr], "-p") ||
980 !strcmp(argv[iArgPtr], "--port"))
981 {
982 if (argc >= iArgPtr + 2)
983 {
984 g_iHDMIPort = (int8_t)atoi(argv[iArgPtr + 1]);
985 cout << "using HDMI port '" << (int)g_iHDMIPort << "'" << endl;
986 ++iArgPtr;
987 }
988 ++iArgPtr;
989 }
990 else
991 {
992 g_strPort = argv[iArgPtr++];
993 }
994 }
995 }
996
997 return bReturn;
998 }
999
1000 int main (int argc, char *argv[])
1001 {
1002 g_typeList.clear();
1003
1004 if (!ProcessCommandLineArguments(argc, argv))
1005 return 0;
1006
1007 if (g_typeList.IsEmpty())
1008 {
1009 if (!g_bSingleCommand)
1010 cout << "No device type given. Using 'recording device'" << endl;
1011 g_typeList.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
1012 }
1013
1014 ICECAdapter *parser = LibCecInit("CECTester", g_typeList);
1015 if (!parser || parser->GetMinLibVersion() > CEC_TEST_CLIENT_VERSION)
1016 {
1017 #ifdef __WINDOWS__
1018 cout << "Cannot load libcec.dll" << endl;
1019 #else
1020 cout << "Cannot load libcec.so" << endl;
1021 #endif
1022
1023 if (parser)
1024 UnloadLibCec(parser);
1025
1026 return 1;
1027 }
1028
1029 if (!g_bSingleCommand)
1030 {
1031 CStdString strLog;
1032 strLog.Format("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
1033 cout << strLog.c_str() << endl;
1034
1035 //make stdin non-blocking
1036 #ifndef __WINDOWS__
1037 int flags = fcntl(0, F_GETFL, 0);
1038 flags |= O_NONBLOCK;
1039 fcntl(0, F_SETFL, flags);
1040 #endif
1041 }
1042
1043 if (g_strPort.IsEmpty())
1044 {
1045 if (!g_bSingleCommand)
1046 cout << "no serial port given. trying autodetect: ";
1047 cec_adapter devices[10];
1048 uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
1049 if (iDevicesFound <= 0)
1050 {
1051 if (g_bSingleCommand)
1052 cout << "autodetect ";
1053 cout << "FAILED" << endl;
1054 UnloadLibCec(parser);
1055 return 1;
1056 }
1057 else
1058 {
1059 if (!g_bSingleCommand)
1060 {
1061 cout << endl << " path: " << devices[0].path << endl <<
1062 " com port: " << devices[0].comm << endl << endl;
1063 }
1064 g_strPort = devices[0].comm;
1065 }
1066 }
1067
1068 EnableCallbacks(parser);
1069
1070 parser->SetHDMIPort(g_iBaseDevice, g_iHDMIPort);
1071 PrintToStdOut("opening a connection to the CEC adapter...");
1072
1073 if (!parser->Open(g_strPort.c_str()))
1074 {
1075 CStdString strLog;
1076 strLog.Format("unable to open the device on port %s");
1077 PrintToStdOut(strLog);
1078 UnloadLibCec(parser);
1079 return 1;
1080 }
1081
1082 if (!g_bSingleCommand)
1083 {
1084 PrintToStdOut("cec device opened");
1085
1086 parser->PowerOnDevices(CECDEVICE_TV);
1087 parser->SetActiveSource();
1088
1089 PrintToStdOut("waiting for input");
1090 }
1091
1092 bool bContinue(true);
1093 while (bContinue)
1094 {
1095 string input;
1096 getline(cin, input);
1097 cin.clear();
1098
1099 if (ProcessConsoleCommand(parser, input) && !g_bSingleCommand)
1100 {
1101 if (!input.empty())
1102 PrintToStdOut("waiting for input");
1103 }
1104 else
1105 bContinue = false;
1106
1107 if (bContinue)
1108 CCondition::Sleep(50);
1109 }
1110
1111 if (!g_bSingleCommand)
1112 parser->StandbyDevices(CECDEVICE_BROADCAST);
1113
1114 parser->Close();
1115 UnloadLibCec(parser);
1116
1117 if (g_logOutput.is_open())
1118 g_logOutput.close();
1119
1120 return 0;
1121 }