[deb_libcec.git] / src / lib / implementations / CECCommandHandler.cpp

/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011 Pulse-Eight Limited.  All rights reserved.
 * libCEC(R) is an original work, containing original code.
 *
 * libCEC(R) is a trademark of Pulse-Eight Limited.
 *
 * This program is dual-licensed; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 *
 * Alternatively, you can license this library under a commercial license,
 * please contact Pulse-Eight Licensing for more information.
 *
 * For more information contact:
 * Pulse-Eight Licensing       <license@pulse-eight.com>
 *     http://www.pulse-eight.com/
 *     http://www.pulse-eight.net/
 */

#include "CECCommandHandler.h"
#include "../devices/CECBusDevice.h"
#include "../devices/CECAudioSystem.h"
#include "../CECProcessor.h"

using namespace CEC;

CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice)
{
  m_busDevice = busDevice;
}

bool CCECCommandHandler::HandleCommand(const cec_command &command)
{
  bool bHandled(true);

  if (m_busDevice->MyLogicalAddressContains(command.destination))
  {
    switch(command.opcode)
    {
    case CEC_OPCODE_REPORT_POWER_STATUS:
      HandleReportPowerStatus(command);
      break;
    case CEC_OPCODE_CEC_VERSION:
      HandleDeviceCecVersion(command);
      break;
    case CEC_OPCODE_SET_MENU_LANGUAGE:
      HandleSetMenuLanguage(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      break;
    case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
      HandleGivePhysicalAddress(command);
      break;
    case CEC_OPCODE_GIVE_OSD_NAME:
      HandleGiveOSDName(command);
      break;
    case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
      HandleGiveDeviceVendorId(command);
      break;
    case CEC_OPCODE_DEVICE_VENDOR_ID:
      HandleDeviceVendorId(command);
      break;
    case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
      HandleDeviceVendorCommandWithId(command);
      break;
    case CEC_OPCODE_GIVE_DECK_STATUS:
      HandleGiveDeckStatus(command);
      break;
    case CEC_OPCODE_MENU_REQUEST:
      HandleMenuRequest(command);
      break;
    case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
      HandleGiveDevicePowerStatus(command);
      break;
    case CEC_OPCODE_GET_CEC_VERSION:
      HandleGetCecVersion(command);
      break;
    case CEC_OPCODE_USER_CONTROL_PRESSED:
      HandleUserControlPressed(command);
      break;
    case CEC_OPCODE_USER_CONTROL_RELEASE:
      HandleUserControlRelease(command);
      break;
    case CEC_OPCODE_GIVE_AUDIO_STATUS:
      HandleGiveAudioStatus(command);
      break;
    case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
      HandleGiveSystemAudioModeStatus(command);
      break;
    case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
      HandleSetSystemAudioModeRequest(command);
      break;
    default:
      UnhandledCommand(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      bHandled = false;
      break;
    }
  }
  else if (command.destination == CECDEVICE_BROADCAST)
  {
    CStdString strLog;
    switch (command.opcode)
    {
    case CEC_OPCODE_SET_MENU_LANGUAGE:
      HandleSetMenuLanguage(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      break;
    case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
      HandleRequestActiveSource(command);
      break;
    case CEC_OPCODE_SET_STREAM_PATH:
      HandleSetStreamPath(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      break;
    case CEC_OPCODE_ROUTING_CHANGE:
      HandleRoutingChange(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      break;
    case CEC_OPCODE_DEVICE_VENDOR_ID:
      HandleDeviceVendorId(command);
      break;
    case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
      HandleDeviceVendorCommandWithId(command);
     break;
    default:
      UnhandledCommand(command);
      m_busDevice->GetProcessor()->AddCommand(command);
      bHandled = false;
      break;
    }
  }
  else
  {
    CStdString strLog;
    strLog.Format("ignoring frame: we're not at destination %x", command.destination);
    m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
    bHandled = false;
  }

  return bHandled;
}

bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
{
  if (command.parameters.size == 1)
  {
    CCECBusDevice *device = GetDevice(command.initiator);
    if (device)
      device->SetCecVersion((cec_version) command.parameters[0]);
  }

  return true;
}

bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
{
  SetVendorId(command);
  return true;
}

bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
{
  SetVendorId(command);
  return true;
}

bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitCECVersion(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
    return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitDeckStatus(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitPowerState(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitVendorID(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitOSDName(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device)
    return device->TransmitPhysicalAddress();

  return false;
}

bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
{
  if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
  {
    CCECBusDevice *device = GetDevice(command.destination);
    if (device)
      return device->TransmitMenuState(command.initiator);
  }
  return false;
}

bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
{
  if (command.parameters.size == 1)
  {
    CCECBusDevice *device = GetDevice(command.initiator);
    if (device)
      device->SetPowerStatus((cec_power_status) command.parameters[0]);
  }
  return true;
}

bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
{
  CStdString strLog;
  strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
  m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
  CCECBusDevice *device = m_busDevice->GetProcessor()->m_busDevices[m_busDevice->GetMyLogicalAddress()];
  if (device)
    return device->TransmitActiveSource();
  return false;
}

bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
{
  if (command.parameters.size == 4)
  {
    uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
    uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) | ((uint16_t)command.parameters[3]);

    CCECBusDevice *device = GetDevice(command.initiator);
    if (device)
      device->SetStreamPath(iNewAddress, iOldAddress);
  }
  return true;
}

bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
{
  if (command.parameters.size == 3)
  {
    CCECBusDevice *device = GetDevice(command.initiator);
    if (device)
    {
      cec_menu_language language;
      language.device = command.initiator;
      for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
        language.language[iPtr] = command.parameters[iPtr];
      language.language[3] = 0;
      device->SetMenuLanguage(language);
    }
  }
  return true;
}

bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
{
  if (command.parameters.size >= 2)
  {
    int streamaddr = ((uint16_t)command.parameters[0] << 8) | ((uint16_t)command.parameters[1]);
    CStdString strLog;
    strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
    m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
    CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
    if (device)
      return device->TransmitActiveSource();
  }
  return true;
}

bool CCECCommandHandler::HandleSetSystemAudioModeRequest(const cec_command &command)
{
  if (command.parameters.size >= 1)
  {
    CCECBusDevice *device = GetDevice(command.destination);
    if (device&& device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
      return ((CCECAudioSystem *) device)->SetSystemAudioMode(command);
  }
  return true;
}

bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.destination);
  if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
    return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);

  return false;
}

bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
{
  if (command.parameters.size > 0)
  {
    m_busDevice->GetProcessor()->AddKey();

    if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
    {
      CStdString strLog;
      strLog.Format("key pressed: %1x", command.parameters[0]);
      m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());

      m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
    }
  }
  return true;
}

bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
{
  m_busDevice->GetProcessor()->AddKey();
  return true;
}

void CCECCommandHandler::UnhandledCommand(const cec_command &command)
{
  CStdString strLog;
  strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
  m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
}

CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
{
  CCECBusDevice *device = NULL;

  if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
    device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];

  return device;
}

CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
{
  CCECBusDevice *device = NULL;

  for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
  {
    if (m_busDevice->GetProcessor()->m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
    {
      device = m_busDevice->GetProcessor()->m_busDevices[iPtr];
      break;
    }
  }

  return device;
}

void CCECCommandHandler::SetVendorId(const cec_command &command)
{
  if (command.parameters.size < 3)
  {
    m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
    return;
  }

  uint64_t iVendorId = ((uint64_t)command.parameters[0] << 3) +
                       ((uint64_t)command.parameters[1] << 2) +
                        (uint64_t)command.parameters[2];

  CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
  if (device)
    device->SetVendorId(iVendorId, command.parameters.size > 3 ? command.parameters[3] : 0);
}
Commit	Line	Data
e9de9629 LOK	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 "CECCommandHandler.h"
eafa9d46	34	#include "../devices/CECBusDevice.h"
a1f8fb1b	35	#include "../devices/CECAudioSystem.h"
387b6f6f	36	#include "../CECProcessor.h"
e9de9629 LOK	37
	38	using namespace CEC;
	39
	40	CCECCommandHandler::CCECCommandHandler(CCECBusDevice *busDevice)
	41	{
	42	m_busDevice = busDevice;
	43	}
	44
	45	bool CCECCommandHandler::HandleCommand(const cec_command &command)
	46	{
	47	bool bHandled(true);
	48
f8513317	49	if (m_busDevice->MyLogicalAddressContains(command.destination))
e9de9629 LOK	50	{
	51	switch(command.opcode)
	52	{
e55f3f70 LOK	53	case CEC_OPCODE_REPORT_POWER_STATUS:
	54	HandleReportPowerStatus(command);
	55	break;
6a1c0009 LOK	56	case CEC_OPCODE_CEC_VERSION:
	57	HandleDeviceCecVersion(command);
	58	break;
a3269a0a LOK	59	case CEC_OPCODE_SET_MENU_LANGUAGE:
a3269a0a LOK	60	HandleSetMenuLanguage(command);
a9e03a86	61	m_busDevice->GetProcessor()->AddCommand(command);
a3269a0a	62	break;
e9de9629 LOK	63	case CEC_OPCODE_GIVE_PHYSICAL_ADDRESS:
	64	HandleGivePhysicalAddress(command);
	65	break;
	66	case CEC_OPCODE_GIVE_OSD_NAME:
	67	HandleGiveOSDName(command);
	68	break;
	69	case CEC_OPCODE_GIVE_DEVICE_VENDOR_ID:
	70	HandleGiveDeviceVendorId(command);
	71	break;
	72	case CEC_OPCODE_DEVICE_VENDOR_ID:
	73	HandleDeviceVendorId(command);
	74	break;
	75	case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
	76	HandleDeviceVendorCommandWithId(command);
	77	break;
	78	case CEC_OPCODE_GIVE_DECK_STATUS:
	79	HandleGiveDeckStatus(command);
	80	break;
	81	case CEC_OPCODE_MENU_REQUEST:
	82	HandleMenuRequest(command);
	83	break;
	84	case CEC_OPCODE_GIVE_DEVICE_POWER_STATUS:
	85	HandleGiveDevicePowerStatus(command);
	86	break;
	87	case CEC_OPCODE_GET_CEC_VERSION:
	88	HandleGetCecVersion(command);
	89	break;
	90	case CEC_OPCODE_USER_CONTROL_PRESSED:
	91	HandleUserControlPressed(command);
	92	break;
	93	case CEC_OPCODE_USER_CONTROL_RELEASE:
	94	HandleUserControlRelease(command);
	95	break;
a1f8fb1b LOK	96	case CEC_OPCODE_GIVE_AUDIO_STATUS:
	97	HandleGiveAudioStatus(command);
	98	break;
cf0ecd85 LOK	99	case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
	100	HandleGiveSystemAudioModeStatus(command);
	101	break;
e5e86c76 LOK	102	case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
	103	HandleSetSystemAudioModeRequest(command);
	104	break;
e9de9629 LOK	105	default:
e9de9629 LOK	106	UnhandledCommand(command);
a9e03a86	107	m_busDevice->GetProcessor()->AddCommand(command);
e9de9629 LOK	108	bHandled = false;
	109	break;
	110	}
	111	}
	112	else if (command.destination == CECDEVICE_BROADCAST)
	113	{
	114	CStdString strLog;
	115	switch (command.opcode)
	116	{
a3269a0a LOK	117	case CEC_OPCODE_SET_MENU_LANGUAGE:
a3269a0a LOK	118	HandleSetMenuLanguage(command);
a9e03a86	119	m_busDevice->GetProcessor()->AddCommand(command);
a3269a0a	120	break;
e9de9629 LOK	121	case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
	122	HandleRequestActiveSource(command);
	123	break;
	124	case CEC_OPCODE_SET_STREAM_PATH:
	125	HandleSetStreamPath(command);
a9e03a86	126	m_busDevice->GetProcessor()->AddCommand(command);
e9de9629 LOK	127	break;
	128	case CEC_OPCODE_ROUTING_CHANGE:
	129	HandleRoutingChange(command);
a9e03a86	130	m_busDevice->GetProcessor()->AddCommand(command);
e9de9629 LOK	131	break;
	132	case CEC_OPCODE_DEVICE_VENDOR_ID:
	133	HandleDeviceVendorId(command);
	134	break;
	135	case CEC_OPCODE_VENDOR_COMMAND_WITH_ID:
	136	HandleDeviceVendorCommandWithId(command);
	137	break;
	138	default:
	139	UnhandledCommand(command);
a9e03a86	140	m_busDevice->GetProcessor()->AddCommand(command);
e9de9629 LOK	141	bHandled = false;
	142	break;
	143	}
	144	}
	145	else
	146	{
	147	CStdString strLog;
f8513317	148	strLog.Format("ignoring frame: we're not at destination %x", command.destination);
e9de9629 LOK	149	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	150	bHandled = false;
	151	}
	152
	153	return bHandled;
	154	}
	155
6a1c0009 LOK	156	bool CCECCommandHandler::HandleDeviceCecVersion(const cec_command &command)
	157	{
	158	if (command.parameters.size == 1)
	159	{
	160	CCECBusDevice *device = GetDevice(command.initiator);
	161	if (device)
	162	device->SetCecVersion((cec_version) command.parameters[0]);
	163	}
	164
	165	return true;
	166	}
	167
e9de9629 LOK	168	bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
e9de9629 LOK	169	{
181b3475	170	SetVendorId(command);
6a1c0009	171	return true;
e9de9629 LOK	172	}
	173
	174	bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
	175	{
181b3475	176	SetVendorId(command);
6a1c0009	177	return true;
e9de9629 LOK	178	}
	179
	180	bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
	181	{
f8513317	182	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	183	if (device)
29912296	184	return device->TransmitCECVersion(command.initiator);
0f23c85c LOK	185
0f23c85c LOK	186	return false;
e9de9629 LOK	187	}
e9de9629 LOK	188
a1f8fb1b LOK	189	bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
	190	{
	191	CCECBusDevice *device = GetDevice(command.destination);
	192	if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	193	return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
	194
	195	return false;
	196	}
	197
e9de9629 LOK	198	bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
e9de9629 LOK	199	{
f8513317	200	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	201	if (device)
29912296	202	return device->TransmitDeckStatus(command.initiator);
0f23c85c LOK	203
0f23c85c LOK	204	return false;
e9de9629 LOK	205	}
	206
	207	bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
	208	{
f8513317	209	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	210	if (device)
29912296	211	return device->TransmitPowerState(command.initiator);
0f23c85c LOK	212
0f23c85c LOK	213	return false;
e9de9629 LOK	214	}
	215
	216	bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
	217	{
f8513317	218	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	219	if (device)
29912296	220	return device->TransmitVendorID(command.initiator);
0f23c85c LOK	221
0f23c85c LOK	222	return false;
e9de9629 LOK	223	}
	224
	225	bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
	226	{
f8513317	227	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	228	if (device)
29912296	229	return device->TransmitOSDName(command.initiator);
0f23c85c LOK	230
0f23c85c LOK	231	return false;
e9de9629 LOK	232	}
	233
	234	bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
	235	{
f8513317	236	CCECBusDevice *device = GetDevice(command.destination);
09c10b66	237	if (device)
29912296	238	return device->TransmitPhysicalAddress();
09c10b66 LOK	239
09c10b66 LOK	240	return false;
e9de9629 LOK	241	}
	242
	243	bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
	244	{
	245	if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
0f23c85c	246	{
f8513317	247	CCECBusDevice *device = GetDevice(command.destination);
0f23c85c	248	if (device)
29912296	249	return device->TransmitMenuState(command.initiator);
0f23c85c LOK	250	}
0f23c85c LOK	251	return false;
e9de9629 LOK	252	}
e9de9629 LOK	253
e55f3f70 LOK	254	bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
	255	{
	256	if (command.parameters.size == 1)
	257	{
	258	CCECBusDevice *device = GetDevice(command.initiator);
	259	if (device)
	260	device->SetPowerStatus((cec_power_status) command.parameters[0]);
	261	}
	262	return true;
	263	}
	264
e9de9629 LOK	265	bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
	266	{
	267	CStdString strLog;
	268	strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
	269	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
f8513317	270	CCECBusDevice *device = m_busDevice->GetProcessor()->m_busDevices[m_busDevice->GetMyLogicalAddress()];
09c10b66	271	if (device)
29912296	272	return device->TransmitActiveSource();
09c10b66	273	return false;
e9de9629 LOK	274	}
	275
	276	bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
	277	{
	278	if (command.parameters.size == 4)
	279	{
	280	uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) \| ((uint16_t)command.parameters[1]);
	281	uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) \| ((uint16_t)command.parameters[3]);
e9de9629	282
0f23c85c LOK	283	CCECBusDevice *device = GetDevice(command.initiator);
0f23c85c LOK	284	if (device)
9dc04b07	285	device->SetStreamPath(iNewAddress, iOldAddress);
e9de9629 LOK	286	}
	287	return true;
	288	}
	289
a3269a0a LOK	290	bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
	291	{
	292	if (command.parameters.size == 3)
	293	{
	294	CCECBusDevice *device = GetDevice(command.initiator);
	295	if (device)
	296	{
	297	cec_menu_language language;
	298	language.device = command.initiator;
56701628	299	for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
a3269a0a LOK	300	language.language[iPtr] = command.parameters[iPtr];
	301	language.language[3] = 0;
	302	device->SetMenuLanguage(language);
	303	}
	304	}
	305	return true;
	306	}
	307
e9de9629 LOK	308	bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
	309	{
	310	if (command.parameters.size >= 2)
	311	{
	312	int streamaddr = ((uint16_t)command.parameters[0] << 8) \| ((uint16_t)command.parameters[1]);
	313	CStdString strLog;
	314	strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
	315	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
6685ae07 LOK	316	CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
	317	if (device)
	318	return device->TransmitActiveSource();
e9de9629 LOK	319	}
	320	return true;
	321	}
	322
e5e86c76 LOK	323	bool CCECCommandHandler::HandleSetSystemAudioModeRequest(const cec_command &command)
	324	{
	325	if (command.parameters.size >= 1)
	326	{
	327	CCECBusDevice *device = GetDevice(command.destination);
	328	if (device&& device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	329	return ((CCECAudioSystem *) device)->SetSystemAudioMode(command);
	330	}
	331	return true;
	332	}
	333
cf0ecd85 LOK	334	bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
	335	{
	336	CCECBusDevice *device = GetDevice(command.destination);
	337	if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	338	return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
	339
	340	return false;
	341	}
	342
e9de9629 LOK	343	bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
	344	{
	345	if (command.parameters.size > 0)
	346	{
	347	m_busDevice->GetProcessor()->AddKey();
	348
	349	if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
	350	{
	351	CStdString strLog;
	352	strLog.Format("key pressed: %1x", command.parameters[0]);
	353	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	354
	355	m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
	356	}
	357	}
	358	return true;
	359	}
	360
	361	bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
	362	{
	363	m_busDevice->GetProcessor()->AddKey();
	364	return true;
	365	}
	366
	367	void CCECCommandHandler::UnhandledCommand(const cec_command &command)
	368	{
b5b53c7d LOK	369	CStdString strLog;
	370	strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
	371	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
0f23c85c LOK	372	}
	373
	374	CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
	375	{
	376	CCECBusDevice *device = NULL;
	377
	378	if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
	379	device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
	380
	381	return device;
e9de9629	382	}
6685ae07 LOK	383
	384	CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
	385	{
	386	CCECBusDevice *device = NULL;
	387
	388	for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
	389	{
	390	if (m_busDevice->GetProcessor()->m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
	391	{
	392	device = m_busDevice->GetProcessor()->m_busDevices[iPtr];
	393	break;
	394	}
	395	}
	396
	397	return device;
	398	}
181b3475	399
181b3475 LOK	400	void CCECCommandHandler::SetVendorId(const cec_command &command)
	401	{
	402	if (command.parameters.size < 3)
	403	{
	404	m_busDevice->AddLog(CEC_LOG_WARNING, "invalid vendor ID received");
	405	return;
	406	}
	407
	408	uint64_t iVendorId = ((uint64_t)command.parameters[0] << 3) +
	409	((uint64_t)command.parameters[1] << 2) +
	410	(uint64_t)command.parameters[2];
	411
	412	CCECBusDevice *device = GetDevice((cec_logical_address) command.initiator);
	413	if (device)
a7bed660	414	device->SetVendorId(iVendorId, command.parameters.size > 3 ? command.parameters[3] : 0);
181b3475	415	}