cec: added typedefs for the callback methods
[deb_libcec.git] / src / lib / implementations / SLCommandHandler.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 "SLCommandHandler.h"
34 #include "../devices/CECBusDevice.h"
35 #include "../devices/CECPlaybackDevice.h"
36 #include "../CECProcessor.h"
37 #include "../platform/timeutils.h"
38 #include "../platform/threads.h"
39
40 using namespace CEC;
41
42 #define SL_COMMAND_UNKNOWN_01 0x01
43 #define SL_COMMAND_UNKNOWN_02 0x02
44 #define SL_COMMAND_UNKNOWN_03 0x05
45
46 #define SL_COMMAND_REQUEST_POWER_STATUS 0xa0
47 #define SL_COMMAND_POWER_ON 0x03
48 #define SL_COMMAND_CONNECT_REQUEST 0x04
49 #define SL_COMMAND_CONNECT_ACCEPT 0x05
50
51 CSLCommandHandler::CSLCommandHandler(CCECBusDevice *busDevice) :
52 CCECCommandHandler(busDevice),
53 m_bAwaitingReceiveFailed(false),
54 m_bSLEnabled(false),
55 m_bPowerStateReset(false)
56 {
57 m_vendorId = CEC_VENDOR_LG;
58 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
59
60 /* imitate LG devices */
61 if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
62 primary->SetVendorId(CEC_VENDOR_LG);
63 SetLGDeckStatus();
64
65 /* LG TVs don't always reply to CEC version requests, so just set it to 1.3a */
66 if (m_busDevice->GetLogicalAddress() == CECDEVICE_TV)
67 m_busDevice->SetCecVersion(CEC_VERSION_1_3A);
68
69 /* LG devices always return "korean" as language */
70 cec_menu_language lang;
71 lang.device = m_busDevice->GetLogicalAddress();
72 snprintf(lang.language, 4, "eng");
73 m_busDevice->SetMenuLanguage(lang);
74 }
75
76
77 void CSLCommandHandler::HandlePoll(const cec_logical_address iInitiator, const cec_logical_address iDestination)
78 {
79 CCECCommandHandler::HandlePoll(iInitiator, iDestination);
80 m_bAwaitingReceiveFailed = true;
81 }
82
83 bool CSLCommandHandler::HandleReceiveFailed(void)
84 {
85 if (m_bAwaitingReceiveFailed)
86 {
87 m_bAwaitingReceiveFailed = false;
88 return false;
89 }
90
91 return true;
92 }
93
94 bool CSLCommandHandler::InitHandler(void)
95 {
96 if (m_bHandlerInited)
97 return true;
98 m_bHandlerInited = true;
99
100 /* reply with LGs vendor id */
101 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
102 if (m_busDevice->GetLogicalAddress() != primary->GetLogicalAddress())
103 primary->TransmitVendorID(CECDEVICE_TV, false);
104
105 primary->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
106 return true;
107 }
108
109 bool CSLCommandHandler::ActivateSource(void)
110 {
111 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
112 primary->SetActiveSource();
113 primary->TransmitActiveSource();
114 return true;
115 }
116
117 bool CSLCommandHandler::HandleActiveSource(const cec_command &command)
118 {
119 if (command.parameters.size == 2)
120 {
121 uint16_t iAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
122 if (iAddress != m_busDevice->GetPhysicalAddress(false))
123 m_bSLEnabled = false;
124 return m_processor->SetActiveSource(iAddress);
125 }
126
127 return true;
128 }
129
130 bool CSLCommandHandler::HandleFeatureAbort(const cec_command &command)
131 {
132 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
133 if (primary->GetPowerStatus(false) == CEC_POWER_STATUS_ON && !m_bPowerStateReset && !m_bSLEnabled)
134 {
135 m_bPowerStateReset = true;
136 primary->SetPowerStatus(CEC_POWER_STATUS_STANDBY);
137 }
138
139 return CCECCommandHandler::HandleFeatureAbort(command);
140 }
141
142 bool CSLCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
143 {
144 if (m_processor->IsStarted() && m_busDevice->MyLogicalAddressContains(command.destination))
145 {
146 CCECBusDevice *device = GetDevice(command.destination);
147 if (device)
148 return device->TransmitPhysicalAddress();
149 }
150
151 return false;
152 }
153
154 bool CSLCommandHandler::HandleVendorCommand(const cec_command &command)
155 {
156 if (command.parameters.size == 1 &&
157 command.parameters[0] == SL_COMMAND_UNKNOWN_01)
158 {
159 HandleVendorCommand01(command);
160 return true;
161 }
162 else if (command.parameters.size == 2 &&
163 command.parameters[0] == SL_COMMAND_POWER_ON)
164 {
165 HandleVendorCommandPowerOn(command);
166 return true;
167 }
168 else if (command.parameters.size == 2 &&
169 command.parameters[0] == SL_COMMAND_CONNECT_REQUEST)
170 {
171 HandleVendorCommandSLConnect(command);
172 return true;
173 }
174 else if (command.parameters.size == 1 &&
175 command.parameters[0] == SL_COMMAND_REQUEST_POWER_STATUS)
176 {
177 HandleVendorCommandPowerOnStatus(command);
178 return true;
179 }
180
181 return false;
182 }
183
184 void CSLCommandHandler::HandleVendorCommand01(const cec_command &command)
185 {
186 TransmitVendorCommand0205(command.destination, command.initiator);
187 }
188
189 void CSLCommandHandler::TransmitVendorCommand0205(const cec_logical_address iSource, const cec_logical_address iDestination)
190 {
191 cec_command response;
192 cec_command::Format(response, iSource, iDestination, CEC_OPCODE_VENDOR_COMMAND);
193 response.PushBack(SL_COMMAND_UNKNOWN_02);
194 response.PushBack(SL_COMMAND_UNKNOWN_03);
195
196 Transmit(response, false);
197 }
198
199 void CSLCommandHandler::HandleVendorCommandPowerOn(const cec_command &command)
200 {
201 CCECBusDevice *device = m_processor->GetPrimaryDevice();
202 if (device)
203 {
204 m_bSLEnabled = true;
205
206 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON); //XXX
207 device->TransmitPowerState(command.initiator);
208 device->SetPowerStatus(CEC_POWER_STATUS_ON);
209
210 SetLGDeckStatus();
211 device->SetActiveSource();
212 TransmitImageViewOn(device->GetLogicalAddress(), command.initiator);
213 }
214 }
215 void CSLCommandHandler::HandleVendorCommandPowerOnStatus(const cec_command &command)
216 {
217 if (command.destination != CECDEVICE_BROADCAST)
218 {
219 CCECBusDevice *device = m_processor->m_busDevices[m_processor->GetLogicalAddresses().primary];
220 device->SetPowerStatus(CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON);
221 device->TransmitPowerState(command.initiator);
222 device->SetPowerStatus(CEC_POWER_STATUS_ON);
223 }
224 }
225
226 void CSLCommandHandler::HandleVendorCommandSLConnect(const cec_command &command)
227 {
228 m_bSLEnabled = true;
229 SetLGDeckStatus();
230
231 CCECBusDevice *primary = m_processor->GetPrimaryDevice();
232
233 primary->SetActiveSource();
234 TransmitImageViewOn(primary->GetLogicalAddress(), command.initiator);
235 TransmitVendorCommand05(primary->GetLogicalAddress(), command.initiator);
236 }
237
238 void CSLCommandHandler::TransmitVendorCommand05(const cec_logical_address iSource, const cec_logical_address iDestination)
239 {
240 cec_command response;
241 cec_command::Format(response, iSource, iDestination, CEC_OPCODE_VENDOR_COMMAND);
242 response.PushBack(SL_COMMAND_CONNECT_ACCEPT);
243 response.PushBack((uint8_t)iSource);
244 Transmit(response, false);
245 }
246
247 void CSLCommandHandler::SetLGDeckStatus(void)
248 {
249 /* LG TVs only route keypresses when the deck status is set to 0x20 */
250 CCECBusDevice *device = m_processor->GetDeviceByType(CEC_DEVICE_TYPE_PLAYBACK_DEVICE);
251 if (device)
252 ((CCECPlaybackDevice *)device)->SetDeckStatus(CEC_DECK_INFO_OTHER_STATUS_LG);
253
254 device = m_processor->GetDeviceByType(CEC_DEVICE_TYPE_RECORDING_DEVICE);
255 if (device)
256 ((CCECPlaybackDevice *)device)->SetDeckStatus(CEC_DECK_INFO_OTHER_STATUS_LG);
257 }