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