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