src/msw/mediactrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/mediactrl.cpp
   3 // Purpose:     wxMediaCtrl MSW
   4 // Author:      Ryan Norton <wxprojects@comcast.net>
   5 // Modified by:
   6 // Created:     11/07/04
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Ryan Norton
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 //---------------------------------------------------------------------------
  13 //      Pre-wx includes
  14 //---------------------------------------------------------------------------
  15
  16 //#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  17 //#pragma implementation "moviectrl.h"
  18 //#endif
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24 #pragma hdrstop
  25 #endif
  26
  27 #include "wx/mediactrl.h"
  28
  29 #if wxUSE_MEDIACTRL
  30
  31 //###########################################################################
  32 //  DECLARATIONS
  33 //###########################################################################
  34
  35 IMPLEMENT_CLASS(wxMediaCtrl, wxControl);
  36 IMPLEMENT_DYNAMIC_CLASS(wxMediaEvent, wxEvent);
  37 DEFINE_EVENT_TYPE(wxEVT_MEDIA_FINISHED);
  38
  39 //---------------------------------------------------------------------------
  40 //  wxMediaCtrlImpl
  41 //---------------------------------------------------------------------------
  42
  43 class wxMediaCtrlImpl
  44 {
  45 public:
  46     wxMediaCtrlImpl() : m_bLoaded(false)
  47     {                                                                   }
  48
  49     virtual ~wxMediaCtrlImpl()
  50     {                               }
  51
  52     virtual bool Create(wxMediaCtrl* WXUNUSED(ctrl))
  53     {   return false;               }
  54
  55     virtual bool Play() { return false; }
  56     virtual bool Pause() { return false; }
  57     virtual bool Stop() { return false; }
  58
  59     virtual bool Load(const wxString&) { return false; }
  60     virtual bool Load(const wxURI&) { return false; }
  61
  62     virtual wxMediaState GetState() { return wxMEDIASTATE_STOPPED; }
  63
  64     virtual bool SetPosition(long) { return 0; }
  65     virtual long GetPosition() { return 0; }
  66     virtual long GetDuration() { return 0; }
  67
  68     virtual void DoMoveWindow(int, int, int, int) {  }
  69     virtual wxSize DoGetBestSize() const { return wxSize(0,0); }
  70
  71     virtual double GetPlaybackRate() { return 0; }
  72     virtual bool SetPlaybackRate(double) { return false; }
  73
  74     virtual bool MSWWindowProc(WXUINT, WXWPARAM, WXLPARAM) { return false; }
  75
  76     bool IsLoaded()
  77     {   return m_bLoaded;   }
  78
  79     bool m_bLoaded;
  80 };
  81
  82 //---------------------------------------------------------------------------
  83 //  wxDXMediaCtrlImpl
  84 //---------------------------------------------------------------------------
  85
  86 #if wxUSE_DIRECTSHOW
  87
  88 #include <dshow.h>
  89
  90 #define WM_GRAPHNOTIFY  WM_USER+13
  91
  92 #ifdef __WXDEBUG__
  93 #define wxDSVERIFY(x) wxASSERT( SUCCEEDED ((x)) )
  94 #else
  95 #define wxDSVERIFY(x) (x)
  96 #endif
  97
  98 class wxDXMediaCtrlImpl : public wxMediaCtrlImpl
  99 {
 100 public:
 101     wxDXMediaCtrlImpl();
 102
 103     virtual ~wxDXMediaCtrlImpl();
 104
 105     virtual bool Create(wxMediaCtrl* ctrl);
 106
 107     virtual bool Play();
 108     virtual bool Pause();
 109     virtual bool Stop();
 110
 111     virtual bool Load(const wxString& fileName);
 112     virtual bool Load(const wxURI& location);
 113
 114     virtual wxMediaState GetState();
 115
 116     virtual bool SetPosition(long where);
 117     virtual long GetPosition();
 118     virtual long GetDuration();
 119
 120     virtual void DoMoveWindow(int x, int y, int w, int h);
 121     wxSize DoGetBestSize() const;
 122
 123     virtual double GetPlaybackRate();
 124     virtual bool SetPlaybackRate(double);
 125
 126     void Cleanup();
 127
 128     bool m_bVideo;
 129
 130     bool MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
 131
 132     wxMediaCtrl* m_ctrl;
 133
 134     IGraphBuilder* m_pGB;
 135     IMediaControl* m_pMC;
 136     IMediaEventEx* m_pME;
 137     IVideoWindow* m_pVW;
 138     IBasicAudio* m_pBA;
 139     IBasicVideo* m_pBV;
 140     IMediaSeeking* m_pMS;
 141
 142     wxSize m_bestSize;
 143 };
 144
 145 #endif //wxUSE_DIRECTSHOW
 146
 147 //---------------------------------------------------------------------------
 148 //  wxWMMEMediaCtrlImpl
 149 //---------------------------------------------------------------------------
 150
 151 #include <mmsystem.h>
 152 #include <digitalv.h>
 153
 154 class wxWMMEMediaCtrlImpl : public wxMediaCtrlImpl
 155 {
 156 public:
 157
 158     wxWMMEMediaCtrlImpl();
 159     ~wxWMMEMediaCtrlImpl();
 160
 161     virtual bool Create(wxMediaCtrl* ctrl);
 162
 163     virtual bool Play();
 164     virtual bool Pause();
 165     virtual bool Stop();
 166
 167     virtual bool Load(const wxString& fileName);
 168     virtual bool Load(const wxURI& location);
 169
 170     virtual wxMediaState GetState();
 171
 172     virtual bool SetPosition(long where);
 173     virtual long GetPosition();
 174     virtual long GetDuration();
 175
 176     virtual void DoMoveWindow(int x, int y, int w, int h);
 177     wxSize DoGetBestSize() const;
 178
 179     virtual double GetPlaybackRate();
 180     virtual bool SetPlaybackRate(double);
 181
 182     MCIDEVICEID m_hDev;
 183     wxMediaCtrl* m_ctrl;
 184     bool m_bVideo;
 185 };
 186
 187 //---------------------------------------------------------------------------
 188 //  wxAVIFileMediaCtrlImpl
 189 //---------------------------------------------------------------------------
 190 /*
 191 #include <Vfw.h>
 192 //msvfw32.dll
 193 //#pragma comment(lib, "vfw32.lib")
 194
 195 class wxAVIFileMediaCtrlImpl : public wxMediaCtrlImpl
 196 {
 197 public:
 198
 199     wxAVIFileMediaCtrlImpl();
 200     ~wxAVIFileMediaCtrlImpl();
 201
 202     virtual bool Create(wxMediaCtrl* ctrl);
 203
 204     virtual bool Play();
 205     virtual bool Pause();
 206     virtual bool Stop();
 207
 208     virtual bool Load(const wxString& fileName);
 209     virtual bool Load(const wxURI& location);
 210
 211     virtual wxMediaState GetState();
 212
 213     virtual bool SetPosition(long where);
 214     virtual long GetPosition();
 215     virtual long GetDuration();
 216
 217     virtual void DoMoveWindow(int x, int y, int w, int h);
 218     wxSize DoGetBestSize() const;
 219
 220     virtual double GetPlaybackRate();
 221     virtual bool SetPlaybackRate(double);
 222
 223     HMODULE m_hDll;
 224     PAVIFILE m_hAVIFile;
 225     wxMediaCtrl* m_ctrl;
 226 };
 227 */
 228
 229 //###########################################################################
 230 //
 231 //  IMPLEMENTATION
 232 //
 233 //###########################################################################
 234
 235 //---------------------------------------------------------------------------
 236 //
 237 //  wxMediaCtrl
 238 //
 239 //---------------------------------------------------------------------------
 240
 241 bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, const wxString& fileName,
 242                          const wxPoint& pos, const wxSize& size,
 243                          long style, long WXUNUSED(driver), const wxString& name)
 244 {
 245     //base create
 246     if ( !wxControl::Create(parent, id, pos, size, (style | wxNO_BORDER) | wxCLIP_CHILDREN,
 247                             wxDefaultValidator, name) )
 248         return false;
 249
 250     //Set our background color to black by default
 251     SetBackgroundColour(*wxBLACK);
 252
 253 #if wxUSE_DIRECTSHOW
 254     m_imp = new wxDXMediaCtrlImpl;
 255     if(!m_imp->Create(this))
 256     {
 257         delete m_imp;
 258 #endif
 259         m_imp = new wxWMMEMediaCtrlImpl;
 260         if(!m_imp->Create(this))
 261         {
 262             delete m_imp;
 263             m_imp = NULL;
 264             return false;
 265         }
 266 #if wxUSE_DIRECTSHOW
 267     }
 268 #endif
 269
 270     if(!fileName.empty())
 271     {
 272         if (!Load(fileName))
 273             return false;
 274     }
 275
 276     return true;
 277 }
 278
 279 bool wxMediaCtrl::Create(wxWindow* parent, wxWindowID id, const wxURI& location,
 280                          const wxPoint& pos, const wxSize& size,
 281                          long style, long WXUNUSED(driver), const wxString& name)
 282 {
 283     //base create
 284     if ( !wxControl::Create(parent, id, pos, size, (style | wxNO_BORDER) | wxCLIP_CHILDREN,
 285                             wxDefaultValidator, name) )
 286         return false;
 287
 288     //Set our background color to black by default
 289     SetBackgroundColour(*wxBLACK);
 290
 291 #if wxUSE_DIRECTSHOW
 292     m_imp = new wxDXMediaCtrlImpl;
 293     if(!m_imp->Create(this))
 294     {
 295         delete m_imp;
 296 #endif
 297         m_imp = new wxWMMEMediaCtrlImpl;
 298         if(!m_imp->Create(this))
 299         {
 300             delete m_imp;
 301             m_imp = NULL;
 302             return false;
 303         }
 304 #if wxUSE_DIRECTSHOW
 305     }
 306 #endif
 307
 308     if (!Load(location))
 309         return false;
 310
 311     return true;
 312 }
 313
 314 bool wxMediaCtrl::Load(const wxString& fileName)
 315 {
 316     if(m_imp)
 317         return m_imp->Load(fileName);
 318     return false;
 319 }
 320
 321 bool wxMediaCtrl::Load(const wxURI& location)
 322 {
 323     if(m_imp)
 324         return m_imp->Load(location);
 325     return false;
 326 }
 327
 328 bool wxMediaCtrl::Play()
 329 {
 330     if(m_imp && m_imp->IsLoaded())
 331         return m_imp->Play();
 332     return false;
 333 }
 334
 335 bool wxMediaCtrl::Pause()
 336 {
 337     if(m_imp && m_imp->IsLoaded())
 338         return m_imp->Pause();
 339     return false;
 340 }
 341
 342 bool wxMediaCtrl::Stop()
 343 {
 344     if(m_imp && m_imp->IsLoaded())
 345         return m_imp->Stop();
 346     return false;
 347 }
 348
 349 double wxMediaCtrl::GetPlaybackRate()
 350 {
 351     if(m_imp && m_imp->IsLoaded())
 352         return m_imp->GetPlaybackRate();
 353     return 0;
 354 }
 355
 356 bool wxMediaCtrl::SetPlaybackRate(double dRate)
 357 {
 358     if(m_imp && m_imp->IsLoaded())
 359         return m_imp->SetPlaybackRate(dRate);
 360     return false;
 361 }
 362
 363 bool wxMediaCtrl::SetPosition(long where)
 364 {
 365     if(m_imp && m_imp->IsLoaded())
 366         return m_imp->SetPosition(where);
 367     return false;
 368 }
 369
 370 long wxMediaCtrl::GetPosition()
 371 {
 372     if(m_imp && m_imp->IsLoaded())
 373         return m_imp->GetPosition();
 374     return 0;
 375 }
 376
 377 long wxMediaCtrl::GetDuration()
 378 {
 379     if(m_imp && m_imp->IsLoaded())
 380         return m_imp->GetDuration();
 381     return 0;
 382 }
 383
 384 wxMediaState wxMediaCtrl::GetState()
 385 {
 386     if(m_imp && m_imp->IsLoaded())
 387         return m_imp->GetState();
 388     return wxMEDIASTATE_STOPPED;
 389 }
 390
 391 WXLRESULT wxMediaCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 392 {
 393     if(m_imp && m_imp->IsLoaded() && m_imp->MSWWindowProc(nMsg, wParam, lParam) )
 394            return wxControl::MSWDefWindowProc(nMsg, wParam, lParam);
 395     //pass the event to our parent
 396     return wxControl::MSWWindowProc(nMsg, wParam, lParam);
 397 }
 398
 399 wxSize wxMediaCtrl::DoGetBestSize() const
 400 {
 401     if(m_imp && m_imp->IsLoaded())
 402         return m_imp->DoGetBestSize();
 403     return wxSize(0,0);
 404 }
 405
 406 void wxMediaCtrl::DoMoveWindow(int x, int y, int w, int h)
 407 {
 408     wxControl::DoMoveWindow(x,y,w,h);
 409
 410     if(m_imp && m_imp->IsLoaded())
 411         m_imp->DoMoveWindow(x, y, w, h);
 412 }
 413
 414 wxMediaCtrl::~wxMediaCtrl()
 415 {
 416     if (m_imp)
 417         delete m_imp;
 418 }
 419
 420
 421 //---------------------------------------------------------------------------
 422 //
 423 //  wxDXMediaCtrlImpl
 424 //
 425 //---------------------------------------------------------------------------
 426
 427 #if wxUSE_DIRECTSHOW
 428
 429 wxDXMediaCtrlImpl::wxDXMediaCtrlImpl() : m_pGB(NULL)
 430 {
 431 }
 432
 433 bool wxDXMediaCtrlImpl::Create(wxMediaCtrl* ctrl)
 434 {
 435     //create our filter graph
 436    HRESULT hr = CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
 437                       IID_IGraphBuilder, (void**)&m_pGB);
 438
 439    //directshow not installed?
 440     if ( FAILED(hr) )
 441         return false;
 442
 443     m_ctrl = ctrl;
 444
 445     return true;
 446 }
 447
 448 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
 449
 450 bool wxDXMediaCtrlImpl::Load(const wxString& fileName)
 451 {
 452     if(m_bLoaded)
 453         Cleanup();
 454
 455     SAFE_RELEASE(m_pGB);
 456
 457     CoCreateInstance(CLSID_FilterGraph, NULL, CLSCTX_INPROC_SERVER,
 458                       IID_IGraphBuilder, (void**)&m_pGB);
 459
 460     //load the graph & render
 461     if( FAILED(m_pGB->RenderFile(fileName.wc_str(wxConvLocal), NULL)) )
 462         return false;
 463
 464     //get the interfaces, all of them
 465     wxDSVERIFY( m_pGB->QueryInterface(IID_IMediaControl, (void**)&m_pMC) );
 466     wxDSVERIFY( m_pGB->QueryInterface(IID_IMediaEventEx, (void**)&m_pME) );
 467     wxDSVERIFY( m_pGB->QueryInterface(IID_IMediaSeeking, (void**)&m_pMS) );
 468     wxDSVERIFY( m_pGB->QueryInterface(IID_IVideoWindow, (void**)&m_pVW) );
 469     wxDSVERIFY( m_pGB->QueryInterface(IID_IBasicAudio, (void**)&m_pBA) );
 470     wxDSVERIFY( m_pGB->QueryInterface(IID_IBasicVideo, (void**)&m_pBV) );
 471
 472     //long lVolume;
 473     //pBA->get_Volume(&lVolume);
 474     //E_NOTIMPL
 475
 476     //get the _actual_ size of the movie & remember it
 477     long nX, nY, nSX, nSY;
 478     if (FAILED(m_pVW->GetWindowPosition(&nX,&nY,&nSX,&nSY)))
 479     {
 480         m_bVideo = false;
 481
 482         nSX = nSY = 0;
 483     }
 484     else
 485     {
 486         m_bVideo = true;
 487     }
 488
 489     m_bestSize.x = nSX;
 490     m_bestSize.y = nSY;
 491
 492     if (m_bVideo)
 493     {
 494         wxDSVERIFY( m_pVW->put_Owner((OAHWND)m_ctrl->GetHandle()) );
 495         wxDSVERIFY( m_pVW->put_WindowStyle(WS_CHILD | WS_CLIPSIBLINGS) );
 496         wxDSVERIFY( m_pVW->put_Visible(OATRUE) ); //OATRUE == -1
 497     }
 498
 499     //make it so that wxEVT_MOVIE_FINISHED works
 500     wxDSVERIFY( m_pME->SetNotifyWindow((OAHWND)m_ctrl->GetHandle(), WM_GRAPHNOTIFY, 0) );
 501
 502     //set the time format
 503     wxDSVERIFY( m_pMS->SetTimeFormat(&TIME_FORMAT_MEDIA_TIME) );
 504
 505     //so that DoGetBestSize will work :)
 506     m_bLoaded = true;
 507
 508     //work around refresh issues
 509     m_ctrl->InvalidateBestSize();
 510     m_ctrl->GetParent()->Layout();
 511     m_ctrl->GetParent()->Refresh();
 512     m_ctrl->GetParent()->Update();
 513
 514     return true;
 515 }
 516
 517 bool wxDXMediaCtrlImpl::Load(const wxURI& location)
 518 {
 519     return Load(location.BuildUnescapedURI());
 520 }
 521
 522 bool wxDXMediaCtrlImpl::Play()
 523 {
 524     return SUCCEEDED( m_pMC->Run() );
 525 }
 526
 527 bool wxDXMediaCtrlImpl::Pause()
 528 {
 529     return SUCCEEDED( m_pMC->Pause() );
 530 }
 531
 532 bool wxDXMediaCtrlImpl::Stop()
 533 {
 534     return SUCCEEDED( m_pMC->Stop() ) && SetPosition(0);
 535 }
 536
 537 bool wxDXMediaCtrlImpl::SetPosition(long where)
 538 {
 539     //DS uses 100 nanos - so we need a 10 mult
 540     LONGLONG pos = ((LONGLONG)where) * 10000;
 541
 542     return SUCCEEDED( m_pMS->SetPositions(
 543                                 &pos,
 544                                 AM_SEEKING_AbsolutePositioning,
 545                                 NULL,
 546                                 AM_SEEKING_NoPositioning
 547                                     ) );
 548 }
 549
 550 long wxDXMediaCtrlImpl::GetPosition()
 551 {
 552     LONGLONG outCur, outStop;
 553     wxDSVERIFY( m_pMS->GetPositions(&outCur, &outStop) );
 554
 555     //h,m,s,milli - outdur is in 100 nanos
 556     return outCur/10000;
 557 }
 558
 559 long wxDXMediaCtrlImpl::GetDuration()
 560 {
 561     LONGLONG outDuration;
 562     wxDSVERIFY( m_pMS->GetDuration(&outDuration) );
 563
 564     //h,m,s,milli - outdur is in 100 nanos
 565     return outDuration/10000;
 566 }
 567
 568 wxMediaState wxDXMediaCtrlImpl::GetState()
 569 {
 570     //TODO: MS recommends against INFINITE here - do it in stages
 571     HRESULT hr;
 572     OAFilterState theState;
 573     hr = m_pMC->GetState(INFINITE, &theState);
 574
 575     wxASSERT( SUCCEEDED(hr) );
 576
 577     //MSW state is the same as ours
 578     //State_Stopped   = 0,
 579     //State_Paused    = State_Stopped + 1,
 580     //State_Running   = State_Paused + 1
 581
 582     return (wxMediaState) theState;
 583 }
 584
 585 double wxDXMediaCtrlImpl::GetPlaybackRate()
 586 {
 587     double dRate;
 588     wxDSVERIFY( m_pMS->GetRate(&dRate) );
 589     return dRate;
 590 }
 591
 592 bool wxDXMediaCtrlImpl::SetPlaybackRate(double dRate)
 593 {
 594     return SUCCEEDED( m_pMS->SetRate(dRate) );
 595 }
 596
 597 bool wxDXMediaCtrlImpl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
 598 {
 599     if (nMsg == WM_GRAPHNOTIFY)
 600     {
 601         LONG evCode, evParam1, evParam2;
 602         HRESULT hr=S_OK;
 603
 604         // Process all queued events
 605         while(SUCCEEDED(m_pME->GetEvent(&evCode, (LONG_PTR *) &evParam1,
 606                                        (LONG_PTR *) &evParam2, 0)
 607                        )
 608              )
 609         {
 610             // Free memory associated with callback, since we're not using it
 611             hr = m_pME->FreeEventParams(evCode, evParam1, evParam2);
 612
 613             // If this is the end of the clip, notify handler
 614             if(EC_COMPLETE == evCode)
 615             {
 616 #ifdef __WXDEBUG__
 617                 wxASSERT( Stop() );
 618 #else
 619                 Stop();
 620 #endif
 621                 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED, m_ctrl->GetId());
 622                 m_ctrl->GetParent()->ProcessEvent(theEvent);
 623             }
 624         }
 625         return true;
 626     }
 627     return false;
 628 }
 629
 630 void wxDXMediaCtrlImpl::Cleanup()
 631 {
 632     // Hide then disown the window
 633     if(m_pVW)
 634     {
 635         m_pVW->put_Visible(OAFALSE); //OSFALSE == 0
 636         m_pVW->put_Owner(NULL);
 637     }
 638
 639     // Release and zero DirectShow interfaces
 640     SAFE_RELEASE(m_pME);
 641     SAFE_RELEASE(m_pMS);
 642     SAFE_RELEASE(m_pMC);
 643     SAFE_RELEASE(m_pBA);
 644     SAFE_RELEASE(m_pBV);
 645     SAFE_RELEASE(m_pVW);
 646 }
 647
 648 wxDXMediaCtrlImpl::~wxDXMediaCtrlImpl()
 649 {
 650     if (m_bLoaded)
 651         Cleanup();
 652
 653     SAFE_RELEASE(m_pGB);
 654 }
 655
 656 wxSize wxDXMediaCtrlImpl::DoGetBestSize() const
 657 {
 658     return m_bestSize;
 659 }
 660
 661 void wxDXMediaCtrlImpl::DoMoveWindow(int x, int y, int w, int h)
 662 {
 663     if(m_bLoaded && m_bVideo)
 664     {
 665         wxDSVERIFY( m_pVW->SetWindowPosition(0, 0, w, h) );
 666     }
 667 }
 668
 669 #endif //wxUSE_DIRECTSHOW
 670
 671 //---------------------------------------------------------------------------
 672 //
 673 //  wxWMMEMediaCtrlImpl
 674 //
 675 //---------------------------------------------------------------------------
 676
 677 wxWMMEMediaCtrlImpl::wxWMMEMediaCtrlImpl() : m_bVideo(false)
 678 {
 679
 680 }
 681
 682 wxWMMEMediaCtrlImpl::~wxWMMEMediaCtrlImpl()
 683 {
 684     mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
 685 }
 686
 687 bool wxWMMEMediaCtrlImpl::Create(wxMediaCtrl* ctrl)
 688 {
 689     m_ctrl = ctrl;
 690     return true;
 691 }
 692
 693 bool wxWMMEMediaCtrlImpl::Play()
 694 {
 695     return (mciSendCommand(m_hDev, MCI_PLAY, 0, 0) == 0) ||
 696            (mciSendCommand(m_hDev, MCI_RESUME, 0, 0) == 0);
 697 }
 698
 699 bool wxWMMEMediaCtrlImpl::Pause()
 700 {
 701     return (mciSendCommand(m_hDev, MCI_PAUSE, MCI_WAIT, 0) == 0);
 702 }
 703
 704 bool wxWMMEMediaCtrlImpl::Stop()
 705 {
 706     return (mciSendCommand(m_hDev, MCI_STOP, MCI_WAIT, 0) == 0);
 707 }
 708
 709 #include "wx/log.h"
 710
 711 bool wxWMMEMediaCtrlImpl::Load(const wxString& fileName)
 712 {
 713     if(m_bLoaded)
 714         mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
 715
 716     MCI_OPEN_PARMS openParms;
 717     MCI_SET_PARMS setParms;
 718
 719     memset(&openParms, 0, sizeof(MCI_DGV_OPEN_PARMS));
 720     openParms.lpstrElementName = (wxChar*) fileName.c_str();
 721
 722     bool bFound = false;
 723
 724     for(size_t i = MCI_DEVTYPE_FIRST; i <= MCI_DEVTYPE_LAST; ++i)
 725     {
 726         openParms.lpstrDeviceType = (LPSTR)i;
 727
 728         DWORD nError;
 729
 730         if ((nError = mciSendCommand(0, MCI_OPEN,
 731                  MCI_OPEN_ELEMENT|MCI_OPEN_ELEMENT|MCI_OPEN_TYPE|MCI_OPEN_TYPE_ID,
 732                 (DWORD)(LPVOID)&openParms)) == 0)
 733         {
 734             bFound = true;
 735             break;
 736         }
 737     }
 738
 739     if(!bFound)
 740         return false;
 741
 742     m_hDev = openParms.wDeviceID;
 743
 744
 745     setParms.dwCallback = 0;
 746     setParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
 747
 748     if (mciSendCommand(m_hDev, MCI_SET, MCI_SET_TIME_FORMAT,
 749                          (DWORD)(LPVOID)&setParms) != 0)
 750         return false;
 751
 752
 753     //TODO: Does this work?
 754     /*
 755     MCI_DGV_WINDOW_PARMS windowParms;
 756
 757   windowParms.hWnd = (HWND)m_ctrl->GetHWND();
 758     m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW,
 759                         MCI_DGV_WINDOW_HWND, (DWORD)(LPVOID)&windowParms) == 0);
 760 */
 761     m_bLoaded = true;
 762
 763     return true;
 764 }
 765
 766 bool wxWMMEMediaCtrlImpl::Load(const wxURI& WXUNUSED(location))
 767 {
 768     return false;
 769 }
 770
 771 wxMediaState wxWMMEMediaCtrlImpl::GetState()
 772 {
 773     MCI_STATUS_PARMS statusParms;
 774     statusParms.dwItem = MCI_STATUS_MODE;
 775     mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
 776                          (DWORD)(LPVOID)&statusParms);
 777
 778     if(statusParms.dwReturn == MCI_MODE_PAUSE)
 779         return wxMEDIASTATE_PAUSED;
 780     else if(statusParms.dwReturn == MCI_MODE_PLAY)
 781         return wxMEDIASTATE_PLAYING;
 782     else
 783         return wxMEDIASTATE_STOPPED;
 784 }
 785
 786 bool wxWMMEMediaCtrlImpl::SetPosition(long where)
 787 {
 788     MCI_SEEK_PARMS seekParms;
 789     seekParms.dwCallback = 0;
 790     seekParms.dwTo = where;
 791
 792     bool bReplay = GetState() == wxMEDIASTATE_PLAYING;
 793
 794     if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO, (DWORD)(LPVOID)&seekParms) != 0)
 795         return false;
 796 /*        TCHAR sz[5000];
 797          mciGetErrorString(nError, sz, 5000);
 798             wxMessageBox(wxString::Format(_T("Error:%s"), sz));
 799   */
 800
 801     if (bReplay)
 802         return Play();
 803     else
 804         return true;
 805 }
 806
 807 long wxWMMEMediaCtrlImpl::GetPosition()
 808 {
 809     MCI_STATUS_PARMS statusParms;
 810
 811     statusParms.dwItem = MCI_STATUS_POSITION;
 812     if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
 813         (DWORD)(LPSTR)&statusParms) != 0)
 814         return 0;
 815
 816     return statusParms.dwReturn;
 817 }
 818
 819 long wxWMMEMediaCtrlImpl::GetDuration()
 820 {
 821     MCI_STATUS_PARMS statusParms;
 822
 823     statusParms.dwItem = MCI_STATUS_LENGTH;
 824     if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
 825         (DWORD)(LPSTR)&statusParms) != 0)
 826         return 0;
 827
 828     return statusParms.dwReturn;
 829 }
 830
 831 void wxWMMEMediaCtrlImpl::DoMoveWindow(int, int, int, int)
 832 {
 833 }
 834
 835 wxSize wxWMMEMediaCtrlImpl::DoGetBestSize() const
 836 {
 837     if(m_bVideo)
 838     {
 839         //TODO:  Does this work?
 840         /*
 841         MCI_DGV_RECT_PARMS rect;
 842
 843         mciSendCommand(m_hDev, MCI_WHERE, MCI_DGV_WHERE_SOURCE, (DWORD)(LPSTR)&rect);
 844         return wxSize(rect.rc.right, rect.rc.bottom);
 845         */
 846     }
 847     return wxSize(0,0);
 848 }
 849
 850 double wxWMMEMediaCtrlImpl::GetPlaybackRate()
 851 {
 852     return 1.0;
 853 }
 854
 855 bool wxWMMEMediaCtrlImpl::SetPlaybackRate(double)
 856 {
 857     return false;
 858 }
 859
 860 //---------------------------------------------------------------------------
 861 //
 862 //  wxAVIFileMediaCtrlImpl
 863 //
 864 //---------------------------------------------------------------------------
 865
 866 //---------------------------------------------------------------------------
 867 //  Functions located in msvfw32.dll
 868 //---------------------------------------------------------------------------
 869
 870 /*
 871
 872 typedef void (WINAPI *LPAVIFileInit) ();
 873 typedef void (WINAPI *LPAVIFileExit) ();
 874
 875 typedef ULONG (WINAPI *LPAVIFileOpen) (
 876 PAVIFILE FAR * ppfile,
 877 const wxChar* szFile,
 878 UINT uMode,
 879 LPCLSID lpHandler
 880 );
 881
 882 typedef ULONG (WINAPI *LPAVIFileRelease) (PAVIFILE pfile);
 883
 884 wxAVIFileMediaCtrlImpl::wxAVIFileMediaCtrlImpl()
 885 {
 886 }
 887
 888 wxAVIFileMediaCtrlImpl::~wxAVIFileMediaCtrlImpl()
 889 {
 890 }
 891
 892 bool wxAVIFileMediaCtrlImpl::Create(wxMediaCtrl* ctrl)
 893 {
 894     m_hDll = ::LoadLibrary(_T("avifil32.dll"));
 895
 896     if(m_hDll == NULL)
 897         return false;
 898
 899     LPAVIFileInit pAVIFileInit = (LPAVIFileInit) ::GetProcAddress(m_hDll, _T("AVIFileInit"));
 900
 901     if(!pAVIFileInit)
 902         return false;
 903
 904     (*pAVIFileInit)();
 905
 906     m_ctrl = ctrl;
 907     return false;
 908 }
 909
 910
 911 bool wxAVIFileMediaCtrlImpl::Load(const wxString& fileName)
 912 {
 913 //    if( AVIFileOpen(&m_hAVIFile, fileName.c_str(), OF_SHARE_DENY_WRITE, 0L) != 0)
 914         return false;
 915
 916     m_bLoaded = true;
 917
 918     return true;
 919 }
 920
 921 bool wxAVIFileMediaCtrlImpl::Load(const wxURI& WXUNUSED(location))
 922 {
 923     return false;
 924 }
 925
 926 bool wxAVIFileMediaCtrlImpl::Play()
 927 {
 928     return 0;
 929 }
 930
 931 bool wxAVIFileMediaCtrlImpl::Pause()
 932 {
 933     return 0;
 934 }
 935
 936 bool wxAVIFileMediaCtrlImpl::Stop()
 937 {
 938     return 0;
 939 }
 940
 941 wxMediaState wxAVIFileMediaCtrlImpl::GetState()
 942 {
 943     return wxMEDIASTATE_STOPPED;
 944 }
 945
 946 bool wxAVIFileMediaCtrlImpl::SetPosition(long where)
 947 {
 948     return 0;
 949 }
 950
 951 long wxAVIFileMediaCtrlImpl::GetPosition()
 952 {
 953     return 0;
 954 }
 955
 956 long wxAVIFileMediaCtrlImpl::GetDuration()
 957 {
 958     return 0;
 959 }
 960
 961 void wxAVIFileMediaCtrlImpl::DoMoveWindow(int, int, int, int)
 962 {
 963 }
 964
 965 wxSize wxAVIFileMediaCtrlImpl::DoGetBestSize() const
 966 {
 967     return wxSize(0,0);
 968 }
 969
 970 double wxAVIFileMediaCtrlImpl::GetPlaybackRate()
 971 {
 972     return 1.0;
 973 }
 974
 975 bool wxAVIFileMediaCtrlImpl::SetPlaybackRate(double)
 976 {
 977     return false;
 978 }
 979
 980   */
 981
 982 #endif //wxUSE_MEDIACTRL