409b30b1cdde68d6f4ff79304a9fecc32a7d1316
[deb_libcec.git] / CECProcessor.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 "env.h"
34 #include "CECProcessor.h"
35
36 #include "adapter/AdapterFactory.h"
37 #include "devices/CECBusDevice.h"
38 #include "devices/CECAudioSystem.h"
39 #include "devices/CECPlaybackDevice.h"
40 #include "devices/CECRecordingDevice.h"
41 #include "devices/CECTuner.h"
42 #include "devices/CECTV.h"
43 #include "implementations/CECCommandHandler.h"
44 #include "LibCEC.h"
45 #include "CECClient.h"
46 #include "CECTypeUtils.h"
47 #include "platform/util/timeutils.h"
48 #include "platform/util/util.h"
49
50 using namespace CEC;
51 using namespace std;
52 using namespace PLATFORM;
53
54 #define CEC_PROCESSOR_SIGNAL_WAIT_TIME 1000
55 #define ACTIVE_SOURCE_CHECK_INTERVAL 500
56
57 #define ToString(x) CCECTypeUtils::ToString(x)
58
59 CCECProcessor::CCECProcessor(CLibCEC *libcec) :
60 m_bInitialised(false),
61 m_communication(NULL),
62 m_libcec(libcec),
63 m_iStandardLineTimeout(3),
64 m_iRetryLineTimeout(3),
65 m_iLastTransmission(0),
66 m_bMonitor(true),
67 m_addrAllocator(NULL),
68 m_bStallCommunication(false)
69 {
70 m_busDevices = new CCECDeviceMap(this);
71 }
72
73 CCECProcessor::~CCECProcessor(void)
74 {
75 m_bStallCommunication = false;
76 DELETE_AND_NULL(m_addrAllocator);
77 Close();
78 DELETE_AND_NULL(m_busDevices);
79 }
80
81 bool CCECProcessor::Start(const char *strPort, uint16_t iBaudRate /* = CEC_SERIAL_DEFAULT_BAUDRATE */, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
82 {
83 CLockObject lock(m_mutex);
84 // open a connection
85 if (!OpenConnection(strPort, iBaudRate, iTimeoutMs))
86 return false;
87
88 // create the processor thread
89 if (!IsRunning())
90 {
91 if (!CreateThread())
92 {
93 m_libcec->AddLog(CEC_LOG_ERROR, "could not create a processor thread");
94 return false;
95 }
96 }
97
98 return true;
99 }
100
101 void CCECProcessor::Close(void)
102 {
103 // mark as uninitialised
104 SetCECInitialised(false);
105
106 // stop the processor
107 StopThread();
108
109 // close the connection
110 DELETE_AND_NULL(m_communication);
111 }
112
113 void CCECProcessor::ResetMembers(void)
114 {
115 // close the connection
116 DELETE_AND_NULL(m_communication);
117
118 // reset the other members to the initial state
119 m_iStandardLineTimeout = 3;
120 m_iRetryLineTimeout = 3;
121 m_iLastTransmission = 0;
122 m_busDevices->ResetDeviceStatus();
123 }
124
125 bool CCECProcessor::OpenConnection(const char *strPort, uint16_t iBaudRate, uint32_t iTimeoutMs, bool bStartListening /* = true */)
126 {
127 bool bReturn(false);
128 CTimeout timeout(iTimeoutMs > 0 ? iTimeoutMs : CEC_DEFAULT_TRANSMIT_WAIT);
129
130 // ensure that a previous connection is closed
131 Close();
132
133 // reset all member to the initial state
134 ResetMembers();
135
136 // check whether the Close() method deleted any previous connection
137 if (m_communication)
138 {
139 m_libcec->AddLog(CEC_LOG_ERROR, "previous connection could not be closed");
140 return bReturn;
141 }
142
143 // create a new connection
144 m_communication = CAdapterFactory(this->m_libcec).GetInstance(strPort, iBaudRate);
145
146 // open a new connection
147 unsigned iConnectTry(0);
148 while (timeout.TimeLeft() > 0 && (bReturn = m_communication->Open((timeout.TimeLeft() / CEC_CONNECT_TRIES), false, bStartListening)) == false)
149 {
150 m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
151 m_communication->Close();
152 CEvent::Sleep(CEC_DEFAULT_CONNECT_RETRY_WAIT);
153 }
154
155 m_libcec->AddLog(CEC_LOG_NOTICE, "connection opened");
156
157 // mark as initialised
158 SetCECInitialised(true);
159
160 return bReturn;
161 }
162
163 bool CCECProcessor::CECInitialised(void)
164 {
165 CLockObject lock(m_threadMutex);
166 return m_bInitialised;
167 }
168
169 void CCECProcessor::SetCECInitialised(bool bSetTo /* = true */)
170 {
171 {
172 CLockObject lock(m_mutex);
173 m_bInitialised = bSetTo;
174 }
175 if (!bSetTo)
176 UnregisterClients();
177 }
178
179 bool CCECProcessor::TryLogicalAddress(cec_logical_address address, cec_version libCECSpecVersion /* = CEC_VERSION_1_4 */)
180 {
181 // find the device
182 CCECBusDevice *device = m_busDevices->At(address);
183 if (device)
184 {
185 // check if it's already marked as present or used
186 if (device->IsPresent() || device->IsHandledByLibCEC())
187 return false;
188
189 // poll the LA if not
190 return device->TryLogicalAddress(libCECSpecVersion);
191 }
192
193 return false;
194 }
195
196 void CCECProcessor::ReplaceHandlers(void)
197 {
198 if (!CECInitialised())
199 return;
200
201 // check each device
202 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
203 it->second->ReplaceHandler(true);
204 }
205
206 bool CCECProcessor::OnCommandReceived(const cec_command &command)
207 {
208 return m_inBuffer.Push(command);
209 }
210
211 void *CCECProcessor::Process(void)
212 {
213 m_libcec->AddLog(CEC_LOG_DEBUG, "processor thread started");
214
215 cec_command command; command.Clear();
216 CTimeout activeSourceCheck(ACTIVE_SOURCE_CHECK_INTERVAL);
217
218 // as long as we're not being stopped and the connection is open
219 while (!IsStopped() && m_communication->IsOpen())
220 {
221 // wait for a new incoming command, and process it
222 if (m_inBuffer.Pop(command, CEC_PROCESSOR_SIGNAL_WAIT_TIME))
223 ProcessCommand(command);
224
225 if (CECInitialised())
226 {
227 // check clients for keypress timeouts
228 m_libcec->CheckKeypressTimeout();
229
230 // check if we need to replace handlers
231 ReplaceHandlers();
232
233 // check whether we need to activate a source, if it failed before
234 if (activeSourceCheck.TimeLeft() == 0)
235 {
236 if (CECInitialised())
237 TransmitPendingActiveSourceCommands();
238 activeSourceCheck.Init(ACTIVE_SOURCE_CHECK_INTERVAL);
239 }
240 }
241 }
242
243 return NULL;
244 }
245
246 bool CCECProcessor::ActivateSource(uint16_t iStreamPath)
247 {
248 bool bReturn(false);
249
250 // find the device with the given PA
251 CCECBusDevice *device = GetDeviceByPhysicalAddress(iStreamPath);
252 // and make it the active source when found
253 if (device)
254 bReturn = device->ActivateSource();
255 else
256 m_libcec->AddLog(CEC_LOG_DEBUG, "device with PA '%04x' not found", iStreamPath);
257
258 return bReturn;
259 }
260
261 void CCECProcessor::SetStandardLineTimeout(uint8_t iTimeout)
262 {
263 CLockObject lock(m_mutex);
264 m_iStandardLineTimeout = iTimeout;
265 }
266
267 uint8_t CCECProcessor::GetStandardLineTimeout(void)
268 {
269 CLockObject lock(m_mutex);
270 return m_iStandardLineTimeout;
271 }
272
273 void CCECProcessor::SetRetryLineTimeout(uint8_t iTimeout)
274 {
275 CLockObject lock(m_mutex);
276 m_iRetryLineTimeout = iTimeout;
277 }
278
279 uint8_t CCECProcessor::GetRetryLineTimeout(void)
280 {
281 CLockObject lock(m_mutex);
282 return m_iRetryLineTimeout;
283 }
284
285 bool CCECProcessor::PhysicalAddressInUse(uint16_t iPhysicalAddress)
286 {
287 CCECBusDevice *device = GetDeviceByPhysicalAddress(iPhysicalAddress);
288 return device != NULL;
289 }
290
291 void CCECProcessor::LogOutput(const cec_command &data)
292 {
293 CStdString strTx;
294
295 // initiator and destination
296 strTx.Format("<< %02x", ((uint8_t)data.initiator << 4) + (uint8_t)data.destination);
297
298 // append the opcode
299 if (data.opcode_set)
300 strTx.AppendFormat(":%02x", (uint8_t)data.opcode);
301
302 // append the parameters
303 for (uint8_t iPtr = 0; iPtr < data.parameters.size; iPtr++)
304 strTx.AppendFormat(":%02x", data.parameters[iPtr]);
305
306 // and log it
307 m_libcec->AddLog(CEC_LOG_TRAFFIC, strTx.c_str());
308 }
309
310 bool CCECProcessor::PollDevice(cec_logical_address iAddress)
311 {
312 // try to find the primary device
313 CCECBusDevice *primary = GetPrimaryDevice();
314 // poll the destination, with the primary as source
315 if (primary)
316 return primary->TransmitPoll(iAddress, false);
317
318 CCECBusDevice *device = m_busDevices->At(CECDEVICE_UNREGISTERED);
319 if (device)
320 return device->TransmitPoll(iAddress, false);
321
322 return false;
323 }
324
325 CCECBusDevice *CCECProcessor::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress, bool bSuppressUpdate /* = true */)
326 {
327 return m_busDevices ?
328 m_busDevices->GetDeviceByPhysicalAddress(iPhysicalAddress, bSuppressUpdate) :
329 NULL;
330 }
331
332 CCECBusDevice *CCECProcessor::GetDevice(cec_logical_address address) const
333 {
334 return m_busDevices ?
335 m_busDevices->At(address) :
336 NULL;
337 }
338
339 cec_logical_address CCECProcessor::GetActiveSource(bool bRequestActiveSource /* = true */)
340 {
341 // get the device that is marked as active source from the device map
342 CCECBusDevice *activeSource = m_busDevices->GetActiveSource();
343 if (activeSource)
344 return activeSource->GetLogicalAddress();
345
346 if (bRequestActiveSource)
347 {
348 // request the active source from the bus
349 CCECBusDevice *primary = GetPrimaryDevice();
350 if (primary)
351 {
352 primary->RequestActiveSource();
353 return GetActiveSource(false);
354 }
355 }
356
357 // unknown or none
358 return CECDEVICE_UNKNOWN;
359 }
360
361 bool CCECProcessor::IsActiveSource(cec_logical_address iAddress)
362 {
363 CCECBusDevice *device = m_busDevices->At(iAddress);
364 return device && device->IsActiveSource();
365 }
366
367 bool CCECProcessor::Transmit(const cec_command &data, bool bIsReply)
368 {
369 cec_command transmitData(data);
370 uint8_t iMaxTries(0);
371 bool bRetry(true);
372 uint8_t iTries(0);
373
374 // get the current timeout setting
375 uint8_t iLineTimeout(GetStandardLineTimeout());
376
377 // reset the state of this message to 'unknown'
378 cec_adapter_message_state adapterState = ADAPTER_MESSAGE_STATE_UNKNOWN;
379
380 if (!m_communication->SupportsSourceLogicalAddress(transmitData.initiator))
381 {
382 if (transmitData.initiator == CECDEVICE_UNREGISTERED && m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE))
383 {
384 m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter. using '%s' instead", ToString(transmitData.initiator), ToString(CECDEVICE_FREEUSE));
385 transmitData.initiator = CECDEVICE_FREEUSE;
386 }
387 else
388 {
389 m_libcec->AddLog(CEC_LOG_DEBUG, "initiator '%s' is not supported by the CEC adapter", ToString(transmitData.initiator));
390 return false;
391 }
392 }
393
394 LogOutput(transmitData);
395
396 // find the initiator device
397 CCECBusDevice *initiator = m_busDevices->At(transmitData.initiator);
398 if (!initiator)
399 {
400 m_libcec->AddLog(CEC_LOG_WARNING, "invalid initiator");
401 return false;
402 }
403
404 // find the destination device, if it's not the broadcast address
405 if (transmitData.destination != CECDEVICE_BROADCAST)
406 {
407 // check if the device is marked as handled by libCEC
408 CCECBusDevice *destination = m_busDevices->At(transmitData.destination);
409 if (destination && destination->IsHandledByLibCEC())
410 {
411 // and reject the command if it's trying to send data to a device that is handled by libCEC
412 m_libcec->AddLog(CEC_LOG_WARNING, "not sending data to myself!");
413 return false;
414 }
415 }
416
417 // wait until we finished allocating a new LA if it got lost
418 while (m_bStallCommunication) Sleep(5);
419
420 {
421 CLockObject lock(m_mutex);
422 m_iLastTransmission = GetTimeMs();
423 // set the number of tries
424 iMaxTries = initiator->GetHandler()->GetTransmitRetries() + 1;
425 initiator->MarkHandlerReady();
426 }
427
428 // and try to send the command
429 while (bRetry && ++iTries < iMaxTries)
430 {
431 if (initiator->IsUnsupportedFeature(transmitData.opcode))
432 return false;
433
434 adapterState = !IsStopped() && m_communication && m_communication->IsOpen() ?
435 m_communication->Write(transmitData, bRetry, iLineTimeout, bIsReply) :
436 ADAPTER_MESSAGE_STATE_ERROR;
437 iLineTimeout = m_iRetryLineTimeout;
438 }
439
440 return bIsReply ?
441 adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED || adapterState == ADAPTER_MESSAGE_STATE_SENT || adapterState == ADAPTER_MESSAGE_STATE_WAITING_TO_BE_SENT :
442 adapterState == ADAPTER_MESSAGE_STATE_SENT_ACKED;
443 }
444
445 void CCECProcessor::TransmitAbort(cec_logical_address source, cec_logical_address destination, cec_opcode opcode, cec_abort_reason reason /* = CEC_ABORT_REASON_UNRECOGNIZED_OPCODE */)
446 {
447 m_libcec->AddLog(CEC_LOG_DEBUG, "<< transmitting abort message");
448
449 cec_command command;
450 cec_command::Format(command, source, destination, CEC_OPCODE_FEATURE_ABORT);
451 command.parameters.PushBack((uint8_t)opcode);
452 command.parameters.PushBack((uint8_t)reason);
453
454 Transmit(command, true);
455 }
456
457 void CCECProcessor::ProcessCommand(const cec_command &command)
458 {
459 // log the command
460 CStdString dataStr;
461 dataStr.Format(">> %1x%1x", command.initiator, command.destination);
462 if (command.opcode_set == 1)
463 dataStr.AppendFormat(":%02x", command.opcode);
464 for (uint8_t iPtr = 0; iPtr < command.parameters.size; iPtr++)
465 dataStr.AppendFormat(":%02x", (unsigned int)command.parameters[iPtr]);
466 m_libcec->AddLog(CEC_LOG_TRAFFIC, dataStr.c_str());
467
468 // find the initiator
469 CCECBusDevice *device = m_busDevices->At(command.initiator);
470
471 if (device)
472 device->HandleCommand(command);
473 }
474
475 bool CCECProcessor::IsPresentDevice(cec_logical_address address)
476 {
477 CCECBusDevice *device = m_busDevices->At(address);
478 return device && device->GetStatus() == CEC_DEVICE_STATUS_PRESENT;
479 }
480
481 bool CCECProcessor::IsPresentDeviceType(cec_device_type type)
482 {
483 CECDEVICEVEC devices;
484 m_busDevices->GetByType(type, devices);
485 CCECDeviceMap::FilterActive(devices);
486 return !devices.empty();
487 }
488
489 uint16_t CCECProcessor::GetDetectedPhysicalAddress(void) const
490 {
491 return m_communication ? m_communication->GetPhysicalAddress() : CEC_INVALID_PHYSICAL_ADDRESS;
492 }
493
494 bool CCECProcessor::ClearLogicalAddresses(void)
495 {
496 cec_logical_addresses addresses; addresses.Clear();
497 return SetLogicalAddresses(addresses);
498 }
499
500 bool CCECProcessor::SetLogicalAddresses(const cec_logical_addresses &addresses)
501 {
502 return m_communication ? m_communication->SetLogicalAddresses(addresses) : false;
503 }
504
505 bool CCECProcessor::StandbyDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
506 {
507 bool bReturn(true);
508 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
509 bReturn &= (*it)->Standby(initiator);
510 return bReturn;
511 }
512
513 bool CCECProcessor::StandbyDevice(const cec_logical_address initiator, cec_logical_address address)
514 {
515 CCECBusDevice *device = m_busDevices->At(address);
516 return device ? device->Standby(initiator) : false;
517 }
518
519 bool CCECProcessor::PowerOnDevices(const cec_logical_address initiator, const CECDEVICEVEC &devices)
520 {
521 bool bReturn(true);
522 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
523 bReturn &= (*it)->PowerOn(initiator);
524 return bReturn;
525 }
526
527 bool CCECProcessor::PowerOnDevice(const cec_logical_address initiator, cec_logical_address address)
528 {
529 CCECBusDevice *device = m_busDevices->At(address);
530 return device ? device->PowerOn(initiator) : false;
531 }
532
533 bool CCECProcessor::StartBootloader(const char *strPort /* = NULL */)
534 {
535 bool bReturn(false);
536 // open a connection if no connection has been opened
537 if (!m_communication && strPort)
538 {
539 CAdapterFactory factory(this->m_libcec);
540 IAdapterCommunication *comm = factory.GetInstance(strPort);
541 CTimeout timeout(CEC_DEFAULT_CONNECT_TIMEOUT);
542 int iConnectTry(0);
543 while (timeout.TimeLeft() > 0 && (bReturn = comm->Open(timeout.TimeLeft() / CEC_CONNECT_TRIES, true)) == false)
544 {
545 m_libcec->AddLog(CEC_LOG_ERROR, "could not open a connection (try %d)", ++iConnectTry);
546 comm->Close();
547 Sleep(CEC_DEFAULT_TRANSMIT_RETRY_WAIT);
548 }
549 if (comm->IsOpen())
550 {
551 bReturn = comm->StartBootloader();
552 DELETE_AND_NULL(comm);
553 }
554 return bReturn;
555 }
556 else
557 {
558 m_communication->StartBootloader();
559 Close();
560 bReturn = true;
561 }
562
563 return bReturn;
564 }
565
566 bool CCECProcessor::PingAdapter(void)
567 {
568 return m_communication->PingAdapter();
569 }
570
571 void CCECProcessor::HandlePoll(cec_logical_address initiator, cec_logical_address destination)
572 {
573 CCECBusDevice *device = m_busDevices->At(destination);
574 if (device)
575 device->HandlePollFrom(initiator);
576 }
577
578 bool CCECProcessor::HandleReceiveFailed(cec_logical_address initiator)
579 {
580 CCECBusDevice *device = m_busDevices->At(initiator);
581 return !device || !device->HandleReceiveFailed();
582 }
583
584 bool CCECProcessor::CanPersistConfiguration(void)
585 {
586 return m_communication ? m_communication->GetFirmwareVersion() >= 2 : false;
587 }
588
589 bool CCECProcessor::PersistConfiguration(const libcec_configuration &configuration)
590 {
591 libcec_configuration persistConfiguration = configuration;
592 if (!CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
593 {
594 CCECBusDevice *device = GetPrimaryDevice();
595 if (device)
596 persistConfiguration.iPhysicalAddress = device->GetCurrentPhysicalAddress();
597 }
598
599 return m_communication ? m_communication->PersistConfiguration(persistConfiguration) : false;
600 }
601
602 void CCECProcessor::RescanActiveDevices(void)
603 {
604 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
605 it->second->GetStatus(true);
606 }
607
608 bool CCECProcessor::GetDeviceInformation(const char *strPort, libcec_configuration *config, uint32_t iTimeoutMs /* = CEC_DEFAULT_CONNECT_TIMEOUT */)
609 {
610 if (!OpenConnection(strPort, CEC_SERIAL_DEFAULT_BAUDRATE, iTimeoutMs, false))
611 return false;
612
613 config->iFirmwareVersion = m_communication->GetFirmwareVersion();
614 config->iPhysicalAddress = m_communication->GetPhysicalAddress();
615 config->iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
616 config->adapterType = m_communication->GetAdapterType();
617
618 return true;
619 }
620
621 bool CCECProcessor::TransmitPendingActiveSourceCommands(void)
622 {
623 bool bReturn(true);
624 for (CECDEVICEMAP::iterator it = m_busDevices->Begin(); it != m_busDevices->End(); it++)
625 bReturn &= it->second->TransmitPendingActiveSourceCommands();
626 return bReturn;
627 }
628
629 CCECTV *CCECProcessor::GetTV(void) const
630 {
631 return CCECBusDevice::AsTV(m_busDevices->At(CECDEVICE_TV));
632 }
633
634 CCECAudioSystem *CCECProcessor::GetAudioSystem(void) const
635 {
636 return CCECBusDevice::AsAudioSystem(m_busDevices->At(CECDEVICE_AUDIOSYSTEM));
637 }
638
639 CCECPlaybackDevice *CCECProcessor::GetPlaybackDevice(cec_logical_address address) const
640 {
641 return CCECBusDevice::AsPlaybackDevice(m_busDevices->At(address));
642 }
643
644 CCECRecordingDevice *CCECProcessor::GetRecordingDevice(cec_logical_address address) const
645 {
646 return CCECBusDevice::AsRecordingDevice(m_busDevices->At(address));
647 }
648
649 CCECTuner *CCECProcessor::GetTuner(cec_logical_address address) const
650 {
651 return CCECBusDevice::AsTuner(m_busDevices->At(address));
652 }
653
654 bool CCECProcessor::AllocateLogicalAddresses(CCECClient* client)
655 {
656 libcec_configuration &configuration = *client->GetConfiguration();
657
658 // mark as unregistered
659 client->SetRegistered(false);
660
661 // unregister this client from the old addresses
662 CECDEVICEVEC devices;
663 m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses);
664 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
665 {
666 // remove client entry
667 CLockObject lock(m_mutex);
668 m_clients.erase((*it)->GetLogicalAddress());
669 }
670
671 // find logical addresses for this client
672 if (!client->AllocateLogicalAddresses())
673 {
674 m_libcec->AddLog(CEC_LOG_ERROR, "failed to find a free logical address for the client");
675 return false;
676 }
677
678 // register this client on the new addresses
679 devices.clear();
680 m_busDevices->GetByLogicalAddresses(devices, configuration.logicalAddresses);
681 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
682 {
683 // set the physical address of the device at this LA
684 if (CLibCEC::IsValidPhysicalAddress(configuration.iPhysicalAddress))
685 (*it)->SetPhysicalAddress(configuration.iPhysicalAddress);
686
687 // replace a previous client
688 CLockObject lock(m_mutex);
689 m_clients.erase((*it)->GetLogicalAddress());
690 m_clients.insert(make_pair<cec_logical_address, CCECClient *>((*it)->GetLogicalAddress(), client));
691 }
692
693 // set the new ackmask
694 SetLogicalAddresses(GetLogicalAddresses());
695
696 // resume outgoing communication
697 m_bStallCommunication = false;
698
699 return true;
700 }
701
702 bool CCECProcessor::RegisterClient(CCECClient *client)
703 {
704 if (!client)
705 return false;
706
707 libcec_configuration &configuration = *client->GetConfiguration();
708
709 if (configuration.clientVersion >= CEC_CLIENT_VERSION_1_6_3 && configuration.bMonitorOnly == 1)
710 return true;
711
712 if (!CECInitialised())
713 {
714 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register a new CEC client: CEC processor is not initialised");
715 return false;
716 }
717
718 // unregister the client first if it's already been marked as registered
719 if (client->IsRegistered())
720 UnregisterClient(client);
721
722 // ensure that controlled mode is enabled
723 m_communication->SetControlledMode(true);
724
725 // ensure that we know the vendor id of the TV
726 CCECBusDevice *tv = GetTV();
727 cec_vendor_id tvVendor = CEC_VENDOR_UNKNOWN;
728 if (m_communication->SupportsSourceLogicalAddress(CECDEVICE_UNREGISTERED))
729 tvVendor = tv->GetVendorId(CECDEVICE_UNREGISTERED);
730 else if (m_communication->SupportsSourceLogicalAddress(CECDEVICE_FREEUSE))
731 tvVendor = tv->GetVendorId(CECDEVICE_FREEUSE);
732
733 // wait until the handler is replaced, to avoid double registrations
734 if (tvVendor != CEC_VENDOR_UNKNOWN &&
735 CCECCommandHandler::HasSpecificHandler(tvVendor))
736 {
737 while (!tv->ReplaceHandler(false))
738 CEvent::Sleep(5);
739 }
740
741 // get the configuration from the client
742 m_libcec->AddLog(CEC_LOG_NOTICE, "registering new CEC client - v%s", ToString((cec_client_version)configuration.clientVersion));
743
744 // get the current ackmask, so we can restore it if polling fails
745 cec_logical_addresses previousMask = GetLogicalAddresses();
746
747 // mark as uninitialised
748 client->SetInitialised(false);
749
750 // find logical addresses for this client
751 if (!AllocateLogicalAddresses(client))
752 {
753 m_libcec->AddLog(CEC_LOG_ERROR, "failed to register the new CEC client - cannot allocate the requested device types");
754 SetLogicalAddresses(previousMask);
755 return false;
756 }
757
758 // get the settings from the rom
759 if (configuration.bGetSettingsFromROM == 1)
760 {
761 libcec_configuration config; config.Clear();
762 m_communication->GetConfiguration(config);
763
764 CLockObject lock(m_mutex);
765 if (!config.deviceTypes.IsEmpty())
766 configuration.deviceTypes = config.deviceTypes;
767 if (CLibCEC::IsValidPhysicalAddress(config.iPhysicalAddress))
768 configuration.iPhysicalAddress = config.iPhysicalAddress;
769 snprintf(configuration.strDeviceName, 13, "%s", config.strDeviceName);
770 }
771
772 // set the firmware version and build date
773 configuration.serverVersion = LIBCEC_VERSION_CURRENT;
774 configuration.iFirmwareVersion = m_communication->GetFirmwareVersion();
775 configuration.iFirmwareBuildDate = m_communication->GetFirmwareBuildDate();
776 configuration.adapterType = m_communication->GetAdapterType();
777
778 // mark the client as registered
779 client->SetRegistered(true);
780
781 // initialise the client
782 bool bReturn = client->OnRegister();
783
784 // log the new registration
785 CStdString strLog;
786 strLog.Format("%s: %s", bReturn ? "CEC client registered" : "failed to register the CEC client", client->GetConnectionInfo().c_str());
787 m_libcec->AddLog(bReturn ? CEC_LOG_NOTICE : CEC_LOG_ERROR, strLog);
788
789 // display a warning if the firmware can be upgraded
790 if (bReturn && !IsRunningLatestFirmware())
791 {
792 const char *strUpgradeMessage = "The firmware of this adapter can be upgraded. Please visit http://blog.pulse-eight.com/ for more information.";
793 m_libcec->AddLog(CEC_LOG_WARNING, strUpgradeMessage);
794 libcec_parameter param;
795 param.paramData = (void*)strUpgradeMessage; param.paramType = CEC_PARAMETER_TYPE_STRING;
796 client->Alert(CEC_ALERT_SERVICE_DEVICE, param);
797 }
798
799 // ensure that the command handler for the TV is initialised
800 if (bReturn)
801 {
802 CCECCommandHandler *handler = GetTV()->GetHandler();
803 if (handler)
804 handler->InitHandler();
805 GetTV()->MarkHandlerReady();
806 }
807
808 return bReturn;
809 }
810
811 bool CCECProcessor::UnregisterClient(CCECClient *client)
812 {
813 if (!client)
814 return false;
815
816 if (client->IsRegistered())
817 m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering client: %s", client->GetConnectionInfo().c_str());
818
819 // notify the client that it will be unregistered
820 client->OnUnregister();
821
822 {
823 CLockObject lock(m_mutex);
824 // find all devices that match the LA's of this client
825 CECDEVICEVEC devices;
826 m_busDevices->GetByLogicalAddresses(devices, client->GetConfiguration()->logicalAddresses);
827 for (CECDEVICEVEC::const_iterator it = devices.begin(); it != devices.end(); it++)
828 {
829 // find the client
830 map<cec_logical_address, CCECClient *>::iterator entry = m_clients.find((*it)->GetLogicalAddress());
831 // unregister the client
832 if (entry != m_clients.end())
833 m_clients.erase(entry);
834
835 // reset the device status
836 (*it)->ResetDeviceStatus();
837 }
838 }
839
840 // set the new ackmask
841 cec_logical_addresses addresses = GetLogicalAddresses();
842 if (SetLogicalAddresses(addresses))
843 {
844 // no more clients left, disable controlled mode
845 if (addresses.IsEmpty() && !m_bMonitor)
846 m_communication->SetControlledMode(false);
847
848 return true;
849 }
850
851 return false;
852 }
853
854 void CCECProcessor::UnregisterClients(void)
855 {
856 m_libcec->AddLog(CEC_LOG_NOTICE, "unregistering all CEC clients");
857
858 vector<CCECClient *> clients = m_libcec->GetClients();
859 for (vector<CCECClient *>::iterator client = clients.begin(); client != clients.end(); client++)
860 UnregisterClient(*client);
861
862 CLockObject lock(m_mutex);
863 m_clients.clear();
864 }
865
866 CCECClient *CCECProcessor::GetClient(const cec_logical_address address)
867 {
868 CLockObject lock(m_mutex);
869 map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.find(address);
870 if (client != m_clients.end())
871 return client->second;
872 return NULL;
873 }
874
875 CCECClient *CCECProcessor::GetPrimaryClient(void)
876 {
877 CLockObject lock(m_mutex);
878 map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin();
879 if (client != m_clients.end())
880 return client->second;
881 return NULL;
882 }
883
884 CCECBusDevice *CCECProcessor::GetPrimaryDevice(void)
885 {
886 return m_busDevices->At(GetLogicalAddress());
887 }
888
889 cec_logical_address CCECProcessor::GetLogicalAddress(void)
890 {
891 cec_logical_addresses addresses = GetLogicalAddresses();
892 return addresses.primary;
893 }
894
895 cec_logical_addresses CCECProcessor::GetLogicalAddresses(void)
896 {
897 CLockObject lock(m_mutex);
898 cec_logical_addresses addresses;
899 addresses.Clear();
900 for (map<cec_logical_address, CCECClient *>::const_iterator client = m_clients.begin(); client != m_clients.end(); client++)
901 addresses.Set(client->first);
902
903 return addresses;
904 }
905
906 bool CCECProcessor::IsHandledByLibCEC(const cec_logical_address address) const
907 {
908 CCECBusDevice *device = GetDevice(address);
909 return device && device->IsHandledByLibCEC();
910 }
911
912 bool CCECProcessor::IsRunningLatestFirmware(void)
913 {
914 return m_communication && m_communication->IsOpen() ?
915 m_communication->IsRunningLatestFirmware() :
916 true;
917 }
918
919 void CCECProcessor::SwitchMonitoring(bool bSwitchTo)
920 {
921 {
922 CLockObject lock(m_mutex);
923 m_bMonitor = bSwitchTo;
924 }
925 if (bSwitchTo)
926 UnregisterClients();
927 }
928
929 void CCECProcessor::HandleLogicalAddressLost(cec_logical_address oldAddress)
930 {
931 // stall outgoing messages until we know our new LA
932 m_bStallCommunication = true;
933
934 m_libcec->AddLog(CEC_LOG_NOTICE, "logical address %x was taken by another device, allocating a new address", oldAddress);
935 CCECClient* client = GetClient(oldAddress);
936 if (client)
937 {
938 if (m_addrAllocator)
939 while (m_addrAllocator->IsRunning()) Sleep(5);
940 delete m_addrAllocator;
941
942 m_addrAllocator = new CCECAllocateLogicalAddress(this, client);
943 m_addrAllocator->CreateThread();
944 }
945 }
946
947 CCECAllocateLogicalAddress::CCECAllocateLogicalAddress(CCECProcessor* processor, CCECClient* client) :
948 m_processor(processor),
949 m_client(client) { }
950
951 void* CCECAllocateLogicalAddress::Process(void)
952 {
953 m_processor->AllocateLogicalAddresses(m_client);
954 return NULL;
955 }