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