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