player.cc

   1 /*\r
   2     Copyright 2004-2008 Chris Tallon\r
   3 \r
   4     This file is part of VOMP.\r
   5 \r
   6     VOMP is free software; you can redistribute it and/or modify\r
   7     it under the terms of the GNU General Public License as published by\r
   8     the Free Software Foundation; either version 2 of the License, or\r
   9     (at your option) any later version.\r
  10 \r
  11     VOMP is distributed in the hope that it will be useful,\r
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  14     GNU General Public License for more details.\r
  15 \r
  16     You should have received a copy of the GNU General Public License\r
  17     along with VOMP; if not, write to the Free Software\r
  18     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.\r
  19 */\r
  20 \r
  21 #include "player.h"\r
  22 \r
  23 #include "log.h"\r
  24 #include "audio.h"\r
  25 #include "video.h"\r
  26 #include "demuxervdr.h"\r
  27 #include "demuxerts.h"\r
  28 #include "vdr.h"\r
  29 #include "messagequeue.h"\r
  30 #include "remote.h"\r
  31 #include "message.h"\r
  32 #include "dvbsubtitles.h"\r
  33 #include "osdreceiver.h"\r
  34 \r
  35 #define USER_RESPONSE_TIME 500 // Milliseconds\r
  36 \r
  37 // ----------------------------------- Called from outside, one offs or info funcs\r
  38 \r
  39 Player::Player(MessageQueue* tmessageQueue, void* tmessageReceiver, OSDReceiver* tosdReceiver)\r
  40 : vfeed(this), afeed(this), tfeed(this)\r
  41 {\r
  42   messageQueue = tmessageQueue;\r
  43   messageReceiver = tmessageReceiver;\r
  44   osdReceiver = tosdReceiver;\r
  45   audio = Audio::getInstance();\r
  46   video = Video::getInstance();\r
  47   logger = Log::getInstance();\r
  48   vdr = VDR::getInstance();\r
  49   initted = false;\r
  50   lengthBytes = 0;\r
  51   lengthFrames = 0;\r
  52   currentFrameNumber = 0;\r
  53   state = S_STOP;\r
  54   ifactor = 4;\r
  55   is_pesrecording=true;\r
  56 \r
  57   subtitlesShowing = false;\r
  58 \r
  59   videoStartup = false;\r
  60   threadBuffer = NULL;\r
  61  \r
  62   blockSize = 100000;\r
  63   startupBlockSize = 250000;\r
  64   video->turnVideoOn();\r
  65 }\r
  66 \r
  67 Player::~Player()\r
  68 {\r
  69   if (initted) shutdown();\r
  70 }\r
  71 \r
  72 int Player::init(bool p_isPesRecording,double framespersecond)\r
  73 {\r
  74   if (initted) return 0;\r
  75 #ifndef WIN32\r
  76   pthread_mutex_init(&mutex, NULL);\r
  77 #else\r
  78   mutex=CreateMutex(NULL,FALSE,NULL);\r
  79 #endif\r
  80   is_pesrecording = p_isPesRecording;\r
  81   fps=framespersecond;\r
  82   if (is_pesrecording)\r
  83     demuxer = new DemuxerVDR();\r
  84   else\r
  85     demuxer = new DemuxerTS();\r
  86   if (!demuxer) return 0;\r
  87   subtitles = new DVBSubtitles(osdReceiver);\r
  88   if (!subtitles) return 0;\r
  89 \r
  90   teletext = new TeletextDecoderVBIEBU();\r
  91   if (!teletext) return 0;\r
  92   teletext->setRecordigMode(true);\r
  93   unsigned int demux_video_size=2097152;\r
  94    if (video->supportsh264()) demux_video_size*=5;\r
  95  \r
  96   if (!demuxer->init(this, audio, video,teletext, demux_video_size,524288,65536, framespersecond, subtitles))\r
  97   {\r
  98     logger->log("Player", Log::ERR, "Demuxer failed to init");\r
  99     shutdown();\r
 100     return 0;\r
 101   }\r
 102 \r
 103   vfeed.init();\r
 104   afeed.init();\r
 105   tfeed.init();\r
 106 \r
 107   video->stop();\r
 108   video->blank();\r
 109   audio->stop();\r
 110 \r
 111   initted = true;\r
 112   return 1;\r
 113 }\r
 114 \r
 115 int Player::shutdown()\r
 116 {\r
 117   if (!initted) return 0;\r
 118   switchState(S_STOP);\r
 119   initted = false;\r
 120 \r
 121   delete demuxer;\r
 122   demuxer = NULL;\r
 123   delete subtitles;\r
 124   subtitles = NULL;\r
 125   delete teletext;\r
 126   teletext = NULL;\r
 127 \r
 128 #ifdef WIN32\r
 129   CloseHandle(mutex);\r
 130 #endif\r
 131 \r
 132   return 1;\r
 133 }\r
 134 \r
 135 void Player::setStartFrame(ULONG startFrame)\r
 136 {\r
 137   currentFrameNumber = startFrame;\r
 138 }\r
 139 \r
 140 void Player::setLengthBytes(ULLONG length)\r
 141 {\r
 142   lengthBytes = length;\r
 143   logger->log("Player", Log::DEBUG, "Player has received length bytes of %llu", lengthBytes);\r
 144 }\r
 145 \r
 146 void Player::setLengthFrames(ULONG length)\r
 147 {\r
 148   lengthFrames = length;\r
 149   logger->log("Player", Log::DEBUG, "Player has received length frames of %lu", lengthFrames);\r
 150 }\r
 151 \r
 152 ULONG Player::getLengthFrames()\r
 153 {\r
 154   return lengthFrames;\r
 155 }\r
 156 \r
 157 ULONG Player::getCurrentFrameNum()\r
 158 {\r
 159   if (startup) return 0;\r
 160   switch(state)\r
 161   {\r
 162     case S_PLAY:\r
 163     case S_PAUSE_P:\r
 164       return demuxer->getFrameNumFromPTS(video->getCurrentTimestamp());\r
 165     case S_PAUSE_I:\r
 166     case S_FFWD:\r
 167     case S_FBWD:\r
 168       return currentFrameNumber;\r
 169     default:\r
 170       return 0; // shouldn't happen\r
 171   }\r
 172 }\r
 173 \r
 174 bool* Player::getDemuxerMpegAudioChannels()\r
 175 {\r
 176   return demuxer->getmpAudioChannels();\r
 177 }\r
 178 \r
 179 bool* Player::getDemuxerAc3AudioChannels()\r
 180 {\r
 181   return demuxer->getac3AudioChannels();\r
 182 }\r
 183 \r
 184 bool* Player::getDemuxerSubtitleChannels()\r
 185 {\r
 186   return demuxer->getSubtitleChannels();\r
 187 }\r
 188 \r
 189 int Player::getCurrentAudioChannel()\r
 190 {\r
 191     if (is_pesrecording) {\r
 192         return demuxer->getselAudioChannel();\r
 193     } else {\r
 194         return ((DemuxerTS*)demuxer)->getAID();\r
 195     }\r
 196 }\r
 197 \r
 198 int Player::getCurrentSubtitleChannel()\r
 199 {\r
 200     if (is_pesrecording) {\r
 201         return demuxer->getselSubtitleChannel();\r
 202     } else {\r
 203         return ((DemuxerTS*)demuxer)->getSubID();\r
 204     }\r
 205 }\r
 206 \r
 207 void Player::setSubtitleChannel(int newChannel)\r
 208 {\r
 209     if (is_pesrecording) {\r
 210          demuxer->setDVBSubtitleStream(newChannel);\r
 211     } else {\r
 212         ((DemuxerTS*)demuxer)->setSubID(newChannel);\r
 213     }\r
 214 }\r
 215 \r
 216 int *Player::getTeletxtSubtitlePages()\r
 217 {\r
 218     return teletext->getSubtitlePages();\r
 219 }\r
 220 \r
 221 void Player::setAudioChannel(int newChannel, int type)\r
 222 {\r
 223     if (is_pesrecording) {\r
 224         demuxer->setAudioStream(newChannel);\r
 225         return;\r
 226     } else {\r
 227         ((DemuxerTS*)demuxer)->setAID(newChannel,type);\r
 228         return;\r
 229     }\r
 230 }\r
 231 \r
 232 bool Player::toggleSubtitles()\r
 233 {\r
 234   if (!subtitlesShowing)\r
 235   {\r
 236     subtitlesShowing = true;\r
 237     subtitles->show();\r
 238   }\r
 239   else\r
 240   {\r
 241     subtitlesShowing = false;\r
 242     subtitles->hide();\r
 243   }\r
 244   return subtitlesShowing;\r
 245 }\r
 246 \r
 247 void  Player::turnSubtitlesOn(bool ison) {\r
 248  if (ison)\r
 249   {\r
 250     subtitlesShowing = true;\r
 251     subtitles->show();\r
 252   }\r
 253   else\r
 254   {\r
 255     subtitlesShowing = false;\r
 256     subtitles->hide();\r
 257   }\r
 258 \r
 259 }\r
 260 \r
 261 Channel Player::getDemuxerChannel() {\r
 262     if (!is_pesrecording) {\r
 263         return ((DemuxerTS*) demuxer)->getChannelInfo();\r
 264     } \r
 265     return Channel(); //Should not happen!\r
 266 }\r
 267 \r
 268 \r
 269 // ----------------------------------- Externally called events\r
 270 \r
 271 void Player::play()\r
 272 {\r
 273   if (!initted) return;\r
 274   if (state == S_PLAY) return;\r
 275   lock();\r
 276 \r
 277   bool doUnlock = false;\r
 278   if (state == S_PAUSE_P) doUnlock = true;\r
 279   switchState(S_PLAY);\r
 280   if (doUnlock) unLock();\r
 281 }\r
 282 \r
 283 void Player::playpause()\r
 284 {\r
 285   if (!initted) return;\r
 286   lock();\r
 287 \r
 288   bool doUnlock = false;\r
 289   if (state==S_PLAY) {\r
 290           doUnlock=true;\r
 291           switchState(S_PAUSE_P);\r
 292   } else {\r
 293           if (state == S_PAUSE_P) doUnlock = true;\r
 294           switchState(S_PLAY);\r
 295   }\r
 296   if (doUnlock) unLock();\r
 297 \r
 298 }\r
 299 \r
 300 \r
 301 \r
 302 \r
 303 void Player::stop()\r
 304 {\r
 305   if (!initted) return;\r
 306   if (state == S_STOP) return;\r
 307   lock();\r
 308   logger->log("Player", Log::DEBUG, "Stop called lock");\r
 309   switchState(S_STOP);\r
 310   unLock();\r
 311 }\r
 312 \r
 313 void Player::pause()\r
 314 {\r
 315   if (!initted) return;\r
 316   lock();\r
 317 \r
 318   if ((state == S_FFWD) || (state == S_FBWD))\r
 319   {\r
 320     switchState(S_PAUSE_I);\r
 321   }\r
 322   else if ((state == S_PAUSE_I) || (state == S_PAUSE_P))\r
 323   {\r
 324     switchState(S_PLAY);\r
 325   }\r
 326   else\r
 327   {\r
 328     switchState(S_PAUSE_P);\r
 329   }\r
 330 \r
 331   unLock();\r
 332 }\r
 333 \r
 334 void Player::fastForward()\r
 335 {\r
 336   if (!initted) return;\r
 337   lock();\r
 338 \r
 339   if (state == S_FFWD)\r
 340   {\r
 341     // change the rate\r
 342     switch(ifactor)\r
 343     {\r
 344       case 4: ifactor = 8; break;\r
 345       case 8: ifactor = 16; break;\r
 346       case 16: ifactor = 32; break;\r
 347       case 32: ifactor = 4; break;\r
 348     }\r
 349   }\r
 350   else\r
 351   {\r
 352     ifactor = 4;\r
 353     switchState(S_FFWD);\r
 354   }\r
 355   unLock();\r
 356 }\r
 357 \r
 358 void Player::fastBackward()\r
 359 {\r
 360   if (!initted) return;\r
 361   lock();\r
 362 \r
 363   if (state == S_FBWD)\r
 364   {\r
 365     // change the rate\r
 366     switch(ifactor)\r
 367     {\r
 368       case 4: ifactor = 8; break;\r
 369       case 8: ifactor = 16; break;\r
 370       case 16: ifactor = 32; break;\r
 371       case 32: ifactor = 4; break;\r
 372     }\r
 373   }\r
 374   else\r
 375   {\r
 376     ifactor = 4;\r
 377     switchState(S_FBWD);\r
 378   }\r
 379   unLock();\r
 380 }\r
 381 \r
 382 void Player::jumpToPercent(double percent)\r
 383 {\r
 384   lock();\r
 385   logger->log("Player", Log::DEBUG, "JUMP TO %f%%", percent);\r
 386   ULONG newFrame = (ULONG)(percent * lengthFrames / 100);\r
 387   switchState(S_JUMP, newFrame);\r
 388 //  unLock(); - let thread unlock this\r
 389 }\r
 390 \r
 391 void Player::jumpToMark(int mark)\r
 392 {\r
 393   lock();\r
 394   logger->log("Player", Log::DEBUG, "JUMP TO MARK %i%%", mark);\r
 395   switchState(S_JUMP, mark);\r
 396 //  unLock(); - let thread unlock this\r
 397 }\r
 398 \r
 399 void Player::jumpToFrameP(int newFrame)\r
 400 {\r
 401   lock();\r
 402   logger->log("Player", Log::DEBUG, "JUMP TO FRAME AND PAUSE %i", newFrame);\r
 403   switchState(S_JUMP_PI, newFrame);\r
 404   unLock();\r
 405 }\r
 406 \r
 407 void Player::skipForward(int seconds)\r
 408 {\r
 409   lock();\r
 410   logger->log("Player", Log::DEBUG, "SKIP FORWARD %i SECONDS", seconds);\r
 411   ULONG newFrame = getCurrentFrameNum();\r
 412   if (newFrame == 0) { unLock(); return; } // Current pos from demuxer is not valid\r
 413   newFrame +=(ULONG) (((double)seconds) * fps);\r
 414   if (newFrame > lengthFrames) { switchState(S_PLAY); unLock(); }\r
 415   else switchState(S_JUMP, newFrame);\r
 416 //  unLock(); - let thread unlock this\r
 417 }\r
 418 \r
 419 void Player::skipBackward(int seconds)\r
 420 {\r
 421   lock();\r
 422   logger->log("Player", Log::DEBUG, "SKIP BACKWARD %i SECONDS", seconds);\r
 423   long newFrame = getCurrentFrameNum();\r
 424   if (newFrame == 0) { unLock(); return; } // Current pos from demuxer is not valid\r
 425   newFrame -= (ULONG) (((double)seconds) * fps);\r
 426   if (newFrame < 0) newFrame = 0;\r
 427   switchState(S_JUMP, newFrame);\r
 428 //  unLock(); - let thread unlock this\r
 429 }\r
 430 \r
 431 // ----------------------------------- Implementations called events\r
 432 \r
 433 void Player::switchState(UCHAR toState, ULONG jumpFrame)\r
 434 {\r
 435   if (!initted) return;\r
 436 \r
 437   logger->log("Player", Log::DEBUG, "Switch state from %u to %u", state, toState);\r
 438 \r
 439   switch(state) // current state selector\r
 440   {\r
 441     case S_PLAY: // from S_PLAY -----------------------------------\r
 442     {\r
 443       switch(toState)\r
 444       {\r
 445         case S_PLAY: // to S_PLAY\r
 446         {\r
 447           return;\r
 448         }\r
 449         case S_PAUSE_P: // to S_PAUSE_P\r
 450         {\r
 451           video->pause();\r
 452           audio->pause();\r
 453           state = S_PAUSE_P;\r
 454           return;\r
 455         }\r
 456         case S_PAUSE_I: // to S_PAUSE_I\r
 457         {\r
 458           // can't occur\r
 459           return;\r
 460         }\r
 461         case S_FFWD: // to S_FFWD\r
 462         {\r
 463           currentFrameNumber = getCurrentFrameNum();\r
 464           audio->systemMuteOn();\r
 465           threadStop();\r
 466           vfeed.stop();\r
 467           afeed.stop();\r
 468           tfeed.stop();\r
 469           subtitles->stop();\r
 470           demuxer->flush();\r
 471           state = S_FFWD;\r
 472           threadStart();\r
 473           return;\r
 474         }\r
 475         case S_FBWD: // to S_FBWD\r
 476         {\r
 477           currentFrameNumber = getCurrentFrameNum();\r
 478           audio->systemMuteOn();\r
 479           threadStop();\r
 480           vfeed.stop();\r
 481           afeed.stop();\r
 482           tfeed.stop();\r
 483           subtitles->stop();\r
 484           demuxer->flush();\r
 485           state = S_FBWD;\r
 486           threadStart();\r
 487           return;\r
 488         }\r
 489         case S_STOP: // to S_STOP\r
 490         {\r
 491           vfeed.stop();\r
 492           afeed.stop();\r
 493           tfeed.stop();\r
 494           subtitles->stop();\r
 495           threadStop();\r
 496           video->stop();\r
 497           video->blank();\r
 498           audio->stop();\r
 499           audio->unPause();\r
 500           video->reset();\r
 501           demuxer->reset();\r
 502           state = S_STOP;\r
 503           return;\r
 504         }\r
 505         case S_JUMP: // to S_JUMP\r
 506         {\r
 507           restartAtFrame(jumpFrame);\r
 508           return;\r
 509         }\r
 510         case S_JUMP_PI: // to S_JUMP_PI\r
 511         {\r
 512           audio->systemMuteOn();\r
 513           threadStop();\r
 514           vfeed.stop();\r
 515           afeed.stop();\r
 516           tfeed.stop();\r
 517           subtitles->stop();\r
 518           demuxer->flush();\r
 519           state = S_PAUSE_I;\r
 520           video->reset();\r
 521           video->play();\r
 522           restartAtFramePI(jumpFrame);\r
 523           return;\r
 524         }\r
 525       }\r
 526     }\r
 527     case S_PAUSE_P: // from S_PAUSE_P -----------------------------------\r
 528     {\r
 529       switch(toState)\r
 530       {\r
 531         case S_PLAY: // to S_PLAY\r
 532         {\r
 533           video->unPause();\r
 534           audio->unPause();\r
 535           state = S_PLAY;\r
 536           return;\r
 537         }\r
 538         case S_PAUSE_P: // to S_PAUSE_P\r
 539         {\r
 540           return;\r
 541         }\r
 542         case S_PAUSE_I: // to S_PAUSE_I\r
 543         {\r
 544           return;\r
 545         }\r
 546         case S_FFWD: // to S_FFWD\r
 547         {\r
 548           currentFrameNumber = getCurrentFrameNum();\r
 549           audio->systemMuteOn();\r
 550           vfeed.stop();\r
 551           afeed.stop();\r
 552           tfeed.stop();\r
 553           subtitles->stop();\r
 554           threadStop();\r
 555           video->unPause();\r
 556           audio->unPause();\r
 557           state = S_FFWD;\r
 558           threadStart();\r
 559           return;\r
 560         }\r
 561         case S_FBWD: // to S_FBWD\r
 562         {\r
 563           currentFrameNumber = getCurrentFrameNum();\r
 564           audio->systemMuteOn();\r
 565           vfeed.stop();\r
 566           afeed.stop();\r
 567           tfeed.stop();\r
 568           subtitles->stop();\r
 569           threadStop();\r
 570           video->unPause();\r
 571           audio->unPause();\r
 572           state = S_FBWD;\r
 573           threadStart();\r
 574           return;\r
 575         }\r
 576         case S_STOP: // to S_STOP\r
 577         {\r
 578           vfeed.stop();\r
 579           afeed.stop();\r
 580           tfeed.stop();\r
 581           subtitles->stop();\r
 582           threadStop();\r
 583           video->stop();\r
 584           video->blank();\r
 585           audio->stop();\r
 586           video->reset();\r
 587           audio->unPause();\r
 588           demuxer->reset();\r
 589           audio->systemMuteOff();\r
 590           state = S_STOP;\r
 591           return;\r
 592         }\r
 593         case S_JUMP: // to S_JUMP\r
 594         {\r
 595           state = S_PLAY;\r
 596           audio->systemMuteOn();\r
 597           audio->unPause();\r
 598           restartAtFrame(jumpFrame);\r
 599           return;\r
 600         }\r
 601         case S_JUMP_PI: // to S_JUMP_PI\r
 602         {\r
 603           audio->systemMuteOn();\r
 604           audio->unPause();\r
 605           threadStop();\r
 606           vfeed.stop();\r
 607           afeed.stop();\r
 608           tfeed.stop();\r
 609           subtitles->stop();\r
 610           demuxer->flush();\r
 611           state = S_PAUSE_I;\r
 612           video->reset();\r
 613           video->play();\r
 614           restartAtFramePI(jumpFrame);\r
 615           return;\r
 616         }\r
 617       }\r
 618     }\r
 619     case S_PAUSE_I: // from S_PAUSE_I -----------------------------------\r
 620     {\r
 621       switch(toState)\r
 622       {\r
 623         case S_PLAY: // to S_PLAY\r
 624         {\r
 625           state = S_PLAY;\r
 626           restartAtFrame(currentFrameNumber);\r
 627           return;\r
 628         }\r
 629         case S_PAUSE_P: // to S_PAUSE_P\r
 630         {\r
 631           return;\r
 632         }\r
 633         case S_PAUSE_I: // to S_PAUSE_I\r
 634         {\r
 635           return;\r
 636         }\r
 637         case S_FFWD: // to S_FFWD\r
 638         {\r
 639           state = S_FFWD;\r
 640           threadStart();\r
 641           return;\r
 642         }\r
 643         case S_FBWD: // to S_FBWD\r
 644         {\r
 645           state = S_FBWD;\r
 646           threadStart();\r
 647           return;\r
 648         }\r
 649         case S_STOP: // to S_STOP\r
 650         {\r
 651           video->stop();\r
 652           video->blank();\r
 653           audio->stop();\r
 654           video->reset();\r
 655           demuxer->reset();\r
 656           audio->systemMuteOff();\r
 657           state = S_STOP;\r
 658           return;\r
 659         }\r
 660         case S_JUMP: // to S_JUMP\r
 661         {\r
 662           state = S_PLAY;\r
 663           restartAtFrame(jumpFrame);\r
 664           return;\r
 665         }\r
 666         case S_JUMP_PI: // to S_JUMP_PI\r
 667         {\r
 668           restartAtFramePI(jumpFrame);\r
 669           return;\r
 670         }\r
 671       }\r
 672     }\r
 673     case S_FFWD: // from S_FFWD -----------------------------------\r
 674     {\r
 675       switch(toState)\r
 676       {\r
 677         case S_PLAY: // to S_PLAY\r
 678         {\r
 679           state = S_PLAY;\r
 680           ULONG stepback = (ULONG)(((double)USER_RESPONSE_TIME * ifactor) * fps / 1000.);\r
 681           if (stepback < currentFrameNumber)\r
 682             currentFrameNumber -= stepback;\r
 683           else\r
 684             currentFrameNumber = 0;\r
 685           restartAtFrame(currentFrameNumber);\r
 686           return;\r
 687         }\r
 688         case S_PAUSE_P: // to S_PAUSE_P\r
 689         {\r
 690           // can't occur\r
 691           return;\r
 692         }\r
 693         case S_PAUSE_I: // to S_PAUSE_I\r
 694         {\r
 695           threadStop();\r
 696           state = S_PAUSE_I;\r
 697           return;\r
 698         }\r
 699         case S_FFWD: // to S_FFWD\r
 700         {\r
 701           return;\r
 702         }\r
 703         case S_FBWD: // to S_FBWD\r
 704         {\r
 705           threadStop();\r
 706           state = S_FBWD;\r
 707           threadStart();\r
 708           return;\r
 709         }\r
 710         case S_STOP: // to S_STOP\r
 711         {\r
 712           threadStop();\r
 713           video->stop();\r
 714           video->blank();\r
 715           audio->stop();\r
 716           video->reset();\r
 717           demuxer->reset();\r
 718           state = S_STOP;\r
 719           return;\r
 720         }\r
 721         case S_JUMP: // to S_JUMP\r
 722         {\r
 723           state = S_PLAY;\r
 724           restartAtFrame(jumpFrame);\r
 725           return;\r
 726         }\r
 727         case S_JUMP_PI: // to S_JUMP_PI\r
 728         {\r
 729           threadStop();\r
 730           state = S_PAUSE_I;\r
 731           restartAtFramePI(jumpFrame);\r
 732           return;\r
 733         }\r
 734       }\r
 735     }\r
 736     case S_FBWD: // from S_FBWD -----------------------------------\r
 737     {\r
 738       switch(toState)\r
 739       {\r
 740         case S_PLAY: // to S_PLAY\r
 741         {\r
 742           state = S_PLAY;\r
 743           restartAtFrame(currentFrameNumber);\r
 744           return;\r
 745         }\r
 746         case S_PAUSE_P: // to S_PAUSE_P\r
 747         {\r
 748           // can't occur\r
 749           return;\r
 750         }\r
 751         case S_PAUSE_I: // to S_PAUSE_I\r
 752         {\r
 753           threadStop();\r
 754           state = S_PAUSE_I;\r
 755           return;\r
 756         }\r
 757         case S_FFWD: // to S_FFWD\r
 758         {\r
 759           threadStop();\r
 760           state = S_FFWD;\r
 761           threadStart();\r
 762           return;\r
 763         }\r
 764         case S_FBWD: // to S_FBWD\r
 765         {\r
 766           return;\r
 767         }\r
 768         case S_STOP: // to S_STOP\r
 769         {\r
 770           threadStop();\r
 771           video->stop();\r
 772           video->blank();\r
 773           audio->stop();\r
 774           video->reset();\r
 775           demuxer->reset();\r
 776           state = S_STOP;\r
 777           return;\r
 778         }\r
 779         case S_JUMP: // to S_JUMP\r
 780         {\r
 781           state = S_PLAY;\r
 782           restartAtFrame(jumpFrame);\r
 783           return;\r
 784         }\r
 785         case S_JUMP_PI: // to S_JUMP_PI\r
 786         {\r
 787           threadStop();\r
 788           state = S_PAUSE_I;\r
 789           restartAtFramePI(jumpFrame);\r
 790           return;\r
 791         }\r
 792       }\r
 793     }\r
 794     case S_STOP: // from S_STOP -----------------------------------\r
 795     {\r
 796       switch(toState)\r
 797       {\r
 798         case S_PLAY: // to S_PLAY\r
 799         {\r
 800           startup = true;\r
 801 \r
 802           audio->reset();\r
 803           audio->setStreamType(Audio::MPEG2_PES);\r
 804           audio->systemMuteOff();\r
 805           video->reset();\r
 806           demuxer->reset();\r
 807           // FIXME use restartAtFrame here?\r
 808           if (currentFrameNumber > lengthFrames) currentFrameNumber = 0;\r
 809           demuxer->setFrameNum(currentFrameNumber);\r
 810           demuxer->seek();\r
 811           videoStartup = true;\r
 812           state = S_PLAY;\r
 813           threadStart();\r
 814           logger->log("Player", Log::DEBUG, "Immediate play");\r
 815           afeed.start();\r
 816           vfeed.start();\r
 817           tfeed.start();\r
 818           subtitles->start();\r
 819           video->sync();\r
 820           audio->sync();\r
 821           audio->play();\r
 822           video->pause();\r
 823           return;\r
 824         }\r
 825         case S_PAUSE_P: // to S_PAUSE_P\r
 826         {\r
 827           return;\r
 828         }\r
 829         case S_PAUSE_I: // to S_PAUSE_I\r
 830         {\r
 831           return;\r
 832         }\r
 833         case S_FFWD: // to S_FFWD\r
 834         {\r
 835           return;\r
 836         }\r
 837         case S_FBWD: // to S_FBWD\r
 838         {\r
 839           return;\r
 840         }\r
 841         case S_STOP: // to S_STOP\r
 842         {\r
 843           return;\r
 844         }\r
 845         case S_JUMP: // to S_JUMP\r
 846         {\r
 847           return;\r
 848         }\r
 849         case S_JUMP_PI: // to S_JUMP_PI\r
 850         {\r
 851           return;\r
 852         }\r
 853       }\r
 854     }\r
 855     // case S_JUMP cannot be a start state because it auto flips to play\r
 856     // case S_JUMP_PI cannot be a start state because it auto flips to S_PAUSE_I\r
 857   }\r
 858 }\r
 859 \r
 860 // ----------------------------------- Internal functions\r
 861 \r
 862 void Player::lock()\r
 863 {\r
 864 #ifndef WIN32\r
 865   pthread_mutex_lock(&mutex);\r
 866   logger->log("Player", Log::DEBUG, "LOCKED");\r
 867 \r
 868 #else\r
 869    WaitForSingleObject(mutex, INFINITE);\r
 870 #endif\r
 871 }\r
 872 \r
 873 void Player::unLock()\r
 874 {\r
 875 #ifndef WIN32\r
 876   logger->log("Player", Log::DEBUG, "UNLOCKING");\r
 877   pthread_mutex_unlock(&mutex);\r
 878 #else\r
 879    ReleaseMutex(mutex);\r
 880 #endif\r
 881 }\r
 882 \r
 883 void Player::restartAtFrame(ULONG newFrame)\r
 884 {\r
 885   vfeed.stop();\r
 886   afeed.stop();\r
 887   tfeed.stop();\r
 888   subtitles->stop();\r
 889   threadStop();\r
 890   video->stop();\r
 891   video->reset();\r
 892   audio->reset();\r
 893   audio->setStreamType(Audio::MPEG2_PES);\r
 894   demuxer->flush();\r
 895   demuxer->seek();\r
 896   currentFrameNumber = newFrame;\r
 897   demuxer->setFrameNum(newFrame);\r
 898   videoStartup = true;\r
 899   afeed.start();\r
 900   tfeed.start();\r
 901   vfeed.start();\r
 902   subtitles->start();\r
 903   threadStart();\r
 904   audio->play();\r
 905   video->sync();\r
 906   audio->sync();\r
 907   audio->systemMuteOff();\r
 908   audio->doMuting();\r
 909 }\r
 910 \r
 911 \r
 912 void Player::restartAtFramePI(ULONG newFrame)\r
 913 {\r
 914   ULLONG filePos;\r
 915   ULONG nextiframeNumber;\r
 916   ULONG iframeLength;\r
 917   ULONG iframeNumber;\r
 918 \r
 919   UCHAR* buffer;\r
 920   UINT amountReceived;\r
 921   UINT videoLength;\r
 922 \r
 923   // newFrame could be anywhere, go forwards to next I-Frame\r
 924   if (!vdr->getNextIFrame(newFrame, 1, &filePos, &nextiframeNumber, &iframeLength)) return;\r
 925 \r
 926   // Now step back a GOP. This ensures we go to the greatest I-Frame equal to or less than the requested frame\r
 927   vdr->getNextIFrame(nextiframeNumber, 0, &filePos, &iframeNumber, &iframeLength);\r
 928 \r
 929   buffer = vdr->getBlock(filePos, iframeLength, &amountReceived);\r
 930   if (!vdr->isConnected())\r
 931   {\r
 932     if (buffer) free(buffer);\r
 933     doConnectionLost();\r
 934   }\r
 935   else\r
 936   {\r
 937     videoLength = demuxer->stripAudio(buffer, amountReceived);\r
 938     video->displayIFrame(buffer, videoLength);\r
 939     video->displayIFrame(buffer, videoLength); // If you do it twice, it works :)\r
 940     free(buffer);\r
 941     currentFrameNumber = iframeNumber;\r
 942   }\r
 943 }\r
 944 \r
 945 void Player::doConnectionLost()\r
 946 {\r
 947   logger->log("Player", Log::DEBUG, "Connection lost, sending message");\r
 948   Message* m = new Message();\r
 949   m->to = messageReceiver;\r
 950   m->from = this;\r
 951   m->message = Message::PLAYER_EVENT;\r
 952   m->parameter = Player::CONNECTION_LOST;\r
 953   messageQueue->postMessage(m);\r
 954 }\r
 955 \r
 956 // ----------------------------------- Callback\r
 957 \r
 958 void Player::call(void* caller)\r
 959 {\r
 960   if (caller == demuxer)\r
 961   {\r
 962     logger->log("Player", Log::DEBUG, "Callback from demuxer");\r
 963 \r
 964     if (video->getTVsize() == Video::ASPECT4X3)\r
 965     {\r
 966       logger->log("Player", Log::DEBUG, "TV is 4:3, ignoring aspect switching");\r
 967       return;\r
 968     }\r
 969 \r
 970     int dxCurrentAspect = demuxer->getAspectRatio();\r
 971     if (dxCurrentAspect == Demuxer::ASPECT_4_3)\r
 972     {\r
 973       logger->log("Player", Log::DEBUG, "Demuxer said video is 4:3 aspect, switching TV");\r
 974       video->setAspectRatio(Video::ASPECT4X3);\r
 975 \r
 976       Message* m = new Message();\r
 977       m->from = this;\r
 978       m->to = messageReceiver;\r
 979       m->message = Message::PLAYER_EVENT;\r
 980       m->parameter = Player::ASPECT43;\r
 981       messageQueue->postMessageFromOuterSpace(m);\r
 982     }\r
 983     else if (dxCurrentAspect == Demuxer::ASPECT_16_9)\r
 984     {\r
 985       logger->log("Player", Log::DEBUG, "Demuxer said video is 16:9 aspect, switching TV");\r
 986       video->setAspectRatio(Video::ASPECT16X9);\r
 987 \r
 988       Message* m = new Message();\r
 989       m->from = this;\r
 990       m->to = messageReceiver;\r
 991       m->message = Message::PLAYER_EVENT;\r
 992       m->parameter = Player::ASPECT169;\r
 993       messageQueue->postMessageFromOuterSpace(m);\r
 994     }\r
 995     else\r
 996     {\r
 997       logger->log("Player", Log::DEBUG, "Demuxer said video is something else... ignoring");\r
 998     }\r
 999 \r
1000   }\r
1001   else\r
1002   {\r
1003     if (videoStartup)\r
1004     {\r
1005       videoStartup = false;\r
1006       video->reset();\r
1007       video->play();\r
1008       video->sync();\r
1009       vfeed.release();\r
1010       unLock();\r
1011     }\r
1012 \r
1013     threadSignalNoLock();\r
1014   }\r
1015 }\r
1016 \r
1017 // ----------------------------------- Feed thread\r
1018 \r
1019 void Player::threadMethod()\r
1020 {\r
1021   // this method used to be simple, the only thing it does\r
1022   // is farm out to threadFeed Live/Play/Scan\r
1023   // All the guff is to support scan hitting one end\r
1024 \r
1025   if ((state == S_FFWD) || (state == S_FBWD))\r
1026   {\r
1027     if (video->PTSIFramePlayback()) threadPTSFeedScan();\r
1028     else threadFeedScan();\r
1029     // if this returns then scan hit one end\r
1030     if (state == S_FFWD) // scan hit the end. stop\r
1031     {\r
1032       threadCheckExit();\r
1033       Message* m = new Message(); // Must be done after this thread finishes, and must break into master mutex\r
1034       m->to = messageReceiver;\r
1035       m->from = this;\r
1036       m->message = Message::PLAYER_EVENT;\r
1037       m->parameter = STOP_PLAYBACK;\r
1038       logger->log("Player", Log::DEBUG, "Posting message to %p...", messageQueue);\r
1039       messageQueue->postMessage(m);\r
1040       logger->log("Player", Log::DEBUG, "Message posted...");\r
1041       return;\r
1042     }\r
1043     // if execution gets to here, threadFeedScan hit the start, go to play mode\r
1044     state = S_PLAY;\r
1045     audio->reset();\r
1046     audio->setStreamType(Audio::MPEG2_PES);\r
1047     demuxer->flush();\r
1048     demuxer->seek();\r
1049     demuxer->setFrameNum(currentFrameNumber);\r
1050     videoStartup = true;\r
1051     afeed.start();\r
1052     tfeed.start();\r
1053     vfeed.start();\r
1054     subtitles->start();\r
1055     audio->play();\r
1056     audio->sync();\r
1057     audio->systemMuteOff();\r
1058     audio->doMuting();\r
1059   }\r
1060 \r
1061   if (state == S_PLAY) threadFeedPlay();\r
1062 }\r
1063 \r
1064 void Player::threadFeedPlay()\r
1065 {\r
1066   ULLONG feedPosition;\r
1067   UINT thisRead, writeLength, thisWrite, askFor;\r
1068   time_t lastRescan = time(NULL);\r
1069 \r
1070   feedPosition = vdr->positionFromFrameNumber(currentFrameNumber);\r
1071   if (!vdr->isConnected()) { doConnectionLost(); return; }\r
1072   logger->log("Player", Log::DEBUG, "startFeedPlay: wantedframe %i goto %llu", currentFrameNumber, feedPosition);\r
1073 \r
1074 \r
1075   while(1)\r
1076   {\r
1077     thisRead = 0;\r
1078     writeLength = 0;\r
1079     thisWrite = 0;\r
1080 \r
1081     threadCheckExit();\r
1082 \r
1083     // If we havn't rescanned for a while..\r
1084     if ((lastRescan + 60) < time(NULL))\r
1085     {\r
1086       lengthBytes = vdr->rescanRecording(&lengthFrames);\r
1087       if (!vdr->isConnected()) { doConnectionLost(); return; }\r
1088       logger->log("Player", Log::DEBUG, "Rescanned and reset length: %llu", lengthBytes);\r
1089       lastRescan = time(NULL);\r
1090     }\r
1091 \r
1092     if (feedPosition >= lengthBytes) break;  // finished playback\r
1093 \r
1094     if (startup)\r
1095     {\r
1096       if (startupBlockSize > lengthBytes)\r
1097         askFor = lengthBytes; // is a very small recording!\r
1098       else\r
1099         askFor = startupBlockSize; // normal, but a startup sized block to detect all the audio streams\r
1100     }\r
1101     else\r
1102     {\r
1103       if ((feedPosition + blockSize) > lengthBytes) // last block of recording\r
1104         askFor = lengthBytes - feedPosition;\r
1105       else // normal\r
1106         askFor = blockSize;\r
1107     }\r
1108     //logger->log("Player", Log::DEBUG, "Get Block in");\r
1109 \r
1110     threadBuffer = vdr->getBlock(feedPosition, askFor, &thisRead);\r
1111     //logger->log("Player", Log::DEBUG, "Get Block out");\r
1112 \r
1113     feedPosition += thisRead;\r
1114 \r
1115     if (!vdr->isConnected())\r
1116     {\r
1117       doConnectionLost();\r
1118       return;\r
1119     }\r
1120 \r
1121     if (!threadBuffer) break;\r
1122 \r
1123     if (startup)\r
1124     {\r
1125       int a_stream = demuxer->scan(threadBuffer, thisRead);\r
1126       demuxer->setAudioStream(a_stream);\r
1127       logger->log("Player", Log::DEBUG, "Startup Audio stream chosen %x", a_stream);\r
1128       startup = false;\r
1129     }\r
1130 \r
1131     threadCheckExit();\r
1132 \r
1133     while(writeLength < thisRead)\r
1134     {\r
1135       //logger->log("Player", Log::DEBUG, "Put in");\r
1136       thisWrite = demuxer->put(threadBuffer + writeLength, thisRead - writeLength);\r
1137       //logger->log("Player", Log::DEBUG, "Put out");\r
1138       writeLength += thisWrite;\r
1139 \r
1140       if (!thisWrite)\r
1141       {\r
1142         // demuxer is full and can't take anymore\r
1143         threadLock();\r
1144         threadWaitForSignal();\r
1145         threadUnlock();\r
1146       }\r
1147 \r
1148       threadCheckExit();\r
1149     }\r
1150 \r
1151     free(threadBuffer);\r
1152     threadBuffer = NULL;\r
1153 \r
1154   }\r
1155 \r
1156   // end of recording\r
1157   logger->log("Player", Log::DEBUG, "Recording playback ends");\r
1158 \r
1159   if (videoStartup) // oh woe. there never was a stream, I was conned!\r
1160   {\r
1161     videoStartup = false;\r
1162     unLock();\r
1163     MILLISLEEP(500); // I think this will solve a race\r
1164   }\r
1165 \r
1166   threadCheckExit();\r
1167 \r
1168 \r
1169   Message* m = new Message(); // Must be done after this thread finishes, and must break into master mutex\r
1170   m->to = messageReceiver;\r
1171   m->from = this;\r
1172   m->message = Message::PLAYER_EVENT;\r
1173   m->parameter = Player::STOP_PLAYBACK;\r
1174   logger->log("Player", Log::DEBUG, "Posting message to %p...", messageQueue);\r
1175   messageQueue->postMessage(m);\r
1176 }\r
1177 \r
1178 \r
1179 void Player::threadPTSFeedScan()\r
1180 {\r
1181   // This method manipulates the PTS instead of waiting, this is for the android devices, maybe later for windows?\r
1182 \r
1183   ULONG direction = 0;\r
1184   int dir_fac=-1;\r
1185   ULONG baseFrameNumber = 0;\r
1186   ULONG iframeNumber = 0;\r
1187   ULONG iframeLength = 0;\r
1188   ULONG currentfeedFrameNumber=currentFrameNumber;\r
1189   ULONG firstFrameNumber=currentFrameNumber;\r
1190   ULLONG filePos;\r
1191   UINT amountReceived;\r
1192   UINT videoLength;\r
1193 \r
1194   UINT playtime=0;\r
1195 \r
1196 #ifndef WIN32\r
1197   struct timeval clock0 = {0,0};  // Time stamp after fetching I-frame info\r
1198   struct timeval clock1 = {0,0};  // Time stamp after fetching I-frame data\r
1199   struct timeval clock2 = {0,0} ; // Time stamp after displaying I-frame\r
1200 #else\r
1201   DWORD clock0 = 0, clock1 = 0, clock2 = 0;\r
1202 #endif\r
1203 \r
1204   int frameTimeOffset = 0; // Time in msec between frames\r
1205   int disp_msec = 0;  // Time taken to display data\r
1206   int total_msec = 0; // Time taken to fetch data and display it\r
1207   int sleepTime = 0;\r
1208 \r
1209   if (state == S_FFWD) {\r
1210           direction = 1; // and 0 for backward\r
1211           dir_fac=1;\r
1212   }\r
1213   video->EnterIframePlayback();\r
1214 \r
1215   while(1)\r
1216   {\r
1217     // Fetch I-frames until we get one that can be displayed in good time\r
1218     // Repeat while clock0 + total_msec > clock2 + frameTimeOffset\r
1219 \r
1220     baseFrameNumber = currentfeedFrameNumber;\r
1221 \r
1222     threadCheckExit();\r
1223     if (!vdr->getNextIFrame(baseFrameNumber, direction, &filePos, &iframeNumber, &iframeLength))\r
1224        return;\r
1225 \r
1226     if (iframeNumber >= lengthFrames) return;\r
1227         // scan has got to the end of what we knew to be there before we started scanning\r
1228 \r
1229     baseFrameNumber = iframeNumber;\r
1230 \r
1231     frameTimeOffset =(int) ((double)(abs((int)iframeNumber - (int)currentfeedFrameNumber) * 1000) / (fps * (double)ifactor));\r
1232 \r
1233     logger->log("Player", Log::DEBUG, "XXX Got frame");\r
1234 \r
1235     threadBuffer = vdr->getBlock(filePos, iframeLength, &amountReceived);\r
1236 \r
1237     if (!vdr->isConnected())\r
1238     {\r
1239       if (threadBuffer) free(threadBuffer);\r
1240       doConnectionLost();\r
1241       break;\r
1242     }\r
1243 \r
1244 \r
1245     threadCheckExit();\r
1246 \r
1247 \r
1248     videoLength = demuxer->stripAudio(threadBuffer, amountReceived);\r
1249     demuxer->changeTimes(threadBuffer,videoLength,playtime);\r
1250     int count=0;\r
1251     while (!video->displayIFrame(threadBuffer, videoLength)) // the device might block\r
1252     {\r
1253         MILLISLEEP(20);\r
1254         threadCheckExit();\r
1255         count++;\r
1256         if (count%300==0) {\r
1257                 ULLONG cur_time=video->getCurrentTimestamp();\r
1258         //       logger->log("Player", Log::ERR, "FFN: %d CFN: %d dirfac %d time %lld ifac %d fps %g",\r
1259                 //              firstFrameNumber, currentFrameNumber,dir_fac,cur_time,ifactor,fps);\r
1260                 if (cur_time!=0) {\r
1261                     currentFrameNumber=firstFrameNumber+(int)(((double)(dir_fac*((long long)cur_time)*((int)ifactor))*fps/90000.));\r
1262                 }\r
1263         }\r
1264 \r
1265     }\r
1266     playtime +=frameTimeOffset;\r
1267     currentfeedFrameNumber = iframeNumber;\r
1268     {\r
1269                 ULLONG cur_time=video->getCurrentTimestamp();\r
1270         //       logger->log("Player", Log::ERR, "FFN: %d CFN: %d dirfac %d time %lld ifac %d fps %g",\r
1271                 //              firstFrameNumber, currentFrameNumber,dir_fac,cur_time,ifactor,fps);\r
1272                 if (cur_time!=0) {\r
1273                     currentFrameNumber=firstFrameNumber+(int)(((double)(dir_fac*((long long)cur_time)*((int)ifactor))*fps/90000.));\r
1274                 }\r
1275         }\r
1276 \r
1277     free(threadBuffer);\r
1278     threadBuffer = NULL;\r
1279   }\r
1280 }\r
1281 \r
1282 \r
1283 \r
1284 void Player::threadFeedScan()\r
1285 {\r
1286   // This method is actually really simple - get frame from vdr,\r
1287   // spit it at the video chip, wait for a time. Most of the code here\r
1288   // is to get the wait right so that the scan occurs at the correct rate.\r
1289 \r
1290   ULONG direction = 0;\r
1291   ULONG baseFrameNumber = 0;\r
1292   ULONG iframeNumber = 0;\r
1293   ULONG iframeLength = 0;\r
1294   ULLONG filePos;\r
1295   UINT amountReceived;\r
1296   UINT videoLength;\r
1297 \r
1298 #ifndef WIN32\r
1299   struct timeval clock0 = {0,0};  // Time stamp after fetching I-frame info\r
1300   struct timeval clock1 = {0,0};  // Time stamp after fetching I-frame data\r
1301   struct timeval clock2 = {0,0} ; // Time stamp after displaying I-frame\r
1302 #else\r
1303   DWORD clock0 = 0, clock1 = 0, clock2 = 0;\r
1304 #endif\r
1305 \r
1306   int frameTimeOffset = 0; // Time in msec between frames\r
1307   int disp_msec = 0;  // Time taken to display data\r
1308   int total_msec = 0; // Time taken to fetch data and display it\r
1309   int sleepTime = 0;\r
1310 \r
1311   if (state == S_FFWD) direction = 1; // and 0 for backward\r
1312 \r
1313   while(1)\r
1314   {\r
1315     // Fetch I-frames until we get one that can be displayed in good time\r
1316     // Repeat while clock0 + total_msec > clock2 + frameTimeOffset\r
1317 \r
1318     baseFrameNumber = currentFrameNumber;\r
1319     do\r
1320     {\r
1321       threadCheckExit();\r
1322       if (!vdr->getNextIFrame(baseFrameNumber, direction, &filePos, &iframeNumber, &iframeLength))\r
1323         return;\r
1324 \r
1325       if (iframeNumber >= lengthFrames) return;\r
1326         // scan has got to the end of what we knew to be there before we started scanning\r
1327 \r
1328       baseFrameNumber = iframeNumber;\r
1329       frameTimeOffset =(int) ((double)(abs((int)iframeNumber - (int)currentFrameNumber) * 1000) / (fps * (double)ifactor));\r
1330 #ifndef WIN32\r
1331       gettimeofday(&clock0, NULL);\r
1332 #else\r
1333       clock0 = timeGetTime();\r
1334 #endif\r
1335     }\r
1336 #ifndef WIN32\r
1337     while (clock2.tv_sec != 0 &&\r
1338           (clock0.tv_sec - clock2.tv_sec) * 1000 +\r
1339           (clock0.tv_usec - clock2.tv_usec) / 1000 > frameTimeOffset - total_msec);\r
1340 #else\r
1341     while (clock2 != 0 && clock0 + total_msec > clock2 + frameTimeOffset);\r
1342 #endif\r
1343     logger->log("Player", Log::DEBUG, "XXX Got frame");\r
1344 \r
1345     threadBuffer = vdr->getBlock(filePos, iframeLength, &amountReceived);\r
1346     \r
1347     if (!vdr->isConnected())\r
1348     {\r
1349       if (threadBuffer) free(threadBuffer);\r
1350       doConnectionLost();\r
1351       break;\r
1352     }\r
1353     \r
1354 #ifndef WIN32\r
1355     gettimeofday(&clock1, NULL);\r
1356     if (clock2.tv_sec != 0)\r
1357       sleepTime = (clock2.tv_sec - clock1.tv_sec) * 1000\r
1358                 + (clock2.tv_usec - clock1.tv_usec) / 1000\r
1359                 + frameTimeOffset - disp_msec;\r
1360 #else\r
1361     clock1 = timeGetTime();\r
1362     if (clock2 != 0)\r
1363       sleepTime = clock2 + frameTimeOffset - disp_msec - clock1;\r
1364 #endif\r
1365     if (sleepTime < 0) sleepTime = 0;\r
1366     threadCheckExit();\r
1367     MILLISLEEP(sleepTime);\r
1368    logger->log("Player", Log::DEBUG, "XXX Slept for %d", sleepTime);\r
1369 \r
1370     videoLength = demuxer->stripAudio(threadBuffer, amountReceived);\r
1371     video->displayIFrame(threadBuffer, videoLength);\r
1372     currentFrameNumber = iframeNumber;\r
1373     free(threadBuffer);\r
1374     threadBuffer = NULL;\r
1375 \r
1376 #ifndef WIN32\r
1377     gettimeofday(&clock2, NULL);\r
1378     total_msec = (clock2.tv_sec - clock0.tv_sec) * 1000\r
1379                + (clock2.tv_usec - clock0.tv_usec) / 1000\r
1380                - sleepTime;\r
1381     disp_msec = (clock2.tv_sec - clock1.tv_sec) * 1000\r
1382               + (clock2.tv_usec - clock1.tv_usec) / 1000\r
1383               - sleepTime;\r
1384 #else\r
1385     clock2 = timeGetTime();\r
1386     total_msec = clock2 - clock0 - sleepTime;\r
1387     disp_msec = clock2 - clock1 - sleepTime;\r
1388 #endif\r
1389     logger->log("Player", Log::DEBUG, "XXX disp_msec = %4d total_msec = %4d", disp_msec, total_msec);\r
1390   }\r
1391 }\r
1392 \r
1393 void Player::threadPostStopCleanup()\r
1394 {\r
1395   if (threadBuffer)\r
1396   {\r
1397     free(threadBuffer);\r
1398     threadBuffer = NULL;\r
1399   }\r
1400 }\r
1401 \r
1402 // ----------------------------------- Dev\r
1403 \r
1404 #ifdef DEV\r
1405 void Player::test1()\r
1406 {\r
1407   logger->log("Player", Log::DEBUG, "PLAYER TEST 1");\r
1408 }\r
1409 \r
1410 void Player::test2()\r
1411 {\r
1412   logger->log("Player", Log::DEBUG, "PLAYER TEST 2");\r
1413 }\r
1414 #endif\r