[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)
{
  CCECBusDevice *device = GetDevice(command.initiator);
  if (device)
    device->SetVendorId(command.parameters);

  return true;
}

bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
{
  CCECBusDevice *device = GetDevice(command.initiator);
  if (device)
    device->SetVendorId(command.parameters);

  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;
}
Commit	Line	Data
	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"
	34	#include "../devices/CECBusDevice.h"
	35	#include "../devices/CECAudioSystem.h"
	36	#include "../CECProcessor.h"
	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
	49	if (m_busDevice->MyLogicalAddressContains(command.destination))
	50	{
	51	switch(command.opcode)
	52	{
	53	case CEC_OPCODE_REPORT_POWER_STATUS:
	54	HandleReportPowerStatus(command);
	55	break;
	56	case CEC_OPCODE_CEC_VERSION:
	57	HandleDeviceCecVersion(command);
	58	break;
	59	case CEC_OPCODE_SET_MENU_LANGUAGE:
	60	HandleSetMenuLanguage(command);
	61	m_busDevice->GetProcessor()->AddCommand(command);
	62	break;
	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;
	96	case CEC_OPCODE_GIVE_AUDIO_STATUS:
	97	HandleGiveAudioStatus(command);
	98	break;
	99	case CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS:
	100	HandleGiveSystemAudioModeStatus(command);
	101	break;
	102	case CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST:
	103	HandleSetSystemAudioModeRequest(command);
	104	break;
	105	default:
	106	UnhandledCommand(command);
	107	m_busDevice->GetProcessor()->AddCommand(command);
	108	bHandled = false;
	109	break;
	110	}
	111	}
	112	else if (command.destination == CECDEVICE_BROADCAST)
	113	{
	114	CStdString strLog;
	115	switch (command.opcode)
	116	{
	117	case CEC_OPCODE_SET_MENU_LANGUAGE:
	118	HandleSetMenuLanguage(command);
	119	m_busDevice->GetProcessor()->AddCommand(command);
	120	break;
	121	case CEC_OPCODE_REQUEST_ACTIVE_SOURCE:
	122	HandleRequestActiveSource(command);
	123	break;
	124	case CEC_OPCODE_SET_STREAM_PATH:
	125	HandleSetStreamPath(command);
	126	m_busDevice->GetProcessor()->AddCommand(command);
	127	break;
	128	case CEC_OPCODE_ROUTING_CHANGE:
	129	HandleRoutingChange(command);
	130	m_busDevice->GetProcessor()->AddCommand(command);
	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);
	140	m_busDevice->GetProcessor()->AddCommand(command);
	141	bHandled = false;
	142	break;
	143	}
	144	}
	145	else
	146	{
	147	CStdString strLog;
	148	strLog.Format("ignoring frame: we're not at destination %x", command.destination);
	149	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	150	bHandled = false;
	151	}
	152
	153	return bHandled;
	154	}
	155
	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
	168	bool CCECCommandHandler::HandleDeviceVendorCommandWithId(const cec_command &command)
	169	{
	170	CCECBusDevice *device = GetDevice(command.initiator);
	171	if (device)
	172	device->SetVendorId(command.parameters);
	173
	174	return true;
	175	}
	176
	177	bool CCECCommandHandler::HandleDeviceVendorId(const cec_command &command)
	178	{
	179	CCECBusDevice *device = GetDevice(command.initiator);
	180	if (device)
	181	device->SetVendorId(command.parameters);
	182
	183	return true;
	184	}
	185
	186	bool CCECCommandHandler::HandleGetCecVersion(const cec_command &command)
	187	{
	188	CCECBusDevice *device = GetDevice(command.destination);
	189	if (device)
	190	return device->TransmitCECVersion(command.initiator);
	191
	192	return false;
	193	}
	194
	195	bool CCECCommandHandler::HandleGiveAudioStatus(const cec_command &command)
	196	{
	197	CCECBusDevice *device = GetDevice(command.destination);
	198	if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	199	return ((CCECAudioSystem *) device)->TransmitAudioStatus(command.initiator);
	200
	201	return false;
	202	}
	203
	204	bool CCECCommandHandler::HandleGiveDeckStatus(const cec_command &command)
	205	{
	206	CCECBusDevice *device = GetDevice(command.destination);
	207	if (device)
	208	return device->TransmitDeckStatus(command.initiator);
	209
	210	return false;
	211	}
	212
	213	bool CCECCommandHandler::HandleGiveDevicePowerStatus(const cec_command &command)
	214	{
	215	CCECBusDevice *device = GetDevice(command.destination);
	216	if (device)
	217	return device->TransmitPowerState(command.initiator);
	218
	219	return false;
	220	}
	221
	222	bool CCECCommandHandler::HandleGiveDeviceVendorId(const cec_command &command)
	223	{
	224	CCECBusDevice *device = GetDevice(command.destination);
	225	if (device)
	226	return device->TransmitVendorID(command.initiator);
	227
	228	return false;
	229	}
	230
	231	bool CCECCommandHandler::HandleGiveOSDName(const cec_command &command)
	232	{
	233	CCECBusDevice *device = GetDevice(command.destination);
	234	if (device)
	235	return device->TransmitOSDName(command.initiator);
	236
	237	return false;
	238	}
	239
	240	bool CCECCommandHandler::HandleGivePhysicalAddress(const cec_command &command)
	241	{
	242	CCECBusDevice *device = GetDevice(command.destination);
	243	if (device)
	244	return device->TransmitPhysicalAddress();
	245
	246	return false;
	247	}
	248
	249	bool CCECCommandHandler::HandleMenuRequest(const cec_command &command)
	250	{
	251	if (command.parameters[0] == CEC_MENU_REQUEST_TYPE_QUERY)
	252	{
	253	CCECBusDevice *device = GetDevice(command.destination);
	254	if (device)
	255	return device->TransmitMenuState(command.initiator);
	256	}
	257	return false;
	258	}
	259
	260	bool CCECCommandHandler::HandleReportPowerStatus(const cec_command &command)
	261	{
	262	if (command.parameters.size == 1)
	263	{
	264	CCECBusDevice *device = GetDevice(command.initiator);
	265	if (device)
	266	device->SetPowerStatus((cec_power_status) command.parameters[0]);
	267	}
	268	return true;
	269	}
	270
	271	bool CCECCommandHandler::HandleRequestActiveSource(const cec_command &command)
	272	{
	273	CStdString strLog;
	274	strLog.Format(">> %i requests active source", (uint8_t) command.initiator);
	275	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	276	CCECBusDevice *device = m_busDevice->GetProcessor()->m_busDevices[m_busDevice->GetMyLogicalAddress()];
	277	if (device)
	278	return device->TransmitActiveSource();
	279	return false;
	280	}
	281
	282	bool CCECCommandHandler::HandleRoutingChange(const cec_command &command)
	283	{
	284	if (command.parameters.size == 4)
	285	{
	286	uint16_t iOldAddress = ((uint16_t)command.parameters[0] << 8) \| ((uint16_t)command.parameters[1]);
	287	uint16_t iNewAddress = ((uint16_t)command.parameters[2] << 8) \| ((uint16_t)command.parameters[3]);
	288
	289	CCECBusDevice *device = GetDevice(command.initiator);
	290	if (device)
	291	device->SetStreamPath(iNewAddress, iOldAddress);
	292	}
	293	return true;
	294	}
	295
	296	bool CCECCommandHandler::HandleSetMenuLanguage(const cec_command &command)
	297	{
	298	if (command.parameters.size == 3)
	299	{
	300	CCECBusDevice *device = GetDevice(command.initiator);
	301	if (device)
	302	{
	303	cec_menu_language language;
	304	language.device = command.initiator;
	305	for (uint8_t iPtr = 0; iPtr < 4; iPtr++)
	306	language.language[iPtr] = command.parameters[iPtr];
	307	language.language[3] = 0;
	308	device->SetMenuLanguage(language);
	309	}
	310	}
	311	return true;
	312	}
	313
	314	bool CCECCommandHandler::HandleSetStreamPath(const cec_command &command)
	315	{
	316	if (command.parameters.size >= 2)
	317	{
	318	int streamaddr = ((uint16_t)command.parameters[0] << 8) \| ((uint16_t)command.parameters[1]);
	319	CStdString strLog;
	320	strLog.Format(">> %i requests stream path from physical address %04x", command.initiator, streamaddr);
	321	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	322	CCECBusDevice *device = GetDeviceByPhysicalAddress(streamaddr);
	323	if (device)
	324	return device->TransmitActiveSource();
	325	}
	326	return true;
	327	}
	328
	329	bool CCECCommandHandler::HandleSetSystemAudioModeRequest(const cec_command &command)
	330	{
	331	if (command.parameters.size >= 1)
	332	{
	333	CCECBusDevice *device = GetDevice(command.destination);
	334	if (device&& device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	335	return ((CCECAudioSystem *) device)->SetSystemAudioMode(command);
	336	}
	337	return true;
	338	}
	339
	340	bool CCECCommandHandler::HandleGiveSystemAudioModeStatus(const cec_command &command)
	341	{
	342	CCECBusDevice *device = GetDevice(command.destination);
	343	if (device && device->GetType() == CEC_DEVICE_TYPE_AUDIO_SYSTEM)
	344	return ((CCECAudioSystem *) device)->TransmitSystemAudioModeStatus(command.initiator);
	345
	346	return false;
	347	}
	348
	349	bool CCECCommandHandler::HandleUserControlPressed(const cec_command &command)
	350	{
	351	if (command.parameters.size > 0)
	352	{
	353	m_busDevice->GetProcessor()->AddKey();
	354
	355	if (command.parameters[0] <= CEC_USER_CONTROL_CODE_MAX)
	356	{
	357	CStdString strLog;
	358	strLog.Format("key pressed: %1x", command.parameters[0]);
	359	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog.c_str());
	360
	361	m_busDevice->GetProcessor()->SetCurrentButton((cec_user_control_code) command.parameters[0]);
	362	}
	363	}
	364	return true;
	365	}
	366
	367	bool CCECCommandHandler::HandleUserControlRelease(const cec_command &command)
	368	{
	369	m_busDevice->GetProcessor()->AddKey();
	370	return true;
	371	}
	372
	373	void CCECCommandHandler::UnhandledCommand(const cec_command &command)
	374	{
	375	CStdString strLog;
	376	strLog.Format("unhandled command with opcode %02x from address %d", command.opcode, command.initiator);
	377	m_busDevice->AddLog(CEC_LOG_DEBUG, strLog);
	378	}
	379
	380	CCECBusDevice *CCECCommandHandler::GetDevice(cec_logical_address iLogicalAddress) const
	381	{
	382	CCECBusDevice *device = NULL;
	383
	384	if (iLogicalAddress >= CECDEVICE_TV && iLogicalAddress <= CECDEVICE_BROADCAST)
	385	device = m_busDevice->GetProcessor()->m_busDevices[iLogicalAddress];
	386
	387	return device;
	388	}
	389
	390	CCECBusDevice *CCECCommandHandler::GetDeviceByPhysicalAddress(uint16_t iPhysicalAddress) const
	391	{
	392	CCECBusDevice *device = NULL;
	393
	394	for (unsigned int iPtr = 0; iPtr < 16; iPtr++)
	395	{
	396	if (m_busDevice->GetProcessor()->m_busDevices[iPtr]->GetPhysicalAddress() == iPhysicalAddress)
	397	{
	398	device = m_busDevice->GetProcessor()->m_busDevices[iPtr];
	399	break;
	400	}
	401	}
	402
	403	return device;
	404	}