[deb_libcec.git] / src / cec-config / cec-config.cpp

/*
 * This file is part of the libCEC(R) library.
 *
 * libCEC(R) is Copyright (C) 2011-2012 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 "../../include/cec.h"

#include <cstdio>
#include <fcntl.h>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>
#include "../lib/platform/threads/mutex.h"
#include "../lib/platform/util/timeutils.h"
#include "../lib/implementations/CECCommandHandler.h"

using namespace CEC;
using namespace std;
using namespace PLATFORM;

#include <cecloader.h>

CMutex                g_outputMutex;

CEvent                g_responseEvent;
cec_opcode            g_lastCommand = CEC_OPCODE_NONE;

CEvent                g_keyEvent;
cec_user_control_code g_lastKey = CEC_USER_CONTROL_CODE_UNKNOWN;

ICECCallbacks         g_callbacks;
libcec_configuration  g_config;
ICECAdapter *         g_parser;

inline void PrintToStdOut(const char *strFormat, ...)
{
  CStdString strLog;

  va_list argList;
  va_start(argList, strFormat);
  strLog.FormatV(strFormat, argList);
  va_end(argList);

  CLockObject lock(g_outputMutex);
  cout << strLog << endl;
}

//get the first word (separated by whitespace) from string data and place that in word
//then remove that word from string data
bool GetWord(string& data, string& word)
{
  stringstream datastream(data);
  string end;

  datastream >> word;
  if (datastream.fail())
  {
    data.clear();
    return false;
  }

  size_t pos = data.find(word) + word.length();

  if (pos >= data.length())
  {
    data.clear();
    return true;
  }

  data = data.substr(pos);

  datastream.clear();
  datastream.str(data);

  datastream >> end;
  if (datastream.fail())
    data.clear();

  return true;
}

int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message)
{
  switch (message.level)
  {
  case CEC_LOG_ERROR:
    PrintToStdOut("ERROR:\t%s", message.message);
    break;
  case CEC_LOG_WARNING:
    PrintToStdOut("ERROR:\t%s", message.message);
    break;
  default:
    break;
  }

  return 0;
}

int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &key)
{
  g_lastKey = key.keycode;
  g_keyEvent.Signal();
  return 0;
}

int CecCommand(void *UNUSED(cbParam), const cec_command &command)
{
  g_lastCommand = command.opcode;
  g_responseEvent.Signal();
  return 0;
}

bool ProcessConsoleCommand(string &input)
{
  if (!input.empty())
  {
    string command;
    if (GetWord(input, command))
    {
      if (command == "q" || command == "quit")
        return false;
    }
  }
  return true;
}

bool OpenConnection(cec_device_type type = CEC_DEVICE_TYPE_RECORDING_DEVICE)
{
  g_config.Clear();
  snprintf(g_config.strDeviceName, 13, "CEC-config");
  g_config.callbackParam      = NULL;
  g_config.clientVersion      = (uint32_t)CEC_CLIENT_VERSION_1_6_2;
  g_callbacks.CBCecLogMessage = &CecLogMessage;
  g_callbacks.CBCecKeyPress   = &CecKeyPress;
  g_callbacks.CBCecCommand    = &CecCommand;
  g_config.callbacks          = &g_callbacks;

  g_config.deviceTypes.add(type);

  g_parser = LibCecInitialise(&g_config);
  if (!g_parser)
    return false;

  CStdString strPort;
  cec_adapter devices[10];
  uint8_t iDevicesFound = g_parser->FindAdapters(devices, 10, NULL);
  if (iDevicesFound <= 0)
  {
    PrintToStdOut("autodetect FAILED");
    UnloadLibCec(g_parser);
    return false;
  }
  else
  {
    strPort = devices[0].comm;
  }

  PrintToStdOut("opening a connection to the CEC adapter...");
  if (!g_parser->Open(strPort.c_str()))
  {
    PrintToStdOut("unable to open the device on port %s", strPort.c_str());
    UnloadLibCec(g_parser);
    return false;
  }

  g_parser->GetCurrentConfiguration(&g_config);
  PrintToStdOut("CEC Parser created - libCEC version %s", g_parser->ToString((cec_server_version)g_config.serverVersion));

  return true;
}

int8_t FindPhysicalAddressPortNumber(void)
{
  PrintToStdOut("Enter the HDMI port number to which you connected your CEC adapter, followed by <enter>. Valid ports are in the range 1-15. Anything else will cancel this wizard.");
  string input;
  getline(cin, input);
  cin.clear();
  if (input.empty())
    return -1;

  int hdmiport = atoi(input.c_str());
  return (hdmiport < 1 || hdmiport > 15) ? -1 : (int8_t)hdmiport;
}

cec_logical_address FindPhysicalAddressBaseDevice(void)
{
  PrintToStdOut("Press 1 if your CEC adapter is connected to your TV or\nPress 2 if it's connected to an AVR, followed by <enter>. Anything else will cancel this wizard.");

  string input;
  getline(cin, input);
  cin.clear();
  if (input.empty() || (input != "1" && input != "2"))
  {
    PrintToStdOut("Exiting...");
    return CECDEVICE_UNKNOWN;
  }
  return (input == "2") ?
    CECDEVICE_AUDIOSYSTEM :
    CECDEVICE_TV;
}

uint16_t FindPhysicalAddress(void)
{
  PrintToStdOut("=== Physical Address Configuration ===\n");
  uint16_t iAddress(CEC_INVALID_PHYSICAL_ADDRESS);

  PrintToStdOut("Do you want to let libCEC try to autodetect the address (y/n)?");
  string input;
  getline(cin, input);
  cin.clear();
  if (input == "y" || input == "Y")
  {
    cec_logical_address baseDevice = FindPhysicalAddressBaseDevice();
    if (baseDevice == CECDEVICE_UNKNOWN)
      return iAddress;

    int8_t iPortNumber = FindPhysicalAddressPortNumber();
    if (iPortNumber == -1)
      return iAddress;

    PrintToStdOut("Trying to detect the physical address...");
    if (!g_parser->SetHDMIPort(baseDevice, iPortNumber))
      PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
    else
    {
      g_parser->GetCurrentConfiguration(&g_config);
      iAddress = g_parser->GetDevicePhysicalAddress(g_config.logicalAddresses.primary);
      if (iAddress == 0 || iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
        PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
    }
  }

  if (iAddress == 0 || iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
  {
    PrintToStdOut("Please enter the physical address (0001 - FFFE), followed by <enter>.");
    getline(cin, input);
    cin.clear();

    int iAddressTmp;
    if (sscanf(input.c_str(), "%x", &iAddressTmp) == 1)
    {
      if (iAddressTmp <= CEC_PHYSICAL_ADDRESS_TV || iAddressTmp > CEC_MAX_PHYSICAL_ADDRESS)
        iAddressTmp = CEC_INVALID_PHYSICAL_ADDRESS;
      iAddress = (uint16_t)iAddressTmp;
    }
  }

  if (iAddress != 0)
  {
    g_parser->SetPhysicalAddress(iAddress);
    g_parser->SetActiveSource(g_config.deviceTypes[0]);
  }

  return iAddress;
}

bool PowerOnTV(uint64_t iTimeout = 60000)
{
  cec_power_status currentTvPower(CEC_POWER_STATUS_UNKNOWN);
  uint64_t iNow = GetTimeMs();
  uint64_t iTarget = iNow + iTimeout;

  if (currentTvPower != CEC_POWER_STATUS_ON)
  {
    currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);
    if (currentTvPower != CEC_POWER_STATUS_ON)
    {
      PrintToStdOut("Sending 'power on' command to the TV\n=== Please wait ===");
      g_parser->PowerOnDevices(CECDEVICE_TV);
      while (iTarget > iNow)
      {
        g_responseEvent.Wait((uint32_t)(iTarget - iNow));
        if (g_lastCommand == CEC_OPCODE_REQUEST_ACTIVE_SOURCE)
          break;
        iNow = GetTimeMs();
      }
    }
  }

  currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);

  if (currentTvPower != CEC_POWER_STATUS_ON)
    PrintToStdOut("Failed to power on the TV, or the TV does not respond properly");

  return currentTvPower == CEC_POWER_STATUS_ON;
}

int main (int UNUSED(argc), char *UNUSED(argv[]))
{
  g_callbacks.Clear();
  g_config.Clear();
  PrintToStdOut("=== USB-CEC Adapter Configuration ===\n");
  if (!OpenConnection())
    return 1;

  if (!PowerOnTV())
    return 1;

  bool bAddressOk(false);
  while (!bAddressOk)
  {
    uint16_t iAddress = FindPhysicalAddress();

    PrintToStdOut("Physical address: %4X", iAddress);
    PrintToStdOut("Is this correct (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    bAddressOk = (input == "y" || input == "Y");
  }

  g_parser->GetCurrentConfiguration(&g_config);

  {
    cec_menu_language lang;
    if (g_parser->GetDeviceMenuLanguage(CECDEVICE_TV, &lang))
    {
      PrintToStdOut("TV menu language: %s", lang.language);
      PrintToStdOut("Do you want the application to use the menu language of the TV (y/n)?");
      string input;
      getline(cin, input);
      cin.clear();
      g_config.bUseTVMenuLanguage = (input == "y" || input == "Y") ? 1 : 0;
    }
    else
    {
      PrintToStdOut("The TV did not respond properly to the menu language request.");
    }
  }

  {
    PrintToStdOut("Do you want to make the CEC adapter the active source when starting the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bActivateSource = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to power on the TV when starting the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    if (input == "y" || input == "Y")
      g_config.wakeDevices.Set(CECDEVICE_TV);
  }

  {
    PrintToStdOut("Do you want to power off CEC devices when closing the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    if (input == "y" || input == "Y")
      g_config.powerOffDevices.Set(CECDEVICE_TV);
  }

  {
    PrintToStdOut("Do you want to power off CEC devices when the screensaver is activated (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bPowerOffScreensaver = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to put the PC in standby when the TV is put in standby mode (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bPowerOffOnStandby = (input == "y" || input == "Y") ? 1 : 0;
  }

  {
    PrintToStdOut("Do you want to send an inactive source message when stopping the application (y/n)?");
    string input;
    getline(cin, input);
    cin.clear();
    g_config.bSendInactiveSource = (input == "y" || input == "Y") ? 1 : 0;
  }

  PrintToStdOut("\n\n=== USB-CEC Adapter Configuration Summary ===");
  PrintToStdOut("HDMI port number:                                        %d", g_config.iHDMIPort);
  PrintToStdOut("Connected to HDMI device:                                %X", (uint8_t)g_config.baseDevice);
  PrintToStdOut("Physical address:                                        %4X", g_config.iPhysicalAddress);
  PrintToStdOut("Use the TV's language setting:                           %s", g_config.bUseTVMenuLanguage ? "yes" : "no");
  PrintToStdOut("Make the adapter the active source when starting XBMC:   %s", g_config.bActivateSource ? "yes" : "no");
  PrintToStdOut("Power on the TV when starting XBMC:                      %s", g_config.wakeDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
  PrintToStdOut("Power off devices when stopping XBMC:                    %s", g_config.powerOffDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
  PrintToStdOut("Put devices in standby mode when activating screensaver: %s", g_config.bPowerOffScreensaver ? "yes" : "no");
  PrintToStdOut("Put this PC in standby mode when the TV is switched off: %s", g_config.bPowerOffOnStandby ? "yes" : "no");
  PrintToStdOut("Send an inactive source message when stopping XBMC:      %s\n\n", g_config.bSendInactiveSource ? "yes" : "no");

  PrintToStdOut("Storing settings ...");
  if (g_parser->PersistConfiguration(&g_config))
    PrintToStdOut("Settings stored.");
  else
    PrintToStdOut("The settings could not be stored");

  ofstream configOutput;
  configOutput.open("usb_2548_1001.xml");
  if (configOutput.is_open())
  {
    CStdString strWakeDevices;
    for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
      if (g_config.wakeDevices[iPtr])
        strWakeDevices.AppendFormat(" %d" + iPtr);
    CStdString strStandbyDevices;
    for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
      if (g_config.powerOffDevices[iPtr])
        strStandbyDevices.AppendFormat(" %d" + iPtr);

    configOutput <<
        "<settings>\n" <<
          "\t<setting id=\"enabled\" value=\"1\" />\n" <<
          "\t<setting id=\"activate_source\" value=\"" << (int)g_config.bActivateSource << "\" />\n" <<
          "\t<setting id=\"wake_devices\" value=\"" << strWakeDevices.c_str() << "\" />\n" <<
          "\t<setting id=\"standby_devices\" value=\"" << strStandbyDevices.c_str() << "\" />\n" <<
          "\t<setting id=\"cec_standby_screensaver\" value=\"" << (int)g_config.bPowerOffScreensaver << "\" />\n" <<
          "\t<setting id=\"standby_pc_on_tv_standby\" value=\"" << (int)g_config.bPowerOffOnStandby << "\" />\n" <<
          "\t<setting id=\"use_tv_menu_language\" value=\"" << (int)g_config.bUseTVMenuLanguage << "\" />\n" <<
          "\t<setting id=\"physical_address\" value=\"" << hex << g_config.iPhysicalAddress << "\" />\n" <<
          "\t<setting id=\"cec_hdmi_port\" value=\"" << g_config.iHDMIPort << "\" />\n" <<
          "\t<setting id=\"connected_device\" value=\"" << (int)g_config.baseDevice << "\" />\n" <<
          "\t<setting id=\"port\" value=\"\" />\n" <<
          "\t<setting id=\"send_inactive_source\" value=\"" << (int)g_config.bSendInactiveSource << "\" />\n" <<
        "</settings>";
    configOutput.close();

    PrintToStdOut("The configuration has been stored in 'usb_2548_1001.xml'. Copy this file to ~/.userdata/peripheral_data to use it in XBMC");
  }

  g_parser->StandbyDevices();
  g_parser->Close();
  UnloadLibCec(g_parser);

  PrintToStdOut("Press enter to close this wizard.");
  string input;
  getline(cin, input);
  return 0;
}
Commit	Line	Data
f57cba64 LOK	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 "../../include/cec.h"
	34
	35	#include <cstdio>
	36	#include <fcntl.h>
	37	#include <iostream>
	38	#include <fstream>
	39	#include <string>
	40	#include <sstream>
	41	#include "../lib/platform/threads/mutex.h"
	42	#include "../lib/platform/util/timeutils.h"
	43	#include "../lib/implementations/CECCommandHandler.h"
	44
	45	using namespace CEC;
	46	using namespace std;
	47	using namespace PLATFORM;
	48
	49	#include <cecloader.h>
	50
	51	CMutex g_outputMutex;
	52
960f33c6	53	CEvent g_responseEvent;
f57cba64 LOK	54	cec_opcode g_lastCommand = CEC_OPCODE_NONE;
f57cba64 LOK	55
960f33c6	56	CEvent g_keyEvent;
f57cba64 LOK	57	cec_user_control_code g_lastKey = CEC_USER_CONTROL_CODE_UNKNOWN;
	58
	59	ICECCallbacks g_callbacks;
c7dc6e28	60	libcec_configuration g_config;
f57cba64	61	ICECAdapter * g_parser;
f57cba64 LOK	62
	63	inline void PrintToStdOut(const char *strFormat, ...)
	64	{
	65	CStdString strLog;
	66
	67	va_list argList;
	68	va_start(argList, strFormat);
	69	strLog.FormatV(strFormat, argList);
	70	va_end(argList);
	71
	72	CLockObject lock(g_outputMutex);
	73	cout << strLog << endl;
	74	}
	75
	76	//get the first word (separated by whitespace) from string data and place that in word
	77	//then remove that word from string data
	78	bool GetWord(string& data, string& word)
	79	{
	80	stringstream datastream(data);
	81	string end;
	82
	83	datastream >> word;
	84	if (datastream.fail())
	85	{
	86	data.clear();
	87	return false;
	88	}
	89
	90	size_t pos = data.find(word) + word.length();
	91
	92	if (pos >= data.length())
	93	{
	94	data.clear();
	95	return true;
	96	}
	97
	98	data = data.substr(pos);
	99
	100	datastream.clear();
	101	datastream.str(data);
	102
	103	datastream >> end;
	104	if (datastream.fail())
	105	data.clear();
	106
	107	return true;
	108	}
	109
	110	int CecLogMessage(void *UNUSED(cbParam), const cec_log_message &message)
	111	{
	112	switch (message.level)
	113	{
	114	case CEC_LOG_ERROR:
	115	PrintToStdOut("ERROR:\t%s", message.message);
	116	break;
	117	case CEC_LOG_WARNING:
	118	PrintToStdOut("ERROR:\t%s", message.message);
	119	break;
	120	default:
	121	break;
	122	}
	123
	124	return 0;
	125	}
126
127	int CecKeyPress(void *UNUSED(cbParam), const cec_keypress &key)
128	{
f57cba64	129	g_lastKey = key.keycode;
960f33c6	130	g_keyEvent.Signal();
f57cba64 LOK	131	return 0;
	132	}
	133
	134	int CecCommand(void *UNUSED(cbParam), const cec_command &command)
	135	{
f57cba64	136	g_lastCommand = command.opcode;
960f33c6	137	g_responseEvent.Signal();
f57cba64 LOK	138	return 0;
	139	}
	140
f57cba64 LOK	141	bool ProcessConsoleCommand(string &input)
	142	{
	143	if (!input.empty())
	144	{
	145	string command;
	146	if (GetWord(input, command))
	147	{
	148	if (command == "q" \|\| command == "quit")
	149	return false;
	150	}
	151	}
	152	return true;
	153	}
	154
	155	bool OpenConnection(cec_device_type type = CEC_DEVICE_TYPE_RECORDING_DEVICE)
	156	{
c7dc6e28 LOK	157	g_config.Clear();
	158	snprintf(g_config.strDeviceName, 13, "CEC-config");
	159	g_config.callbackParam = NULL;
eb617f35	160	g_config.clientVersion = (uint32_t)CEC_CLIENT_VERSION_1_6_2;
c7dc6e28 LOK	161	g_callbacks.CBCecLogMessage = &CecLogMessage;
	162	g_callbacks.CBCecKeyPress = &CecKeyPress;
	163	g_callbacks.CBCecCommand = &CecCommand;
	164	g_config.callbacks = &g_callbacks;
f57cba64	165
c7dc6e28 LOK	166	g_config.deviceTypes.add(type);
	167
	168	g_parser = LibCecInitialise(&g_config);
f57cba64 LOK	169	if (!g_parser)
	170	return false;
	171
	172	CStdString strPort;
	173	cec_adapter devices[10];
	174	uint8_t iDevicesFound = g_parser->FindAdapters(devices, 10, NULL);
	175	if (iDevicesFound <= 0)
	176	{
	177	PrintToStdOut("autodetect FAILED");
	178	UnloadLibCec(g_parser);
	179	return false;
	180	}
	181	else
	182	{
	183	strPort = devices[0].comm;
	184	}
	185
f57cba64	186	PrintToStdOut("opening a connection to the CEC adapter...");
f57cba64 LOK	187	if (!g_parser->Open(strPort.c_str()))
	188	{
	189	PrintToStdOut("unable to open the device on port %s", strPort.c_str());
	190	UnloadLibCec(g_parser);
	191	return false;
	192	}
	193
eb617f35 LOK	194	g_parser->GetCurrentConfiguration(&g_config);
eb617f35 LOK	195	PrintToStdOut("CEC Parser created - libCEC version %s", g_parser->ToString((cec_server_version)g_config.serverVersion));
f57cba64	196
f57cba64 LOK	197	return true;
	198	}
	199
	200	int8_t FindPhysicalAddressPortNumber(void)
	201	{
86393878	202	PrintToStdOut("Enter the HDMI port number to which you connected your CEC adapter, followed by <enter>. Valid ports are in the range 1-15. Anything else will cancel this wizard.");
f57cba64 LOK	203	string input;
	204	getline(cin, input);
	205	cin.clear();
86393878	206	if (input.empty())
f57cba64	207	return -1;
86393878	208
21d83978 LOK	209	int hdmiport = atoi(input.c_str());
21d83978 LOK	210	return (hdmiport < 1 \|\| hdmiport > 15) ? -1 : (int8_t)hdmiport;
f57cba64 LOK	211	}
	212
	213	cec_logical_address FindPhysicalAddressBaseDevice(void)
	214	{
eb617f35	215	PrintToStdOut("Press 1 if your CEC adapter is connected to your TV or\nPress 2 if it's connected to an AVR, followed by <enter>. Anything else will cancel this wizard.");
f57cba64 LOK	216
	217	string input;
	218	getline(cin, input);
	219	cin.clear();
	220	if (input.empty() \|\| (input != "1" && input != "2"))
	221	{
	222	PrintToStdOut("Exiting...");
	223	return CECDEVICE_UNKNOWN;
	224	}
	225	return (input == "2") ?
	226	CECDEVICE_AUDIOSYSTEM :
	227	CECDEVICE_TV;
	228	}
	229
	230	uint16_t FindPhysicalAddress(void)
	231	{
	232	PrintToStdOut("=== Physical Address Configuration ===\n");
b32ffd87	233	uint16_t iAddress(CEC_INVALID_PHYSICAL_ADDRESS);
f57cba64 LOK	234
	235	PrintToStdOut("Do you want to let libCEC try to autodetect the address (y/n)?");
	236	string input;
	237	getline(cin, input);
	238	cin.clear();
	239	if (input == "y" \|\| input == "Y")
	240	{
	241	cec_logical_address baseDevice = FindPhysicalAddressBaseDevice();
	242	if (baseDevice == CECDEVICE_UNKNOWN)
	243	return iAddress;
	244
	245	int8_t iPortNumber = FindPhysicalAddressPortNumber();
	246	if (iPortNumber == -1)
	247	return iAddress;
	248
	249	PrintToStdOut("Trying to detect the physical address...");
	250	if (!g_parser->SetHDMIPort(baseDevice, iPortNumber))
	251	PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
	252	else
	253	{
eb617f35 LOK	254	g_parser->GetCurrentConfiguration(&g_config);
eb617f35 LOK	255	iAddress = g_parser->GetDevicePhysicalAddress(g_config.logicalAddresses.primary);
b32ffd87	256	if (iAddress == 0 \|\| iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
f57cba64 LOK	257	PrintToStdOut("Failed. Please enter the address manually, or restart this wizard and use different settings.");
	258	}
	259	}
	260
b32ffd87	261	if (iAddress == 0 \|\| iAddress == CEC_INVALID_PHYSICAL_ADDRESS)
f57cba64	262	{
b32ffd87	263	PrintToStdOut("Please enter the physical address (0001 - FFFE), followed by <enter>.");
f57cba64 LOK	264	getline(cin, input);
	265	cin.clear();
	266
	267	int iAddressTmp;
	268	if (sscanf(input.c_str(), "%x", &iAddressTmp) == 1)
	269	{
b32ffd87 LOK	270	if (iAddressTmp <= CEC_PHYSICAL_ADDRESS_TV \|\| iAddressTmp > CEC_MAX_PHYSICAL_ADDRESS)
b32ffd87 LOK	271	iAddressTmp = CEC_INVALID_PHYSICAL_ADDRESS;
f57cba64 LOK	272	iAddress = (uint16_t)iAddressTmp;
	273	}
	274	}
	275
9a5fc0e8 LOK	276	if (iAddress != 0)
	277	{
	278	g_parser->SetPhysicalAddress(iAddress);
	279	g_parser->SetActiveSource(g_config.deviceTypes[0]);
	280	}
	281
f57cba64 LOK	282	return iAddress;
	283	}
	284
9a5fc0e8	285	bool PowerOnTV(uint64_t iTimeout = 60000)
f57cba64 LOK	286	{
	287	cec_power_status currentTvPower(CEC_POWER_STATUS_UNKNOWN);
	288	uint64_t iNow = GetTimeMs();
	289	uint64_t iTarget = iNow + iTimeout;
f57cba64	290
9a5fc0e8	291	if (currentTvPower != CEC_POWER_STATUS_ON)
f57cba64 LOK	292	{
	293	currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);
	294	if (currentTvPower != CEC_POWER_STATUS_ON)
	295	{
9a5fc0e8	296	PrintToStdOut("Sending 'power on' command to the TV\n=== Please wait ===");
f57cba64 LOK	297	g_parser->PowerOnDevices(CECDEVICE_TV);
	298	while (iTarget > iNow)
	299	{
960f33c6	300	g_responseEvent.Wait((uint32_t)(iTarget - iNow));
f57cba64 LOK	301	if (g_lastCommand == CEC_OPCODE_REQUEST_ACTIVE_SOURCE)
	302	break;
	303	iNow = GetTimeMs();
	304	}
	305	}
	306	}
	307
	308	currentTvPower = g_parser->GetDevicePowerStatus(CECDEVICE_TV);
	309
	310	if (currentTvPower != CEC_POWER_STATUS_ON)
	311	PrintToStdOut("Failed to power on the TV, or the TV does not respond properly");
	312
	313	return currentTvPower == CEC_POWER_STATUS_ON;
	314	}
	315
39b1216c	316	int main (int UNUSED(argc), char *UNUSED(argv[]))
f57cba64	317	{
38f1fbcc LOK	318	g_callbacks.Clear();
38f1fbcc LOK	319	g_config.Clear();
f57cba64 LOK	320	PrintToStdOut("=== USB-CEC Adapter Configuration ===\n");
	321	if (!OpenConnection())
	322	return 1;
	323
	324	if (!PowerOnTV())
	325	return 1;
	326
	327	bool bAddressOk(false);
f57cba64 LOK	328	while (!bAddressOk)
f57cba64 LOK	329	{
d40928b5	330	uint16_t iAddress = FindPhysicalAddress();
f57cba64 LOK	331
	332	PrintToStdOut("Physical address: %4X", iAddress);
	333	PrintToStdOut("Is this correct (y/n)?");
	334	string input;
	335	getline(cin, input);
	336	cin.clear();
	337	bAddressOk = (input == "y" \|\| input == "Y");
	338	}
	339
b0a7410c	340	g_parser->GetCurrentConfiguration(&g_config);
caca2d81	341
b0a7410c LOK	342	{
	343	cec_menu_language lang;
	344	if (g_parser->GetDeviceMenuLanguage(CECDEVICE_TV, &lang))
	345	{
	346	PrintToStdOut("TV menu language: %s", lang.language);
	347	PrintToStdOut("Do you want the application to use the menu language of the TV (y/n)?");
	348	string input;
	349	getline(cin, input);
	350	cin.clear();
9a5fc0e8	351	g_config.bUseTVMenuLanguage = (input == "y" \|\| input == "Y") ? 1 : 0;
b0a7410c LOK	352	}
	353	else
	354	{
	355	PrintToStdOut("The TV did not respond properly to the menu language request.");
	356	}
	357	}
	358
b0a7410c	359	{
ca27e6cf	360	PrintToStdOut("Do you want to make the CEC adapter the active source when starting the application (y/n)?");
b0a7410c LOK	361	string input;
	362	getline(cin, input);
	363	cin.clear();
ca27e6cf	364	g_config.bActivateSource = (input == "y" \|\| input == "Y") ? 1 : 0;
b0a7410c LOK	365	}
b0a7410c LOK	366
eb617f35 LOK	367	{
	368	PrintToStdOut("Do you want to power on the TV when starting the application (y/n)?");
	369	string input;
	370	getline(cin, input);
	371	cin.clear();
	372	if (input == "y" \|\| input == "Y")
	373	g_config.wakeDevices.Set(CECDEVICE_TV);
	374	}
	375
b0a7410c LOK	376	{
	377	PrintToStdOut("Do you want to power off CEC devices when closing the application (y/n)?");
	378	string input;
	379	getline(cin, input);
	380	cin.clear();
ca27e6cf	381	if (input == "y" \|\| input == "Y")
eb617f35	382	g_config.powerOffDevices.Set(CECDEVICE_TV);
b0a7410c LOK	383	}
b0a7410c LOK	384
b0a7410c LOK	385	{
	386	PrintToStdOut("Do you want to power off CEC devices when the screensaver is activated (y/n)?");
	387	string input;
	388	getline(cin, input);
	389	cin.clear();
9a5fc0e8	390	g_config.bPowerOffScreensaver = (input == "y" \|\| input == "Y") ? 1 : 0;
b0a7410c LOK	391	}
b0a7410c LOK	392
b0a7410c LOK	393	{
	394	PrintToStdOut("Do you want to put the PC in standby when the TV is put in standby mode (y/n)?");
	395	string input;
	396	getline(cin, input);
	397	cin.clear();
41e3372a LOK	398	g_config.bPowerOffOnStandby = (input == "y" \|\| input == "Y") ? 1 : 0;
	399	}
	400
	401	{
	402	PrintToStdOut("Do you want to send an inactive source message when stopping the application (y/n)?");
	403	string input;
	404	getline(cin, input);
	405	cin.clear();
	406	g_config.bSendInactiveSource = (input == "y" \|\| input == "Y") ? 1 : 0;
b0a7410c LOK	407	}
	408
	409	PrintToStdOut("\n\n=== USB-CEC Adapter Configuration Summary ===");
	410	PrintToStdOut("HDMI port number: %d", g_config.iHDMIPort);
	411	PrintToStdOut("Connected to HDMI device: %X", (uint8_t)g_config.baseDevice);
	412	PrintToStdOut("Physical address: %4X", g_config.iPhysicalAddress);
9a5fc0e8	413	PrintToStdOut("Use the TV's language setting: %s", g_config.bUseTVMenuLanguage ? "yes" : "no");
ca27e6cf	414	PrintToStdOut("Make the adapter the active source when starting XBMC: %s", g_config.bActivateSource ? "yes" : "no");
eb617f35	415	PrintToStdOut("Power on the TV when starting XBMC: %s", g_config.wakeDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
ca27e6cf	416	PrintToStdOut("Power off devices when stopping XBMC: %s", g_config.powerOffDevices.IsSet(CECDEVICE_BROADCAST) ? "yes" : "no");
9a5fc0e8	417	PrintToStdOut("Put devices in standby mode when activating screensaver: %s", g_config.bPowerOffScreensaver ? "yes" : "no");
41e3372a	418	PrintToStdOut("Put this PC in standby mode when the TV is switched off: %s", g_config.bPowerOffOnStandby ? "yes" : "no");
eb617f35	419	PrintToStdOut("Send an inactive source message when stopping XBMC: %s\n\n", g_config.bSendInactiveSource ? "yes" : "no");
9a5fc0e8	420
eb617f35 LOK	421	PrintToStdOut("Storing settings ...");
	422	if (g_parser->PersistConfiguration(&g_config))
	423	PrintToStdOut("Settings stored.");
9a5fc0e8	424	else
eb617f35	425	PrintToStdOut("The settings could not be stored");
1361efd2	426
eb617f35 LOK	427	ofstream configOutput;
	428	configOutput.open("usb_2548_1001.xml");
	429	if (configOutput.is_open())
	430	{
	431	CStdString strWakeDevices;
	432	for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
	433	if (g_config.wakeDevices[iPtr])
	434	strWakeDevices.AppendFormat(" %d" + iPtr);
	435	CStdString strStandbyDevices;
	436	for (uint8_t iPtr = 0; iPtr < 16; iPtr++)
	437	if (g_config.powerOffDevices[iPtr])
	438	strStandbyDevices.AppendFormat(" %d" + iPtr);
	439
	440	configOutput <<
1361efd2	441	"<settings>\n" <<
41e3372a LOK	442	"\t<setting id=\"enabled\" value=\"1\" />\n" <<
41e3372a LOK	443	"\t<setting id=\"activate_source\" value=\"" << (int)g_config.bActivateSource << "\" />\n" <<
be54289b LOK	444	"\t<setting id=\"wake_devices\" value=\"" << strWakeDevices.c_str() << "\" />\n" <<
be54289b LOK	445	"\t<setting id=\"standby_devices\" value=\"" << strStandbyDevices.c_str() << "\" />\n" <<
1361efd2 LOK	446	"\t<setting id=\"cec_standby_screensaver\" value=\"" << (int)g_config.bPowerOffScreensaver << "\" />\n" <<
1361efd2 LOK	447	"\t<setting id=\"standby_pc_on_tv_standby\" value=\"" << (int)g_config.bPowerOffOnStandby << "\" />\n" <<
41e3372a LOK	448	"\t<setting id=\"use_tv_menu_language\" value=\"" << (int)g_config.bUseTVMenuLanguage << "\" />\n" <<
	449	"\t<setting id=\"physical_address\" value=\"" << hex << g_config.iPhysicalAddress << "\" />\n" <<
	450	"\t<setting id=\"cec_hdmi_port\" value=\"" << g_config.iHDMIPort << "\" />\n" <<
	451	"\t<setting id=\"connected_device\" value=\"" << (int)g_config.baseDevice << "\" />\n" <<
1361efd2	452	"\t<setting id=\"port\" value=\"\" />\n" <<
41e3372a	453	"\t<setting id=\"send_inactive_source\" value=\"" << (int)g_config.bSendInactiveSource << "\" />\n" <<
1361efd2	454	"</settings>";
eb617f35	455	configOutput.close();
1361efd2	456
eb617f35	457	PrintToStdOut("The configuration has been stored in 'usb_2548_1001.xml'. Copy this file to ~/.userdata/peripheral_data to use it in XBMC");
9a5fc0e8	458	}
f57cba64 LOK	459
	460	g_parser->StandbyDevices();
	461	g_parser->Close();
	462	UnloadLibCec(g_parser);
	463
	464	PrintToStdOut("Press enter to close this wizard.");
	465	string input;
	466	getline(cin, input);
	467	return 0;
	468	}