d14bec66cd1fe0c71cd569ab3bec21c53ab0a390
[deb_libcec.git] / src / lib / implementations / VLCommandHandler.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 "VLCommandHandler.h"
35
36 #include "lib/devices/CECBusDevice.h"
37 #include "lib/devices/CECPlaybackDevice.h"
38 #include "lib/devices/CECTV.h"
39 #include "lib/CECProcessor.h"
40 #include "lib/LibCEC.h"
41 #include "lib/CECClient.h"
42
43 #define VL_POWER_CHANGE 0x20
44 #define VL_POWERED_UP 0x00
45 #define VL_POWERED_DOWN 0x01
46 #define VL_UNKNOWN1 0x06
47
48 #define VL_REQUEST_POWER_STATUS_TIMEOUT 5000
49
50 using namespace CEC;
51 using namespace PLATFORM;
52
53 #define LIB_CEC m_busDevice->GetProcessor()->GetLib()
54 #define ToString(p) LIB_CEC->ToString(p)
55
56 // wait this amount of ms before trying to switch sources after receiving the message from the TV that it's powered on
57 #define SOURCE_SWITCH_DELAY_MS 3000
58
59 CVLCommandHandler::CVLCommandHandler(CCECBusDevice *busDevice,
60 int32_t iTransmitTimeout /* = CEC_DEFAULT_TRANSMIT_TIMEOUT */,
61 int32_t iTransmitWait /* = CEC_DEFAULT_TRANSMIT_WAIT */,
62 int8_t iTransmitRetries /* = CEC_DEFAULT_TRANSMIT_RETRIES */,
63 int64_t iActiveSourcePending /* = 0 */) :
64 CCECCommandHandler(busDevice, iTransmitTimeout, iTransmitWait, iTransmitRetries, iActiveSourcePending),
65 m_iPowerUpEventReceived(0),
66 m_bCapabilitiesSent(false),
67 m_iPowerStatusRequested(0)
68 {
69 m_vendorId = CEC_VENDOR_PANASONIC;
70 }
71
72 bool CVLCommandHandler::InitHandler(void)
73 {
74 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
75 if (primary && primary->GetLogicalAddress() != CECDEVICE_UNREGISTERED)
76 {
77 /* use the VL commandhandler for the primary device that is handled by libCEC */
78 if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
79 {
80 if (primary && m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
81 {
82 primary->SetVendorId(CEC_VENDOR_PANASONIC);
83 primary->ReplaceHandler(false);
84 }
85 }
86
87 if (primary->GetType() == CEC_DEVICE_TYPE_RECORDING_DEVICE)
88 return m_processor->GetPrimaryClient()->ChangeDeviceType(CEC_DEVICE_TYPE_RECORDING_DEVICE, CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
89 }
90
91 return CCECCommandHandler::InitHandler();
92 }
93
94 int CVLCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
95 {
96 if (!m_processor->IsHandledByLibCEC(command.destination))
97 return CEC_ABORT_REASON_INVALID_OPERAND;
98
99 if (command.parameters[0] != 0x00 ||
100 command.parameters[1] != 0x80 ||
101 command.parameters[2] != 0x45)
102 return CEC_ABORT_REASON_INVALID_OPERAND;
103
104 // XXX this is also sent when the TV is powered off
105 #if 0
106 if (command.initiator == CECDEVICE_TV &&
107 command.parameters.At(3) == VL_UNKNOWN1)
108 {
109 // set the power up event time
110 {
111 CLockObject lock(m_mutex);
112 if (m_iPowerUpEventReceived == 0)
113 m_iPowerUpEventReceived = GetTimeMs();
114 }
115 // mark the TV as powered on
116 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
117 }
118 else
119 #endif
120 if (command.initiator == CECDEVICE_TV &&
121 command.destination == CECDEVICE_BROADCAST &&
122 command.parameters.At(3) == VL_POWER_CHANGE)
123 {
124 if (command.parameters.At(4) == VL_POWERED_UP)
125 {
126 // set the power up event time
127 {
128 CLockObject lock(m_mutex);
129 if (m_iPowerUpEventReceived == 0)
130 m_iPowerUpEventReceived = GetTimeMs();
131 }
132 // mark the TV as powered on
133 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
134
135 // send capabilties
136 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
137
138 // reactivate the source, so the tv switches channels
139 if (m_processor->IsActiveSource(m_processor->GetLogicalAddress()))
140 m_processor->GetDevice(m_processor->GetLogicalAddress())->TransmitActiveSource(false);
141 }
142 else if (command.parameters.At(4) == VL_POWERED_DOWN)
143 {
144 // reset the power up event time
145 {
146 CLockObject lock(m_mutex);
147 m_iPowerUpEventReceived = 0;
148 }
149 // mark the TV as powered off
150 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
151 }
152 else
153 LIB_CEC->AddLog(CEC_LOG_DEBUG, "skipping unknown vendor command");
154
155 return COMMAND_HANDLED;
156 }
157
158 return CCECCommandHandler::HandleDeviceVendorCommandWithId(command);
159 }
160
161 bool CVLCommandHandler::PowerUpEventReceived(void)
162 {
163 bool bPowerUpEventReceived(true);
164
165 if (m_busDevice->GetLogicalAddress() != CECDEVICE_TV)
166 {
167 CCECBusDevice* tv = m_processor->GetTV();
168 if (tv && tv->GetStatus() != CEC_DEVICE_STATUS_PRESENT)
169 return true;
170
171 // get the status from the TV
172 if (tv && tv->GetCurrentVendorId() == CEC_VENDOR_PANASONIC)
173 {
174 CVLCommandHandler *handler = static_cast<CVLCommandHandler *>(tv->GetHandler());
175 bPowerUpEventReceived = handler ? handler->PowerUpEventReceived() : false;
176 tv->MarkHandlerReady();
177 }
178 }
179 else
180 {
181 // get the current status
182 {
183 CLockObject lock(m_mutex);
184 bPowerUpEventReceived = m_iPowerUpEventReceived > 0 &&
185 GetTimeMs() - m_iPowerUpEventReceived > SOURCE_SWITCH_DELAY_MS;
186 }
187
188 // if we didn't receive the event, check if the TV is already marked as powered on
189 if (!bPowerUpEventReceived && m_busDevice->GetCurrentPowerStatus() == CEC_POWER_STATUS_ON)
190 {
191 CLockObject lock(m_mutex);
192 m_iPowerUpEventReceived = GetTimeMs();
193 bPowerUpEventReceived = true;
194 }
195 }
196
197 return bPowerUpEventReceived;
198 }
199
200 int CVLCommandHandler::HandleStandby(const cec_command &command)
201 {
202 // reset the power up event time
203 {
204 CLockObject lock(m_mutex);
205 m_iPowerUpEventReceived = 0;
206 m_bCapabilitiesSent = false;
207 }
208
209 return CCECCommandHandler::HandleStandby(command);
210 }
211
212 void CVLCommandHandler::VendorPreActivateSourceHook(void)
213 {
214 bool bTransmit(false);
215 {
216 CLockObject lock(m_mutex);
217 bTransmit = !m_bCapabilitiesSent;
218 }
219 if (bTransmit)
220 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), CECDEVICE_TV);
221 }
222
223 void CVLCommandHandler::SendVendorCommandCapabilities(const cec_logical_address initiator, const cec_logical_address destination)
224 {
225 if (PowerUpEventReceived())
226 {
227 cec_command response;
228 cec_command::Format(response, initiator, destination, CEC_OPCODE_VENDOR_COMMAND);
229 uint8_t iResponseData[] = {0x10, 0x02, 0xFF, 0xFF, 0x00, 0x05, 0x05, 0x45, 0x55, 0x5c, 0x58, 0x32};
230 response.PushArray(12, iResponseData);
231
232 if (Transmit(response, false, true))
233 {
234 CLockObject lock(m_mutex);
235 m_bCapabilitiesSent = true;
236 }
237 }
238 }
239
240 int CVLCommandHandler::HandleVendorCommand(const cec_command &command)
241 {
242 // some vendor command voodoo that will enable more buttons on the remote
243 if (command.parameters.size == 3 &&
244 command.parameters[0] == 0x10 &&
245 command.parameters[1] == 0x01 &&
246 command.parameters[2] == 0x05 &&
247 m_processor->IsHandledByLibCEC(command.destination))
248 {
249 SendVendorCommandCapabilities(m_processor->GetLogicalAddress(), command.initiator);
250 return COMMAND_HANDLED;
251 }
252
253 return CEC_ABORT_REASON_INVALID_OPERAND;
254 }
255
256 bool CVLCommandHandler::TransmitRequestPowerStatus(const cec_logical_address iInitiator, const cec_logical_address iDestination, bool bWaitForResponse /* = true */)
257 {
258 m_iPowerStatusRequested = GetTimeMs();
259 return CCECCommandHandler::TransmitRequestPowerStatus(iInitiator, iDestination, bWaitForResponse);
260 }
261
262 bool CVLCommandHandler::SourceSwitchAllowed(void)
263 {
264 int64_t now(GetTimeMs());
265 if (!PowerUpEventReceived() && now - m_iPowerStatusRequested > VL_REQUEST_POWER_STATUS_TIMEOUT)
266 TransmitRequestPowerStatus(m_processor->GetPrimaryDevice()->GetLogicalAddress(), CECDEVICE_TV, false);
267
268 return PowerUpEventReceived();
269 }
270
271 int CVLCommandHandler::HandleSystemAudioModeRequest(const cec_command &command)
272 {
273 if (command.initiator == CECDEVICE_TV)
274 {
275 // set the power up event time
276 {
277 CLockObject lock(m_mutex);
278 if (m_iPowerUpEventReceived == 0)
279 m_iPowerUpEventReceived = GetTimeMs();
280 }
281 // mark the TV as powered on
282 m_processor->GetTV()->SetPowerStatus(CEC_POWER_STATUS_ON);
283 }
284
285 return CCECCommandHandler::HandleSystemAudioModeRequest(command);
286 }
287
288 int CVLCommandHandler::HandleReportPowerStatus(const cec_command &command)
289 {
290 if (command.initiator == m_busDevice->GetLogicalAddress() &&
291 command.parameters.size == 1 &&
292 (cec_power_status)command.parameters[0] == CEC_POWER_STATUS_ON)
293 {
294 CLockObject lock(m_mutex);
295 if (m_iPowerUpEventReceived == 0)
296 m_iPowerUpEventReceived = GetTimeMs();
297 }
298
299 return CCECCommandHandler::HandleReportPowerStatus(command);
300 }