开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 电子书籍 > VC书籍 > 查看源码
MediaPlayback.cpp
资源名称：VC++视频传输.rar　[点击查看]
上传用户：hxb_1234
上传日期：2010-03-30
资源大小：8328k
文件大小：28k
源码类别：

VC书籍

开发平台：

Visual C++

MediaPlayback.cpp：源码内容
  1. /**************************************************************************************
  2.  *                                                                                    *
  3.  *                                                                                    *
  4.  **************************************************************************************/
  6. #include "MediaPlayback.h"
  7. #include "DebugFile.h"
  9. DebugFile *debug;
  11. /*
  12.  * 音频回调
  13.  *
  14.  */
  16. unsigned int PlaybackAudioCallback(void *lpData, void *buffer, unsigned int size);
  18. /*
  19.  * 回放类
  20.  * --------------
  21.  * 
  22.  *  ——为所有媒体类中的项和过滤器提供一个前端处理
  23.  *
  24.  */
  26. MediaPlayback::MediaPlayback()
  27. {
  28. this->input         = new MediaInput();
  29. this->decaps        = new MediaDecaps();
  30. this->videoDecoder  = new MediaVideoDecoder();
  31. this->videoBuffer   = new MediaVideoBuffer();
  32. this->videoRenderer = new MediaVideoRenderer();
  34. this->audioDecoder  = new MediaAudioDecoder();
  35. this->audioRenderer = new MediaAudioRenderer();
  37. this->subtitler     = new MediaSubtitler();
  39. this->hasVideo      = FALSE;
  40. this->hasAudio      = FALSE;
  41. this->hasSubtitles  = FALSE;
  43. this->fullscreen    = FALSE;
  44. this->fastForward   = FALSE;
  45. this->rewind        = FALSE;
  47. this->playing       = FALSE;  
  48. this->paused        = FALSE;
  50. this->buffering         = FALSE;
  51. this->bufferingProgress = 0;
  52. this->volume            = 100;
  54. this->playbackMutex = CreateMutex (NULL, FALSE, NULL);
  55. }
  57. MediaPlayback::~MediaPlayback()
  58. {
  59. delete this->input;
  60. delete this->decaps;
  61. delete this->videoDecoder;
  62. delete this->videoRenderer;
  63. delete this->videoBuffer;
  64. delete this->subtitler;
  66. CloseHandle(this->playbackMutex);
  67. }
  69. MP_RESULT     MediaPlayback::OpenMediaSource(char *lpFilename) 
  70. {
  71. this->hasVideo      = FALSE;
  73. this->fastForward   = FALSE;
  74. this->rewind        = FALSE;
  76. this->playing       = FALSE;  
  77. this->paused        = FALSE;
  79. this->hasVideo      = FALSE;
  80. this->hasAudio      = FALSE;
  81. this->hasSubtitles  = FALSE;
  83. this->buffering     = FALSE;
  84. this->hasToBuffer   = FALSE;
  85. this->bufferingProgress = 0;
  87. if(lpFilename) {
  89. if(this->input->Open(lpFilename, INPUT_OPEN_BINARY) == MP_RESULT_OK) {
  91. if(this->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  93. this->buffering         = TRUE;
  94. this->bufferingProgress = 0;
  95. }
  97. strcpy(this->filename, lpFilename);
  98. this->filename[strlen(lpFilename)] = '';
  100. return MP_RESULT_OK;
  101. }
  102. }
  104. return MP_RESULT_ERROR;
  105. }
  107. MP_RESULT     MediaPlayback::OpenMediaFromSource(HWND hwndPlayback)
  108. {
  109. if(this->input && hwndPlayback) {
  111. if(this->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  113. this->buffering = 0;
  114. }
  117. if(this->decaps->Connect(this->input) == MP_RESULT_OK) {
  119. /*
  120.  * 视频流
  121.  */
  123. if(this->decaps->GetNumberOfVideoStreams() > 0) {
  125. if(this->videoDecoder->Connect(decaps) == MP_RESULT_OK) {
  127. /*
  128.  * 我们有一个有效的解码器，因此现在我们
  129.  *尝试建立一个视频补偿器并得到相同的视频模式
  130.  *
  131.  */
  133. media_video_mode_t codecMode, rendererMode;
  135. codecMode = this->videoDecoder->GetVideoMode();
  137. if(this->fullscreen)  {
  139. if(this->videoRenderer->InitFullscreen(hwndPlayback, 
  140.    this->decaps->GetVideoWidth(0),
  141.    this->decaps->GetVideoHeight(0), 
  142.    codecMode) == MP_RESULT_OK) {
  144. rendererMode = this->videoRenderer->GetVideoMode();
  146. if(this->videoDecoder->SetVideoMode(rendererMode) == MP_RESULT_OK) {
  148. if(this->videoBuffer->Connect(this->videoDecoder) == MP_RESULT_OK) {
  150. this->hasVideo     = TRUE;
  151. this->hwndPlayback = hwndPlayback;
  153. this->end = FALSE;
  155. this->videoRect    = NULL;
  156. }
  157. }
  159. }
  160. }
  161. else {
  163. if(this->videoRenderer->Init(hwndPlayback, 
  164.  this->decaps->GetVideoWidth(0),
  165.  this->decaps->GetVideoHeight(0), 
  166.  codecMode) == MP_RESULT_OK) {
  168. rendererMode = this->videoRenderer->GetVideoMode();
  170. if(this->videoDecoder->SetVideoMode(rendererMode) == MP_RESULT_OK) {
  172. if(this->videoBuffer->Connect(this->videoDecoder) == MP_RESULT_OK) {
  174. this->hasVideo     = TRUE;
  175. this->hwndPlayback = hwndPlayback;
  177. this->end = FALSE;
  179. this->videoRect    = NULL;
  180. }
  181. }
  182. }
  183. }
  184. }
  185. }
  187. /*
  188.  * 音频流
  189.  */
  191. if(this->decaps->GetNumberOfAudioStreams() > 0) {
  193. if(this->audioDecoder->Connect(this->decaps) == MP_RESULT_OK) {
  195. /*
  196.  * 我们有一个有效的音频解码器，因此现在我们
  197.  * 在给定模式下尝试建立缺省的音频补偿器
  198.  *
  199.  */
  201. if(this->audioRenderer->Open(hwndPlayback, this->audioDecoder->GetAudioFormat()) == MP_RESULT_OK) {
  203. /*
  204.  * 建立回调
  205.  */
  207. this->audioRenderer->SetVolume(this->volume);
  208. this->audioRenderer->SetCallback((LPVOID) this, PlaybackAudioCallback);
  210. this->hasAudio = TRUE;
  211. }
  212. }
  213. }
  215. /*
  216.  * 字幕流
  217.  */
  219. if(this->HasVideo() && !(this->input->GetCaps() & MEDIA_CAPS_BUFFERIZE)) {
  221. char *subFilename;
  223. subFilename = (char *) new char[strlen(this->filename)];
  225. strncpy(subFilename, this->filename, strlen(this->filename) - 4);
  226. subFilename[strlen(this->filename) - 4] = '';
  227. strcat(subFilename, ".sub");
  229. if(this->subtitler->Open(subFilename) == MP_RESULT_OK) {
  231. if(this->videoRenderer->Connect(this->subtitler) == MP_RESULT_OK) {
  233. this->hasSubtitles = TRUE;
  234. }
  235. }
  236. }
  239. if(this->hasVideo) {
  241. return MP_RESULT_OK;
  242. }
  243. }
  244. }
  246. return MP_RESULT_ERROR;
  247. }
  249. MP_RESULT     MediaPlayback::OpenMedia(char *lpFilename, HWND hwndPlayback)
  250. {
  251. if(lpFilename && hwndPlayback) {
  253. if(this->OpenMediaSource(lpFilename) == MP_RESULT_OK) {
  255. if(this->OpenMediaFromSource(hwndPlayback) == MP_RESULT_OK) {
  257. return MP_RESULT_OK;
  258. }
  259. }
  260. }
  262. this->Close();
  264. return MP_RESULT_ERROR;
  265. }
  267. BOOL          MediaPlayback::HasVideo()
  268. {
  269. return this->hasVideo;
  270. }
  272. BOOL          MediaPlayback::HasAudio()
  273. {
  274. return this->hasAudio;
  275. }
  277. char         *MediaPlayback::GetFilename()
  278. {
  279. if(this->HasAudio() || this->HasVideo()) {
  281. return this->filename;
  282. }
  284. return NULL;
  285. }
  287. unsigned int  MediaPlayback::GetVideoWidth()
  288. {
  289. if(this->decaps)
  290. return this->decaps->GetVideoWidth(0);
  292. return 0;
  293. }
  295. unsigned int  MediaPlayback::GetVideoHeight()
  296. {
  297. if(this->decaps)
  298. return this->decaps->GetVideoHeight(0);
  300. return 0;
  301. }
  303. unsigned long MediaPlayback::GetVideoTime()
  304. {
  305. if(this->decaps) {
  307. return (unsigned long) ((double) this->videoFrames * 1000.0 / (double) this->decaps->GetVideoFrameRate(0));
  308. }
  310. return 0;
  311. }
  313. unsigned long MediaPlayback::GetAudioTime()
  314. {
  315. return this->audioRenderer->GetAudioTime();
  316. }
  318. double        MediaPlayback::GetPlaybackProgress()
  319. {
  320. if(this->HasAudio() || this->HasVideo()) {
  322. return (double) ((double) this->decaps->GetCurrentVideoFrame(0) * 100 / (double) this->decaps->GetTotalVideoFrames(0));
  323. }
  325. return 0;
  326. }
  328. unsigned int  MediaPlayback::GetActualTime()
  329. {
  330. if(this->HasVideo()) {
  332. return this->decaps->GetCurrentVideoFrame(0) / this->decaps->GetVideoFrameRate(0);
  333. }
  335. return 0;
  336. }
  338. BOOL          MediaPlayback::IsBuffering()
  339. {
  340. return this->buffering;
  341. }
  343. DWORD         MediaPlayback::GetBufferingProgress()
  344. {
  345. return this->bufferingProgress;
  346. }
  348. MP_RESULT     MediaPlayback::UpdateBuffering()
  349. {
  350. DWORD size;
  352. size = this->input->GetBufferSize();
  354. this->bufferingProgress = size * 100 / this->input->GetBufferingSize();
  356. return MP_RESULT_OK;
  357. }
  359. unsigned int  MediaPlayback::GetTotalTime()
  360. {
  361. if(this->HasVideo()) {
  363. return (unsigned int) ( (double) this->decaps->GetTotalVideoFrames(0)/ (double) this->decaps->GetVideoFrameRate(0));
  364. }
  366. return 0;
  367. }
  369. double        MediaPlayback::GetCurrentFps()
  370. {
  371. return 0;
  372. }
  374. BOOL          MediaPlayback::IsPaused()
  375. {
  376. return (this->paused || this->buffering);
  377. }
  379. BOOL          MediaPlayback::IsPlaying()
  380. {
  381. return this->playing;
  382. }
  384. BOOL          MediaPlayback::IsInFullscreen()
  385. {
  386. return this->fullscreen;
  387. }
  389. BOOL          MediaPlayback::IsOverlay()
  390. {
  391. if(this->videoRenderer) {
  393. return (strstr(this->videoRenderer->GetName(), "Overlay") != NULL);
  394. }
  396. return FALSE;
  397. }
  400. /**************************************************************
  401.  *                                                            *
  402.  *                      音频回调方法                          *
  403.  *                 -----------------------                    *
  404.  *                                                            *
  405.  **************************************************************/
  407. unsigned int PlaybackAudioCallback(void *lpData, void *buffer, unsigned int size)
  408. {
  409. int real_size;
  411. MediaPlayback *playback = (MediaPlayback *) lpData;
  413. if(playback && playback->playing && !playback->paused) {
  415. playback->audioBytes += size;
  417. if(playback->audioDecoder) {
  419. if((real_size = playback->audioDecoder->Decompress(buffer, size)) != size) {
  421. if(playback->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  422.  
  423. if(!(playback->input->GetBufferSize() >= playback->input->GetSize())) {
  425. playback->hasToBuffer = TRUE;
  427. return real_size;
  428. }
  429. else {
  431. if(!playback->end) {
  433. playback->end = TRUE;
  435. playback->Pause();
  436. playback->decaps->UpdateForSize();
  437. playback->Pause();
  439. return real_size;
  440. }
  441. else {
  443. memset(buffer, 0, size);
  444. return size;
  445. }
  446. }
  447. }
  448. else {
  450. memset(buffer, 0, size);
  451. return size;
  452. }
  453. }
  455. return size;
  456. }
  457. }
  458. else {
  460. memset(buffer, 0, size);
  461. return size;
  462. }
  464. return 0;
  465. }
  467. /**************************************************************
  468.  *                                                            *
  469.  *                       视频线程方法                         *
  470.  *                 -----------------------                    *
  471.  *                                                            *
  472.  **************************************************************/
  474. /*
  475.  * 仅有视频的线程 
  476.  *
  477.  */
  479. DWORD WINAPI PlaybackVideoOnlyThreadFunc( LPVOID lpData)
  480. {
  481. MediaPlayback *playback = (MediaPlayback *) lpData;
  482. int timeDiff;
  483. MediaBuffer *frame = NULL;
  485. if(playback != NULL) {
  487. playback->baseTime = GetTickCount();
  489. while(playback->playing) {
  491. /*
  492.  * 检查是否正在缓冲
  493.  *
  494.  */
  497. if(playback->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  499. if((playback->input->GetBufferPosition() > 0.95*playback->input->GetBufferSize()) && 
  500.   !(playback->input->GetBufferSize() >= playback->input->GetSize())) {
  502. startBuffering:
  504. DWORD size  = playback->input->GetBufferSize();
  505. DWORD sizeI = playback->input->GetBufferSize();
  507. /*
  508.  * 等待更多缓冲
  509.  */
  511. playback->bufferingProgress = 0;
  512. playback->buffering = TRUE;
  514. while(size < sizeI + playback->input->GetBufferingSize() && !(playback->input->GetBufferSize() >= playback->input->GetSize())) {
  516. Sleep(10);
  517. size = playback->input->GetBufferSize();
  519. playback->bufferingProgress = (size - sizeI) * 100 / playback->input->GetBufferingSize();
  520. }
  522. playback->buffering = FALSE;
  524. playback->decaps->UpdateForSize();
  525. playback->baseTime = GetTickCount();
  526. playback->videoFrames = 0;
  528. RECT rect;
  530. GetClientRect(playback->hwndPlayback, &rect);
  531. InvalidateRect(playback->hwndPlayback, &rect, TRUE); 
  532.   UpdateWindow(playback->hwndPlayback);
  533. }
  534. }
  536. startPlaying:
  538. frame = NULL;
  540. if(!playback->paused) {
  542. if(playback->fastForward) {
  544. playback->decaps->SeekNextKeyFrame(0);
  545. }
  546. else {
  547. if(playback->rewind) {
  549. playback->decaps->SeekPreviousKeyFrame(0);
  550. }
  551. }
  553. /*
  554.  * 合成
  555.  *
  556.  */
  558. if(!playback->fastForward && !playback->rewind) {
  560. timeDiff = playback->GetVideoTime() - (GetTickCount() - playback->baseTime);
  562. if(timeDiff > 10) {
  564. Sleep(timeDiff/2);
  565. }
  567. if(timeDiff < -150) {
  569. /*
  570.  * 跳过，即不进行补偿
  571.  */
  573. playback->videoBuffer->DropOneFrame();
  574. playback->videoFrames++;
  575. }
  577. if(timeDiff < -230) {
  579. /*
  580.  * 跳过，即不进行补偿
  581.  */
  583. playback->videoBuffer->DropOneFrame();
  584. playback->videoFrames++;
  585. }
  586. }
  587. else {
  589. Sleep(80);
  590. }
  593. frame = playback->videoBuffer->GetOneFrame();
  594. playback->videoFrames++;
  596. if(frame == NULL) {
  598. if(playback->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  600. if(playback->input->GetBufferSize() < playback->input->GetSize()) {
  602. goto startBuffering;
  603. }
  604. }
  606. if(!playback->loop) {
  608. SendMessage(playback->hwndPlayback, WM_PLAYA_PLAYBACK_END, 0, 0);
  609. playback->Stop(TRUE);
  611. }
  612. else {
  614. playback->decaps->Rewind(0, 0);
  616. playback->videoBuffer->StopBuffering();
  617. playback->videoBuffer->StartBuffering(playback->decaps->GetVideoWidth(0));
  619. playback->videoFrames = 0;
  620. playback->baseTime    = GetTickCount();
  622. goto startPlaying;
  623. }
  625. break;
  626. }
  628. WaitForSingleObject(playback->playbackMutex, INFINITE);
  630. if(!playback->paused) {
  632.     if(playback->fullscreen) {
  634. playback->videoRenderer->DrawFullscreen(frame, playback->decaps->GetCurrentVideoFrame(0), 
  635. playback->videoDecoder->GetInvertFlag(), playback->desktopMode);
  636. }
  637. else {
  638. playback->videoRenderer->Draw(frame, playback->videoRect, playback->decaps->GetCurrentVideoFrame(0), 
  639.   playback->videoDecoder->GetInvertFlag());
  640. }
  641. }
  643. ReleaseMutex(playback->playbackMutex);
  645. }
  646. }
  647. }
  648. else {
  650. MessageBox(playback->hwndPlayback, "Playing : NULL playback engine!", "", MB_OK);
  651. }
  653. return 0;
  654. }
  656. /*
  657.  * 视频与音频线程（即主线程）同步
  658.  */
  660. DWORD WINAPI PlaybackVideoAndAudioThreadFunc( LPVOID lpData)
  661. {
  662. MediaPlayback *playback = (MediaPlayback *) lpData;
  663. long  timeDiff;
  664. MediaBuffer *frame = NULL;
  666. if(playback != NULL)
  667. {
  668. while(playback->playing) {
  670. if(playback->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  672. if(((playback->input->GetBufferPosition() > 0.95*playback->input->GetBufferSize()) && 
  673.   !(playback->input->GetBufferSize() >= playback->input->GetSize())) || playback->hasToBuffer) {
  675. startBufferingWAudio:
  677. if(!playback->audioRenderer->paused)
  678. playback->audioRenderer->Pause();
  680. if(playback->input->GetBufferSize() >= playback->input->GetSize()) {
  682. playback->decaps->UpdateForSize();
  684. if(playback->audioRenderer->paused)
  685. playback->audioRenderer->Pause();
  687. goto startPlayingWAudio;
  688. }
  690. DWORD size  = playback->input->GetBufferSize();
  691. DWORD sizeI = playback->input->GetBufferSize();
  693. /*
  694.  * 等待更多缓冲
  695.  */
  697. playback->bufferingProgress = 0;
  698. playback->buffering = TRUE;
  700. while(size < sizeI + playback->input->GetBufferingSize() && !(playback->input->GetBufferSize() >= playback->input->GetSize())) {
  702. Sleep(10);
  703. size = playback->input->GetBufferSize();
  705. playback->bufferingProgress = (size - sizeI) * 100 / playback->input->GetBufferingSize();
  706. }
  708. playback->buffering   = FALSE;
  709. playback->hasToBuffer = FALSE;
  711. playback->decaps->UpdateForSize();
  713. RECT rect;
  715. GetClientRect(playback->hwndPlayback, &rect);
  716. InvalidateRect(playback->hwndPlayback, &rect, TRUE); 
  717.   UpdateWindow(playback->hwndPlayback);
  719. if(playback->audioRenderer->paused)
  720. playback->audioRenderer->Pause();
  721. }
  722. }
  724. startPlayingWAudio:
  726. frame = NULL;
  728. if(!playback->paused) {
  730. if(playback->fastForward) {
  732. playback->decaps->SeekNextKeyFrame(0);
  733. }
  734. else {
  735. if(playback->rewind) {
  737. playback->decaps->SeekPreviousKeyFrame(0);
  738. }
  739. }
  741. /*
  742.  * 同步
  743.  *
  744.  */
  746. if(!playback->fastForward && !playback->rewind) {
  748. timeDiff = playback->GetVideoTime() - playback->GetAudioTime();
  752. if(timeDiff == 0) {
  754. /*
  755.  * 什么也不做
  756.  */
  757. }
  758. else {
  760. if(timeDiff > 10) {
  761. Sleep(timeDiff/2);
  762. }
  764. if(timeDiff < -150) {
  766. /*
  767.  * 跳过，不进行补偿
  768.  */
  770. playback->videoBuffer->DropOneFrame();
  771. playback->videoFrames++;
  772. }
  775. if(timeDiff < -230) {
  777. /*
  778.  * 跳过，不进行补偿
  779.  */
  781. playback->videoBuffer->DropOneFrame();
  782. playback->videoFrames++;
  783. }
  784. }
  785. }
  786. else {
  788. Sleep(120);
  789. }
  791. frame = playback->videoBuffer->GetOneFrame();
  792. playback->videoFrames++;
  794. if(frame == NULL) {
  796. /*
  797.  * 在文件或缓冲末尾
  798.  */
  800. if(playback->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  802. if(playback->input->GetBufferSize() < playback->input->GetSize()) {
  804. goto startBufferingWAudio;
  805. }
  806. else {
  808. if(!playback->audioRenderer->paused)
  809. playback->audioRenderer->Pause();
  811. playback->decaps->UpdateForSize();
  813. frame = playback->videoBuffer->GetOneFrame();
  815. if(playback->audioRenderer->paused)
  816. playback->audioRenderer->Pause();
  817. }
  818. }
  819. }
  821. if(frame == NULL) {
  823. if(!playback->loop) {
  825. SendMessage(playback->hwndPlayback, WM_PLAYA_PLAYBACK_END, 0, 0);
  826. playback->Stop(TRUE);
  827. }
  828. else {
  830. playback->decaps->Rewind(0, 0);
  832. if(!playback->fastForward && !playback->rewind) {
  834. if(playback->hasAudio)
  835. playback->audioRenderer->Stop();
  837. if(playback->hasAudio)
  838. playback->audioDecoder->EmptyAudioBuffer();
  839. }
  841. playback->audioBytes      = 0;
  842. playback->videoFrames     = 0;
  844. playback->videoBuffer->StopBuffering();
  845. playback->videoBuffer->StartBuffering(playback->decaps->GetVideoWidth(0));
  847. if(!playback->fastForward && !playback->rewind) {
  849. if(playback->hasAudio)
  850. playback->audioRenderer->Start();
  851. }
  853. goto startPlayingWAudio;
  854. }
  856. break;
  857. }
  859. WaitForSingleObject(playback->playbackMutex, INFINITE);
  861. if(!playback->paused) {
  863. if(playback->fullscreen) {
  865. playback->videoRenderer->DrawFullscreen(frame, playback->decaps->GetCurrentVideoFrame(0), playback->videoDecoder->GetInvertFlag(), playback->desktopMode);
  866. }
  867. else {
  869. playback->videoRenderer->Draw(frame, playback->videoRect, playback->decaps->GetCurrentVideoFrame(0), playback->videoDecoder->GetInvertFlag());
  870. }
  871. }
  873. ReleaseMutex(playback->playbackMutex);
  874. }
  875. }
  876. }
  878. return 0;
  879. }
  881. /*
  882.  * 图形设备接口(GDI)方法
  883.  *
  884.  */
  886. MP_RESULT     MediaPlayback::FlipToGDI() 
  887. {
  888. return MP_RESULT_OK;
  889. }
  892. /**************************************************************
  893.  *                                                            *
  894.  *                      视频回调方法                          *
  895.  *                 ------------------------                   *
  896.  *                                                            *
  897.  **************************************************************/
  900. MP_RESULT     MediaPlayback::Play()
  901. {
  902. if(this->HasAudio() || this->HasVideo()) {
  904. if(this->fastForward) {
  906. this->fastForward = FALSE;
  908. this->baseTime = GetTickCount();
  910. this->videoFrames = 0;
  911. this->audioBytes  = 0;
  913. if(this->decaps) {
  915. this->decaps->ReSeekAudio(0);
  916. }
  918. if(this->hasAudio) {
  920. this->audioDecoder->EmptyAudioBuffer();
  922. this->audioRenderer->SetVolume(this->volume);
  924. this->audioRenderer->Stop();
  925. this->audioRenderer->Start();
  926. }
  927. }
  928. else {
  930. if(this->rewind) {
  932. this->rewind  = FALSE;
  934. this->baseTime = GetTickCount();
  936. this->videoFrames     = 0;
  937. this->audioBytes      = 0;
  939. if(this->decaps) {
  941. this->decaps->ReSeekAudio(0);
  942. }
  944. if(this->hasAudio) {
  946. this->audioDecoder->EmptyAudioBuffer();
  948. this->audioRenderer->SetVolume(this->volume);
  949. this->audioRenderer->Stop();
  950. this->audioRenderer->Start();
  951. }
  952. }
  953. else {
  955. if(this->paused) {
  957. this->Pause();
  958. return MP_RESULT_OK;
  959. }
  961. if(this->playing)
  962. return MP_RESULT_ERROR;
  964. this->playing = TRUE;
  965. this->paused  = FALSE;
  967. this->videoFrames = 0;
  968. this->audioBytes  = 0;
  970. this->decaps->Rewind(0, 0);
  972. if(this->HasAudio()) {
  974. this->audioDecoder->EmptyAudioBuffer();
  976. this->audioRenderer->SetVolume(this->volume);
  978. this->videoBuffer->StartBuffering(this->decaps->GetVideoWidth(0));
  980. if(this->audioRenderer->paused && (this->input->GetCaps() & MEDIA_CAPS_BUFFERIZE)) {
  982. this->audioRenderer->Pause();
  983. this->audioRenderer->Stop();
  984. this->audioRenderer->Start();
  985. }
  986. else {
  987. this->audioRenderer->Start();
  988. }
  990. this->videoThread = CreateThread( NULL, 0, PlaybackVideoAndAudioThreadFunc, (LPVOID) this, 0, &this->videoThreadId );
  992. return MP_RESULT_OK;
  993. }
  994. else {
  996. if(this->HasVideo()) {
  998. this->videoBuffer->StartBuffering(this->decaps->GetVideoWidth(0));
  1000. this->videoThread = CreateThread( NULL, 0, PlaybackVideoOnlyThreadFunc, (LPVOID) this, 0, &this->videoThreadId );
  1002. return MP_RESULT_OK;
  1003. }
  1004. }
  1005. }
  1006. }
  1007. }
  1009. return MP_RESULT_ERROR;
  1010. }
  1012. MP_RESULT     MediaPlayback::Pause()
  1013. {
  1014. if(this->playing) {
  1016. if(this->paused) {
  1018. if(this->hasAudio) {
  1019. this->audioRenderer->Pause();
  1020. }
  1022. this->paused = FALSE;
  1024. ReleaseMutex(this->playbackMutex);
  1026. this->baseTime += (GetTickCount() - this->stopTime);
  1028. ResumeThread(this->videoThread);
  1029. }
  1030. else {
  1032. WaitForSingleObject(this->playbackMutex, INFINITE);
  1034. if(!this->fastForward && !this->rewind) {
  1036. if(this->hasAudio) {
  1037. this->audioRenderer->Pause();
  1038. }
  1039. }
  1040. else {
  1042. this->videoFrames     = 0;
  1044. if(this->hasAudio) {
  1046. this->decaps->ReSeekAudio(0);
  1047. this->audioDecoder->EmptyAudioBuffer();
  1049. this->audioBytes     = 0;
  1051. this->audioRenderer->Stop();
  1052. this->audioRenderer->Start();
  1053. this->audioRenderer->Pause();
  1054. }
  1055. }
  1057. this->fastForward = FALSE;
  1058. this->rewind      = FALSE;
  1060. this->stopTime = GetTickCount();
  1062. SuspendThread(this->videoThread);
  1063. this->paused = TRUE;
  1064. }
  1065. }
  1067. return MP_RESULT_ERROR;
  1068. }
  1070. MP_RESULT     MediaPlayback::NextFrame()
  1071. {
  1072. return MP_RESULT_ERROR;
  1073. }
  1075. MP_RESULT     MediaPlayback::Stop(int redrawWindow)
  1076. {
  1077. if(this->paused)
  1078. this->Pause();
  1080. if(this->playing) {
  1082. WaitForSingleObject(this->playbackMutex, INFINITE);
  1084. if(this->hasAudio) {
  1086. this->audioRenderer->Stop();
  1087. }
  1089. this->playing = FALSE;
  1091. this->buffering = FALSE;
  1092. this->bufferingProgress = 0;
  1094. if(this->HasVideo()) {
  1096. this->videoBuffer->StopBuffering();
  1097. }
  1099. ReleaseMutex(this->playbackMutex);
  1100. }
  1102. this->fastForward  = FALSE;
  1103. this->rewind       = FALSE;
  1105. this->playing      = FALSE;
  1106. this->paused       = FALSE;
  1108. this->audioBytes      = 0;
  1109. this->videoFrames     = 0;
  1111. this->decaps->Rewind(0, 0);
  1113. if(this->hasAudio)
  1114. this->audioDecoder->EmptyAudioBuffer();
  1116. if(this->videoRenderer)
  1117. this->videoRenderer->Stop();
  1119. /*
  1120.  * 刷新
  1121.  */
  1123. RECT rect;
  1125. if(redrawWindow) {
  1127. GetClientRect(this->hwndPlayback, &rect);
  1128. InvalidateRect(this->hwndPlayback, &rect, TRUE); 
  1129.   UpdateWindow(this->hwndPlayback);
  1130. }
  1132. TerminateThread(this->videoThread, 0);
  1134. return MP_RESULT_ERROR;
  1135. }
  1137. MP_RESULT     MediaPlayback::FastForward()
  1138. {
  1139. if(this->paused) {
  1141. this->fastForward = TRUE;
  1142. this->paused      = FALSE;
  1144. ReleaseMutex(this->playbackMutex);
  1145. this->baseTime += (GetTickCount() - this->stopTime);
  1147. ResumeThread(this->videoThread);
  1149. return MP_RESULT_OK;
  1150. }
  1152. if(this->playing && !this->rewind && !this->fastForward) {
  1154. if(this->hasAudio) {
  1155. this->audioRenderer->Stop();
  1156. }
  1158. this->stopTime = GetTickCount();
  1160. this->fastForward = TRUE;
  1161. }
  1163. return MP_RESULT_OK;
  1164. }
  1166. MP_RESULT     MediaPlayback::Rewind()
  1167. {
  1168. if(this->paused) {
  1170. this->rewind = TRUE;
  1171. this->paused = FALSE;
  1173. ReleaseMutex(this->playbackMutex);
  1174. this->baseTime += (GetTickCount() - this->stopTime);
  1176. ResumeThread(this->videoThread);
  1178. return MP_RESULT_OK;
  1179. }
  1181. if(this->playing && !this->fastForward && !this->rewind) {
  1183. if(this->hasAudio) {
  1184. this->audioRenderer->Stop();
  1185. }
  1187. this->stopTime = GetTickCount();
  1189. this->rewind = TRUE;
  1190. }
  1193. return MP_RESULT_OK;
  1194. }
  1196. MP_RESULT     MediaPlayback::MaintainImage()
  1197. {
  1198. if(this->HasVideo()) {
  1200. if(this->fullscreen) {
  1202. this->videoRenderer->DrawFullscreen(this->videoBuffer->GetLastFrame(), 0, this->videoDecoder->GetInvertFlag(), this->desktopMode);
  1203. }
  1204. else {
  1206. this->videoRenderer->Draw(this->videoBuffer->GetLastFrame(), this->videoRect, 0, this->videoDecoder->GetInvertFlag());
  1207. }
  1208. }
  1210. return MP_RESULT_OK;
  1211. }
  1213. MP_RESULT     MediaPlayback::Seek(int percent)
  1214. {
  1215. int has_to_play = 0;
  1216. RECT rect;
  1218. if(this->HasAudio() || this->HasVideo()) {
  1220. if(this->playing) {
  1222. Stop(FALSE);
  1223. has_to_play = 1;
  1224. }
  1226. this->decaps->Seek(0, 0, percent);
  1228. if(this->input->GetCaps() & MEDIA_CAPS_BUFFERIZE) {
  1230. this->decaps->UpdateForSize();
  1231. }
  1233. if(this->hasAudio)
  1234. this->audioDecoder->EmptyAudioBuffer();
  1236. if(has_to_play) {
  1238. this->playing = TRUE;
  1239. this->paused  = FALSE;
  1241. this->videoFrames     = 0;
  1242. this->audioBytes      = 0;
  1244. if(this->HasAudio()) {
  1246. this->audioRenderer->Start();
  1248. this->videoThread = CreateThread( NULL, 0, PlaybackVideoAndAudioThreadFunc, (LPVOID) this, 0, &this->videoThreadId );
  1249. }
  1250. else {
  1252. this->videoThread = CreateThread( NULL, 0, PlaybackVideoOnlyThreadFunc, (LPVOID) this, 0, &this->videoThreadId );
  1253. }
  1254. }
  1256. GetClientRect(this->hwndPlayback, &rect);
  1257. InvalidateRect(this->hwndPlayback, &rect, TRUE); 
  1258.   UpdateWindow(this->hwndPlayback);
  1260. }
  1262. return MP_RESULT_ERROR;
  1263. }
  1265. MP_RESULT     MediaPlayback::SetFullscreen(int active, HWND hwnd)
  1266. {
  1267. if(active && !this->fullscreen) {
  1269. int has_to_play = 0;
  1271. if(this->playing && !this->paused) {
  1273. this->Pause();
  1274. has_to_play = 1;
  1275. }
  1277. this->fullscreen = TRUE;
  1279. if(this->videoRenderer->InitFullscreen(hwnd, this->decaps->GetVideoWidth(0), this->decaps->GetVideoHeight(0)) != MP_RESULT_OK) {
  1281. this->videoRenderer->Init(hwnd, this->decaps->GetVideoWidth(0), this->decaps->GetVideoHeight(0));
  1282. this->fullscreen = FALSE;
  1284. return MP_RESULT_ERROR;
  1285. }
  1287. if(has_to_play) {
  1289. this->Pause();
  1290. }
  1291. }
  1292. else {
  1294. if(this->fullscreen) {
  1296. int has_to_play = 0;
  1298. if(this->playing && !this->paused) {
  1300. this->Pause();
  1301. has_to_play = 1;
  1302. }
  1304. this->videoRenderer->Init(hwnd, this->decaps->GetVideoWidth(0), this->decaps->GetVideoHeight(0));
  1305. this->fullscreen = FALSE;
  1307. if(has_to_play) {
  1309. this->Pause();
  1310. }
  1311. }
  1312. }
  1314. return MP_RESULT_ERROR;
  1315. }
  1317. MP_RESULT     MediaPlayback::SetVolume(int volume)
  1318. {
  1319. this->volume = volume;
  1321. if(this->hasAudio) {
  1323. this->audioRenderer->SetVolume(this->volume);
  1324. }
  1326. return MP_RESULT_OK;
  1327. }
  1329. MP_RESULT     MediaPlayback::SetLoop(int loop)
  1330. {
  1331. this->loop = loop;
  1333. return MP_RESULT_OK;
  1334. }
  1336. MP_RESULT     MediaPlayback::SetDesktopMode(BOOL on)
  1337. {
  1338. this->desktopMode = on;
  1340. return MP_RESULT_OK;
  1341. }
  1343. MP_RESULT     MediaPlayback::SetVideoRect(RECT *rect)
  1344. {
  1345. this->videoRect = rect;
  1347. return MP_RESULT_OK;
  1348. }
  1350. MP_RESULT     MediaPlayback::Close()
  1351. {
  1352. if(this->input)
  1353. this->input->Close();
  1355. if(this->HasVideo()) {
  1357. /*
  1358.  * 清除视频
  1359.  *
  1360.  */
  1362. this->Stop(FALSE);
  1364. this->videoRenderer->Close();
  1366. this->videoBuffer->StopBuffering();
  1368. this->videoBuffer->ReleaseConnections();
  1369. this->videoDecoder->ReleaseConnections();
  1370. this->decaps->ReleaseConnections();
  1372. }
  1374. if(this->HasAudio()) {
  1376. /*
  1377.  * 清除音频
  1378.  *
  1379.  */
  1381. this->audioRenderer->Close();
  1382. this->audioDecoder->ReleaseConnections();
  1383. }
  1385. if(this->hasSubtitles) {
  1387. this->subtitler->ReleaseConnections();
  1388. this->subtitler->Close();
  1389. }
  1391. return MP_RESULT_OK;
  1392. }