Commit | Line | Data |
---|---|---|
f57cba64 LOK |
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 | CMutex g_responseMutex; | |
54 | CCondition g_responseCondtion; | |
55 | cec_opcode g_lastCommand = CEC_OPCODE_NONE; | |
56 | ||
57 | CMutex g_keyMutex; | |
58 | CCondition g_keyCondtion; | |
59 | cec_user_control_code g_lastKey = CEC_USER_CONTROL_CODE_UNKNOWN; | |
60 | ||
61 | ICECCallbacks g_callbacks; | |
c7dc6e28 | 62 | libcec_configuration g_config; |
f57cba64 LOK |
63 | ICECAdapter * g_parser; |
64 | cec_logical_address g_primaryAddress; | |
65 | ||
66 | inline void PrintToStdOut(const char *strFormat, ...) | |
67 | { | |
68 | CStdString strLog; | |
69 | ||
70 | va_list argList; | |
71 | va_start(argList, strFormat); | |
72 | strLog.FormatV(strFormat, argList); | |
73 | va_end(argList); | |
74 | ||
75 | CLockObject lock(g_outputMutex); | |
76 | cout << strLog << endl; | |
77 | } | |
78 | ||
79 | //get the first word (separated by whitespace) from string data and place that in word | |
80 | //then remove that word from string data | |
81 | bool GetWord(string& data, string& word) | |
82 | { | |
83 | stringstream datastream(data); | |
84 | string end; | |
85 | ||
86 | datastream >> word; | |
87 | if (datastream.fail()) | |
88 | { | |
89 | data.clear(); | |
90 | return false; | |
91 | } | |
92 | ||
93 | size_t pos = data.find(word) + word.length(); | |
94 | ||
95 | if (pos >= data.length()) | |
96 | { | |
97 | data.clear(); | |
98 | return true; | |
99 | } | |
100 | ||
101 | data = data.substr(pos); | |
102 | ||
103 | datastream.clear(); | |
104 | datastream.str(data); | |
105 | ||
106 | datastream >> end; | |
107 | if (datastream.fail()) | |
108 | data.clear(); | |
109 | ||
110 | return true; | |
111 | } | |
112 | ||
113 | int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message) | |
114 | { | |
115 | switch (message.level) | |
116 | { | |
117 | case CEC_LOG_ERROR: | |
118 | PrintToStdOut("ERROR:\t%s", message.message); | |
119 | break; | |
120 | case CEC_LOG_WARNING: | |
121 | PrintToStdOut("ERROR:\t%s", message.message); | |
122 | break; | |
123 | default: | |
124 | break; | |
125 | } | |
126 | ||
127 | return 0; | |
128 | } | |
129 | ||
130 | int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &key) | |
131 | { | |
132 | CLockObject lock(g_keyMutex); | |
133 | g_lastKey = key.keycode; | |
134 | g_keyCondtion.Signal(); | |
135 | return 0; | |
136 | } | |
137 | ||
138 | int CecCommand(void *UNUSED(cbParam), const cec_command &command) | |
139 | { | |
140 | CLockObject lock(g_responseMutex); | |
141 | g_lastCommand = command.opcode; | |
142 | g_responseCondtion.Signal(); | |
143 | return 0; | |
144 | } | |
145 | ||
146 | void EnableCallbacks(ICECAdapter *adapter) | |
147 | { | |
148 | g_callbacks.CBCecLogMessage = &CecLogMessage; | |
149 | g_callbacks.CBCecKeyPress = &CecKeyPress; | |
150 | g_callbacks.CBCecCommand = &CecCommand; | |
151 | adapter->EnableCallbacks(NULL, &g_callbacks); | |
152 | } | |
153 | ||
154 | ICECAdapter *CreateParser(cec_device_type_list typeList) | |
155 | { | |
156 | ICECAdapter *parser = LibCecInit("ButtonConfig", typeList); | |
157 | if (!parser) | |
158 | { | |
159 | #ifdef __WINDOWS__ | |
160 | PrintToStdOut("Cannot load libcec.dll"); | |
161 | #else | |
162 | PrintToStdOut("Cannot load libcec.so"); | |
163 | #endif | |
164 | return NULL; | |
165 | } | |
166 | ||
167 | PrintToStdOut("CEC Parser created - libcec version %d.%d", parser->GetLibVersionMajor(), parser->GetLibVersionMinor()); | |
168 | ||
169 | return parser; | |
170 | } | |
171 | ||
172 | bool ProcessConsoleCommand(string &input) | |
173 | { | |
174 | if (!input.empty()) | |
175 | { | |
176 | string command; | |
177 | if (GetWord(input, command)) | |
178 | { | |
179 | if (command == "q" || command == "quit") | |
180 | return false; | |
181 | } | |
182 | } | |
183 | return true; | |
184 | } | |
185 | ||
186 | bool OpenConnection(cec_device_type type = CEC_DEVICE_TYPE_RECORDING_DEVICE) | |
187 | { | |
c7dc6e28 LOK |
188 | g_config.Clear(); |
189 | snprintf(g_config.strDeviceName, 13, "CEC-config"); | |
190 | g_config.callbackParam = NULL; | |
191 | g_config.clientVersion = CEC_CLIENT_VERSION_1_5_0; | |
192 | g_callbacks.CBCecLogMessage = &CecLogMessage; | |
193 | g_callbacks.CBCecKeyPress = &CecKeyPress; | |
194 | g_callbacks.CBCecCommand = &CecCommand; | |
195 | g_config.callbacks = &g_callbacks; | |
f57cba64 | 196 | |
c7dc6e28 LOK |
197 | g_config.deviceTypes.add(type); |
198 | ||
199 | g_parser = LibCecInitialise(&g_config); | |
f57cba64 LOK |
200 | if (!g_parser) |
201 | return false; | |
202 | ||
203 | CStdString strPort; | |
204 | cec_adapter devices[10]; | |
205 | uint8_t iDevicesFound = g_parser->FindAdapters(devices, 10, NULL); | |
206 | if (iDevicesFound <= 0) | |
207 | { | |
208 | PrintToStdOut("autodetect FAILED"); | |
209 | UnloadLibCec(g_parser); | |
210 | return false; | |
211 | } | |
212 | else | |
213 | { | |
214 | strPort = devices[0].comm; | |
215 | } | |
216 | ||
f57cba64 | 217 | PrintToStdOut("opening a connection to the CEC adapter..."); |
f57cba64 LOK |
218 | if (!g_parser->Open(strPort.c_str())) |
219 | { | |
220 | PrintToStdOut("unable to open the device on port %s", strPort.c_str()); | |
221 | UnloadLibCec(g_parser); | |
222 | return false; | |
223 | } | |
224 | ||
225 | cec_logical_addresses addr = g_parser->GetLogicalAddresses(); | |
226 | g_primaryAddress = addr.primary; | |
227 | ||
228 | PrintToStdOut("cec device opened. using logical address %X", g_primaryAddress); | |
229 | return true; | |
230 | } | |
231 | ||
232 | int8_t FindPhysicalAddressPortNumber(void) | |
233 | { | |
234 | PrintToStdOut("Enter the HDMI port number to which you connected your CEC adapter, followed by <enter>. Only port 1, 2, 3 or 4 are supported. Anything else will cancel this wizard."); | |
235 | string input; | |
236 | getline(cin, input); | |
237 | cin.clear(); | |
238 | if (input.empty() || (input != "1" && input != "2" && input != "3" && input != "4")) | |
239 | return -1; | |
240 | return (int8_t)atoi(input.c_str()); | |
241 | } | |
242 | ||
243 | cec_logical_address FindPhysicalAddressBaseDevice(void) | |
244 | { | |
245 | PrintToStdOut("Press 1 of 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."); | |
246 | ||
247 | string input; | |
248 | getline(cin, input); | |
249 | cin.clear(); | |
250 | if (input.empty() || (input != "1" && input != "2")) | |
251 | { | |
252 | PrintToStdOut("Exiting..."); | |
253 | return CECDEVICE_UNKNOWN; | |
254 | } | |
255 | return (input == "2") ? | |
256 | CECDEVICE_AUDIOSYSTEM : | |
257 | CECDEVICE_TV; | |
258 | } | |
259 | ||
260 | uint16_t FindPhysicalAddress(void) | |
261 | { | |
262 | PrintToStdOut("=== Physical Address Configuration ===\n"); | |
263 | uint16_t iAddress(0xFFFF); | |
264 | ||
265 | PrintToStdOut("Do you want to let libCEC try to autodetect the address (y/n)?"); | |
266 | string input; | |
267 | getline(cin, input); | |
268 | cin.clear(); | |
269 | if (input == "y" || input == "Y") | |
270 | { | |
271 | cec_logical_address baseDevice = FindPhysicalAddressBaseDevice(); | |
272 | if (baseDevice == CECDEVICE_UNKNOWN) | |
273 | return iAddress; | |
274 | ||
275 | int8_t iPortNumber = FindPhysicalAddressPortNumber(); | |
276 | if (iPortNumber == -1) | |
277 | return iAddress; | |
278 | ||
279 | PrintToStdOut("Trying to detect the physical address..."); | |
280 | if (!g_parser->SetHDMIPort(baseDevice, iPortNumber)) | |
281 | PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings."); | |
282 | else | |
283 | { | |
284 | iAddress = g_parser->GetDevicePhysicalAddress(g_primaryAddress); | |
285 | if (iAddress == 0 || iAddress == 0xFFFF) | |
286 | PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings."); | |
287 | } | |
288 | } | |
289 | ||
290 | if (iAddress == 0 || iAddress == 0xFFFF) | |
291 | { | |
292 | PrintToStdOut("Please enter the physical address (0000 - FFFF), followed by <enter>."); | |
293 | getline(cin, input); | |
294 | cin.clear(); | |
295 | ||
296 | int iAddressTmp; | |
297 | if (sscanf(input.c_str(), "%x", &iAddressTmp) == 1) | |
298 | { | |
299 | if (iAddressTmp < 0 || iAddressTmp > 0xFFFF) | |
300 | iAddressTmp = 0xFFFF; | |
301 | iAddress = (uint16_t)iAddressTmp; | |
302 | } | |
303 | } | |
304 | ||
305 | return iAddress; | |
306 | } | |
307 | ||
308 | bool PowerOnTV(uint64_t iTimeout = 60000, unsigned iTries = 2) | |
309 | { | |
310 | cec_power_status currentTvPower(CEC_POWER_STATUS_UNKNOWN); | |
311 | uint64_t iNow = GetTimeMs(); | |
312 | uint64_t iTarget = iNow + iTimeout; | |
313 | unsigned iTry(0); | |
314 | ||
315 | while (currentTvPower != CEC_POWER_STATUS_ON && iTarget > iNow && iTry < iTries) | |
316 | { | |
317 | currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV); | |
318 | if (currentTvPower != CEC_POWER_STATUS_ON) | |
319 | { | |
320 | PrintToStdOut("Sending 'power on' command to the TV"); | |
321 | g_parser->PowerOnDevices(CECDEVICE_TV); | |
322 | while (iTarget > iNow) | |
323 | { | |
324 | CLockObject lock(g_responseMutex); | |
325 | g_responseCondtion.Wait(g_responseMutex, (uint32_t)((iTarget - iNow)/iTries)); | |
326 | if (g_lastCommand == CEC_OPCODE_REQUEST_ACTIVE_SOURCE) | |
327 | break; | |
328 | iNow = GetTimeMs(); | |
329 | } | |
330 | } | |
331 | } | |
332 | ||
333 | currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV); | |
334 | ||
335 | if (currentTvPower != CEC_POWER_STATUS_ON) | |
336 | PrintToStdOut("Failed to power on the TV, or the TV does not respond properly"); | |
337 | ||
338 | return currentTvPower == CEC_POWER_STATUS_ON; | |
339 | } | |
340 | ||
341 | int main (int argc, char *argv[]) | |
342 | { | |
343 | PrintToStdOut("=== USB-CEC Adapter Configuration ===\n"); | |
344 | if (!OpenConnection()) | |
345 | return 1; | |
346 | ||
347 | if (!PowerOnTV()) | |
348 | return 1; | |
349 | ||
350 | bool bAddressOk(false); | |
61064737 | 351 | uint16_t iAddress(0xFFFF); |
f57cba64 LOK |
352 | while (!bAddressOk) |
353 | { | |
354 | iAddress = FindPhysicalAddress(); | |
355 | ||
356 | PrintToStdOut("Physical address: %4X", iAddress); | |
357 | PrintToStdOut("Is this correct (y/n)?"); | |
358 | string input; | |
359 | getline(cin, input); | |
360 | cin.clear(); | |
361 | bAddressOk = (input == "y" || input == "Y"); | |
362 | } | |
363 | ||
364 | PrintToStdOut("=== USB-CEC Adapter Configuration Summary ===\n"); | |
caca2d81 LOK |
365 | bool bHasAudiosystem = g_parser->IsActiveDevice(CECDEVICE_AUDIOSYSTEM); |
366 | ||
f57cba64 LOK |
367 | PrintToStdOut("Physical address: %4X", iAddress); |
368 | ||
369 | g_parser->StandbyDevices(); | |
370 | g_parser->Close(); | |
371 | UnloadLibCec(g_parser); | |
372 | ||
373 | PrintToStdOut("Press enter to close this wizard."); | |
374 | string input; | |
375 | getline(cin, input); | |
376 | return 0; | |
377 | } |