cec: also reset the device status itself in CCECBusDevice::ResetDeviceStatus()
[deb_libcec.git] / src / cec-config / cec-config.cpp
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/threads/mutex.h"
42 #include "../lib/platform/util/timeutils.h"
43 #include "../lib/implementations/CECCommandHandler.h"
44
45 using namespace CEC;
46 using namespace std;
47 using namespace PLATFORM;
48
49 #include <cecloader.h>
50
51 CMutex g_outputMutex;
52
53 CEvent g_responseEvent;
54 cec_opcode g_lastCommand = CEC_OPCODE_NONE;
55
56 CEvent g_keyEvent;
57 cec_user_control_code g_lastKey = CEC_USER_CONTROL_CODE_UNKNOWN;
58
59 ICECCallbacks g_callbacks;
60 libcec_configuration g_config;
61 ICECAdapter * g_parser;
62 cec_logical_address g_primaryAddress;
63
64 inline void PrintToStdOut(const char *strFormat, ...)
65 {
66 CStdString strLog;
67
68 va_list argList;
69 va_start(argList, strFormat);
70 strLog.FormatV(strFormat, argList);
71 va_end(argList);
72
73 CLockObject lock(g_outputMutex);
74 cout << strLog << endl;
75 }
76
77 //get the first word (separated by whitespace) from string data and place that in word
78 //then remove that word from string data
79 bool GetWord(string& data, string& word)
80 {
81 stringstream datastream(data);
82 string end;
83
84 datastream >> word;
85 if (datastream.fail())
86 {
87 data.clear();
88 return false;
89 }
90
91 size_t pos = data.find(word) + word.length();
92
93 if (pos >= data.length())
94 {
95 data.clear();
96 return true;
97 }
98
99 data = data.substr(pos);
100
101 datastream.clear();
102 datastream.str(data);
103
104 datastream >> end;
105 if (datastream.fail())
106 data.clear();
107
108 return true;
109 }
110
111 int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message)
112 {
113 switch (message.level)
114 {
115 case CEC_LOG_ERROR:
116 PrintToStdOut("ERROR:\t%s", message.message);
117 break;
118 case CEC_LOG_WARNING:
119 PrintToStdOut("ERROR:\t%s", message.message);
120 break;
121 default:
122 break;
123 }
124
125 return 0;
126 }
127
128 int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &key)
129 {
130 g_lastKey = key.keycode;
131 g_keyEvent.Signal();
132 return 0;
133 }
134
135 int CecCommand(void *UNUSED(cbParam), const cec_command &command)
136 {
137 g_lastCommand = command.opcode;
138 g_responseEvent.Signal();
139 return 0;
140 }
141
142 void EnableCallbacks(ICECAdapter *adapter)
143 {
144 g_callbacks.CBCecLogMessage = &CecLogMessage;
145 g_callbacks.CBCecKeyPress = &CecKeyPress;
146 g_callbacks.CBCecCommand = &CecCommand;
147 adapter->EnableCallbacks(NULL, &g_callbacks);
148 }
149
150 ICECAdapter *CreateParser(cec_device_type_list typeList)
151 {
152 ICECAdapter *parser = LibCecInit("ButtonConfig", typeList);
153 if (!parser)
154 {
155 #ifdef __WINDOWS__
156 PrintToStdOut("Cannot load libcec.dll");
157 #else
158 PrintToStdOut("Cannot load libcec.so");
159 #endif
160 return NULL;
161 }
162
163 PrintToStdOut("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor());
164
165 return parser;
166 }
167
168 bool ProcessConsoleCommand(string &input)
169 {
170 if (!input.empty())
171 {
172 string command;
173 if (GetWord(input, command))
174 {
175 if (command == "q" || command == "quit")
176 return false;
177 }
178 }
179 return true;
180 }
181
182 bool OpenConnection(cec_device_type type = CEC_DEVICE_TYPE_RECORDING_DEVICE)
183 {
184 g_config.Clear();
185 snprintf(g_config.strDeviceName, 13, "CEC-config");
186 g_config.callbackParam = NULL;
187 g_config.clientVersion = (uint32_t)CEC_CLIENT_VERSION_1_5_0;
188 g_callbacks.CBCecLogMessage = &CecLogMessage;
189 g_callbacks.CBCecKeyPress = &CecKeyPress;
190 g_callbacks.CBCecCommand = &CecCommand;
191 g_config.callbacks = &g_callbacks;
192
193 g_config.deviceTypes.add(type);
194
195 g_parser = LibCecInitialise(&g_config);
196 if (!g_parser)
197 return false;
198
199 CStdString strPort;
200 cec_adapter devices[10];
201 uint8_t iDevicesFound = g_parser->FindAdapters(devices, 10, NULL);
202 if (iDevicesFound <= 0)
203 {
204 PrintToStdOut("autodetect FAILED");
205 UnloadLibCec(g_parser);
206 return false;
207 }
208 else
209 {
210 strPort = devices[0].comm;
211 }
212
213 PrintToStdOut("opening a connection to the CEC adapter...");
214 if (!g_parser->Open(strPort.c_str()))
215 {
216 PrintToStdOut("unable to open the device on port %s", strPort.c_str());
217 UnloadLibCec(g_parser);
218 return false;
219 }
220
221 cec_logical_addresses addr = g_parser->GetLogicalAddresses();
222 g_primaryAddress = addr.primary;
223
224 PrintToStdOut("cec device opened. using logical address %X", g_primaryAddress);
225 return true;
226 }
227
228 int8_t FindPhysicalAddressPortNumber(void)
229 {
230 PrintToStdOut("Enter the HDMI port number to which you connected your CEC adapter, followed by <enter>. Valid ports are in the range 1-15. Anything else will cancel this wizard.");
231 string input;
232 getline(cin, input);
233 cin.clear();
234 if (input.empty())
235 return -1;
236
237 int hdmiport = atoi(input.c_str());
238 return (hdmiport < 1 || hdmiport > 15) ? -1 : (int8_t)hdmiport;
239 }
240
241 cec_logical_address FindPhysicalAddressBaseDevice(void)
242 {
243 PrintToStdOut("Press 1 if your CEC adapter is connected to your TV or\npress 2 if it's connected to an AVR, followed by <enter>. Anything else will cancel this wizard.");
244
245 string input;
246 getline(cin, input);
247 cin.clear();
248 if (input.empty() || (input != "1" && input != "2"))
249 {
250 PrintToStdOut("Exiting...");
251 return CECDEVICE_UNKNOWN;
252 }
253 return (input == "2") ?
254 CECDEVICE_AUDIOSYSTEM :
255 CECDEVICE_TV;
256 }
257
258 uint16_t FindPhysicalAddress(void)
259 {
260 PrintToStdOut("=== Physical Address Configuration ===\n");
261 uint16_t iAddress(CEC_INVALID_PHYSICAL_ADDRESS);
262
263 PrintToStdOut("Do you want to let libCEC try to autodetect the address (y/n)?");
264 string input;
265 getline(cin, input);
266 cin.clear();
267 if (input == "y" || input == "Y")
268 {
269 cec_logical_address baseDevice = FindPhysicalAddressBaseDevice();
270 if (baseDevice == CECDEVICE_UNKNOWN)
271 return iAddress;
272
273 int8_t iPortNumber = FindPhysicalAddressPortNumber();
274 if (iPortNumber == -1)
275 return iAddress;
276
277 PrintToStdOut("Trying to detect the physical address...");
278 if (!g_parser->SetHDMIPort(baseDevice, iPortNumber))
279 PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
280 else
281 {
282 iAddress = g_parser->GetDevicePhysicalAddress(g_primaryAddress);
283 if (iAddress == 0 || iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
284 PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
285 }
286 }
287
288 if (iAddress == 0 || iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
289 {
290 PrintToStdOut("Please enter the physical address (0001 - FFFE), followed by <enter>.");
291 getline(cin, input);
292 cin.clear();
293
294 int iAddressTmp;
295 if (sscanf(input.c_str(), "%x", &iAddressTmp) == 1)
296 {
297 if (iAddressTmp <= CEC_PHYSICAL_ADDRESS_TV || iAddressTmp > CEC_MAX_PHYSICAL_ADDRESS)
298 iAddressTmp = CEC_INVALID_PHYSICAL_ADDRESS;
299 iAddress = (uint16_t)iAddressTmp;
300 }
301 }
302
303 if (iAddress != 0)
304 {
305 g_parser->SetPhysicalAddress(iAddress);
306 g_parser->SetActiveSource(g_config.deviceTypes[0]);
307 }
308
309 return iAddress;
310 }
311
312 bool PowerOnTV(uint64_t iTimeout = 60000)
313 {
314 cec_power_status currentTvPower(CEC_POWER_STATUS_UNKNOWN);
315 uint64_t iNow = GetTimeMs();
316 uint64_t iTarget = iNow + iTimeout;
317
318 if (currentTvPower != CEC_POWER_STATUS_ON)
319 {
320 currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);
321 if (currentTvPower != CEC_POWER_STATUS_ON)
322 {
323 PrintToStdOut("Sending 'power on' command to the TV\n=== Please wait ===");
324 g_parser->PowerOnDevices(CECDEVICE_TV);
325 while (iTarget > iNow)
326 {
327 g_responseEvent.Wait((uint32_t)(iTarget - iNow));
328 if (g_lastCommand == CEC_OPCODE_REQUEST_ACTIVE_SOURCE)
329 break;
330 iNow = GetTimeMs();
331 }
332 }
333 }
334
335 currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);
336
337 if (currentTvPower != CEC_POWER_STATUS_ON)
338 PrintToStdOut("Failed to power on the TV, or the TV does not respond properly");
339
340 return currentTvPower == CEC_POWER_STATUS_ON;
341 }
342
343 int main (int UNUSED(argc), char *UNUSED(argv[]))
344 {
345 PrintToStdOut("=== USB-CEC Adapter Configuration ===\n");
346 if (!OpenConnection())
347 return 1;
348
349 if (!PowerOnTV())
350 return 1;
351
352 bool bAddressOk(false);
353 while (!bAddressOk)
354 {
355 uint16_t iAddress = FindPhysicalAddress();
356
357 PrintToStdOut("Physical address: %4X", iAddress);
358 PrintToStdOut("Is this correct (y/n)?");
359 string input;
360 getline(cin, input);
361 cin.clear();
362 bAddressOk = (input == "y" || input == "Y");
363 }
364
365 g_parser->GetCurrentConfiguration(&g_config);
366
367 {
368 cec_menu_language lang;
369 if (g_parser->GetDeviceMenuLanguage(CECDEVICE_TV, &lang))
370 {
371 PrintToStdOut("TV menu language: %s", lang.language);
372 PrintToStdOut("Do you want the application to use the menu language of the TV (y/n)?");
373 string input;
374 getline(cin, input);
375 cin.clear();
376 g_config.bUseTVMenuLanguage = (input == "y" || input == "Y") ? 1 : 0;
377 }
378 else
379 {
380 PrintToStdOut("The TV did not respond properly to the menu language request.");
381 }
382 }
383
384 {
385 PrintToStdOut("Do you want to make the CEC adapter the active source when starting the application (y/n)?");
386 string input;
387 getline(cin, input);
388 cin.clear();
389 g_config.bActivateSource = (input == "y" || input == "Y") ? 1 : 0;
390 }
391
392 {
393 PrintToStdOut("Do you want to power off CEC devices when closing the application (y/n)?");
394 string input;
395 getline(cin, input);
396 cin.clear();
397 if (input == "y" || input == "Y")
398 g_config.powerOffDevices.Set(CECDEVICE_BROADCAST);
399 }
400
401 {
402 PrintToStdOut("Do you want to power off CEC devices when the screensaver is activated (y/n)?");
403 string input;
404 getline(cin, input);
405 cin.clear();
406 g_config.bPowerOffScreensaver = (input == "y" || input == "Y") ? 1 : 0;
407 }
408
409 {
410 PrintToStdOut("Do you want to put the PC in standby when the TV is put in standby mode (y/n)?");
411 string input;
412 getline(cin, input);
413 cin.clear();
414 g_config.bPowerOffOnStandby = (input == "y" || input == "Y") ? 1 : 0;
415 }
416
417 {
418 PrintToStdOut("Do you want to send an inactive source message when stopping the application (y/n)?");
419 string input;
420 getline(cin, input);
421 cin.clear();
422 g_config.bSendInactiveSource = (input == "y" || input == "Y") ? 1 : 0;
423 }
424
425 PrintToStdOut("\n\n=== USB-CEC Adapter Configuration Summary ===");
426 PrintToStdOut("HDMI port number: %d", g_config.iHDMIPort);
427 PrintToStdOut("Connected to HDMI device: %X", (uint8_t)g_config.baseDevice);
428 PrintToStdOut("Physical address: %4X", g_config.iPhysicalAddress);
429 PrintToStdOut("Use the TV's language setting: %s", g_config.bUseTVMenuLanguage ? "yes" : "no");
430 PrintToStdOut("Make the adapter the active source when starting XBMC: %s", g_config.bActivateSource ? "yes" : "no");
431 PrintToStdOut("Power off devices when stopping XBMC: %s", g_config.powerOffDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
432 PrintToStdOut("Put devices in standby mode when activating screensaver: %s", g_config.bPowerOffScreensaver ? "yes" : "no");
433 PrintToStdOut("Put this PC in standby mode when the TV is switched off: %s", g_config.bPowerOffOnStandby ? "yes" : "no");
434 PrintToStdOut("Seend an inactive source message when stopping XBMC: %s\n\n", g_config.bSendInactiveSource ? "yes" : "no");
435
436 if (g_parser->CanPersistConfiguration())
437 {
438 PrintToStdOut("Do you want to store these settings in the adapter (y/n)?");
439 string input;
440 getline(cin, input);
441 cin.clear();
442 if (input == "y" || input == "Y")
443 {
444 PrintToStdOut("Storing settings ...");
445 if (g_parser->PersistConfiguration(&g_config))
446 PrintToStdOut("Settings stored.");
447 else
448 PrintToStdOut("The settings could not be stored");
449 }
450 }
451 else
452 {
453 PrintToStdOut("This adapter doesn't support settings persistence. Please set up these settings in your media player application.");
454
455 ofstream configOutput;
456 configOutput.open("usb_2548_1001.xml");
457 if (configOutput.is_open())
458 {
459 CStdString strWakeDevices;
460 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
461 if (g_config.wakeDevices[iPtr])
462 strWakeDevices.AppendFormat(" %d" + iPtr);
463 CStdString strStandbyDevices;
464 for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
465 if (g_config.powerOffDevices[iPtr])
466 strStandbyDevices.AppendFormat(" %d" + iPtr);
467
468 configOutput <<
469 "<settings>\n" <<
470 "\t<setting id=\"enabled\" value=\"1\" />\n" <<
471 "\t<setting id=\"activate_source\" value=\"" << (int)g_config.bActivateSource << "\" />\n" <<
472 "\t<setting id=\"wake_devices\" value=\"" << strWakeDevices.c_str() << "\" />\n" <<
473 "\t<setting id=\"standby_devices\" value=\"" << strStandbyDevices.c_str() << "\" />\n" <<
474 "\t<setting id=\"cec_standby_screensaver\" value=\"" << (int)g_config.bPowerOffScreensaver << "\" />\n" <<
475 "\t<setting id=\"standby_pc_on_tv_standby\" value=\"" << (int)g_config.bPowerOffOnStandby << "\" />\n" <<
476 "\t<setting id=\"use_tv_menu_language\" value=\"" << (int)g_config.bUseTVMenuLanguage << "\" />\n" <<
477 "\t<setting id=\"physical_address\" value=\"" << hex << g_config.iPhysicalAddress << "\" />\n" <<
478 "\t<setting id=\"cec_hdmi_port\" value=\"" << g_config.iHDMIPort << "\" />\n" <<
479 "\t<setting id=\"connected_device\" value=\"" << (int)g_config.baseDevice << "\" />\n" <<
480 "\t<setting id=\"port\" value=\"\" />\n" <<
481 "\t<setting id=\"send_inactive_source\" value=\"" << (int)g_config.bSendInactiveSource << "\" />\n" <<
482 "</settings>";
483 configOutput.close();
484
485 PrintToStdOut("The configuration has been stored in 'usb_2548_1001.xml'. Copy this file to ~/.userdata/peripheral_data to use it in XBMC");
486 }
487 }
488
489 g_parser->StandbyDevices();
490 g_parser->Close();
491 UnloadLibCec(g_parser);
492
493 PrintToStdOut("Press enter to close this wizard.");
494 string input;
495 getline(cin, input);
496 return 0;
497 }