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

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

VC书籍

开发平台：

Visual C++

VideoRendererOverlay.cpp：源码内容
  1. /**************************************************************************************
  2.  *                                                                                    *
  3.  *                                                                                    *
  4.  **************************************************************************************/
  6. #include "VideoRendererOverlay.h"
  8. DDPIXELFORMAT ddpfOverlayFormats[] = 
  9. {   
  10. {sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('Y','U','Y','2'),0,0,0,0,0},  // YUY2
  11. {sizeof(DDPIXELFORMAT), DDPF_FOURCC,MAKEFOURCC('U','Y','V','Y'),0,0,0,0,0},  // UYVY
  12. };
  14. media_video_mode_t videoModes[] = 
  15. {
  16. VIDEO_MODE_YUY2,
  17. VIDEO_MODE_UYVY,
  18. };
  23. MediaVideoRendererOverlay::MediaVideoRendererOverlay()
  24. {
  25. this->subtitler    = NULL;
  27. this->lpdd         = NULL;
  28. this->lpddsPrimary = NULL;
  29. this->lpddsOverlay = NULL;
  31. this->videoMode    = VIDEO_MODE_NONE;
  32. }
  34. MediaVideoRendererOverlay::~MediaVideoRendererOverlay()
  35. {
  36. }
  40. media_type_t MediaVideoRendererOverlay::GetType()
  41. {
  42. return MEDIA_TYPE_VIDEO_RENDERER;
  43. }
  45. char *MediaVideoRendererOverlay::GetName()
  46. {
  47. return "Overlay Video Renderer";
  48. }
  50. MP_RESULT MediaVideoRendererOverlay::Connect(MediaItem *item)
  51. {
  54. if(item && item->GetType() == MEDIA_TYPE_SUBTITLER) {
  57. this->subtitler = (MediaItemSubtitler *) item;
  59. return MP_RESULT_OK;
  60. }
  62. return MP_RESULT_ERROR;
  63. }
  65. MP_RESULT MediaVideoRendererOverlay::ReleaseConnections()
  66. {
  69. this->subtitler   = NULL;
  71. return MP_RESULT_OK;
  72. }
  75. DWORD         MediaVideoRendererOverlay::GetCaps()
  76. {
  77. return 0;
  78. }
  80. MP_RESULT     MediaVideoRendererOverlay::Configure(HINSTANCE hInstance, HWND hwnd)
  81. {
  82. return MP_RESULT_ERROR;
  83. }
  87. BOOL MediaVideoRendererOverlay::AreOverlaysSupported()
  88. {
  90.     DDCAPS  capsDrv;
  91.     HRESULT ddrval;
  95.     ZeroMemory(&capsDrv, sizeof(capsDrv));
  96.     capsDrv.dwSize = sizeof(capsDrv);
  97.  
  98.     ddrval = this->lpdd->GetCaps(&capsDrv, NULL);
  99.     
  100. if (FAILED(ddrval))
  101.         return FALSE;
  102.  
  105.     if (!(capsDrv.dwCaps & DDCAPS_OVERLAY))
  106.         return FALSE;
  108.     return TRUE;
  109. }
  112. MP_RESULT MediaVideoRendererOverlay::Init(HWND hwnd, unsigned int width, unsigned int height)
  113. {
  114. if(hwnd && width > 0 && height > 0) {
  116. HRESULT         ddrval;
  117.     DDSURFACEDESC2  ddsd;
  118.     DDSURFACEDESC2  ddsdOverlay;
  119. DWORD           i;
  120.     
  121. this->invertFlag  = FALSE;
  123. ddrval = DirectDrawCreateEx(NULL, (VOID**)&this->lpdd, IID_IDirectDraw7, NULL);
  125. if( FAILED(ddrval))
  126. return MP_RESULT_ERROR;
  127.     
  128. /*
  129.  * 检查是否支持叠加
  130.  */
  132. if(!this->AreOverlaysSupported()) {
  134.         this->lpdd->Release();
  135. this->lpdd=NULL;
  136. return MP_RESULT_ERROR;
  137. }
  140. ddrval = this->lpdd->SetCooperativeLevel(NULL, DDSCL_NORMAL);
  142. if( FAILED(ddrval)) {
  144.         this->lpdd->Release();
  145. this->lpdd=NULL;
  146. return MP_RESULT_ERROR;
  147. }
  150.    
  151.     ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  153. ddsd.dwSize  = sizeof(DDSURFACEDESC2);
  154. ddsd.dwFlags = DDSD_CAPS;
  155. ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  156.     
  157. ddrval = this->lpdd->CreateSurface(&ddsd, &this->lpddsPrimary, NULL );
  159. if(FAILED(ddrval)) {
  161. this->lpdd->Release();
  162.     this->lpdd=NULL;
  163. return MP_RESULT_ERROR;
  164. }
  168.     ddrval = this->lpdd->CreateClipper(0, &this->lpddClipper, NULL);
  170. if(FAILED(ddrval)) {
  172. return MP_RESULT_ERROR;
  173. }
  175.     ddrval = this->lpddClipper->SetHWnd(0, hwnd);
  177. if(FAILED(ddrval)) {
  179. return MP_RESULT_ERROR;
  180. }
  182.     ddrval = this->lpddsPrimary->SetClipper(this->lpddClipper);
  185.     
  186.     ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
  188. ddsdOverlay.dwSize  = sizeof(DDSURFACEDESC2);
  190.     ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
  191. ddsdOverlay.dwFlags= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  193. ddsdOverlay.dwWidth           = width;
  194. ddsdOverlay.dwHeight          = height;
  195.     
  196.     i = 0;
  197.     
  198. do {
  200. ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
  201. this->videoMode = videoModes[i];
  203.    ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
  205. } while( FAILED(ddrval) && (++i < 2) );
  209. if(FAILED(ddrval)) {
  211.     ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
  212. ddsdOverlay.dwSize     = sizeof(DDSURFACEDESC2);
  214. ddsdOverlay.dwWidth           = width;
  215. ddsdOverlay.dwHeight          = height;
  216.         ddsdOverlay.dwBackBufferCount = 0;
  218. ddsdOverlay.ddsCaps.dwCaps    = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
  219. ddsdOverlay.dwFlags           = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  220.         
  222.     i = 0;
  223.     
  224. do {
  226. ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
  227. this->videoMode = videoModes[i];
  229.   ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
  231. } while( FAILED(ddrval) && (++i < 2) );
  232.         
  233. if (FAILED(ddrval)) {
  235. this->lpddsPrimary->Release();
  236. this->lpddsPrimary = NULL;
  238.         this->lpdd->Release();
  239. this->lpdd=NULL;
  241. this->videoMode = VIDEO_MODE_NONE;
  243.             return MP_RESULT_ERROR;
  244. }
  245. }
  247. if(FAILED(ddrval)) {
  249. return MP_RESULT_ERROR;
  250. }
  252. this->width  = width;
  253. this->height = height;
  255. this->bpp    = 16;
  259. ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  260. ddsd.dwSize     = sizeof(DDSURFACEDESC2);
  262. ddrval = this->lpddsPrimary->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WRITEONLY | DDLOCK_WAIT, NULL);
  264. if(FAILED(ddrval)) {
  266. return MP_RESULT_ERROR;
  267. }
  269. this->lpddsPrimary->Unlock(NULL);
  271. switch(ddsd.ddpfPixelFormat.dwRGBBitCount) {
  273. case 8:
  274. return MP_RESULT_ERROR;
  275. break;
  277. case 16:
  278. this->physicalDepth = 16;
  279. break;
  281. case 24:
  282. this->physicalDepth = 24;
  283. break;
  285. case 32:
  286. this->physicalDepth = 32;
  287. break;
  288. }
  292. ddrval = this->lpdd->GetDisplayMode(&ddsd);
  295. this->fullscreenWidth  = ddsd.dwWidth;
  296. this->fullscreenHeight = ddsd.dwHeight;
  300. this->hwndPlayback = hwnd;
  302. return MP_RESULT_OK;
  303. }
  304.     
  305. return MP_RESULT_ERROR;
  306. }
  308. MP_RESULT MediaVideoRendererOverlay::InitFullscreen(HWND hwnd, unsigned int width, unsigned int height)
  309. {
  310. if(hwnd && width > 0 && height > 0) {
  312. HRESULT         ddrval;
  313.     DDSURFACEDESC2  ddsd;
  314.     DDSURFACEDESC2  ddsdOverlay;
  315. DWORD           i;
  317. this->invertFlag  = FALSE;
  318.     
  319.     ddrval = DirectDrawCreateEx(NULL, (VOID**)&this->lpdd, IID_IDirectDraw7, NULL);
  321. if( FAILED(ddrval))
  322. return MP_RESULT_ERROR;
  323.   
  325. if(!this->AreOverlaysSupported()) {
  327.         this->lpdd->Release();
  328. this->lpdd=NULL;
  329. return MP_RESULT_ERROR;
  330. }
  333. ddrval = this->lpdd->SetCooperativeLevel(hwnd, DDSCL_NORMAL);
  335. if( FAILED(ddrval)) {
  337.         this->lpdd->Release();
  338. this->lpdd = NULL;
  340. return MP_RESULT_ERROR;
  341. }
  345. DDSURFACEDESC2 ddDesc;
  347. memset(&ddDesc, 0, sizeof(DDSURFACEDESC2));
  348. ddDesc.dwSize    = sizeof(DDSURFACEDESC2);
  352. ddrval = this->lpdd->GetDisplayMode(&ddDesc);
  354. if(FAILED(ddrval)) {
  356.         this->lpdd->Release();
  357. this->lpdd=NULL;
  358. return MP_RESULT_ERROR;;
  359. }
  363. this->fullscreenWidth  = ddDesc.dwWidth;
  364. this->fullscreenHeight = ddDesc.dwHeight;
  367.    
  368.     ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  370. ddsd.dwSize  = sizeof(DDSURFACEDESC2);
  371. ddsd.dwFlags = DDSD_CAPS;
  372. ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
  373.     
  374. ddrval = this->lpdd->CreateSurface(&ddsd, &this->lpddsPrimary, NULL );
  376. if(FAILED(ddrval)) {
  378. this->lpdd->Release();
  379.     this->lpdd=NULL;
  380. return MP_RESULT_ERROR;
  381. }
  384.     
  385.     ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
  387. ddsdOverlay.dwSize  = sizeof(DDSURFACEDESC2);
  389.     ddsdOverlay.ddsCaps.dwCaps = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
  390. ddsdOverlay.dwFlags= DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  392. ddsdOverlay.dwWidth           = width;
  393. ddsdOverlay.dwHeight          = height;
  394.     
  395.     i = 0;
  396.     
  397. do {
  399. ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
  400. this->videoMode = videoModes[i];
  402.    ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
  404. } while( FAILED(ddrval) && (++i < 2) );
  408. if(FAILED(ddrval)) {
  410.     ZeroMemory(&ddsdOverlay, sizeof(DDSURFACEDESC2));
  411. ddsdOverlay.dwSize     = sizeof(DDSURFACEDESC2);
  413. ddsdOverlay.dwWidth           = width;
  414. ddsdOverlay.dwHeight          = height;
  415.         ddsdOverlay.dwBackBufferCount = 0;
  417. ddsdOverlay.ddsCaps.dwCaps    = DDSCAPS_OVERLAY | DDSCAPS_VIDEOMEMORY;
  418. ddsdOverlay.dwFlags           = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT;
  419.         
  421.     i = 0;
  422.     
  423. do {
  425. ddsdOverlay.ddpfPixelFormat = ddpfOverlayFormats[i];
  426. this->videoMode = videoModes[i];
  428.   ddrval = this->lpdd->CreateSurface(&ddsdOverlay, &this->lpddsOverlay, NULL);
  430. } while( FAILED(ddrval) && (++i < 2) );
  431.         
  432. if (FAILED(ddrval)) {
  434. this->lpddsPrimary->Release();
  435. this->lpddsPrimary = NULL;
  437.         this->lpdd->Release();
  438. this->lpdd=NULL;
  440. this->videoMode = VIDEO_MODE_NONE;
  442.             return MP_RESULT_ERROR;
  443. }
  444. }
  446. if(FAILED(ddrval)) {
  448. return MP_RESULT_ERROR;
  449. }
  451. this->width  = width;
  452. this->height = height;
  454. this->bpp    = 16;
  456. this->hwndPlayback = hwnd;
  458. return MP_RESULT_OK;
  459. }
  460.     
  461. return MP_RESULT_ERROR;
  462. }
  464. MP_RESULT MediaVideoRendererOverlay::Stop()
  465. {
  466. if(this->lpdd && this->lpddsOverlay) {
  468. this->lpddsOverlay->UpdateOverlay(NULL, this->lpddsPrimary, NULL, DDOVER_HIDE, NULL);
  469. }
  471. return MP_RESULT_OK;
  472. }
  474. media_video_mode_t MediaVideoRendererOverlay::GetVideoMode()
  475. {
  476. return this->videoMode;
  477. }
  479. RECT *MediaVideoRendererOverlay::GetFullscreenRects()
  480. {
  481. DWORD width, height;
  483. switch(options.aspect_ratio) {
  485. case ASPECT_RATIO_FREE:
  486. case ASPECT_RATIO_ORIGINAL:
  488. width  = this->width;
  489. height = this->height;
  490. break;
  492. case ASPECT_RATIO_TV:
  493. case ASPECT_RATIO_WIDE:
  494. case ASPECT_RATIO_CUSTOM:
  496. if(aspectRatios[options.aspect_ratio].yFactor < aspectRatios[options.aspect_ratio].xFactor) {
  498. width  = this->width;
  499. height = this->width*aspectRatios[options.aspect_ratio].yFactor/aspectRatios[options.aspect_ratio].xFactor;
  500. }
  501. else {
  503. height = this->height;
  504. width  = this->height*aspectRatios[options.aspect_ratio].xFactor/aspectRatios[options.aspect_ratio].yFactor;
  505. }
  506. break;
  507. }
  509. if(this->fullscreenWidth * height / width > this->fullscreenHeight) {
  511. this->fullRects[0].left   = 0;
  512. this->fullRects[0].right  = (this->fullscreenWidth - (width * this->fullscreenHeight / height)) / 2;
  513. this->fullRects[0].top    = 0;
  514. this->fullRects[0].bottom = this->fullscreenHeight + 10;
  516. this->fullRects[1].left   = (this->fullscreenWidth - (width * this->fullscreenHeight / height)) / 2;
  517. this->fullRects[1].right  = (width * this->fullscreenHeight / height);
  518. this->fullRects[1].top    = 0;
  519. this->fullRects[1].bottom = this->fullscreenHeight + 10;
  521. this->fullRects[2].left   = this->fullRects[1].left + this->fullRects[1].right;
  522. this->fullRects[2].right  = (this->fullscreenWidth - (width * this->fullscreenHeight / height)) / 2;
  523. this->fullRects[2].top    = 0;
  524. this->fullRects[2].bottom = this->fullscreenHeight + 10;
  525. }
  526. else {
  528. this->fullRects[0].left   = 0;
  529. this->fullRects[0].right  = this->fullscreenWidth;
  530. this->fullRects[0].top    = 0;
  531. this->fullRects[0].bottom = (this->fullscreenHeight - (this->fullscreenWidth * height / width)) / 2;
  533. this->fullRects[1].left   = 0;
  534. this->fullRects[1].right  = this->fullscreenWidth;
  535. this->fullRects[1].top    = (this->fullscreenHeight - (this->fullscreenWidth * height / width)) / 2;
  536. this->fullRects[1].bottom = this->fullscreenWidth * height / width;
  538. this->fullRects[2].left   = 0;
  539. this->fullRects[2].right  = this->fullscreenWidth;
  540. this->fullRects[2].top    = this->fullRects[1].top + this->fullRects[1].bottom;
  541. this->fullRects[2].bottom = (this->fullscreenHeight - (this->fullscreenWidth * height / width)) / 2;
  542. }
  544. return this->fullRects;
  545. }
  547. MP_RESULT MediaVideoRendererOverlay::Draw(MediaBuffer *buffer, RECT *rect, int frameNumber, int invertFlag)
  548. {
  549. if(buffer && rect && this->lpdd && this->lpddsPrimary && this->lpddsOverlay) {
  551. POINT           pt;
  552.     HRESULT         ddrval;
  553.     RECT            rs, rd;
  554. DDOVERLAYFX     ovfx;
  555. DDSURFACEDESC2  ddsd;
  556. DDCAPS          capsDrv;
  557. unsigned int    uStretchFactor1000, i;
  558. unsigned int    uDestSizeAlign, uSrcSizeAlign;
  559. DWORD           dwUpdateFlags;
  560.        subtitles_t    *sub;
  561.  
  564. ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  565. ddsd.dwSize     = sizeof(DDSURFACEDESC2);
  567. ddrval = this->lpddsOverlay->Lock( NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);
  568.  
  569. if(FAILED(ddrval)) {
  571. return MP_RESULT_ERROR;
  572. }
  574. if(invertFlag) {
  576. for(i = 0; i < ddsd.dwHeight; i++) {
  578. memcpy((char *) ddsd.lpSurface + i*ddsd.lPitch, ((char *) buffer->GetData()) + (this->height - i - 1)*ddsd.dwWidth*this->bpp/8, ddsd.dwWidth*this->bpp/8);
  579. }
  581. }
  582. else {
  584. if(ddsd.dwWidth == ddsd.lPitch || this->videoMode == VIDEO_MODE_YUV12) {
  586. memcpy(ddsd.lpSurface, buffer->GetData(), this->width*this->height*this->bpp/8);
  587. }
  588. else {
  590. for(i = 0; i < ddsd.dwHeight; i++) {
  592. memcpy((char *) ddsd.lpSurface + i*ddsd.lPitch, ((char *) buffer->GetData()) + i*ddsd.dwWidth*this->bpp/8, ddsd.dwWidth*this->bpp/8);
  593. }
  594. }
  595. }
  597. this->lpddsOverlay->Unlock(NULL);
  601. ZeroMemory(&capsDrv, sizeof(DDCAPS));
  602. capsDrv.dwSize    = sizeof(DDCAPS);
  604. ddrval = this->lpdd->GetCaps(&capsDrv, NULL);
  606. if (FAILED(ddrval))
  607. return MP_RESULT_ERROR;
  608.     
  611. uStretchFactor1000 = capsDrv.dwMinOverlayStretch > 1000 ? capsDrv.dwMinOverlayStretch : 1000;
  612.     
  615. uDestSizeAlign = capsDrv.dwAlignSizeDest;
  616.     uSrcSizeAlign =  capsDrv.dwAlignSizeSrc;
  617.     
  618.     dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX | DDOVER_KEYDESTOVERRIDE;
  619.     
  620. if (capsDrv.dwCKeyCaps & DDCKEYCAPS_SRCOVERLAY)
  621. dwUpdateFlags |= DDOVER_KEYSRCOVERRIDE;
  622.     
  623. ZeroMemory(&ovfx, sizeof(DDOVERLAYFX));
  624. ovfx.dwSize     = sizeof(DDOVERLAYFX);
  626. switch(this->physicalDepth) {
  628. case 16:
  630. ovfx.dckSrcColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_16BPP;
  631. ovfx.dckSrcColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_16BPP;
  632.     
  633. ovfx.dckDestColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_16BPP;
  634. ovfx.dckDestColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_16BPP;
  635. break;
  637. case 24:
  638. case 32:
  639. default:
  641. ovfx.dckSrcColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_32BPP;
  642. ovfx.dckSrcColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_32BPP;
  643.     
  644. ovfx.dckDestColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_32BPP;
  645. ovfx.dckDestColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_32BPP;
  646. break;
  647. }
  651. pt.x = 0;
  652. pt.y = 0;
  654. ClientToScreen(this->hwndPlayback, &pt);
  656.     rd.left   = pt.x + rect->left; 
  657. rd.top    = pt.y + rect->top; 
  658. rd.right  = pt.x + rect->left + (rect->right  * uStretchFactor1000 + 999) / 1000;
  659. rd.bottom = pt.y + rect->bottom * uStretchFactor1000 / 1000;
  661. if (capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST && uDestSizeAlign)
  662. rd.right = (int)((rd.right + uDestSizeAlign - 1) / uDestSizeAlign) * uDestSizeAlign;
  665. rs.left   = 0; 
  666. rs.top    = 0; 
  667. rs.right  = this->width;
  668. rs.bottom = this->height;
  670. if(rd.right < this->fullscreenWidth && rd.left > 0 && rd.top > 0 && rd.bottom < this->fullscreenHeight) {
  672. }
  673. else {
  675. if(rd.right > this->fullscreenWidth) {
  677. rs.right  = (this->fullscreenWidth - rd.left) * this->width / (rd.right - rd.left);
  678. rd.right = this->fullscreenWidth;
  679. }
  682. if(rd.left < 0) {
  684. rs.left = -rd.left * this->width / (rd.right - rd.left);
  685. rd.left = 0;
  686. }
  688. if(rd.bottom > this->fullscreenHeight) {
  690. rs.bottom  = (this->fullscreenHeight - rd.top) * this->height / (rd.bottom - rd.top);
  691. rd.bottom = this->fullscreenHeight;
  692. }
  695. if(rd.top < 0) {
  697. rs.top = -rd.top * this->height / (rd.bottom - rd.top);
  698. rd.top = 0;
  699. }
  700. }
  702.    
  704. if (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC && uSrcSizeAlign)
  705. rs.right -= rs.right % uSrcSizeAlign;
  709. ddrval = this->lpddsOverlay->UpdateOverlay(&rs, this->lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
  710.     
  711. if(FAILED(ddrval)) {
  713.       
  714. return MP_RESULT_ERROR;
  715. }
  716.     
  717. return MP_RESULT_OK;
  718. }
  720. return MP_RESULT_ERROR;
  721. }
  723. MP_RESULT MediaVideoRendererOverlay::DrawFullscreen(MediaBuffer *buffer, int frameNumber, int invertFlag, int desktop)
  724. {
  725. if(buffer && this->lpdd && this->lpddsPrimary && this->lpddsOverlay) {
  728. HRESULT         ddrval;
  729.     RECT            rs, rd;
  730. DDOVERLAYFX     ovfx;
  731. DDSURFACEDESC2  ddsd;
  732. DDCAPS          capsDrv;
  733. unsigned int    uStretchFactor1000, i;
  734. unsigned int    uDestSizeAlign, uSrcSizeAlign;
  735. DWORD           dwUpdateFlags;
  736.  
  739. ZeroMemory(&ddsd, sizeof(DDSURFACEDESC2));
  740. ddsd.dwSize     = sizeof(DDSURFACEDESC2);
  742. ddrval = this->lpddsOverlay->Lock( NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL);
  743.  
  744. if(FAILED(ddrval)) {
  746. return MP_RESULT_ERROR;
  747. }
  749. if(invertFlag) {
  751. for(i = 0; i < ddsd.dwHeight; i++) {
  754. memcpy((char *) ddsd.lpSurface + i*ddsd.lPitch, ((char *) buffer->GetData()) + (this->height - i - 1)*ddsd.dwWidth*this->bpp/8, ddsd.dwWidth*this->bpp/8);
  755. }
  756. }
  757. else {
  759. if(ddsd.dwWidth == ddsd.lPitch) {
  761. memcpy(ddsd.lpSurface, buffer->GetData(), this->width*this->height*this->bpp/8);
  762. }
  763. else {
  765. for(i = 0; i < ddsd.dwHeight; i++) {
  767. memcpy((char *) ddsd.lpSurface + i*ddsd.lPitch, ((char *) buffer->GetData()) + i*ddsd.dwWidth*this->bpp/8, ddsd.dwWidth*this->bpp/8);
  768. }
  769. }
  770. }
  772. this->lpddsOverlay->Unlock(NULL);
  776. ZeroMemory(&capsDrv, sizeof(DDCAPS));
  777. capsDrv.dwSize    = sizeof(DDCAPS);
  779. ddrval = this->lpdd->GetCaps(&capsDrv, NULL);
  781. if (FAILED(ddrval))
  782. return MP_RESULT_ERROR;
  783.     
  786. uStretchFactor1000 = capsDrv.dwMinOverlayStretch > 1000 ? capsDrv.dwMinOverlayStretch : 1000;
  787.     
  789. uDestSizeAlign = capsDrv.dwAlignSizeDest;
  790.     uSrcSizeAlign =  capsDrv.dwAlignSizeSrc;
  791.     
  792.     dwUpdateFlags = DDOVER_SHOW | DDOVER_DDFX | DDOVER_KEYDESTOVERRIDE;
  793.     
  794. if (capsDrv.dwCKeyCaps & DDCKEYCAPS_SRCOVERLAY)
  795. dwUpdateFlags |= DDOVER_KEYSRCOVERRIDE;
  796.     
  798. ZeroMemory(&ovfx, sizeof(DDOVERLAYFX));
  799. ovfx.dwSize     = sizeof(DDOVERLAYFX);
  801. switch(this->physicalDepth) {
  803. case 16:
  805. ovfx.dckSrcColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_16BPP;
  806. ovfx.dckSrcColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_16BPP;
  807.     
  808. ovfx.dckDestColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_16BPP;
  809. ovfx.dckDestColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_16BPP;
  810. break;
  812. case 24:
  813. case 32:
  814. default:
  816. ovfx.dckSrcColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_32BPP;
  817. ovfx.dckSrcColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_32BPP;
  819. ovfx.dckDestColorkey.dwColorSpaceLowValue  = DD_OVERLAY_COLORKEY_32BPP;
  820. ovfx.dckDestColorkey.dwColorSpaceHighValue = DD_OVERLAY_COLORKEY_32BPP;
  821. break;
  822. }
  824.     rs.left   = 0; 
  825. rs.top    = 0; 
  826. rs.right  = this->width;
  827. rs.bottom = this->height;
  828.  
  830. if (capsDrv.dwCaps & DDCAPS_ALIGNSIZESRC && uSrcSizeAlign)
  831. rs.right -= rs.right % uSrcSizeAlign;
  832.  
  834. DWORD height;
  835. DWORD width;
  837. switch(options.aspect_ratio) {
  839. case ASPECT_RATIO_FREE:
  840. case ASPECT_RATIO_ORIGINAL:
  842. width  = this->width;
  843. height = this->height;
  844. break;
  846. case ASPECT_RATIO_TV:
  847. case ASPECT_RATIO_WIDE:
  848. case ASPECT_RATIO_CUSTOM:
  850. if(aspectRatios[options.aspect_ratio].yFactor < aspectRatios[options.aspect_ratio].xFactor) {
  852. width  = this->width;
  853. height = this->width*aspectRatios[options.aspect_ratio].yFactor/aspectRatios[options.aspect_ratio].xFactor;
  854. }
  855. else {
  857. height = this->height;
  858. width  = this->height*aspectRatios[options.aspect_ratio].xFactor/aspectRatios[options.aspect_ratio].yFactor;
  859. }
  860. break;
  861. }
  864. if(this->fullscreenWidth * height / width > this->fullscreenHeight) {
  866.     rd.left   = (this->fullscreenWidth - (this->fullscreenHeight * width / this->height)) / 2; 
  867. rd.top    = 0; 
  868. rd.right  = rd.left + (this->fullscreenHeight * width / height);
  869. rd.bottom = this->fullscreenHeight; 
  870. }
  871. else {
  873.     rd.left   = 0; 
  874. rd.top    = (this->fullscreenHeight - (this->fullscreenWidth * height / width)) / 2; 
  875. rd.right  = this->fullscreenWidth;
  876. rd.bottom = rd.top + (this->fullscreenWidth * height / width); 
  877. }
  879. if (capsDrv.dwCaps & DDCAPS_ALIGNSIZEDEST && uDestSizeAlign)
  880. rd.right = (int)((rd.right + uDestSizeAlign - 1) / uDestSizeAlign) * uDestSizeAlign;
  883. ddrval = this->lpddsOverlay->UpdateOverlay(&rs, this->lpddsPrimary, &rd, dwUpdateFlags, &ovfx);
  884.     
  885. if(FAILED(ddrval)) {
  887.       
  888. return MP_RESULT_ERROR;
  889. }
  890.     
  891. return MP_RESULT_OK;
  892. }
  894. return MP_RESULT_ERROR;
  895. }
  897. MP_RESULT MediaVideoRendererOverlay::Close()
  898. {
  899. if(this->lpdd) {
  901. this->lpdd->RestoreDisplayMode();
  902. this->lpdd->SetCooperativeLevel(this->hwndPlayback, DDSCL_NORMAL);
  903. }
  905. if(this->lpddsOverlay) {
  907. this->lpddsOverlay->Release();
  908. this->lpddsOverlay = NULL;
  909. }
  911. if(this->lpddsPrimary) {
  913. this->lpddsPrimary->Release();
  914. this->lpddsPrimary = NULL;
  915. }
  917. if(this->lpdd) {
  919. this->lpdd->Release();
  920. this->lpdd = NULL;
  921. }
  923. this->invertFlag  = FALSE;
  925. return MP_RESULT_ERROR;
  926. }