999270bdd93fb6666570632e7e098d949bf7249f
[deb_libcec.git] / src / lib / devices / CECBusDevice.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 "CECBusDevice.h"
34 #include "../CECProcessor.h"
35 #include "../implementations/ANCommandHandler.h"
36 #include "../implementations/CECCommandHandler.h"
37 #include "../implementations/SLCommandHandler.h"
38 #include "../implementations/VLCommandHandler.h"
39 #include "../platform/timeutils.h"
40
41 using namespace CEC;
42
43 CCECBusDevice::CCECBusDevice(CCECProcessor *processor, cec_logical_address iLogicalAddress, uint16_t iPhysicalAddress) :
44 m_iPhysicalAddress(iPhysicalAddress),
45 m_iLogicalAddress(iLogicalAddress),
46 m_powerStatus(CEC_POWER_STATUS_UNKNOWN),
47 m_processor(processor),
48 m_bMenuActive(true),
49 m_iVendorClass(CEC_VENDOR_UNKNOWN),
50 m_iLastActive(0),
51 m_cecVersion(CEC_VERSION_1_3A)
52 {
53 m_handler = new CCECCommandHandler(this);
54
55 for (unsigned int iPtr = 0; iPtr < 4; iPtr++)
56 m_menuLanguage.language[iPtr] = '?';
57 m_menuLanguage.language[3] = 0;
58 m_menuLanguage.device = iLogicalAddress;
59
60 m_vendor.vendor = CEC_VENDOR_UNKNOWN;
61 m_type = CEC_DEVICE_TYPE_RESERVED;
62 m_strDeviceName = "Unknown";
63 }
64
65 CCECBusDevice::~CCECBusDevice(void)
66 {
67 m_condition.Broadcast();
68 delete m_handler;
69 }
70
71 void CCECBusDevice::AddLog(cec_log_level level, const CStdString &strMessage)
72 {
73 m_processor->AddLog(level, strMessage);
74 }
75
76 bool CCECBusDevice::HandleCommand(const cec_command &command)
77 {
78 CLockObject lock(&m_mutex);
79 m_iLastActive = GetTimeMs();
80 m_handler->HandleCommand(command);
81 m_condition.Signal();
82 return true;
83 }
84
85 void CCECBusDevice::PollVendorId(void)
86 {
87 CLockObject lock(&m_mutex);
88 if (m_iLastActive > 0 && m_iLogicalAddress != CECDEVICE_BROADCAST &&
89 m_vendor.vendor == CEC_VENDOR_UNKNOWN &&
90 GetTimeMs() - m_iLastActive > 5000)
91 {
92 m_iLastActive = GetTimeMs();
93
94 cec_command command;
95 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
96 if (m_processor->Transmit(command))
97 m_condition.Wait(&m_mutex, 1000);
98 }
99 }
100
101 bool CCECBusDevice::PowerOn(void)
102 {
103 CStdString strLog;
104 strLog.Format("<< powering on device with logical address %d", (int8_t)m_iLogicalAddress);
105 AddLog(CEC_LOG_DEBUG, strLog.c_str());
106
107 cec_command command;
108 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_IMAGE_VIEW_ON);
109
110 return m_processor->Transmit(command);
111 }
112
113 bool CCECBusDevice::Standby(void)
114 {
115 CStdString strLog;
116 strLog.Format("<< putting device with logical address %d in standby mode", (int8_t)m_iLogicalAddress);
117 AddLog(CEC_LOG_DEBUG, strLog.c_str());
118
119 cec_command command;
120 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_STANDBY);
121
122 return m_processor->Transmit(command);
123 }
124
125 /** @name Getters */
126 //@{
127 cec_version CCECBusDevice::GetCecVersion(void)
128 {
129 if (m_cecVersion == CEC_VERSION_UNKNOWN)
130 {
131 if (!MyLogicalAddressContains(m_iLogicalAddress))
132 {
133 AddLog(CEC_LOG_NOTICE, "<< requesting CEC version");
134 cec_command command;
135 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GET_CEC_VERSION);
136 CLockObject lock(&m_mutex);
137 if (m_processor->Transmit(command))
138 m_condition.Wait(&m_mutex, 1000);
139 }
140 }
141
142 return m_cecVersion;
143 }
144
145 cec_menu_language &CCECBusDevice::GetMenuLanguage(void)
146 {
147 if (!strcmp(m_menuLanguage.language, "???"))
148 {
149 if (!MyLogicalAddressContains(m_iLogicalAddress))
150 {
151 AddLog(CEC_LOG_NOTICE, "<< requesting menu language");
152 cec_command command;
153 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GET_MENU_LANGUAGE);
154 CLockObject lock(&m_mutex);
155 if (m_processor->Transmit(command))
156 m_condition.Wait(&m_mutex, 1000);
157 }
158 }
159
160 return m_menuLanguage;
161 }
162
163 cec_logical_address CCECBusDevice::GetMyLogicalAddress(void) const
164 {
165 return m_processor->GetLogicalAddress();
166 }
167
168 uint16_t CCECBusDevice::GetMyPhysicalAddress(void) const
169 {
170 return m_processor->GetPhysicalAddress();
171 }
172
173 cec_power_status CCECBusDevice::GetPowerStatus(void)
174 {
175 if (m_powerStatus == CEC_POWER_STATUS_UNKNOWN)
176 {
177 if (!MyLogicalAddressContains(m_iLogicalAddress))
178 {
179 AddLog(CEC_LOG_NOTICE, "<< requesting power status");
180 cec_command command;
181 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_POWER_STATUS);
182 CLockObject lock(&m_mutex);
183 if (m_processor->Transmit(command))
184 m_condition.Wait(&m_mutex, 1000);
185 }
186 }
187
188 return m_powerStatus;
189 }
190
191 const cec_vendor &CCECBusDevice::GetVendor(void)
192 {
193 if (m_vendor.vendor == CEC_VENDOR_UNKNOWN)
194 {
195 if (!MyLogicalAddressContains(m_iLogicalAddress))
196 {
197 AddLog(CEC_LOG_NOTICE, "<< requesting vendor ID");
198 cec_command command;
199 cec_command::format(command, GetMyLogicalAddress(), m_iLogicalAddress, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
200 CLockObject lock(&m_mutex);
201
202 if (m_processor->Transmit(command))
203 m_condition.Wait(&m_mutex, 1000);
204 }
205 }
206
207 return m_vendor;
208 }
209
210 bool CCECBusDevice::MyLogicalAddressContains(cec_logical_address address) const
211 {
212 return m_processor->HasLogicalAddress(address);
213 }
214
215 //@}
216
217 /** @name Setters */
218 //@{
219 void CCECBusDevice::SetCecVersion(const cec_version newVersion)
220 {
221 CStdString strLog;
222 m_cecVersion = newVersion;
223
224 switch (newVersion)
225 {
226 case CEC_VERSION_1_2:
227 strLog.Format("device %d reports CEC version 1.2", m_iLogicalAddress);
228 break;
229 case CEC_VERSION_1_2A:
230 strLog.Format("device %d reports CEC version 1.2a", m_iLogicalAddress);
231 break;
232 case CEC_VERSION_1_3:
233 strLog.Format("device %d reports CEC version 1.3", m_iLogicalAddress);
234 break;
235 case CEC_VERSION_1_3A:
236 strLog.Format("device %d reports CEC version 1.3a", m_iLogicalAddress);
237 break;
238 default:
239 strLog.Format("device %d reports an unknown CEC version", m_iLogicalAddress);
240 m_cecVersion = CEC_VERSION_UNKNOWN;
241 break;
242 }
243 AddLog(CEC_LOG_DEBUG, strLog);
244 }
245
246 void CCECBusDevice::SetMenuLanguage(const cec_menu_language &language)
247 {
248 if (language.device == m_iLogicalAddress)
249 {
250 CStdString strLog;
251 strLog.Format("device %d menu language set to '%s'", m_iLogicalAddress, language.language);
252 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
253 m_menuLanguage = language;
254 }
255 }
256
257 void CCECBusDevice::SetPhysicalAddress(uint16_t iNewAddress, uint16_t iOldAddress /* = 0 */)
258 {
259 if (iNewAddress > 0)
260 {
261 CStdString strLog;
262 strLog.Format(">> %i changed physical address from %04x to %04x", m_iLogicalAddress, m_iPhysicalAddress, iNewAddress);
263 AddLog(CEC_LOG_DEBUG, strLog.c_str());
264
265 m_iPhysicalAddress = iNewAddress;
266 }
267 }
268
269 void CCECBusDevice::SetPowerStatus(const cec_power_status powerStatus)
270 {
271 if (m_powerStatus != powerStatus)
272 {
273 CStdString strLog;
274 strLog.Format("device %d power status changed from %2x to %2x", m_iLogicalAddress, m_powerStatus, powerStatus);
275 m_processor->AddLog(CEC_LOG_DEBUG, strLog);
276 m_powerStatus = powerStatus;
277 }
278 }
279
280 void CCECBusDevice::SetVendorId(const cec_datapacket &data)
281 {
282 if (data.size < 3)
283 {
284 AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
285 return;
286 }
287
288 uint64_t iVendorId = ((uint64_t)data[0] << 3) +
289 ((uint64_t)data[1] << 2) +
290 (uint64_t)data[2];
291
292 SetVendorId(iVendorId, data.size >= 4 ? data[3] : 0);
293 }
294
295 void CCECBusDevice::SetVendorId(uint64_t iVendorId, uint8_t iVendorClass /* = 0 */)
296 {
297 m_vendor.vendor = (cec_vendor_id)iVendorId;
298 m_iVendorClass = iVendorClass;
299
300 switch (iVendorId)
301 {
302 case CEC_VENDOR_SAMSUNG:
303 if (m_handler->GetVendorId() != CEC_VENDOR_SAMSUNG)
304 {
305 delete m_handler;
306 m_handler = new CANCommandHandler(this);
307 }
308 break;
309 case CEC_VENDOR_LG:
310 if (m_handler->GetVendorId() != CEC_VENDOR_LG)
311 {
312 delete m_handler;
313 m_handler = new CSLCommandHandler(this);
314 }
315 break;
316 case CEC_VENDOR_PANASONIC:
317 if (m_handler->GetVendorId() != CEC_VENDOR_PANASONIC)
318 {
319 delete m_handler;
320 m_handler = new CVLCommandHandler(this);
321 }
322 break;
323 default:
324 if (m_handler->GetVendorId() != CEC_VENDOR_UNKNOWN)
325 {
326 delete m_handler;
327 m_handler = new CCECCommandHandler(this);
328 }
329 break;
330 }
331
332 CStdString strLog;
333 strLog.Format("device %d: vendor = %s (%06x) class = %2x", m_iLogicalAddress, GetVendorName(), GetVendorId(), GetVendorClass());
334 m_processor->AddLog(CEC_LOG_DEBUG, strLog.c_str());
335 }
336 //@}
337
338 /** @name Transmit methods */
339 //@{
340 bool CCECBusDevice::TransmitActiveSource(void)
341 {
342 CStdString strLog;
343 strLog.Format("<< %x -> broadcast: active source (%4x)", m_iLogicalAddress, m_iPhysicalAddress);
344 AddLog(CEC_LOG_NOTICE, strLog);
345
346 cec_command command;
347 cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
348 command.parameters.push_back((uint8_t) ((m_iPhysicalAddress >> 8) & 0xFF));
349 command.parameters.push_back((uint8_t) (m_iPhysicalAddress & 0xFF));
350
351 return m_processor->Transmit(command);
352 }
353
354 bool CCECBusDevice::TransmitActiveView(void)
355 {
356 CStdString strLog;
357 strLog.Format("<< %x -> broadcast: active view (%4x)", m_iLogicalAddress, m_iPhysicalAddress);
358 AddLog(CEC_LOG_NOTICE, strLog);
359
360 cec_command command;
361 cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_ACTIVE_SOURCE);
362 command.parameters.push_back((m_iPhysicalAddress >> 8) & 0xFF);
363 command.parameters.push_back(m_iPhysicalAddress & 0xFF);
364
365 return m_processor->Transmit(command);
366 }
367
368 bool CCECBusDevice::TransmitCECVersion(cec_logical_address dest)
369 {
370 CStdString strLog;
371 strLog.Format("<< %x -> %x: cec version ", m_iLogicalAddress, dest);
372 switch (m_cecVersion)
373 {
374 case CEC_VERSION_1_2:
375 strLog.append("1.2");
376 break;
377 case CEC_VERSION_1_2A:
378 strLog.append("1.2a");
379 break;
380 case CEC_VERSION_1_3:
381 strLog.append("1.3");
382 break;
383 case CEC_VERSION_1_3A:
384 strLog.append("1.3a");
385 break;
386 default:
387 strLog.append("unknown");
388 break;
389 }
390 AddLog(CEC_LOG_NOTICE, strLog);
391
392 cec_command command;
393 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_CEC_VERSION);
394 command.parameters.push_back(m_cecVersion);
395
396 return m_processor->Transmit(command);
397 }
398
399 bool CCECBusDevice::TransmitDeckStatus(cec_logical_address dest)
400 {
401 // need to support opcodes play and deck control before doing anything with this
402 CStdString strLog;
403 strLog.Format("<< %x -> %x: deck status feature abort", m_iLogicalAddress, dest);
404 AddLog(CEC_LOG_NOTICE, strLog);
405
406 m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DECK_STATUS);
407 return false;
408 }
409
410 bool CCECBusDevice::TransmitInactiveView(void)
411 {
412 CStdString strLog;
413 strLog.Format("<< %x -> broadcast: inactive view", m_iLogicalAddress);
414 AddLog(CEC_LOG_NOTICE, strLog);
415
416 cec_command command;
417 cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_INACTIVE_SOURCE);
418 command.parameters.push_back((m_iPhysicalAddress >> 8) & 0xFF);
419 command.parameters.push_back(m_iPhysicalAddress & 0xFF);
420
421 return m_processor->Transmit(command);
422 }
423
424 bool CCECBusDevice::TransmitMenuState(cec_logical_address dest)
425 {
426 CStdString strLog;
427 strLog.Format("<< %x -> %x: ", m_iLogicalAddress, dest);
428 if (m_bMenuActive)
429 strLog.append("menu active");
430 else
431 strLog.append("menu inactive");
432 AddLog(CEC_LOG_NOTICE, strLog);
433
434 cec_command command;
435 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_MENU_STATUS);
436 command.parameters.push_back(m_bMenuActive ? (uint8_t) CEC_MENU_STATE_ACTIVATED : (uint8_t) CEC_MENU_STATE_DEACTIVATED);
437
438 return m_processor->Transmit(command);
439 }
440
441 bool CCECBusDevice::TransmitOSDName(cec_logical_address dest)
442 {
443 CStdString strLog;
444 strLog.Format("<< %x -> %x: OSD name '%s'", m_iLogicalAddress, dest, m_strDeviceName.c_str());
445 AddLog(CEC_LOG_NOTICE, strLog.c_str());
446
447 cec_command command;
448 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_SET_OSD_NAME);
449 for (unsigned int iPtr = 0; iPtr < m_strDeviceName.length(); iPtr++)
450 command.parameters.push_back(m_strDeviceName.at(iPtr));
451
452 return m_processor->Transmit(command);
453 }
454
455 bool CCECBusDevice::TransmitOSDString(cec_logical_address dest, cec_display_control duration, const char *strMessage)
456 {
457 CStdString strLog;
458 strLog.Format("<< %x -> %x: display OSD message '%s'", m_iLogicalAddress, dest, strMessage);
459 AddLog(CEC_LOG_NOTICE, strLog.c_str());
460
461 cec_command command;
462 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_SET_OSD_STRING);
463 command.parameters.push_back((uint8_t)duration);
464
465 unsigned int iLen = strlen(strMessage);
466 if (iLen > 13) iLen = 13;
467
468 for (unsigned int iPtr = 0; iPtr < iLen; iPtr++)
469 command.parameters.push_back(strMessage[iPtr]);
470
471 return m_processor->Transmit(command);
472 }
473
474 bool CCECBusDevice::TransmitPhysicalAddress(void)
475 {
476 CStdString strLog;
477 strLog.Format("<< %x -> broadcast: physical adddress %4x", m_iLogicalAddress, m_iPhysicalAddress);
478 AddLog(CEC_LOG_NOTICE, strLog.c_str());
479
480 cec_command command;
481 cec_command::format(command, m_iLogicalAddress, CECDEVICE_BROADCAST, CEC_OPCODE_REPORT_PHYSICAL_ADDRESS);
482 command.parameters.push_back((uint8_t) ((m_iPhysicalAddress >> 8) & 0xFF));
483 command.parameters.push_back((uint8_t) (m_iPhysicalAddress & 0xFF));
484 command.parameters.push_back((uint8_t) (CEC_DEVICE_TYPE_PLAYBACK_DEVICE));
485
486 return m_processor->Transmit(command);
487 }
488
489 bool CCECBusDevice::TransmitPoll(cec_logical_address dest)
490 {
491 bool bReturn(false);
492
493 if (dest == CECDEVICE_UNKNOWN)
494 dest = m_iLogicalAddress;
495
496 CStdString strLog;
497 strLog.Format("<< %x -> %x: POLL", m_iLogicalAddress, dest);
498 AddLog(CEC_LOG_NOTICE, strLog.c_str());
499
500 cec_command command;
501 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_NONE);
502 CLockObject lock(&m_mutex);
503
504 bReturn = m_processor->Transmit(command);
505 AddLog(CEC_LOG_DEBUG, bReturn ? ">> POLL sent" : ">> POLL not sent");
506 return bReturn;
507 }
508
509 bool CCECBusDevice::TransmitPowerState(cec_logical_address dest)
510 {
511 CStdString strLog;
512 strLog.Format("<< %x -> %x: ", m_iLogicalAddress, dest);
513
514 switch (m_powerStatus)
515 {
516 case CEC_POWER_STATUS_ON:
517 strLog.append("powered on");
518 break;
519 case CEC_POWER_STATUS_STANDBY:
520 strLog.append("in standby mode");
521 break;
522 case CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY:
523 strLog.append("in transition from on to standby");
524 break;
525 case CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON:
526 strLog.append("in transition from standby to on");
527 break;
528 default:
529 strLog.append("power state unknown");
530 break;
531 }
532 AddLog(CEC_LOG_NOTICE, strLog.c_str());
533
534 strLog.Format("<< reporting power status '%d'", m_powerStatus);
535 AddLog(CEC_LOG_NOTICE, strLog);
536
537 cec_command command;
538 cec_command::format(command, m_iLogicalAddress, dest, CEC_OPCODE_REPORT_POWER_STATUS);
539 command.parameters.push_back((uint8_t) m_powerStatus);
540
541 return m_processor->Transmit(command);
542 }
543
544 bool CCECBusDevice::TransmitVendorID(cec_logical_address dest)
545 {
546 CStdString strLog;
547 strLog.Format("<< %x -> %x: vendor id feature abort", m_iLogicalAddress, dest);
548 AddLog(CEC_LOG_NOTICE, strLog);
549
550 m_processor->TransmitAbort(dest, CEC_OPCODE_GIVE_DEVICE_VENDOR_ID);
551 return false;
552 }
553 //@}