cec: set the initial stream path to PA 0xFFFF instead of 0x0. added some logging
[deb_libcec.git] / src / testclient / main.cpp
... / ...
CommitLineData
1/*
2 * This file is part of the libCEC(R) library.
3 *
4 * libCEC(R) is Copyright (C) 2011-2012 Pulse-Eight Limited. All rights reserved.
5 * libCEC(R) is an original work, containing original code.
6 *
7 * libCEC(R) is a trademark of Pulse-Eight Limited.
8 *
9 * This program is dual-licensed; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
22 *
23 *
24 * Alternatively, you can license this library under a commercial license,
25 * please contact Pulse-Eight Licensing for more information.
26 *
27 * For more information contact:
28 * Pulse-Eight Licensing <license@pulse-eight.com>
29 * http://www.pulse-eight.com/
30 * http://www.pulse-eight.net/
31 */
32
33#include "../../include/cec.h"
34
35#include <cstdio>
36#include <fcntl.h>
37#include <iostream>
38#include <fstream>
39#include <string>
40#include <sstream>
41#include "../lib/platform/os.h"
42#include "../lib/implementations/CECCommandHandler.h"
43
44using namespace CEC;
45using namespace std;
46using namespace PLATFORM;
47
48#include <cecloader.h>
49
50ICECCallbacks g_callbacks;
51libcec_configuration g_config;
52int g_cecLogLevel(CEC_LOG_ALL);
53ofstream g_logOutput;
54bool g_bShortLog(false);
55CStdString g_strPort;
56bool g_bSingleCommand(false);
57bool g_bExit(false);
58bool g_bHardExit(false);
59CMutex g_outputMutex;
60
61inline void PrintToStdOut(const char *strFormat, ...)
62{
63 CStdString strLog;
64
65 va_list argList;
66 va_start(argList, strFormat);
67 strLog.FormatV(strFormat, argList);
68 va_end(argList);
69
70 CLockObject lock(g_outputMutex);
71 cout << strLog << endl;
72}
73
74inline bool HexStrToInt(const std::string& data, uint8_t& value)
75{
76 int iTmp(0);
77 if (sscanf(data.c_str(), "%x", &iTmp) == 1)
78 {
79 if (iTmp > 256)
80 value = 255;
81 else if (iTmp < 0)
82 value = 0;
83 else
84 value = (uint8_t) iTmp;
85
86 return true;
87 }
88
89 return false;
90}
91
92//get the first word (separated by whitespace) from string data and place that in word
93//then remove that word from string data
94bool GetWord(string& data, string& word)
95{
96 stringstream datastream(data);
97 string end;
98
99 datastream >> word;
100 if (datastream.fail())
101 {
102 data.clear();
103 return false;
104 }
105
106 size_t pos = data.find(word) + word.length();
107
108 if (pos >= data.length())
109 {
110 data.clear();
111 return true;
112 }
113
114 data = data.substr(pos);
115
116 datastream.clear();
117 datastream.str(data);
118
119 datastream >> end;
120 if (datastream.fail())
121 data.clear();
122
123 return true;
124}
125
126int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message)
127{
128 if ((message.level & g_cecLogLevel) == message.level)
129 {
130 CStdString strLevel;
131 switch (message.level)
132 {
133 case CEC_LOG_ERROR:
134 strLevel = "ERROR: ";
135 break;
136 case CEC_LOG_WARNING:
137 strLevel = "WARNING: ";
138 break;
139 case CEC_LOG_NOTICE:
140 strLevel = "NOTICE: ";
141 break;
142 case CEC_LOG_TRAFFIC:
143 strLevel = "TRAFFIC: ";
144 break;
145 case CEC_LOG_DEBUG:
146 strLevel = "DEBUG: ";
147 break;
148 default:
149 break;
150 }
151
152 CStdString strFullLog;
153 strFullLog.Format("%s[%16lld]\t%s", strLevel.c_str(), message.time, message.message);
154 PrintToStdOut(strFullLog.c_str());
155
156 if (g_logOutput.is_open())
157 {
158 if (g_bShortLog)
159 g_logOutput << message.message << endl;
160 else
161 g_logOutput << strFullLog.c_str() << endl;
162 }
163 }
164
165 return 0;
166}
167
168int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &UNUSED(key))
169{
170 return 0;
171}
172
173int CecCommand(void *UNUSED(cbParam), const cec_command &UNUSED(command))
174{
175 return 0;
176}
177
178int CecAlert(void *UNUSED(cbParam), const libcec_alert type, const libcec_parameter &UNUSED(param))
179{
180 switch (type)
181 {
182 case CEC_ALERT_CONNECTION_LOST:
183 PrintToStdOut("Connection lost - exiting\n");
184 g_bExit = true;
185 break;
186 default:
187 break;
188 }
189 return 0;
190}
191
192void ListDevices(ICECAdapter *parser)
193{
194 cec_adapter *devices = new cec_adapter[10];
195 int8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
196 if (iDevicesFound <= 0)
197 {
198 PrintToStdOut("Found devices: NONE");
199 }
200 else
201 {
202 CStdString strDeviceInfo;
203 strDeviceInfo.Format("Found devices: %d\n\n", iDevicesFound);
204
205 for (int8_t iDevicePtr = 0; iDevicePtr < iDevicesFound; iDevicePtr++)
206 {
207 strDeviceInfo.AppendFormat("device: %d\ncom port: %s\n", iDevicePtr + 1, devices[iDevicePtr].comm);
208 libcec_configuration config;
209 config.Clear();
210
211 if (!parser->GetDeviceInformation(devices[iDevicePtr].comm, &config))
212 PrintToStdOut("WARNING: unable to open the device on port %s", devices[iDevicePtr].comm);
213 else
214 strDeviceInfo.AppendFormat("firmware version: %d\n", config.iFirmwareVersion);
215 strDeviceInfo.append("\n");
216 }
217 PrintToStdOut(strDeviceInfo.c_str());
218 }
219}
220
221void ShowHelpCommandLine(const char* strExec)
222{
223 CLockObject lock(g_outputMutex);
224 cout << endl <<
225 strExec << " {-h|--help|-l|--list-devices|[COM PORT]}" << endl <<
226 endl <<
227 "parameters:" << endl <<
228 " -h --help Shows this help text" << endl <<
229 " -l --list-devices List all devices on this system" << endl <<
230 " -t --type {p|r|t|a} The device type to use. More than one is possible." << endl <<
231 " -p --port {int} The HDMI port to use as active source." << endl <<
232 " -b --base {int} The logical address of the device to with this " << endl <<
233 " adapter is connected." << endl <<
234 " -f --log-file {file} Writes all libCEC log message to a file" << endl <<
235 " -r --rom Read persisted settings from the EEPROM" << endl <<
236 " -sf --short-log-file {file} Writes all libCEC log message without timestamps" << endl <<
237 " and log levels to a file." << endl <<
238 " -d --log-level {level} Sets the log level. See cectypes.h for values." << endl <<
239 " -s --single-command Execute a single command and exit. Does not power" << endl <<
240 " on devices on startup and power them off on exit." << endl <<
241 " -o --osd-name {osd name} Use a custom osd name." << endl <<
242 " [COM PORT] The com port to connect to. If no COM" << endl <<
243 " port is given, the client tries to connect to the" << endl <<
244 " first device that is detected." << endl <<
245 endl <<
246 "Type 'h' or 'help' and press enter after starting the client to display all " << endl <<
247 "available commands" << endl;
248}
249
250void ShowHelpConsole(void)
251{
252 CLockObject lock(g_outputMutex);
253 cout << endl <<
254 "================================================================================" << endl <<
255 "Available commands:" << endl <<
256 endl <<
257 "[tx] {bytes} transfer bytes over the CEC line." << endl <<
258 "[txn] {bytes} transfer bytes but don't wait for transmission ACK." << endl <<
259 "[on] {address} power on the device with the given logical address." << endl <<
260 "[standby] {address} put the device with the given address in standby mode." << endl <<
261 "[la] {logical address} change the logical address of the CEC adapter." << endl <<
262 "[p] {device} {port} change the HDMI port number of the CEC adapter." << endl <<
263 "[pa] {physical address} change the physical address of the CEC adapter." << endl <<
264 "[as] make the CEC adapter the active source." << endl <<
265 "[osd] {addr} {string} set OSD message on the specified device." << endl <<
266 "[ver] {addr} get the CEC version of the specified device." << endl <<
267 "[ven] {addr} get the vendor ID of the specified device." << endl <<
268 "[lang] {addr} get the menu language of the specified device." << endl <<
269 "[pow] {addr} get the power status of the specified device." << endl <<
270 "[name] {addr} get the OSD name of the specified device." << endl <<
271 "[poll] {addr} poll the specified device." << endl <<
272 "[lad] lists active devices on the bus" << endl <<
273 "[ad] {addr} checks whether the specified device is active." << endl <<
274 "[at] {type} checks whether the specified device type is active." << endl <<
275 "[sp] {addr} makes the specified physical address active." << endl <<
276 "[spl] {addr} makes the specified logical address active." << endl <<
277 "[volup] send a volume up command to the amp if present" << endl <<
278 "[voldown] send a volume down command to the amp if present" << endl <<
279 "[mute] send a mute/unmute command to the amp if present" << endl <<
280 "[self] show the list of addresses controlled by libCEC" << endl <<
281 "[scan] scan the CEC bus and display device info" << endl <<
282 "[mon] {1|0} enable or disable CEC bus monitoring." << endl <<
283 "[log] {1 - 31} change the log level. see cectypes.h for values." << endl <<
284 "[ping] send a ping command to the CEC adapter." << endl <<
285 "[bl] to let the adapter enter the bootloader, to upgrade" << endl <<
286 " the flash rom." << endl <<
287 "[r] reconnect to the CEC adapter." << endl <<
288 "[h] or [help] show this help." << endl <<
289 "[q] or [quit] to quit the CEC test client and switch off all" << endl <<
290 " connected CEC devices." << endl <<
291 "================================================================================" << endl;
292}
293
294bool ProcessCommandSELF(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
295{
296 if (command == "self")
297 {
298 cec_logical_addresses addr = parser->GetLogicalAddresses();
299 CStdString strOut = "Addresses controlled by libCEC: ";
300 bool bFirst(true);
301 for (uint8_t iPtr = 0; iPtr <= 15; iPtr++)
302 {
303 if (addr[iPtr])
304 {
305 strOut.AppendFormat((bFirst ? "%d%s" : ", %d%s"), iPtr, parser->IsActiveSource((cec_logical_address)iPtr) ? "*" : "");
306 bFirst = false;
307 }
308 }
309 PrintToStdOut(strOut.c_str());
310 return true;
311 }
312
313 return false;
314}
315
316bool ProcessCommandSP(ICECAdapter *parser, const string &command, string &arguments)
317{
318 if (command == "sp")
319 {
320 string strAddress;
321 int iAddress;
322 if (GetWord(arguments, strAddress))
323 {
324 sscanf(strAddress.c_str(), "%x", &iAddress);
325 if (iAddress >= 0 && iAddress <= 0xFFFF)
326 parser->SetStreamPath((uint16_t)iAddress);
327 return true;
328 }
329 }
330
331 return false;
332}
333
334bool ProcessCommandSPL(ICECAdapter *parser, const string &command, string &arguments)
335{
336 if (command == "spl")
337 {
338 string strAddress;
339 cec_logical_address iAddress;
340 if (GetWord(arguments, strAddress))
341 {
342 iAddress = (cec_logical_address)atoi(strAddress.c_str());
343 if (iAddress >= CECDEVICE_TV && iAddress < CECDEVICE_BROADCAST)
344 parser->SetStreamPath(iAddress);
345 return true;
346 }
347 }
348
349 return false;
350}
351
352bool ProcessCommandTX(ICECAdapter *parser, const string &command, string &arguments)
353{
354 if (command == "tx" || command == "txn")
355 {
356 string strvalue;
357 uint8_t ivalue;
358 cec_command bytes;
359 bytes.Clear();
360
361 while (GetWord(arguments, strvalue) && HexStrToInt(strvalue, ivalue))
362 bytes.PushBack(ivalue);
363
364 if (command == "txn")
365 bytes.transmit_timeout = 0;
366
367 parser->Transmit(bytes);
368
369 return true;
370 }
371
372 return false;
373}
374
375bool ProcessCommandON(ICECAdapter *parser, const string &command, string &arguments)
376{
377 if (command == "on")
378 {
379 string strValue;
380 uint8_t iValue = 0;
381 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
382 {
383 parser->PowerOnDevices((cec_logical_address) iValue);
384 return true;
385 }
386 else
387 {
388 PrintToStdOut("invalid destination");
389 }
390 }
391
392 return false;
393}
394
395bool ProcessCommandSTANDBY(ICECAdapter *parser, const string &command, string &arguments)
396{
397 if (command == "standby")
398 {
399 string strValue;
400 uint8_t iValue = 0;
401 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
402 {
403 parser->StandbyDevices((cec_logical_address) iValue);
404 return true;
405 }
406 else
407 {
408 PrintToStdOut("invalid destination");
409 }
410 }
411
412 return false;
413}
414
415bool ProcessCommandPOLL(ICECAdapter *parser, const string &command, string &arguments)
416{
417 if (command == "poll")
418 {
419 string strValue;
420 uint8_t iValue = 0;
421 if (GetWord(arguments, strValue) && HexStrToInt(strValue, iValue) && iValue <= 0xF)
422 {
423 if (parser->PollDevice((cec_logical_address) iValue))
424 PrintToStdOut("POLL message sent");
425 else
426 PrintToStdOut("POLL message not sent");
427 return true;
428 }
429 else
430 {
431 PrintToStdOut("invalid destination");
432 }
433 }
434
435 return false;
436}
437
438bool ProcessCommandLA(ICECAdapter *parser, const string &command, string &arguments)
439{
440 if (command == "la")
441 {
442 string strvalue;
443 if (GetWord(arguments, strvalue))
444 {
445 parser->SetLogicalAddress((cec_logical_address) atoi(strvalue.c_str()));
446 return true;
447 }
448 }
449
450 return false;
451}
452
453bool ProcessCommandP(ICECAdapter *parser, const string &command, string &arguments)
454{
455 if (command == "p")
456 {
457 string strPort, strDevice;
458 if (GetWord(arguments, strDevice) && GetWord(arguments, strPort))
459 {
460 parser->SetHDMIPort((cec_logical_address)atoi(strDevice.c_str()), (uint8_t)atoi(strPort.c_str()));
461 return true;
462 }
463 }
464
465 return false;
466}
467
468bool ProcessCommandPA(ICECAdapter *parser, const string &command, string &arguments)
469{
470 if (command == "pa")
471 {
472 string strB1, strB2;
473 uint8_t iB1, iB2;
474 if (GetWord(arguments, strB1) && HexStrToInt(strB1, iB1) &&
475 GetWord(arguments, strB2) && HexStrToInt(strB2, iB2))
476 {
477 uint16_t iPhysicalAddress = ((uint16_t)iB1 << 8) + iB2;
478 parser->SetPhysicalAddress(iPhysicalAddress);
479 return true;
480 }
481 }
482
483 return false;
484}
485
486bool ProcessCommandOSD(ICECAdapter *parser, const string &command, string &arguments)
487{
488 if (command == "osd")
489 {
490 bool bFirstWord(false);
491 string strAddr, strMessage, strWord;
492 uint8_t iAddr;
493 if (GetWord(arguments, strAddr) && HexStrToInt(strAddr, iAddr) && iAddr < 0xF)
494 {
495 while (GetWord(arguments, strWord))
496 {
497 if (bFirstWord)
498 {
499 bFirstWord = false;
500 strMessage.append(" ");
501 }
502 strMessage.append(strWord);
503 }
504 parser->SetOSDString((cec_logical_address) iAddr, CEC_DISPLAY_CONTROL_DISPLAY_FOR_DEFAULT_TIME, strMessage.c_str());
505 return true;
506 }
507 }
508
509 return false;
510}
511
512bool ProcessCommandAS(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
513{
514 if (command == "as")
515 {
516 parser->SetActiveView();
517 return true;
518 }
519
520 return false;
521}
522
523
524bool ProcessCommandPING(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
525{
526 if (command == "ping")
527 {
528 parser->PingAdapter();
529 return true;
530 }
531
532 return false;
533}
534
535bool ProcessCommandVOLUP(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
536{
537 if (command == "volup")
538 {
539 PrintToStdOut("volume up: %2X", parser->VolumeUp());
540 return true;
541 }
542
543 return false;
544}
545
546bool ProcessCommandVOLDOWN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
547{
548 if (command == "voldown")
549 {
550 PrintToStdOut("volume down: %2X", parser->VolumeDown());
551 return true;
552 }
553
554 return false;
555}
556
557bool ProcessCommandMUTE(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
558{
559 if (command == "mute")
560 {
561 PrintToStdOut("mute: %2X", parser->MuteAudio());
562 return true;
563 }
564
565 return false;
566}
567
568bool ProcessCommandMON(ICECAdapter *parser, const string &command, string &arguments)
569{
570 if (command == "mon")
571 {
572 CStdString strEnable;
573 if (GetWord(arguments, strEnable) && (strEnable.Equals("0") || strEnable.Equals("1")))
574 {
575 parser->SwitchMonitoring(strEnable.Equals("1"));
576 return true;
577 }
578 }
579
580 return false;
581}
582
583bool ProcessCommandBL(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
584{
585 if (command == "bl")
586 {
587 if (parser->StartBootloader())
588 {
589 PrintToStdOut("entered bootloader mode. exiting cec-client");
590 g_bExit = true;
591 g_bHardExit = true;
592 }
593 return true;
594 }
595
596 return false;
597}
598
599bool ProcessCommandLANG(ICECAdapter *parser, const string &command, string &arguments)
600{
601 if (command == "lang")
602 {
603 CStdString strDev;
604 if (GetWord(arguments, strDev))
605 {
606 int iDev = atoi(strDev);
607 if (iDev >= 0 && iDev < 15)
608 {
609 CStdString strLog;
610 cec_menu_language language;
611 if (parser->GetDeviceMenuLanguage((cec_logical_address) iDev, &language))
612 strLog.Format("menu language '%s'", language.language);
613 else
614 strLog = "failed!";
615 PrintToStdOut(strLog);
616 return true;
617 }
618 }
619 }
620
621 return false;
622}
623
624bool ProcessCommandVEN(ICECAdapter *parser, const string &command, string &arguments)
625{
626 if (command == "ven")
627 {
628 CStdString strDev;
629 if (GetWord(arguments, strDev))
630 {
631 int iDev = atoi(strDev);
632 if (iDev >= 0 && iDev < 15)
633 {
634 uint64_t iVendor = parser->GetDeviceVendorId((cec_logical_address) iDev);
635 PrintToStdOut("vendor id: %06x", iVendor);
636 return true;
637 }
638 }
639 }
640
641 return false;
642}
643
644bool ProcessCommandVER(ICECAdapter *parser, const string &command, string &arguments)
645{
646 if (command == "ver")
647 {
648 CStdString strDev;
649 if (GetWord(arguments, strDev))
650 {
651 int iDev = atoi(strDev);
652 if (iDev >= 0 && iDev < 15)
653 {
654 cec_version iVersion = parser->GetDeviceCecVersion((cec_logical_address) iDev);
655 PrintToStdOut("CEC version %s", parser->ToString(iVersion));
656 return true;
657 }
658 }
659 }
660
661 return false;
662}
663
664bool ProcessCommandPOW(ICECAdapter *parser, const string &command, string &arguments)
665{
666 if (command == "pow")
667 {
668 CStdString strDev;
669 if (GetWord(arguments, strDev))
670 {
671 int iDev = atoi(strDev);
672 if (iDev >= 0 && iDev < 15)
673 {
674 cec_power_status iPower = parser->GetDevicePowerStatus((cec_logical_address) iDev);
675 PrintToStdOut("power status: %s", parser->ToString(iPower));
676 return true;
677 }
678 }
679 }
680
681 return false;
682}
683
684bool ProcessCommandNAME(ICECAdapter *parser, const string &command, string &arguments)
685{
686 if (command == "name")
687 {
688 CStdString strDev;
689 if (GetWord(arguments, strDev))
690 {
691 int iDev = atoi(strDev);
692 if (iDev >= 0 && iDev < 15)
693 {
694 cec_osd_name name = parser->GetDeviceOSDName((cec_logical_address)iDev);
695 PrintToStdOut("OSD name of device %d is '%s'", iDev, name.name);
696 }
697 return true;
698 }
699 }
700
701 return false;
702}
703
704bool ProcessCommandLAD(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
705{
706 if (command == "lad")
707 {
708 PrintToStdOut("listing active devices:");
709 cec_logical_addresses addresses = parser->GetActiveDevices();
710 for (uint8_t iPtr = 0; iPtr <= 11; iPtr++)
711 if (addresses[iPtr])
712 {
713 PrintToStdOut("logical address %X", (int)iPtr);
714 }
715 return true;
716 }
717
718 return false;
719}
720
721bool ProcessCommandAD(ICECAdapter *parser, const string &command, string &arguments)
722{
723 if (command == "ad")
724 {
725 CStdString strDev;
726 if (GetWord(arguments, strDev))
727 {
728 int iDev = atoi(strDev);
729 if (iDev >= 0 && iDev < 15)
730 PrintToStdOut("logical address %X is %s", iDev, (parser->IsActiveDevice((cec_logical_address)iDev) ? "active" : "not active"));
731 }
732 }
733
734 return false;
735}
736
737bool ProcessCommandAT(ICECAdapter *parser, const string &command, string &arguments)
738{
739 if (command == "at")
740 {
741 CStdString strType;
742 if (GetWord(arguments, strType))
743 {
744 cec_device_type type = CEC_DEVICE_TYPE_TV;
745 if (strType.Equals("a"))
746 type = CEC_DEVICE_TYPE_AUDIO_SYSTEM;
747 else if (strType.Equals("p"))
748 type = CEC_DEVICE_TYPE_PLAYBACK_DEVICE;
749 else if (strType.Equals("r"))
750 type = CEC_DEVICE_TYPE_RECORDING_DEVICE;
751 else if (strType.Equals("t"))
752 type = CEC_DEVICE_TYPE_TUNER;
753
754 PrintToStdOut("device %d is %s", type, (parser->IsActiveDeviceType(type) ? "active" : "not active"));
755 return true;
756 }
757 }
758
759 return false;
760}
761
762bool ProcessCommandR(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
763{
764 if (command == "r")
765 {
766 PrintToStdOut("closing the connection");
767 parser->Close();
768
769 PrintToStdOut("opening a new connection");
770 parser->Open(g_strPort.c_str());
771
772 PrintToStdOut("setting active source");
773 parser->SetActiveSource();
774 return true;
775 }
776
777 return false;
778}
779
780bool ProcessCommandH(ICECAdapter * UNUSED(parser), const string &command, string & UNUSED(arguments))
781{
782 if (command == "h" || command == "help")
783 {
784 ShowHelpConsole();
785 return true;
786 }
787
788 return false;
789}
790
791bool ProcessCommandLOG(ICECAdapter * UNUSED(parser), const string &command, string &arguments)
792{
793 if (command == "log")
794 {
795 CStdString strLevel;
796 if (GetWord(arguments, strLevel))
797 {
798 int iNewLevel = atoi(strLevel);
799 if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
800 {
801 g_cecLogLevel = iNewLevel;
802
803 PrintToStdOut("log level changed to %s", strLevel.c_str());
804 return true;
805 }
806 }
807 }
808
809 return false;
810}
811
812bool ProcessCommandSCAN(ICECAdapter *parser, const string &command, string & UNUSED(arguments))
813{
814 if (command == "scan")
815 {
816 PrintToStdOut("CEC bus information");
817 PrintToStdOut("===================");
818 cec_logical_addresses addresses = parser->GetActiveDevices();
819 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
820 {
821 if (addresses[iPtr])
822 {
823 CStdString strLog;
824 uint64_t iVendorId = parser->GetDeviceVendorId((cec_logical_address)iPtr);
825 bool bActive = parser->IsActiveSource((cec_logical_address)iPtr);
826 uint16_t iPhysicalAddress = parser->GetDevicePhysicalAddress((cec_logical_address)iPtr);
827 cec_version iCecVersion = parser->GetDeviceCecVersion((cec_logical_address)iPtr);
828 cec_power_status power = parser->GetDevicePowerStatus((cec_logical_address)iPtr);
829 cec_osd_name osdName = parser->GetDeviceOSDName((cec_logical_address)iPtr);
830 CStdString strAddr;
831 strAddr.Format("%04x", iPhysicalAddress);
832 cec_menu_language lang;
833 lang.device = CECDEVICE_UNKNOWN;
834 parser->GetDeviceMenuLanguage((cec_logical_address)iPtr, &lang);
835
836 strLog.AppendFormat("device #%X: %s\n", (int)iPtr, parser->ToString((cec_logical_address)iPtr));
837 strLog.AppendFormat("address: %s\n", strAddr.c_str());
838 strLog.AppendFormat("active source: %s\n", (bActive ? "yes" : "no"));
839 strLog.AppendFormat("vendor: %s\n", parser->ToString((cec_vendor_id)iVendorId));
840 strLog.AppendFormat("osd string: %s\n", osdName.name);
841 strLog.AppendFormat("CEC version: %s\n", parser->ToString(iCecVersion));
842 strLog.AppendFormat("power status: %s\n", parser->ToString(power));
843 if ((uint8_t)lang.device == iPtr)
844 strLog.AppendFormat("language: %s\n", lang.language);
845 strLog.append("\n");
846 PrintToStdOut(strLog);
847 }
848 }
849 return true;
850 }
851
852 return false;
853}
854
855bool ProcessConsoleCommand(ICECAdapter *parser, string &input)
856{
857 if (!input.empty())
858 {
859 string command;
860 if (GetWord(input, command))
861 {
862 if (command == "q" || command == "quit")
863 return false;
864
865 ProcessCommandTX(parser, command, input) ||
866 ProcessCommandON(parser, command, input) ||
867 ProcessCommandSTANDBY(parser, command, input) ||
868 ProcessCommandPOLL(parser, command, input) ||
869 ProcessCommandLA(parser, command, input) ||
870 ProcessCommandP(parser, command, input) ||
871 ProcessCommandPA(parser, command, input) ||
872 ProcessCommandAS(parser, command, input) ||
873 ProcessCommandOSD(parser, command, input) ||
874 ProcessCommandPING(parser, command, input) ||
875 ProcessCommandVOLUP(parser, command, input) ||
876 ProcessCommandVOLDOWN(parser, command, input) ||
877 ProcessCommandMUTE(parser, command, input) ||
878 ProcessCommandMON(parser, command, input) ||
879 ProcessCommandBL(parser, command, input) ||
880 ProcessCommandLANG(parser, command, input) ||
881 ProcessCommandVEN(parser, command, input) ||
882 ProcessCommandVER(parser, command, input) ||
883 ProcessCommandPOW(parser, command, input) ||
884 ProcessCommandNAME(parser, command, input) ||
885 ProcessCommandLAD(parser, command, input) ||
886 ProcessCommandAD(parser, command, input) ||
887 ProcessCommandAT(parser, command, input) ||
888 ProcessCommandR(parser, command, input) ||
889 ProcessCommandH(parser, command, input) ||
890 ProcessCommandLOG(parser, command, input) ||
891 ProcessCommandSCAN(parser, command, input) ||
892 ProcessCommandSP(parser, command, input) ||
893 ProcessCommandSPL(parser, command, input) ||
894 ProcessCommandSELF(parser, command, input);
895 }
896 }
897 return true;
898}
899
900bool ProcessCommandLineArguments(int argc, char *argv[])
901{
902 bool bReturn(true);
903 int iArgPtr = 1;
904 while (iArgPtr < argc && bReturn)
905 {
906 if (argc >= iArgPtr + 1)
907 {
908 if (!strcmp(argv[iArgPtr], "-f") ||
909 !strcmp(argv[iArgPtr], "--log-file") ||
910 !strcmp(argv[iArgPtr], "-sf") ||
911 !strcmp(argv[iArgPtr], "--short-log-file"))
912 {
913 if (argc >= iArgPtr + 2)
914 {
915 g_logOutput.open(argv[iArgPtr + 1]);
916 g_bShortLog = (!strcmp(argv[iArgPtr], "-sf") || !strcmp(argv[iArgPtr], "--short-log-file"));
917 iArgPtr += 2;
918 }
919 else
920 {
921 cout << "== skipped log-file parameter: no file given ==" << endl;
922 ++iArgPtr;
923 }
924 }
925 else if (!strcmp(argv[iArgPtr], "-d") ||
926 !strcmp(argv[iArgPtr], "--log-level"))
927 {
928 if (argc >= iArgPtr + 2)
929 {
930 int iNewLevel = atoi(argv[iArgPtr + 1]);
931 if (iNewLevel >= CEC_LOG_ERROR && iNewLevel <= CEC_LOG_ALL)
932 {
933 g_cecLogLevel = iNewLevel;
934 if (!g_bSingleCommand)
935 cout << "log level set to " << argv[iArgPtr + 1] << endl;
936 }
937 else
938 {
939 cout << "== skipped log-level parameter: invalid level '" << argv[iArgPtr + 1] << "' ==" << endl;
940 }
941 iArgPtr += 2;
942 }
943 else
944 {
945 cout << "== skipped log-level parameter: no level given ==" << endl;
946 ++iArgPtr;
947 }
948 }
949 else if (!strcmp(argv[iArgPtr], "-t") ||
950 !strcmp(argv[iArgPtr], "--type"))
951 {
952 if (argc >= iArgPtr + 2)
953 {
954 if (!strcmp(argv[iArgPtr + 1], "p"))
955 {
956 if (!g_bSingleCommand)
957 cout << "== using device type 'playback device'" << endl;
958 g_config.deviceTypes.add(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
959 }
960 else if (!strcmp(argv[iArgPtr + 1], "r"))
961 {
962 if (!g_bSingleCommand)
963 cout << "== using device type 'recording device'" << endl;
964 g_config.deviceTypes.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
965 }
966 else if (!strcmp(argv[iArgPtr + 1], "t"))
967 {
968 if (!g_bSingleCommand)
969 cout << "== using device type 'tuner'" << endl;
970 g_config.deviceTypes.add(CEC_DEVICE_TYPE_TUNER);
971 }
972 else if (!strcmp(argv[iArgPtr + 1], "a"))
973 {
974 if (!g_bSingleCommand)
975 cout << "== using device type 'audio system'" << endl;
976 g_config.deviceTypes.add(CEC_DEVICE_TYPE_AUDIO_SYSTEM);
977 }
978 else
979 {
980 cout << "== skipped invalid device type '" << argv[iArgPtr + 1] << "'" << endl;
981 }
982 ++iArgPtr;
983 }
984 ++iArgPtr;
985 }
986 else if (!strcmp(argv[iArgPtr], "--list-devices") ||
987 !strcmp(argv[iArgPtr], "-l"))
988 {
989 ICECAdapter *parser = LibCecInitialise(&g_config);
990 if (parser)
991 {
992 ListDevices(parser);
993 UnloadLibCec(parser);
994 parser = NULL;
995 }
996 bReturn = false;
997 }
998 else if (!strcmp(argv[iArgPtr], "--bootloader"))
999 {
1000 LibCecBootloader();
1001 bReturn = false;
1002 }
1003 else if (!strcmp(argv[iArgPtr], "--single-command") ||
1004 !strcmp(argv[iArgPtr], "-s"))
1005 {
1006 g_bSingleCommand = true;
1007 ++iArgPtr;
1008 }
1009 else if (!strcmp(argv[iArgPtr], "--help") ||
1010 !strcmp(argv[iArgPtr], "-h"))
1011 {
1012 ShowHelpCommandLine(argv[0]);
1013 return 0;
1014 }
1015 else if (!strcmp(argv[iArgPtr], "-b") ||
1016 !strcmp(argv[iArgPtr], "--base"))
1017 {
1018 if (argc >= iArgPtr + 2)
1019 {
1020 g_config.baseDevice = (cec_logical_address)atoi(argv[iArgPtr + 1]);
1021 cout << "using base device '" << (int)g_config.baseDevice << "'" << endl;
1022 ++iArgPtr;
1023 }
1024 ++iArgPtr;
1025 }
1026 else if (!strcmp(argv[iArgPtr], "-p") ||
1027 !strcmp(argv[iArgPtr], "--port"))
1028 {
1029 if (argc >= iArgPtr + 2)
1030 {
1031 uint8_t hdmiport = (int8_t)atoi(argv[iArgPtr + 1]);
1032 if (hdmiport < 1)
1033 hdmiport = 1;
1034 if (hdmiport > 15)
1035 hdmiport = 15;
1036 g_config.iHDMIPort = hdmiport;
1037 cout << "using HDMI port '" << (int)g_config.iHDMIPort << "'" << endl;
1038 ++iArgPtr;
1039 }
1040 ++iArgPtr;
1041 }
1042 else if (!strcmp(argv[iArgPtr], "-r") ||
1043 !strcmp(argv[iArgPtr], "--rom"))
1044 {
1045 cout << "using settings from EEPROM" << endl;
1046 g_config.bGetSettingsFromROM = 1;
1047 ++iArgPtr;
1048 }
1049 else if (!strcmp(argv[iArgPtr], "-o") ||
1050 !strcmp(argv[iArgPtr], "--osd-name"))
1051 {
1052 if (argc >= iArgPtr + 2)
1053 {
1054 snprintf(g_config.strDeviceName, 13, "%s", argv[iArgPtr + 1]);
1055 cout << "using osd name " << g_config.strDeviceName << endl;
1056 ++iArgPtr;
1057 }
1058 ++iArgPtr;
1059 }
1060 else
1061 {
1062 g_strPort = argv[iArgPtr++];
1063 }
1064 }
1065 }
1066
1067 return bReturn;
1068}
1069
1070int main (int argc, char *argv[])
1071{
1072 g_config.Clear();
1073 snprintf(g_config.strDeviceName, 13, "CECTester");
1074 g_config.clientVersion = CEC_CLIENT_VERSION_1_6_2;
1075 g_callbacks.CBCecLogMessage = &CecLogMessage;
1076 g_callbacks.CBCecKeyPress = &CecKeyPress;
1077 g_callbacks.CBCecCommand = &CecCommand;
1078 g_callbacks.CBCecAlert = &CecAlert;
1079 g_config.callbacks = &g_callbacks;
1080
1081 if (!ProcessCommandLineArguments(argc, argv))
1082 return 0;
1083
1084 if (g_config.deviceTypes.IsEmpty())
1085 {
1086 if (!g_bSingleCommand)
1087 cout << "No device type given. Using 'recording device'" << endl;
1088 g_config.deviceTypes.add(CEC_DEVICE_TYPE_RECORDING_DEVICE);
1089 }
1090
1091 ICECAdapter *parser = LibCecInitialise(&g_config);
1092 if (!parser)
1093 {
1094#ifdef __WINDOWS__
1095 cout << "Cannot load libcec.dll" << endl;
1096#else
1097 cout << "Cannot load libcec.so" << endl;
1098#endif
1099
1100 if (parser)
1101 UnloadLibCec(parser);
1102
1103 return 1;
1104 }
1105
1106 if (!g_bSingleCommand)
1107 {
1108 CStdString strLog;
1109 strLog.Format("CEC Parser created - libCEC version %s", parser->ToString((cec_server_version)g_config.serverVersion));
1110 cout << strLog.c_str() << endl;
1111
1112 //make stdin non-blocking
1113 #ifndef __WINDOWS__
1114 int flags = fcntl(0, F_GETFL, 0);
1115 flags |= O_NONBLOCK;
1116 fcntl(0, F_SETFL, flags);
1117 #endif
1118 }
1119
1120 if (g_strPort.IsEmpty())
1121 {
1122 if (!g_bSingleCommand)
1123 cout << "no serial port given. trying autodetect: ";
1124 cec_adapter devices[10];
1125 uint8_t iDevicesFound = parser->FindAdapters(devices, 10, NULL);
1126 if (iDevicesFound <= 0)
1127 {
1128 if (g_bSingleCommand)
1129 cout << "autodetect ";
1130 cout << "FAILED" << endl;
1131 UnloadLibCec(parser);
1132 return 1;
1133 }
1134 else
1135 {
1136 if (!g_bSingleCommand)
1137 {
1138 cout << endl << " path: " << devices[0].path << endl <<
1139 " com port: " << devices[0].comm << endl << endl;
1140 }
1141 g_strPort = devices[0].comm;
1142 }
1143 }
1144
1145 PrintToStdOut("opening a connection to the CEC adapter...");
1146
1147 if (!parser->Open(g_strPort.c_str()))
1148 {
1149 PrintToStdOut("unable to open the device on port %s", g_strPort.c_str());
1150 UnloadLibCec(parser);
1151 return 1;
1152 }
1153
1154 if (!g_bSingleCommand)
1155 PrintToStdOut("waiting for input");
1156
1157 while (!g_bExit && !g_bHardExit)
1158 {
1159 string input;
1160 getline(cin, input);
1161 cin.clear();
1162
1163 if (ProcessConsoleCommand(parser, input) && !g_bSingleCommand && !g_bExit && !g_bHardExit)
1164 {
1165 if (!input.empty())
1166 PrintToStdOut("waiting for input");
1167 }
1168 else
1169 g_bExit = true;
1170
1171 if (!g_bExit && !g_bHardExit)
1172 CEvent::Sleep(50);
1173 }
1174
1175 parser->Close();
1176 UnloadLibCec(parser);
1177
1178 if (g_logOutput.is_open())
1179 g_logOutput.close();
1180
1181 return 0;
1182}