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