vvideolivetv.cc

   1 /*
   2     Copyright 2007-2008 Chris Tallon
   3
   4     This file is part of VOMP.
   5
   6     VOMP is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     VOMP is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with VOMP; if not, write to the Free Software
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19 */
  20
  21 #include "vvideolivetv.h"
  22
  23 #include "vchannellist.h"
  24 #include "video.h"
  25 #include "playerlive.h"
  26 #include "playerlivetv.h"
  27 #include "playerliveradio.h"
  28 #include "channel.h"
  29 #include "boxstack.h"
  30 #include "colour.h"
  31 #include "osd.h"
  32 #include "command.h"
  33 #include "i18n.h"
  34 #include "wtextbox.h"
  35 #include "remote.h"
  36 #include "vaudioselector.h"
  37 #include "colour.h"
  38 #include "event.h"
  39 #include "timers.h"
  40 #include "vepg.h"
  41
  42 VVideoLiveTV::VVideoLiveTV(ChannelList* tchanList, ULONG initialChannelNumber, VChannelList* tvchannelList)
  43 {
  44   vdr = VDR::getInstance();
  45   boxstack = BoxStack::getInstance();
  46   video = Video::getInstance();
  47
  48   vas = NULL;
  49
  50   chanList = tchanList;
  51   vchannelList = tvchannelList;
  52   numberWidth = (int)VDR::getInstance()->getChannelNumberWidth();
  53
  54   currentChannelIndex = 0;
  55   previousChannelIndex = 0;
  56   osdChannelIndex = 0;
  57   keying = 0;
  58   preBuffering = 0;
  59
  60   playing = false;
  61
  62   // Convert channel number to index
  63   UINT i;
  64   for(i = 0; i < chanList->size(); i++)
  65   {
  66     if ((*chanList)[i]->number == (UINT)initialChannelNumber)
  67     {
  68       currentChannelIndex = i;
  69       osdChannelIndex = i;
  70       break;
  71     }
  72   }
  73
  74   eventList = NULL;
  75
  76   videoMode = video->getMode();
  77
  78   if ((*chanList)[currentChannelIndex]->type == VDR::VIDEO)
  79   {
  80     streamType = VDR::VIDEO;
  81     player = new PlayerLiveTV(Command::getInstance(), this, chanList);
  82   }
  83   else
  84   {
  85     streamType = VDR::RADIO;
  86     player = new PlayerLiveRadio(Command::getInstance(), this, chanList);
  87   }
  88   player->init();
  89
  90   setSize(video->getScreenWidth(), video->getScreenHeight());
  91   createBuffer();
  92   Colour transparent(0, 0, 0, 0);
  93   setBackgroundColour(transparent);
  94
  95   dowss = false;
  96   char* optionWSS = vdr->configLoad("General", "WSS");
  97   if (optionWSS)
  98   {
  99     if (strstr(optionWSS, "Yes")) dowss = true;
 100     delete[] optionWSS;
 101   }
 102   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Do WSS: %u", dowss);
 103
 104   if (dowss)
 105   {
 106     wss.setFormat(video->getFormat());
 107     wss.setWide(true);
 108     add(&wss);
 109
 110     wssRegion.x = 0;
 111     wssRegion.y = 6;
 112     wssRegion.w = video->getScreenWidth();
 113     wssRegion.h = 2;
 114   }
 115
 116   Colour osdBack = Colour(0, 0, 0, 128);
 117
 118   osd.setBackgroundColour(osdBack);
 119   osd.setPosition(0, video->getScreenHeight() - 150);
 120   osd.setSize(video->getScreenWidth(), 150);
 121   osd.setVisible(false);
 122   add(&osd);
 123
 124   clock.setBackgroundColour(osdBack);
 125   clock.setPosition(osd.getWidth() - 100, 4);
 126   clock.setSize(90, 30);
 127   osd.add(&clock);
 128
 129   osdChanNum.setBackgroundColour(osdBack);
 130   osdChanNum.setPosition(40, 4);
 131   osdChanNum.setSize((numberWidth*10) + 22, 30); // 10 px = width of number chars in font
 132   osd.add(&osdChanNum);
 133
 134   osdChanName.setBackgroundColour(osdBack);
 135   osdChanName.setPosition(osdChanNum.getX2() + 10, 4);
 136   osdChanName.setSize(300, 30);
 137   osd.add(&osdChanName);
 138
 139   boxRed.setBackgroundColour(Colour::RED);
 140   boxRed.setPosition(50, 104);
 141   boxRed.setSize(18, 16);
 142   osd.add(&boxRed);
 143
 144   boxGreen.setBackgroundColour(Colour::GREEN);
 145   boxGreen.setPosition(220, 104);
 146   boxGreen.setSize(18, 16);
 147   osd.add(&boxGreen);
 148
 149   boxYellow.setBackgroundColour(Colour::YELLOW);
 150   boxYellow.setPosition(390, 104);
 151   boxYellow.setSize(18, 16);
 152   osd.add(&boxYellow);
 153
 154   boxBlue.setBackgroundColour(Colour::BLUE);
 155   boxBlue.setPosition(560, 104);
 156   boxBlue.setSize(18, 16);
 157   osd.add(&boxBlue);
 158
 159   textRed.setBackgroundColour(osdBack);
 160   textRed.setPosition(boxRed.getX()+18, 98);
 161   textRed.setSize(120, 30);
 162   textRed.setText(tr("Summary"));
 163   osd.add(&textRed);
 164
 165   if (streamType == VDR::VIDEO)
 166   {
 167     textGreen.setBackgroundColour(osdBack);
 168     textGreen.setPosition(boxGreen.getX()+18, 98);
 169     textGreen.setSize(120, 30);
 170     textGreen.setText(tr("Audio"));
 171     osd.add(&textGreen);
 172   }
 173
 174   textYellow.setBackgroundColour(osdBack);
 175   textYellow.setPosition(boxYellow.getX()+18, 98);
 176   textYellow.setSize(120, 30);
 177   textYellow.setText("");
 178   osd.add(&textYellow);
 179
 180   textBlue.setBackgroundColour(osdBack);
 181   textBlue.setPosition(boxBlue.getX()+18, 98);
 182   textBlue.setSize(90, 30);
 183   textBlue.setText(tr("EPG"));
 184   osd.add(&textBlue);
 185
 186   sl.setBackgroundColour(osdBack);
 187   sl.setPosition(70, 36);
 188   sl.setSize(500, 58);
 189   sl.setNoLoop();
 190   osd.add(&sl);
 191
 192   // Summary Box
 193   summary.setBackgroundColour(osdBack);
 194   summary.setPosition(0, video->getScreenHeight() - 300);
 195   summary.setSize(video->getScreenWidth(), 150);
 196   summary.setVisible(false);
 197   add(&summary);
 198
 199   textSummary.setBackgroundColour(osdBack);
 200   textSummary.setPosition(40, 10);
 201   textSummary.setSize(video->getScreenWidth() - 80, 130);
 202   textSummary.setParaMode(true);
 203   summary.add(&textSummary);
 204
 205   summaryBlackLine.setBackgroundColour(Colour::BLACK);
 206   summaryBlackLine.setPosition(0, summary.getHeight() - 4);
 207   summaryBlackLine.setSize(summary.getWidth(), 4);
 208   summary.add(&summaryBlackLine);
 209
 210   sAspectRatio.setPosition(osd.getWidth() - 90, 40);
 211   sAspectRatio.nextColour = Colour::SELECTHIGHLIGHT;
 212   sAspectRatio.setVisible(false);
 213   osd.add(&sAspectRatio);
 214
 215   bufferBar.setPosition(osd.getWidth() - 90, 70);
 216   bufferBar.setSize(40, 20);
 217   bufferBar.setVisible(true);
 218   osd.add(&bufferBar);
 219
 220   sAudioChannels.setPosition(osd.getWidth() - 130, 40);
 221   sAudioChannels.nextColour = Colour::SELECTHIGHLIGHT;
 222   sAudioChannels.setVisible(false);
 223   osd.add(&sAudioChannels);
 224
 225   textUnavailable.setBackgroundColour(osdBack);
 226   textUnavailable.setPosition(60, 30);
 227   textUnavailable.setSize(osd.getWidth() - 120, 30);
 228   textUnavailable.setText(tr("Channel Unavailable"));
 229   textUnavailable.setVisible(false);
 230   add(&textUnavailable);
 231
 232   // FIXME painful
 233   Region r1 = summary.getRegionR();
 234   Region r2 = osd.getRegionR();
 235   osdSummaryRegion = r1 + r2;
 236 }
 237
 238 VVideoLiveTV::~VVideoLiveTV()
 239 {
 240   if (playing) stop();
 241
 242   delete player;
 243   video->setDefaultAspect();
 244   delData();
 245 }
 246
 247 void VVideoLiveTV::delData()
 248 {
 249   if (eventList)
 250   {
 251     int eventListSize = eventList->size();
 252     for(int i = 0; i < eventListSize; i++)
 253     {
 254       delete (*eventList)[i];
 255     }
 256     eventList->clear();
 257     delete eventList;
 258
 259   }
 260   sl.clear();
 261 }
 262
 263 int VVideoLiveTV::handleCommand(int command)
 264 {
 265   switch(command)
 266   {
 267     case Remote::BACK:
 268     {
 269       if (osd.getVisible())
 270       {
 271         clearScreen();
 272         return 2;
 273       }
 274       // else drop through to stop
 275     }
 276     case Remote::STOP:
 277     {
 278       stop();
 279       vchannelList->highlightChannel((*chanList)[currentChannelIndex]);
 280       return 4;
 281     }
 282     case Remote::UP:
 283     {
 284       // New remote only
 285       // epg data up
 286       doUpDown(false);
 287       return 2;
 288     }
 289     case Remote::DOWN:
 290     {
 291       // New remote only
 292       // epg data down
 293       doUpDown(true);
 294       return 2;
 295     }
 296     case Remote::LEFT:
 297     {
 298       // New remote only
 299       // epg data ch down
 300       doLeftRight(false);
 301       return 2;
 302     }
 303     case Remote::RIGHT:
 304     {
 305       // New remote only
 306       // epg data ch up
 307       doLeftRight(true);
 308       return 2;
 309     }
 310     case Remote::DF_UP:
 311     {
 312       // Old remote, decide what to do based on whether the osd is showing
 313       if (osd.getVisible()) doUpDown(false);
 314       else doChanUpDown(UP);
 315       return 2;
 316     }
 317     case Remote::DF_DOWN:
 318     {
 319       // Old remote, decide what to do based on whether the osd is showing
 320       if (osd.getVisible()) doUpDown(true);
 321       else doChanUpDown(DOWN);
 322       return 2;
 323     }
 324     case Remote::CHANNELUP:
 325     {
 326       doChanUpDown(UP);
 327       return 2;
 328     }
 329     case Remote::CHANNELDOWN:
 330     {
 331       doChanUpDown(DOWN);
 332       return 2;
 333     }
 334     case Remote::PREVCHANNEL:
 335     {
 336       channelChange(PREVIOUS, 0);
 337       osdChannelIndex = currentChannelIndex;
 338       displayOSD(true);
 339       return 2;
 340     }
 341     case Remote::OK:
 342     {
 343       doOK();
 344       return 2;
 345     }
 346     case Remote::RED:
 347     case Remote::MENU:
 348     {
 349       doSummary();
 350       return 2;
 351     }
 352     case Remote::FULL:
 353     case Remote::TV:
 354     {
 355       toggleChopSides();
 356       return 2;
 357     }
 358
 359     case Remote::ZERO:
 360     case Remote::ONE:
 361     case Remote::TWO:
 362     case Remote::THREE:
 363     case Remote::FOUR:
 364     case Remote::FIVE:
 365     case Remote::SIX:
 366     case Remote::SEVEN:
 367     case Remote::EIGHT:
 368     case Remote::NINE:
 369     {
 370       // key in channel number
 371       doKey(command);
 372       return 2;
 373     }
 374
 375     case Remote::GREEN:
 376     {
 377       if (streamType == VDR::VIDEO) doAudioSelector();
 378       return 2;
 379     }
 380     case Remote::YELLOW:
 381     {
 382       return 2;
 383     }
 384     case Remote::GUIDE:
 385     case Remote::BLUE:
 386     {
 387       doEPG();
 388       return 2;
 389     }
 390   }
 391
 392   return 1;
 393 }
 394
 395 void VVideoLiveTV::go()
 396 {
 397   playing = true;
 398   draw();
 399   boxstack->update(this);
 400
 401   setClock();
 402   displayOSD(true);
 403
 404   player->go(currentChannelIndex);
 405 }
 406
 407 void VVideoLiveTV::stop()
 408 {
 409   Timers::getInstance()->cancelTimer(this, 1);
 410   Timers::getInstance()->cancelTimer(this, 2);
 411   player->stop();
 412   playing = false;
 413 }
 414
 415 void VVideoLiveTV::doLeftRight(bool right)
 416 {
 417   if (osd.getVisible())
 418   {
 419     if (right) osdChannelIndex = upChannel(osdChannelIndex);
 420     else       osdChannelIndex = downChannel(osdChannelIndex);
 421   }
 422   else
 423   {
 424     osdChannelIndex = currentChannelIndex;
 425   }
 426   displayOSD(true);
 427 }
 428
 429 void VVideoLiveTV::doUpDown(bool down)
 430 {
 431   if (osd.getVisible())
 432   {
 433     if (down) sl.down();
 434     else      sl.up();
 435     sl.draw();
 436
 437     displayOSD(false);
 438   }
 439   else
 440   {
 441     displayOSD(true);
 442   }
 443 }
 444
 445 void VVideoLiveTV::doChanUpDown(int which)
 446 {
 447   channelChange(OFFSET, which);
 448   osdChannelIndex = currentChannelIndex;
 449   displayOSD(true);
 450 }
 451
 452 void VVideoLiveTV::doOK()
 453 {
 454   if (osd.getVisible())
 455   {
 456     if (keying)
 457     {
 458       UINT newChannel = 0;
 459       for(int i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 460
 461       channelChange(NUMBER, newChannel);
 462       osdChannelIndex = currentChannelIndex;
 463       displayOSD(true);
 464     }
 465     else if (osdChannelIndex == currentChannelIndex)
 466     {
 467       clearScreen();
 468     }
 469     else
 470     {
 471       channelChange(INDEX, osdChannelIndex);
 472       displayOSD(true);
 473     }
 474   }
 475   else
 476   {
 477     osdChannelIndex = currentChannelIndex;
 478     displayOSD(true);
 479   }
 480 }
 481
 482 void VVideoLiveTV::doSummary()
 483 {
 484   if (summary.getVisible())
 485   {
 486     summary.setVisible(false);
 487     draw();
 488     boxstack->update(this, summary.getRegion());
 489     Timers::getInstance()->setTimerD(this, 1, 8); // Restart a timer to get rid of osd
 490     return;
 491   }
 492
 493   summary.setVisible(true);
 494
 495   if (osd.getVisible())
 496   {
 497     Timers::getInstance()->cancelTimer(this, 1);
 498     displayOSD(false);
 499   }
 500   else
 501   {
 502     displayOSD(true);
 503   }
 504 }
 505
 506 void VVideoLiveTV::doKey(int command)
 507 {
 508   if (!osd.getVisible()) // First key. prep the data
 509   {
 510     setNowNextData();
 511     keying = 0;
 512   }
 513
 514   int i;
 515   for (i = keying - 1; i >= 0; i--) keyingInput[i+1] = keyingInput[i];
 516   keyingInput[0] = command;
 517   keying++;
 518
 519   char* keyingString = new char[numberWidth + 1];
 520   for (i = 0; i < numberWidth; i++) keyingString[i] = '_';
 521   keyingString[numberWidth] = '\0';
 522
 523   for (i = 0; i < keying; i++) keyingString[i] = keyingInput[keying - 1 - i] + 48;
 524
 525   if (keying == numberWidth)
 526   {
 527     UINT newChannel = 0;
 528     for(i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 529
 530     channelChange(NUMBER, newChannel);
 531     osdChannelIndex = currentChannelIndex;
 532     Timers::getInstance()->cancelTimer(this, 1); // cancel the timer to react to keying input,
 533     displayOSD(true); // this will put one back if required
 534   }
 535   else
 536   {
 537     osdChanNum.setText(keyingString);
 538
 539     if (!osd.getVisible())
 540     {
 541       osd.setVisible(true);
 542       draw();
 543     }
 544     else
 545     {
 546       osdChanNum.draw();
 547     }
 548     boxstack->update(this, osd.getRegion());
 549     Timers::getInstance()->setTimerD(this, 1, 3);  // 3s for keying input
 550   }
 551   delete[] keyingString;
 552 }
 553
 554 void VVideoLiveTV::doAudioSelector()
 555 {
 556   // If the osd is already visisble there might be a timer for it
 557   Timers::getInstance()->cancelTimer(this, 1);
 558
 559   // Cancel keying
 560   if (keying)
 561   {
 562     keying = 0;
 563     // and reset the display - this is a copy from setNowNextData
 564     char formatChanNum[20];
 565     SNPRINTF(formatChanNum, 19, "%0*lu", numberWidth, (*chanList)[osdChannelIndex]->number);
 566     osdChanNum.setText(formatChanNum);
 567     osdChanName.setText((*chanList)[osdChannelIndex]->name);
 568   }
 569
 570   // Draw the selector
 571   vas = new VAudioSelector(this, (*chanList)[currentChannelIndex], ((PlayerLiveTV*)player)->getCurrentAudioChannel());
 572   Colour osdBack = Colour(0, 0, 0, 128);
 573   vas->setBackgroundColour(osdBack);
 574   vas->setPosition(0, osd.getScreenY() - vas->getHeight());
 575   vas->draw();
 576
 577   // make vas != null and displayOSD will not set a timer or do any boxstack update
 578   summary.setVisible(false);
 579   if (osd.getVisible()) displayOSD(false);
 580   else displayOSD(true);
 581   draw();
 582
 583   BoxStack::getInstance()->add(vas);
 584   BoxStack::getInstance()->update(this);
 585   BoxStack::getInstance()->update(vas);
 586 }
 587
 588 void VVideoLiveTV::doEPG()
 589 {
 590   if (osd.getVisible()) clearScreen();
 591
 592   video->setMode(Video::QUARTER);
 593   video->setPosition(170, 5); //TODO need to deal with 4:3 switching
 594
 595   VEpg* vepg = new VEpg(this, currentChannelIndex, VDR::VIDEO);
 596   vepg->draw();
 597   boxstack->add(vepg);
 598   boxstack->update(vepg);
 599 }
 600
 601 void VVideoLiveTV::setNowNextData()
 602 {
 603   delData();
 604
 605   Channel* currentChannel = (*chanList)[osdChannelIndex];
 606
 607   char formatChanNum[20];
 608   SNPRINTF(formatChanNum, 19, "%0*lu", numberWidth, currentChannel->number);
 609   osdChanNum.setText(formatChanNum);
 610   osdChanName.setText(currentChannel->name);
 611
 612   eventList = VDR::getInstance()->getChannelSchedule(currentChannel->number);
 613
 614   if (!eventList)
 615   {
 616     sl.addOption(tr("No channel data available"), 0, 1);
 617   }
 618   else
 619   {
 620     sort(eventList->begin(), eventList->end(), EventSorter());
 621
 622     char tempString[300];
 623     char tempString2[300];
 624     struct tm* btime;
 625     Event* event;
 626     int eventListSize = eventList->size();
 627     for(int i = 0; i < eventListSize; i++)
 628     {
 629       event = (*eventList)[i];
 630
 631       //btime = localtime((time_t*)&event->time);
 632       time_t etime = event->time;
 633       btime = localtime(&etime);
 634 #ifndef _MSC_VER
 635       strftime(tempString2, 299, "%0H:%0M ", btime);
 636 #else
 637       strftime(tempString2, 299, "%H:%M ", btime);
 638 #endif
 639       SNPRINTF(tempString, 299, "%s %s", tempString2, event->title);
 640
 641       sl.addOption(tempString, (ULONG)event, (i==0));
 642     }
 643   }
 644 }
 645
 646 void VVideoLiveTV::setSummaryData()
 647 {
 648   // If osd is not being displayed, sl will be filled with now, current channel
 649   // If the display was already on, sl will have programme to show summary for, not necessarily current channel and now
 650   Event* selectedEvent = (Event*)sl.getCurrentOptionData();
 651
 652   if (!selectedEvent)
 653   {
 654     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "No summary");
 655     textSummary.setText(tr("No summary available"));
 656   }
 657   else
 658   {
 659     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Summary: %s", selectedEvent->description);
 660     textSummary.setText(selectedEvent->description);
 661   }
 662 }
 663
 664 void VVideoLiveTV::displayOSD(bool newNowNextData)
 665 {
 666   osd.setVisible(true);
 667   if (newNowNextData)
 668   {
 669     setNowNextData();
 670     keying = 0;
 671   }
 672   osd.draw();
 673
 674   if (summary.getVisible())
 675   {
 676     setSummaryData();
 677     summary.draw();
 678     boxstack->update(this, &osdSummaryRegion);
 679   }
 680   else
 681   {
 682     boxstack->update(this, osd.getRegion());
 683   }
 684
 685   bool setTimer = true;
 686   if (vas) setTimer = false;
 687   if (summary.getVisible()) setTimer = false;
 688   if (textUnavailable.getVisible()) setTimer = false;
 689
 690   if (setTimer) Timers::getInstance()->setTimerD(this, 1, 4);
 691 }
 692
 693 void VVideoLiveTV::clearScreen()
 694 {
 695   if (!summary.getVisible()) Timers::getInstance()->cancelTimer(this, 1);
 696
 697   textUnavailable.setVisible(false);
 698   osd.setVisible(false);
 699   summary.setVisible(false);
 700
 701   draw();
 702   boxstack->update(this);
 703 }
 704
 705 void VVideoLiveTV::showUnavailable()
 706 {
 707   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Show unavailable called");
 708   textUnavailable.setVisible(true);
 709   textUnavailable.draw();
 710
 711   if (!osd.getVisible()) displayOSD(true);
 712
 713   boxstack->update(this, textUnavailable.getRegion());
 714 }
 715
 716 void VVideoLiveTV::setClock()
 717 {
 718   char timeString[20];
 719   time_t t;
 720   time(&t);
 721   struct tm* tms = localtime(&t);
 722   strftime(timeString, 19, "%H:%M", tms);
 723   clock.setText(timeString);
 724
 725   time_t dt = 60 - (t % 60);  // seconds to the next minute
 726   if (dt == 0) dt = 60; // advance a whole minute if necessary
 727   dt += t;  // get a time_t value for it rather than using duration
 728   // (so it will occur at the actual second and not second and a half)
 729
 730   Timers::getInstance()->setTimerT(this, 2, dt);
 731 }
 732
 733 void VVideoLiveTV::timercall(int ref)
 734 {
 735   if (ref == 1)
 736   {
 737     if (keying)
 738     {
 739       UINT newChannel = 0;
 740       for(int i = keying - 1; i >= 0; i--) newChannel += keyingInput[i] * (ULONG)pow(10., i);
 741
 742       Message* m = new Message();
 743       m->message = Message::CHANNEL_CHANGE;
 744       m->to = this;
 745       m->parameter = newChannel;
 746       m->tag = 1; // signal to call displayOSD();
 747       Command::getInstance()->postMessageFromOuterSpace(m);
 748     }
 749     else
 750     {
 751       // We have received a timer, we are not keying. If still prebuffering, don't remove the bar
 752       if (preBuffering < 100)
 753       {
 754         Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Still prebuffering, not removing osd...");
 755         Timers::getInstance()->setTimerD(this, 1, 2); // reset timer for another 2s
 756         return;
 757       }
 758
 759       osd.setVisible(false);
 760       draw();
 761       boxstack->update(this, osd.getRegion());
 762     }
 763   }
 764   else if (ref == 2)
 765   {
 766     setClock();
 767     if (osd.getVisible())
 768     {
 769       clock.draw();
 770       boxstack->update(this, osd.getRegion());
 771     }
 772   }
 773 }
 774
 775 bool VVideoLiveTV::channelChange(UCHAR changeType, UINT newData)
 776 {
 777   UINT newChannel = 0;
 778
 779   if (changeType == INDEX)
 780   {
 781     newChannel = newData;
 782   }
 783   else if (changeType == NUMBER)
 784   {
 785     UINT i;
 786     for(i = 0; i < chanList->size(); i++)
 787     {
 788       if ((*chanList)[i]->number == (UINT)newData)
 789       {
 790         newChannel = i;
 791         break;
 792       }
 793     }
 794
 795     if (i == chanList->size())
 796     {
 797       // no such channel
 798       return false;
 799     }
 800   }
 801   else if (changeType == OFFSET)
 802   {
 803     if (newData == UP) newChannel = upChannel(currentChannelIndex);
 804     else newChannel = downChannel(currentChannelIndex);
 805   }
 806   else if (changeType == PREVIOUS)
 807   {
 808     newChannel = previousChannelIndex;
 809   }
 810   else
 811   {
 812     return false; // bad input
 813   }
 814
 815   if (newChannel == currentChannelIndex) return true;
 816
 817   previousChannelIndex = currentChannelIndex;
 818   currentChannelIndex = newChannel;
 819
 820   preBuffering = 0;
 821
 822   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Set player to channel %u", currentChannelIndex);
 823   player->setChannel(currentChannelIndex);
 824   Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Done Set player to channel %u", currentChannelIndex);
 825
 826   // Blank out the symbols
 827   sAspectRatio.setVisible(false);
 828   bufferBar.setPercent(0);
 829   sAudioChannels.setVisible(false);
 830
 831   // Remove other stuff
 832   if (textUnavailable.getVisible())
 833   {
 834     textUnavailable.setVisible(false);
 835     draw();
 836     BoxStack::getInstance()->update(this);
 837   }
 838
 839   return true;
 840 }
 841
 842 void VVideoLiveTV::processMessage(Message* m)
 843 {
 844   if (m->message == Message::MOUSE_LBDOWN)
 845   {
 846     //check if press is outside this view! then simulate cancel
 847     int x=(m->parameter>>16)-osd.getScreenX();
 848     int y=(m->parameter&0xFFFF)-osd.getScreenY();
 849     if (osd.getVisible()) {
 850
 851         if ((boxRed.getX()<=x) && (boxRed.getX()+(int)boxRed.getWidth()>=x ) &&
 852             (boxRed.getY()<=y) && (boxRed.getY()+(int)boxRed.getHeight()>=y )) {
 853             BoxStack::getInstance()->handleCommand(Remote::RED);
 854         } else if ((boxGreen.getX()<=x) && (boxGreen.getX()+(int)boxGreen.getWidth()>=x ) &&
 855             (boxGreen.getY()<=y) && (boxGreen.getY()+(int)boxGreen.getHeight()>=y)){
 856             BoxStack::getInstance()->handleCommand(Remote::GREEN);
 857         } else if ((boxYellow.getX()<=x) && (boxYellow.getX()+(int)boxYellow.getWidth()>=x ) &&
 858             (boxYellow.getY()<=y) && (boxYellow.getY()+(int)boxYellow.getHeight()>=y )){
 859             BoxStack::getInstance()->handleCommand(Remote::YELLOW);
 860         } else if ((boxBlue.getX()<=x) && (boxBlue.getX()+(int)boxBlue.getWidth()>=x ) &&
 861             (boxBlue.getY()<=y) && (boxBlue.getY()+(int)boxBlue.getHeight()>=y )){
 862             BoxStack::getInstance()->handleCommand(Remote::BLUE);
 863         } else {
 864             BoxStack::getInstance()->handleCommand(Remote::OK); //simulate rok press
 865         }
 866
 867     } else {
 868         BoxStack::getInstance()->handleCommand(Remote::OK); //simulate rok press
 869     }
 870   }
 871   else if (m->message == Message::CHANNEL_CHANGE)
 872   {
 873     channelChange(NUMBER, m->parameter);
 874     osdChannelIndex = currentChannelIndex;
 875     if (m->tag == 1) displayOSD(true);
 876   }
 877   else if (m->message == Message::EPG_CLOSE)
 878   {
 879     video->setMode(videoMode);
 880   }
 881   else if (m->message == Message::CHILD_CLOSE)
 882   {
 883     if (m->from == vas)
 884     {
 885       vas = NULL;
 886       displayOSD(false);
 887     }
 888   }
 889   else if (m->message == Message::AUDIO_CHANGE_CHANNEL)
 890   {
 891     Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Received change audio channel to %i", m->parameter);
 892     player->setAudioChannel((m->parameter & 0xFFFF),(m->parameter & 0xFF0000)>>16);
 893   }
 894   else if (m->message == Message::PLAYER_EVENT)
 895   {
 896     switch(m->parameter)
 897     {
 898       case PlayerLiveTV::CONNECTION_LOST: // connection lost detected
 899       {
 900         Log::getInstance()->log("VVideoLiveTV", Log::DEBUG, "Received connection lost from player");
 901         Command::getInstance()->connectionLost();
 902         break;
 903       }
 904
 905       case PlayerLiveTV::STREAM_END:
 906       {
 907         // Message comes from playerlivetv through master mutex, so can do anything here
 908         showUnavailable();
 909         break;
 910       }
 911
 912       case PlayerLiveTV::ASPECT43:
 913       {
 914         if ((video->getTVsize() == Video::ASPECT16X9) && dowss)
 915         {
 916           Log::getInstance()->log("VVideoRec", Log::DEBUG, "Received do WSS 43");
 917           wss.setWide(false);
 918           wss.draw();
 919           BoxStack::getInstance()->update(this, &wssRegion);
 920         }
 921
 922         sAspectRatio.nextSymbol = WSymbol::VIDEOASPECT43;
 923         sAspectRatio.setVisible(true);
 924
 925         if (osd.getVisible()) // don't wake up the whole osd just for a aspect change
 926         {
 927           osd.draw();
 928           BoxStack::getInstance()->update(this, osd.getRegion());
 929         }
 930
 931         break;
 932       }
 933       case PlayerLiveTV::ASPECT169:
 934       {
 935         if ((video->getTVsize() == Video::ASPECT16X9) && dowss)
 936         {
 937           Log::getInstance()->log("VVideoRec", Log::DEBUG, "Received do WSS 169");
 938           wss.setWide(true);
 939           wss.draw();
 940           BoxStack::getInstance()->update(this, &wssRegion);
 941         }
 942
 943         sAspectRatio.nextSymbol = WSymbol::VIDEOASPECT169;
 944         sAspectRatio.setVisible(true);
 945
 946         if (osd.getVisible()) // don't wake up the whole osd just for a aspect change
 947         {
 948           osd.draw();
 949           BoxStack::getInstance()->update(this, osd.getRegion());
 950         }
 951
 952         break;
 953       }
 954       case PlayerLiveTV::PREBUFFERING:
 955       {
 956         preBuffering = m->tag;
 957         Log::getInstance()->log("VVideoRec", Log::DEBUG, "Prebuffering - %u", preBuffering);
 958         bufferBar.setPercent(preBuffering);
 959
 960         if (osd.getVisible())
 961         {
 962           bufferBar.setVisible(true);
 963           bufferBar.draw();
 964           Region r;
 965           bufferBar.getRootBoxRegion(&r);                       ///////// FIXME !!!
 966           BoxStack::getInstance()->update(this, &r);
 967
 968           if (preBuffering == 100)
 969           {
 970             doAudioChannelSymbol();
 971           }
 972         }
 973       }
 974     }
 975   }
 976 }
 977
 978 void VVideoLiveTV::doAudioChannelSymbol()
 979 {
 980   // get the doobery
 981   Channel* currentChannel = (*chanList)[osdChannelIndex];
 982
 983   bool multiAudio = false;
 984   #if WIN32
 985   if (currentChannel->numDPids > 1) multiAudio = true;
 986   #endif
 987   if (currentChannel->numAPids > 1) multiAudio = true;
 988
 989   // draw the doobery
 990
 991   if (multiAudio) sAudioChannels.nextSymbol = WSymbol::MULTIAUDIO;
 992   else            sAudioChannels.nextSymbol = WSymbol::SINGLEAUDIO;
 993   sAudioChannels.setVisible(true);
 994
 995   if (osd.getVisible())
 996   {
 997     sAudioChannels.draw();
 998     Region r;
 999     sAudioChannels.getRootBoxRegion(&r);                       ///////// FIXME !!!
1000     // Fix this n'all.
1001     r.w = 32;
1002     r.h = 16;
1003     BoxStack::getInstance()->update(this, &r);
1004   }
1005 }
1006
1007 UINT VVideoLiveTV::upChannel(UINT index)
1008 {
1009   if (index == (chanList->size() - 1)) // at the end
1010     return 0; // so go to start
1011   else
1012     return index + 1;
1013 }
1014
1015 UINT VVideoLiveTV::downChannel(UINT index)
1016 {
1017   if (index == 0) // at the start
1018     return chanList->size() - 1; // so go to end
1019   else
1020     return index - 1;
1021 }
1022
1023 void VVideoLiveTV::toggleChopSides()
1024 {
1025   if (video->getTVsize() == Video::ASPECT16X9) return; // Means nothing for 16:9 TVs
1026
1027   if (videoMode == Video::NORMAL)
1028   {
1029     videoMode = Video::LETTERBOX;
1030     video->setMode(Video::LETTERBOX);
1031   }
1032   else
1033   {
1034     videoMode = Video::NORMAL;
1035     video->setMode(Video::NORMAL);
1036   }
1037 }
1038