src/msw/mediactrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        msw/mediactrl.cpp
   3 // Purpose:     Built-in Media Backends for Windows
   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 //  DECLARATIONS
  14 //===========================================================================
  15
  16 //---------------------------------------------------------------------------
  17 // Pre-compiled header stuff
  18 //---------------------------------------------------------------------------
  19
  20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
  21 #pragma implementation "mediactrl.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28 #pragma hdrstop
  29 #endif
  30
  31 //---------------------------------------------------------------------------
  32 // Includes
  33 //---------------------------------------------------------------------------
  34 #include "wx/mediactrl.h"
  35
  36 //---------------------------------------------------------------------------
  37 // Compilation guard
  38 //---------------------------------------------------------------------------
  39 #if wxUSE_MEDIACTRL
  40
  41 #include "wx/dcclient.h"
  42
  43 //---------------------------------------------------------------------------
  44 // Externals (somewhere in src/msw/app.cpp)
  45 //---------------------------------------------------------------------------
  46 extern "C" WXDLLIMPEXP_BASE HINSTANCE wxGetInstance(void);
  47 #ifdef __WXWINCE__
  48 extern WXDLLIMPEXP_CORE       wxChar *wxCanvasClassName;
  49 #else
  50 extern WXDLLIMPEXP_CORE const wxChar *wxCanvasClassName;
  51 #endif
  52
  53 //===========================================================================
  54 //  BACKEND DECLARATIONS
  55 //===========================================================================
  56
  57 //---------------------------------------------------------------------------
  58 //
  59 //  wxAMMediaBackend
  60 //
  61 //---------------------------------------------------------------------------
  62 //
  63 //####################THE BIG DIRECTSHOW OVERVIEW############################
  64 //
  65 //
  66 //  OK... this deserves its own little tutorial.  Knowledge of COM and class
  67 //  factories is assumed throughout this code.
  68 //
  69 //  Basically, the way directshow works is that you tell it to render
  70 //  a file, and it builds and connects a bunch of filters together.
  71 //
  72 //  There are many, many ways to do this.
  73 //
  74 //  WAYS TO RENDER A FILE (URLS WORK IN DS ALSO)
  75 //
  76 //  1)  Create an instance of IGraphBuilder and call RenderFile on it
  77 //  2)  Create an instance of IMediaControl and call RenderFile on it
  78 //  3)  Create an instance of IAMMultiMediaStream, call
  79 //      IAMMultiMediaStream::AddStream and pass an IDirectDraw instance for
  80 //      the video, and pass an IDirectSound(Buffer?) instance or use the
  81 //      default sound renderer, then call RenderFile or RenderMoniker
  82 //  4)  Create a Moniker instance for the file and create and build
  83 //      all of the filtergraph manually
  84 //
  85 //  Our issue here is that we can't use the default representation of 1 and 2
  86 //  because the IVideoWindow instance hogs a lot of the useful window
  87 //  messages such as WM_SETCURSOR.
  88 //
  89 //  Solution #1 was to use #3 by creating a seperate IDirectDraw instance
  90 //  for our window and blitting to that through a thread... unfortunately
  91 //  the blitting resizing is very low quality and its quite slow.
  92 //
  93 //  The current way is to use windowless rendering and have directshow
  94 //  do all the DirectDraw-style clipping to our window
  95 //
  96 //  ~~~~~~~~~~~~~~AFTER RENDERING THE FILE~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  97 //
  98 //  When done rendering the file, we need to get several interfaces from
  99 //  either a IMediaControl or IGraphBuilder instance -
 100 //
 101 //  IMediaPosition - we can set the rate with this... we can also get
 102 //  positions and set positions through this with REFTIME (double) instead
 103 //  of the normal LONGLONG that IAMMultiMediaStream and IMediaControl use
 104 //
 105 //  IBasicAudio - we need this for setting/getting the volume
 106 //
 107 //  Interfaces that we don't use but might be useful one day -
 108 //
 109 //  IDirectDrawVideo - you can get this through the IFilter returned
 110 //  from L"Video Renderer" filter from FindFilter on the IGraphBuilder.
 111 //  Through this we can set the IDirectDraw instance DrawShow uses.
 112 //
 113 //  ~~~~~~~~~~~~~~STOPPING~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 114 //
 115 //  There are two ways we can do this -
 116 //  1)  Have a thread compare the current position to the end position
 117 //  about every 10 milliseconds
 118 //  2)  Have IMediaSeekingEx send a message to a windowproc or signal a
 119 //  windows event
 120 //
 121 //  Note that we can do these both, I.E. if an IMediaSeekingEx interface
 122 //  is unavailable we can check the position instead of an event
 123 //
 124 //---------------------------------------------------------------------------
 125
 126 //---------------------------------------------------------------------------
 127 //  COM includes
 128 //---------------------------------------------------------------------------
 129 #include "wx/msw/ole/oleutils.h" //wxBasicString, IID etc.
 130 #include "wx/msw/ole/uuid.h" //IID etc..
 131
 132 //---------------------------------------------------------------------------
 133 //  COM compatability definitions
 134 //---------------------------------------------------------------------------
 135 #ifndef STDMETHODCALLTYPE
 136 #define STDMETHODCALLTYPE __stdcall
 137 #endif
 138 #ifndef STDMETHOD
 139 #define STDMETHOD(funcname)  virtual HRESULT STDMETHODCALLTYPE funcname
 140 #endif
 141 #ifndef PURE
 142 #define PURE = 0
 143 #endif
 144 //---------------------------------------------------------------------------
 145 //  IIDS - used by CoCreateInstance and IUnknown::QueryInterface
 146 //  Dumped from amstream.idl, quartz.idl, direct draw and with some
 147 //  confirmation from WINE
 148 //
 149 //  Some of these are not used but are kept here for future reference anyway
 150 //---------------------------------------------------------------------------
 151
 152 //QUARTZ
 153 const IID LIBID_QuartzTypeLib = {0x56A868B0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 154 const IID IID_IAMCollection = {0x56A868B9,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 155 const IID IID_IMediaControl = {0x56A868B1,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 156 const IID IID_IMediaEvent = {0x56A868B6,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 157 const IID IID_IMediaEventEx = {0x56A868C0,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 158 const IID IID_IMediaPosition = {0x56A868B2,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 159 const IID IID_IBasicAudio = {0x56A868B3,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 160 const IID IID_IVideoWindow = {0x56A868B4,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 161 const IID IID_IBasicVideo = {0x56A868B5,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 162 const IID IID_IBasicVideo2 = {0x329BB360,0xF6EA,0x11D1,{0x90,0x38,0x00,0xA0,0xC9,0x69,0x72,0x98}};
 163 const IID IID_IDeferredCommand = {0x56A868B8,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 164 const IID IID_IQueueCommand = {0x56A868B7,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 165 const IID IID_IFilterInfo = {0x56A868BA,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 166 const IID IID_IRegFilterInfo = {0x56A868BB,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 167 const IID IID_IMediaTypeInfo = {0x56A868BC,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 168 const IID IID_IPinInfo = {0x56A868BD,0x0AD4,0x11CE,{0xB0,0x3A,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 169 const IID IID_IAMStats = {0xBC9BCF80,0xDCD2,0x11D2,{0xAB,0xF6,0x00,0xA0,0xC9,0x05,0xF3,0x75}};
 170 const CLSID CLSID_FilgraphManager = {0xE436EBB3,0x524F,0x11CE,{0x9F,0x53,0x00,0x20,0xAF,0x0B,0xA7,0x70}};
 171
 172 //AMSTREAM
 173 const CLSID CLSID_AMMultiMediaStream = {0x49C47CE5, 0x9BA4, 0x11D0,{0x82, 0x12, 0x00, 0xC0, 0x4F, 0xC3, 0x2C, 0x45}};
 174 const IID IID_IAMMultiMediaStream = {0xBEBE595C, 0x9A6F, 0x11D0,{0x8F, 0xDE, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D}};
 175 const IID IID_IDirectDrawMediaStream = {0xF4104FCE, 0x9A70, 0x11D0,{0x8F, 0xDE, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D}};
 176 const GUID MSPID_PrimaryVideo = {0xa35FF56A, 0x9FDA, 0x11D0,{0x8F, 0xDF, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D}};
 177 const GUID MSPID_PrimaryAudio = {0xa35FF56B, 0x9FDA, 0x11D0,{0x8F, 0xDF, 0x00, 0xC0, 0x4F, 0xD9, 0x18, 0x9D}};
 178
 179 //DDRAW
 180 const IID IID_IDirectDraw = {0x6C14DB80,0xA733,0x11CE,{0xA5,0x21,0x00,0x20,0xAF,0x0B,0xE5,0x60}};
 181 const CLSID CLSID_DirectDraw = {0xD7B70EE0,0x4340,0x11CF,{0xB0,0x63,0x00,0x20,0xAF,0xC2,0xCD,0x35}};
 182
 183 //??  QUARTZ Also?
 184 const CLSID CLSID_VideoMixingRenderer = {0xB87BEB7B, 0x8D29, 0x423F,{0xAE, 0x4D, 0x65, 0x82, 0xC1, 0x01, 0x75, 0xAC}};
 185 const IID IID_IVMRWindowlessControl =   {0x0EB1088C, 0x4DCD, 0x46F0,{0x87, 0x8F, 0x39, 0xDA, 0xE8, 0x6A, 0x51, 0xB7}};
 186 const IID IID_IFilterGraph =            {0x56A8689F, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
 187 const IID IID_IGraphBuilder =           {0x56A868A9, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
 188 const IID IID_IVMRFilterConfig =        {0x9E5530C5, 0x7034, 0x48B4,{0xBB, 0x46, 0x0B, 0x8A, 0x6E, 0xFC, 0x8E, 0x36}};
 189 const IID IID_IBaseFilter =             {0x56A86895, 0x0AD4, 0x11CE,{0xB0, 0x3A, 0x00, 0x20, 0xAF, 0x0B, 0xA7, 0x70}};
 190
 191 //---------------------------------------------------------------------------
 192 //  DIRECTDRAW COM INTERFACES
 193 //---------------------------------------------------------------------------
 194 //DDSURFACESDESC - we don't need most of the stuff here, esp. DDPIXELFORMAT,
 195 //so just put stubs in
 196 struct DDPIXELFORMAT {DWORD dw1,dw2,dw3,dw4,dw5,dw6,dw7,dw8;};
 197 struct DDCOLORKEY {DWORD dwLow, dwHigh;};
 198
 199 typedef struct IDirectDrawClipper* LPDIRECTDRAWCLIPPER;
 200 typedef struct IDirectDraw* LPDIRECTDRAW;
 201 typedef struct IDirectDrawSurface* LPDIRECTDRAWSURFACE;
 202 typedef struct DDSURFACEDESC* LPDDSURFACEDESC;
 203 typedef struct IDirectDrawPalette* LPDIRECTDRAWPALETTE;
 204 typedef struct DDSCAPS* LPDDSCAPS;
 205 typedef DDCOLORKEY* LPDDCOLORKEY;
 206 typedef DDPIXELFORMAT* LPDDPIXELFORMAT;
 207 typedef struct DDCAPS* LPDDCAPS;
 208
 209 struct DDSURFACEDESC
 210 {
 211     DWORD               dwSize;
 212     DWORD               dwFlags;
 213     DWORD               dwHeight;
 214     DWORD               dwWidth;
 215     union
 216     {
 217         LONG            lPitch;
 218         DWORD           dwLinearSize;
 219     };
 220     DWORD               dwBackBufferCount;
 221     union
 222     {
 223         DWORD           dwMipMapCount;
 224         DWORD           dwZBufferBitDepth;
 225         DWORD           dwRefreshRate;
 226     };
 227     DWORD               dwAlphaBitDepth;
 228     DWORD               dwReserved;
 229     LPVOID              lpSurface;
 230     DDCOLORKEY          ddckCKDestOverlay;
 231     DDCOLORKEY          ddckCKDestBlt;
 232     DDCOLORKEY          ddckCKSrcOverlay;
 233     DDCOLORKEY          ddckCKSrcBlt;
 234     DDPIXELFORMAT ddpfPixelFormat;
 235     struct DDSCAPS {DWORD dwCaps;} ddsCaps;
 236 };
 237
 238 struct IDirectDrawClipper : public IUnknown
 239 {
 240     STDMETHOD(GetClipList)(LPRECT, LPRGNDATA, LPDWORD) PURE;
 241     STDMETHOD(GetHWnd)(HWND*) PURE;
 242     STDMETHOD(Initialize)(LPDIRECTDRAW, DWORD) PURE;
 243     STDMETHOD(IsClipListChanged)(BOOL*) PURE;
 244     STDMETHOD(SetClipList)(LPRGNDATA,DWORD) PURE;
 245     STDMETHOD(SetHWnd)(DWORD, HWND) PURE;
 246 };
 247
 248 struct IDirectDrawSurface : public IUnknown
 249 {
 250     STDMETHOD(AddAttachedSurface)(LPDIRECTDRAWSURFACE) PURE;
 251     STDMETHOD(AddOverlayDirtyRect)(LPRECT) PURE;
 252     STDMETHOD(Blt)(LPRECT,LPDIRECTDRAWSURFACE, LPRECT,DWORD, struct DDBLTFX*) PURE;
 253     STDMETHOD(BltBatch)(struct DDBLTBATCH*, DWORD, DWORD ) PURE;
 254     STDMETHOD(BltFast)(DWORD,DWORD,LPDIRECTDRAWSURFACE, LPRECT,DWORD) PURE;
 255     STDMETHOD(DeleteAttachedSurface)(DWORD,LPDIRECTDRAWSURFACE) PURE;
 256     STDMETHOD(EnumAttachedSurfaces)(LPVOID, LPVOID/*LPDDENUMSURFACESCALLBACK*/) PURE;
 257     STDMETHOD(EnumOverlayZOrders)(DWORD,LPVOID,LPVOID/*LPDDENUMSURFACESCALLBACK*/) PURE;
 258     STDMETHOD(Flip)(LPDIRECTDRAWSURFACE, DWORD) PURE;
 259     STDMETHOD(GetAttachedSurface)(LPDDSCAPS, LPDIRECTDRAWSURFACE*) PURE;
 260     STDMETHOD(GetBltStatus)(DWORD) PURE;
 261     STDMETHOD(GetCaps)(LPDDSCAPS) PURE;
 262     STDMETHOD(GetClipper)(LPDIRECTDRAWCLIPPER*) PURE;
 263     STDMETHOD(GetColorKey)(DWORD, LPDDCOLORKEY) PURE;
 264     STDMETHOD(GetDC)(HDC *) PURE;
 265     STDMETHOD(GetFlipStatus)(DWORD) PURE;
 266     STDMETHOD(GetOverlayPosition)(LPLONG, LPLONG ) PURE;
 267     STDMETHOD(GetPalette)(LPDIRECTDRAWPALETTE FAR*) PURE;
 268     STDMETHOD(GetPixelFormat)(LPDDPIXELFORMAT) PURE;
 269     STDMETHOD(GetSurfaceDesc)(LPDDSURFACEDESC) PURE;
 270     STDMETHOD(Initialize)(LPDIRECTDRAW, LPDDSURFACEDESC) PURE;
 271     STDMETHOD(IsLost)(THIS) PURE;
 272     STDMETHOD(Lock)(LPRECT,LPDDSURFACEDESC,DWORD,HANDLE) PURE;
 273     STDMETHOD(ReleaseDC)(HDC) PURE;
 274     STDMETHOD(Restore)(THIS) PURE;
 275     STDMETHOD(SetClipper)(LPDIRECTDRAWCLIPPER) PURE;
 276     STDMETHOD(SetColorKey)(DWORD, LPDDCOLORKEY) PURE;
 277     STDMETHOD(SetOverlayPosition)(LONG, LONG ) PURE;
 278     STDMETHOD(SetPalette)(IUnknown*) PURE;
 279     STDMETHOD(Unlock)(LPVOID) PURE;
 280     STDMETHOD(UpdateOverlay)(LPRECT, LPDIRECTDRAWSURFACE,LPRECT,
 281                                DWORD, struct DDOVERLAYFX*) PURE;
 282     STDMETHOD(UpdateOverlayDisplay)(DWORD) PURE;
 283     STDMETHOD(UpdateOverlayZOrder)(DWORD, LPDIRECTDRAWSURFACE) PURE;
 284 };
 285
 286 struct IDirectDraw : public IUnknown
 287 {
 288     STDMETHOD(Compact)() PURE;
 289     STDMETHOD(CreateClipper)(DWORD, LPDIRECTDRAWCLIPPER*, IUnknown * ) PURE;
 290     STDMETHOD(CreatePalette)(DWORD, LPPALETTEENTRY, LPDIRECTDRAWPALETTE *, IUnknown * ) PURE;
 291     STDMETHOD(CreateSurface)(LPDDSURFACEDESC, LPDIRECTDRAWSURFACE *, IUnknown *) PURE;
 292     STDMETHOD(DuplicateSurface)(LPDIRECTDRAWSURFACE, LPDIRECTDRAWSURFACE * ) PURE;
 293     STDMETHOD(EnumDisplayModes)(DWORD, LPDDSURFACEDESC, LPVOID, LPVOID ) PURE;
 294     STDMETHOD(EnumSurfaces)(DWORD, LPDDSURFACEDESC, LPVOID,LPVOID ) PURE;
 295     STDMETHOD(FlipToGDISurface)() PURE;
 296     STDMETHOD(GetCaps)(LPDDCAPS, LPDDCAPS) PURE;
 297     STDMETHOD(GetDisplayMode)(LPDDSURFACEDESC) PURE;
 298     STDMETHOD(GetFourCCCodes)(LPDWORD, LPDWORD ) PURE;
 299     STDMETHOD(GetGDISurface)(LPDIRECTDRAWSURFACE *) PURE;
 300     STDMETHOD(GetMonitorFrequency)(LPDWORD) PURE;
 301     STDMETHOD(GetScanLine)(LPDWORD) PURE;
 302     STDMETHOD(GetVerticalBlankStatus)(LPBOOL ) PURE;
 303     STDMETHOD(Initialize)(GUID *) PURE;
 304     STDMETHOD(RestoreDisplayMode)() PURE;
 305     STDMETHOD(SetCooperativeLevel)(HWND, DWORD) PURE;
 306     STDMETHOD(SetDisplayMode)(DWORD, DWORD,DWORD, DWORD, DWORD) PURE;
 307     STDMETHOD(WaitForVerticalBlank)(DWORD, HANDLE ) PURE;
 308 };
 309
 310 //---------------------------------------------------------------------------
 311 //  AMMEDIA COM INTERFACES
 312 //---------------------------------------------------------------------------
 313 struct IMediaStream;
 314 struct IMultiMediaStream;
 315 struct IStreamSample : public IUnknown
 316 {
 317 public:
 318     STDMETHOD(GetMediaStream)(IMediaStream **) PURE;
 319     STDMETHOD(GetSampleTimes)(LONGLONG *, LONGLONG *, LONGLONG *) PURE;
 320     STDMETHOD(SetSampleTimes)(const LONGLONG *, const LONGLONG *) PURE;
 321     STDMETHOD(Update)(DWORD, HANDLE, LPVOID, DWORD_PTR) PURE;
 322     STDMETHOD(CompletionStatus)(DWORD, DWORD) PURE;
 323 };
 324
 325 struct IDirectDrawStreamSample : public IStreamSample
 326 {
 327 public:
 328     STDMETHOD(GetSurface)(IDirectDrawSurface **, RECT *) PURE;
 329     STDMETHOD(SetRect)(const RECT *) PURE;
 330 };
 331
 332 struct IMediaStream : public IUnknown
 333 {
 334     STDMETHOD(GetMultiMediaStream)(IMultiMediaStream **) PURE;
 335     STDMETHOD(GetInformation)(GUID *, int *) PURE;
 336     STDMETHOD(SetSameFormat)(IMediaStream *, DWORD) PURE;
 337     STDMETHOD(AllocateSample)(DWORD, IStreamSample **) PURE;
 338     STDMETHOD(CreateSharedSample)(IStreamSample *, DWORD,
 339                                   IStreamSample **) PURE;
 340     STDMETHOD(SendEndOfStream)(DWORD dwFlags) PURE;
 341 };
 342
 343 struct IDirectDrawMediaStream : public IMediaStream
 344 {
 345     STDMETHOD(GetFormat)(DDSURFACEDESC *, IDirectDrawPalette **,
 346                          DDSURFACEDESC *, DWORD *) PURE;
 347     STDMETHOD(SetFormat)(const DDSURFACEDESC *, IDirectDrawPalette *) PURE;
 348     STDMETHOD(GetDirectDraw)(IDirectDraw **) PURE;
 349     STDMETHOD(SetDirectDraw)(IDirectDraw *) PURE;
 350     STDMETHOD(CreateSample)(IDirectDrawSurface *, const RECT *,
 351                               DWORD, IDirectDrawStreamSample **) PURE;
 352     STDMETHOD(GetTimePerFrame)(LONGLONG *) PURE;
 353 };
 354
 355 struct IMultiMediaStream : public IUnknown
 356 {
 357     STDMETHOD(GetInformation)(DWORD *, int *) PURE;
 358     STDMETHOD(GetMediaStream)(REFGUID, IMediaStream **) PURE;
 359     STDMETHOD(EnumMediaStreams)(long, IMediaStream **) PURE;
 360     STDMETHOD(GetState)(int *pCurrentState) PURE;
 361     STDMETHOD(SetState)(int NewState) PURE;
 362     STDMETHOD(GetTime)(LONGLONG *pCurrentTime) PURE;
 363     STDMETHOD(GetDuration)(LONGLONG *pDuration) PURE;
 364     STDMETHOD(Seek)(LONGLONG SeekTime) PURE;
 365     STDMETHOD(GetEndOfStreamEventHandle)(HANDLE *phEOS) PURE;
 366 };
 367
 368 struct IAMMultiMediaStream : public IMultiMediaStream
 369 {
 370     STDMETHOD(Initialize)(int, DWORD, IUnknown *) PURE;
 371     STDMETHOD(GetFilterGraph)(IUnknown **) PURE;
 372     STDMETHOD(GetFilter)(IUnknown **) PURE;
 373     STDMETHOD(AddMediaStream)(IUnknown *, const GUID*, DWORD,
 374                               IMediaStream **) PURE;
 375     STDMETHOD(OpenFile)(LPCWSTR, DWORD) PURE;
 376     STDMETHOD(OpenMoniker)(IBindCtx *, IMoniker *, DWORD) PURE;
 377     STDMETHOD(Render)(DWORD) PURE;
 378 };
 379
 380 //---------------------------------------------------------------------------
 381 //  QUARTZ COM INTERFACES (dumped from quartz.idl from MSVC COM Browser)
 382 //---------------------------------------------------------------------------
 383 struct IAMCollection : public IDispatch
 384 {
 385     STDMETHOD(get_Count)(long *) PURE;
 386     STDMETHOD(Item)(long, IUnknown **) PURE;
 387     STDMETHOD(get__NewEnum)(IUnknown **) PURE;
 388 };
 389
 390 struct IMediaControl : public IDispatch
 391 {
 392     STDMETHOD(Run)() PURE;
 393     STDMETHOD(Pause)() PURE;
 394     STDMETHOD(Stop)() PURE;
 395     STDMETHOD(GetState)(long, long*) PURE;
 396     STDMETHOD(RenderFile)(BSTR) PURE;
 397     STDMETHOD(AddSourceFilter)(BSTR, IDispatch **) PURE;
 398     STDMETHOD(get_FilterCollection)(IDispatch **) PURE;
 399     STDMETHOD(get_RegFilterCollection)(IDispatch **) PURE;
 400     STDMETHOD(StopWhenReady)() PURE;
 401 };
 402
 403 struct IMediaEvent : public IDispatch
 404 {
 405     STDMETHOD(GetEventHandle)(LONG_PTR *) PURE;
 406     STDMETHOD(GetEvent)(long *, LONG_PTR *, LONG_PTR *, long) PURE;
 407     STDMETHOD(WaitForCompletion)(long, long *) PURE;
 408     STDMETHOD(CancelDefaultHandling)(long) PURE;
 409     STDMETHOD(RestoreDefaultHandling)(long) PURE;
 410     STDMETHOD(FreeEventParams)(long, LONG_PTR, LONG_PTR) PURE;
 411 };
 412
 413 struct IMediaEventEx : public IMediaEvent
 414 {
 415     STDMETHOD(SetNotifyWindow)(LONG_PTR, long, LONG_PTR) PURE;
 416     STDMETHOD(SetNotifyFlags)(long) PURE;
 417     STDMETHOD(GetNotifyFlags)(long *) PURE;
 418 };
 419
 420 struct IMediaPosition : public IDispatch
 421 {
 422     STDMETHOD(get_Duration)(double *) PURE;
 423     STDMETHOD(put_CurrentPosition)(double) PURE;
 424     STDMETHOD(get_CurrentPosition)(double *) PURE;
 425     STDMETHOD(get_StopTime)(double *) PURE;
 426     STDMETHOD(put_StopTime)(double) PURE;
 427     STDMETHOD(get_PrerollTime)(double *) PURE;
 428     STDMETHOD(put_PrerollTime)(double) PURE;
 429     STDMETHOD(put_Rate)(double) PURE;
 430     STDMETHOD(get_Rate)(double *) PURE;
 431     STDMETHOD(CanSeekForward)(long *) PURE;
 432     STDMETHOD(CanSeekBackward)(long *) PURE;
 433 };
 434
 435 struct IBasicAudio : public IDispatch
 436 {
 437     STDMETHOD(put_Volume)(long) PURE;
 438     STDMETHOD(get_Volume)(long *) PURE;
 439     STDMETHOD(put_Balance)(long) PURE;
 440     STDMETHOD(get_Balance)(long *) PURE;
 441 };
 442
 443 //---------------------------------------------------------------------------
 444 // MISC COM INTERFACES
 445 //---------------------------------------------------------------------------
 446 struct IVMRWindowlessControl : public IUnknown
 447 {
 448     STDMETHOD(GetNativeVideoSize)(LONG *, LONG *, LONG *, LONG *) PURE;
 449     STDMETHOD(GetMinIdealVideoSize)(LONG *, LONG *) PURE;
 450     STDMETHOD(GetMaxIdealVideoSize)(LONG *, LONG *) PURE;
 451     STDMETHOD(SetVideoPosition)(const LPRECT,const LPRECT) PURE;
 452     STDMETHOD(GetVideoPosition)(LPRECT, LPRECT) PURE;
 453     STDMETHOD(GetAspectRatioMode)(DWORD *) PURE;
 454     STDMETHOD(SetAspectRatioMode)(DWORD) PURE;
 455     STDMETHOD(SetVideoClippingWindow)(HWND) PURE;
 456     STDMETHOD(RepaintVideo)(HWND, HDC) PURE;
 457     STDMETHOD(DisplayModeChanged)() PURE;
 458     STDMETHOD(GetCurrentImage)(BYTE **) PURE;
 459     STDMETHOD(SetBorderColor)(COLORREF) PURE;
 460     STDMETHOD(GetBorderColor)(COLORREF *) PURE;
 461     STDMETHOD(SetColorKey)(COLORREF) PURE;
 462     STDMETHOD(GetColorKey)(COLORREF *) PURE;
 463 };
 464
 465 typedef IUnknown IVMRImageCompositor;
 466
 467 struct IVMRFilterConfig : public IUnknown
 468 {
 469     STDMETHOD(SetImageCompositor)(IVMRImageCompositor *) PURE;
 470     STDMETHOD(SetNumberOfStreams)(DWORD) PURE;
 471     STDMETHOD(GetNumberOfStreams)(DWORD *) PURE;
 472     STDMETHOD(SetRenderingPrefs)(DWORD) PURE;
 473     STDMETHOD(GetRenderingPrefs)(DWORD *) PURE;
 474     STDMETHOD(SetRenderingMode)(DWORD) PURE;
 475     STDMETHOD(GetRenderingMode)(DWORD *) PURE;
 476 };
 477
 478 typedef IUnknown IBaseFilter;
 479 typedef IUnknown IPin;
 480 typedef IUnknown IEnumFilters;
 481 typedef int AM_MEDIA_TYPE;
 482
 483 struct IFilterGraph : public IUnknown
 484 {
 485     STDMETHOD(AddFilter)(IBaseFilter *, LPCWSTR) PURE;
 486     STDMETHOD(RemoveFilter)(IBaseFilter *) PURE;
 487     STDMETHOD(EnumFilters)(IEnumFilters **) PURE;
 488     STDMETHOD(FindFilterByName)(LPCWSTR, IBaseFilter **) PURE;
 489     STDMETHOD(ConnectDirect)(IPin *, IPin *, const AM_MEDIA_TYPE *) PURE;
 490     STDMETHOD(Reconnect)(IPin *) PURE;
 491     STDMETHOD(Disconnect)(IPin *) PURE;
 492     STDMETHOD(SetDefaultSyncSource)() PURE;
 493 };
 494
 495 struct IGraphBuilder : public IFilterGraph
 496 {
 497 public:
 498     STDMETHOD(Connect)(IPin *, IPin *) PURE;
 499     STDMETHOD(Render)(IPin *) PURE;
 500     STDMETHOD(RenderFile)(LPCWSTR, LPCWSTR) PURE;
 501     STDMETHOD(AddSourceFilter)(LPCWSTR, LPCWSTR, IBaseFilter **) PURE;
 502     STDMETHOD(SetLogFile)(DWORD_PTR) PURE;
 503     STDMETHOD(Abort)() PURE;
 504     STDMETHOD(ShouldOperationContinue)() PURE;
 505 };
 506
 507 //------------------------------------------------------------------
 508 // wxAMMediaBackend (Active Movie)
 509 //------------------------------------------------------------------
 510 class WXDLLIMPEXP_MEDIA wxAMMediaThread : public wxThread
 511 {
 512 public:
 513     virtual ExitCode Entry();
 514
 515     class wxAMMediaBackend* pThis;
 516 };
 517
 518 //cludgy workaround for wx events.  slots would be nice :)
 519 class WXDLLIMPEXP_MEDIA wxAMMediaEvtHandler : public wxEvtHandler
 520 {
 521 public:
 522     void OnPaint(wxPaintEvent&);
 523     void OnEraseBackground(wxEraseEvent&);
 524 };
 525
 526 typedef BOOL (WINAPI* LPAMGETERRORTEXT)(HRESULT, wxChar *, DWORD);
 527
 528 class WXDLLIMPEXP_MEDIA wxAMMediaBackend : public wxMediaBackend
 529 {
 530 public:
 531     wxAMMediaBackend();
 532
 533     virtual ~wxAMMediaBackend();
 534
 535     virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
 536                                      wxWindowID id,
 537                                      const wxPoint& pos,
 538                                      const wxSize& size,
 539                                      long style,
 540                                      const wxValidator& validator,
 541                                      const wxString& name);
 542
 543     virtual bool Play();
 544     virtual bool Pause();
 545     virtual bool Stop();
 546
 547     virtual bool Load(const wxString& fileName);
 548     virtual bool Load(const wxURI& location);
 549
 550     virtual wxMediaState GetState();
 551
 552     virtual bool SetPosition(wxLongLong where);
 553     virtual wxLongLong GetPosition();
 554     virtual wxLongLong GetDuration();
 555
 556     virtual void Move(int x, int y, int w, int h);
 557     wxSize GetVideoSize() const;
 558
 559     virtual double GetPlaybackRate();
 560     virtual bool SetPlaybackRate(double);
 561
 562     virtual double GetVolume();
 563     virtual bool SetVolume(double);
 564
 565     void Cleanup();
 566     void OnStop();
 567     bool SetWindowlessMode(IGraphBuilder* pGB,
 568                            IVMRWindowlessControl** ppVMC = NULL);
 569
 570     wxControl* m_ctrl;
 571
 572     wxMediaState m_state;
 573     wxCriticalSection m_rendercs;
 574
 575     IVMRWindowlessControl* m_pVMC;
 576     IGraphBuilder* m_pGB;
 577     IBasicAudio* m_pBA;
 578     IMediaControl* m_pMC;
 579     IMediaEvent* m_pME;
 580     IMediaPosition* m_pMS;
 581     bool m_bVideo;
 582
 583     wxAMMediaThread* m_pThread;
 584
 585     wxSize m_bestSize;
 586
 587 #ifdef __WXDEBUG__
 588     HMODULE m_hQuartzDll;
 589     LPAMGETERRORTEXT m_lpAMGetErrorText;
 590     wxString GetErrorString(HRESULT hrdsv);
 591 #endif
 592
 593     friend class wxAMMediaThread;
 594     friend class wxAMMediaEvtHandler;
 595
 596     DECLARE_DYNAMIC_CLASS(wxAMMediaBackend)
 597 };
 598
 599 //---------------------------------------------------------------------------
 600 //
 601 //  wxMCIMediaBackend
 602 //
 603 //---------------------------------------------------------------------------
 604
 605 //---------------------------------------------------------------------------
 606 //  MCI Includes
 607 //---------------------------------------------------------------------------
 608 #include <mmsystem.h>
 609
 610 class WXDLLIMPEXP_MEDIA wxMCIMediaBackend : public wxMediaBackend
 611 {
 612 public:
 613
 614     wxMCIMediaBackend();
 615     ~wxMCIMediaBackend();
 616
 617     virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
 618                                      wxWindowID id,
 619                                      const wxPoint& pos,
 620                                      const wxSize& size,
 621                                      long style,
 622                                      const wxValidator& validator,
 623                                      const wxString& name);
 624
 625     virtual bool Play();
 626     virtual bool Pause();
 627     virtual bool Stop();
 628
 629     virtual bool Load(const wxString& fileName);
 630     virtual bool Load(const wxURI& location);
 631
 632     virtual wxMediaState GetState();
 633
 634     virtual bool SetPosition(wxLongLong where);
 635     virtual wxLongLong GetPosition();
 636     virtual wxLongLong GetDuration();
 637
 638     virtual void Move(int x, int y, int w, int h);
 639     wxSize GetVideoSize() const;
 640
 641     virtual double GetPlaybackRate();
 642     virtual bool SetPlaybackRate(double dRate);
 643
 644     virtual double GetVolume();
 645     virtual bool SetVolume(double);
 646
 647     static LRESULT CALLBACK NotifyWndProc(HWND hWnd, UINT nMsg,
 648                                              WPARAM wParam, LPARAM lParam);
 649
 650     LRESULT CALLBACK OnNotifyWndProc(HWND hWnd, UINT nMsg,
 651                                      WPARAM wParam, LPARAM lParam);
 652
 653     MCIDEVICEID m_hDev;     //Our MCI Device ID/Handler
 654     wxControl* m_ctrl;      //Parent control
 655     HWND m_hNotifyWnd;      //Window to use for MCI events
 656     bool m_bVideo;          //Whether or not we have video
 657
 658     DECLARE_DYNAMIC_CLASS(wxMCIMediaBackend)
 659 };
 660
 661 //---------------------------------------------------------------------------
 662 //
 663 //  wxQTMediaBackend
 664 //
 665 //---------------------------------------------------------------------------
 666
 667 //---------------------------------------------------------------------------
 668 //  QT Includes
 669 //---------------------------------------------------------------------------
 670 //#include <qtml.h>                   //Windoze QT include
 671 //#include <QuickTimeComponents.h>    //Standard QT stuff
 672 #include "wx/dynlib.h"
 673
 674 //---------------------------------------------------------------------------
 675 //  QT Types
 676 //---------------------------------------------------------------------------
 677 typedef struct MovieRecord* Movie;
 678 typedef wxInt16 OSErr;
 679 typedef wxInt32 OSStatus;
 680 #define noErr 0
 681 #define fsRdPerm 1
 682 typedef unsigned char                   Str255[256];
 683 #define StringPtr unsigned char*
 684 #define newMovieActive 1
 685 #define Ptr char*
 686 #define Handle Ptr*
 687 #define Fixed long
 688 #define OSType unsigned long
 689 #define CGrafPtr struct GrafPort *
 690 #define TimeScale long
 691 #define TimeBase struct TimeBaseRecord *
 692
 693 #ifndef URLDataHandlerSubType
 694 #if defined(__WATCOMC__) || defined(__MINGW32__)
 695 // use magic numbers for compilers which complain about multicharacter integers
 696 const OSType URLDataHandlerSubType     = 1970433056;
 697 const OSType VisualMediaCharacteristic = 1702454643;
 698 #else
 699 const OSType URLDataHandlerSubType     = 'url ';
 700 const OSType VisualMediaCharacteristic = 'eyes';
 701 #endif
 702 #endif
 703
 704 struct FSSpec {
 705     short      vRefNum;
 706     long       parID;
 707     Str255     name;  /*Str63 on mac, Str255 on msw */
 708 };
 709
 710 struct Rect {
 711     short      top;
 712     short      left;
 713     short      bottom;
 714     short      right;
 715 };
 716
 717 struct wide {
 718     wxInt32    hi;
 719     wxUint32   lo;
 720 };
 721
 722 struct TimeRecord {
 723     wide       value; /* units */
 724     TimeScale  scale; /* units per second */
 725     TimeBase   base;
 726 };
 727
 728 //---------------------------------------------------------------------------
 729 //  QT Library
 730 //---------------------------------------------------------------------------
 731 #define wxDL_METHOD_DEFINE( rettype, name, args, shortargs, defret ) \
 732     typedef rettype (* name ## Type) args ; \
 733     name ## Type pfn_ ## name; \
 734     rettype name args \
 735     { if (m_ok) return pfn_ ## name shortargs ; return defret; }
 736
 737 #define wxDL_VOIDMETHOD_DEFINE( name, args, shortargs ) \
 738     typedef void (* name ## Type) args ; \
 739     name ## Type pfn_ ## name; \
 740     void name args \
 741     { if (m_ok) pfn_ ## name shortargs ; }
 742
 743 #define wxDL_METHOD_LOAD( lib, name, success ) \
 744     pfn_ ## name = (name ## Type) lib.GetSymbol( wxT(#name), &success ); \
 745     if (!success) { wxLog::EnableLogging(true); return false; }
 746
 747
 748 //Class that utilizes Robert Roeblings Dynamic Library Macros
 749 class WXDLLIMPEXP_MEDIA wxQuickTimeLibrary
 750 {
 751 public:
 752     ~wxQuickTimeLibrary()
 753     {
 754         if(m_dll.IsLoaded())
 755             m_dll.Unload();
 756     }
 757
 758     bool Initialize();
 759     bool IsOk() const {return m_ok;}
 760
 761 protected:
 762     wxDynamicLibrary m_dll;
 763     bool m_ok;
 764
 765 public:
 766     wxDL_VOIDMETHOD_DEFINE( StartMovie, (Movie m), (m) );
 767     wxDL_VOIDMETHOD_DEFINE( StopMovie, (Movie m), (m) );
 768     wxDL_METHOD_DEFINE( bool, IsMovieDone, (Movie m), (m), false);
 769     wxDL_VOIDMETHOD_DEFINE( GoToBeginningOfMovie, (Movie m), (m) );
 770     wxDL_METHOD_DEFINE( OSErr, GetMoviesError, (), (), -1);
 771     wxDL_METHOD_DEFINE( OSErr, EnterMovies, (), (), -1);
 772     wxDL_VOIDMETHOD_DEFINE( ExitMovies, (), () );
 773     wxDL_METHOD_DEFINE( OSErr, InitializeQTML, (long flags), (flags), -1);
 774     wxDL_VOIDMETHOD_DEFINE( TerminateQTML, (), () );
 775
 776     wxDL_METHOD_DEFINE( OSErr, NativePathNameToFSSpec,
 777                         (char* inName, FSSpec* outFile, long flags),
 778                         (inName, outFile, flags), -1);
 779
 780     wxDL_METHOD_DEFINE( OSErr, OpenMovieFile,
 781                         (const FSSpec * fileSpec, short * resRefNum, wxInt8 permission),
 782                         (fileSpec, resRefNum, permission), -1 );
 783
 784     wxDL_METHOD_DEFINE( OSErr, CloseMovieFile,
 785                         (short resRefNum), (resRefNum), -1);
 786
 787     wxDL_METHOD_DEFINE( OSErr, NewMovieFromFile,
 788                             (Movie * theMovie, short resRefNum, short *  resId,
 789                              StringPtr resName, short newMovieFlags,
 790                              bool * dataRefWasChanged),
 791                              (theMovie, resRefNum, resId, resName, newMovieFlags,
 792                               dataRefWasChanged), -1);
 793
 794     wxDL_VOIDMETHOD_DEFINE( SetMovieRate, (Movie m, Fixed rate), (m, rate) );
 795     wxDL_METHOD_DEFINE( Fixed, GetMovieRate, (Movie m), (m), 0);
 796     wxDL_VOIDMETHOD_DEFINE( MoviesTask, (Movie m, long maxms), (m, maxms) );
 797     wxDL_VOIDMETHOD_DEFINE( BlockMove,
 798         (const char* p1, const char* p2, long s), (p1,p2,s) );
 799     wxDL_METHOD_DEFINE( Handle, NewHandleClear, (long s), (s), NULL );
 800
 801     wxDL_METHOD_DEFINE( OSErr, NewMovieFromDataRef,
 802                            (Movie * m, short flags, short * id,
 803                             Handle  dataRef, OSType  dataRefType),
 804                             (m,flags,id,dataRef,dataRefType), -1 );
 805
 806     wxDL_VOIDMETHOD_DEFINE( DisposeHandle, (Handle h), (h) );
 807     wxDL_VOIDMETHOD_DEFINE( GetMovieNaturalBoundsRect, (Movie m, Rect* r), (m,r) );
 808     wxDL_METHOD_DEFINE( void*, GetMovieIndTrackType,
 809                         (Movie m, long index, OSType type, long flags),
 810                         (m,index,type,flags), NULL );
 811     wxDL_VOIDMETHOD_DEFINE( CreatePortAssociation,
 812             (void* hWnd, void* junk, long morejunk), (hWnd, junk, morejunk) );
 813     wxDL_METHOD_DEFINE(void*, GetNativeWindowPort, (void* hWnd), (hWnd), NULL);
 814     wxDL_VOIDMETHOD_DEFINE(SetMovieGWorld, (Movie m, CGrafPtr port, void* whatever),
 815                             (m, port, whatever) );
 816     wxDL_VOIDMETHOD_DEFINE(DisposeMovie, (Movie m), (m) );
 817     wxDL_VOIDMETHOD_DEFINE(SetMovieBox, (Movie m, Rect* r), (m,r));
 818     wxDL_VOIDMETHOD_DEFINE(SetMovieTimeScale, (Movie m, long s), (m,s));
 819     wxDL_METHOD_DEFINE(long, GetMovieDuration, (Movie m), (m), 0);
 820     wxDL_METHOD_DEFINE(TimeBase, GetMovieTimeBase, (Movie m), (m), 0);
 821     wxDL_METHOD_DEFINE(TimeScale, GetMovieTimeScale, (Movie m), (m), 0);
 822     wxDL_METHOD_DEFINE(long, GetMovieTime, (Movie m, void* cruft), (m,cruft), 0);
 823     wxDL_VOIDMETHOD_DEFINE(SetMovieTime, (Movie m, TimeRecord* tr), (m,tr) );
 824     wxDL_METHOD_DEFINE(short, GetMovieVolume, (Movie m), (m), 0);
 825     wxDL_VOIDMETHOD_DEFINE(SetMovieVolume, (Movie m, short sVolume), (m,sVolume) );
 826 };
 827
 828 bool wxQuickTimeLibrary::Initialize()
 829 {
 830     m_ok = false;
 831
 832     wxLog::EnableLogging(false);    //Turn off the wxDynamicLibrary logging
 833
 834     if(!m_dll.Load(wxT("qtmlClient.dll")))
 835     {
 836         wxLog::EnableLogging(true);
 837         return false;
 838     }
 839
 840     bool bOk;   //TODO:  Get rid of this, use m_ok instead (not a biggie)
 841
 842     wxDL_METHOD_LOAD( m_dll, StartMovie, bOk );
 843     wxDL_METHOD_LOAD( m_dll, StopMovie, bOk );
 844     wxDL_METHOD_LOAD( m_dll, IsMovieDone, bOk );
 845     wxDL_METHOD_LOAD( m_dll, GoToBeginningOfMovie, bOk );
 846     wxDL_METHOD_LOAD( m_dll, GetMoviesError, bOk );
 847     wxDL_METHOD_LOAD( m_dll, EnterMovies, bOk );
 848     wxDL_METHOD_LOAD( m_dll, ExitMovies, bOk );
 849     wxDL_METHOD_LOAD( m_dll, InitializeQTML, bOk );
 850     wxDL_METHOD_LOAD( m_dll, TerminateQTML, bOk );
 851     wxDL_METHOD_LOAD( m_dll, NativePathNameToFSSpec, bOk );
 852     wxDL_METHOD_LOAD( m_dll, OpenMovieFile, bOk );
 853     wxDL_METHOD_LOAD( m_dll, CloseMovieFile, bOk );
 854     wxDL_METHOD_LOAD( m_dll, NewMovieFromFile, bOk );
 855     wxDL_METHOD_LOAD( m_dll, GetMovieRate, bOk );
 856     wxDL_METHOD_LOAD( m_dll, SetMovieRate, bOk );
 857     wxDL_METHOD_LOAD( m_dll, MoviesTask, bOk );
 858     wxDL_METHOD_LOAD( m_dll, BlockMove, bOk );
 859     wxDL_METHOD_LOAD( m_dll, NewHandleClear, bOk );
 860     wxDL_METHOD_LOAD( m_dll, NewMovieFromDataRef, bOk );
 861     wxDL_METHOD_LOAD( m_dll, DisposeHandle, bOk );
 862     wxDL_METHOD_LOAD( m_dll, GetMovieNaturalBoundsRect, bOk );
 863     wxDL_METHOD_LOAD( m_dll, GetMovieIndTrackType, bOk );
 864     wxDL_METHOD_LOAD( m_dll, CreatePortAssociation, bOk );
 865     wxDL_METHOD_LOAD( m_dll, GetNativeWindowPort, bOk );
 866     wxDL_METHOD_LOAD( m_dll, SetMovieGWorld, bOk );
 867     wxDL_METHOD_LOAD( m_dll, DisposeMovie, bOk );
 868     wxDL_METHOD_LOAD( m_dll, SetMovieBox, bOk );
 869     wxDL_METHOD_LOAD( m_dll, SetMovieTimeScale, bOk );
 870     wxDL_METHOD_LOAD( m_dll, GetMovieDuration, bOk );
 871     wxDL_METHOD_LOAD( m_dll, GetMovieTimeBase, bOk );
 872     wxDL_METHOD_LOAD( m_dll, GetMovieTimeScale, bOk );
 873     wxDL_METHOD_LOAD( m_dll, GetMovieTime, bOk );
 874     wxDL_METHOD_LOAD( m_dll, SetMovieTime, bOk );
 875     wxDL_METHOD_LOAD( m_dll, GetMovieVolume, bOk );
 876     wxDL_METHOD_LOAD( m_dll, SetMovieVolume, bOk );
 877
 878     wxLog::EnableLogging(true);
 879     m_ok = true;
 880
 881     return true;
 882 }
 883
 884 class WXDLLIMPEXP_MEDIA wxQTMediaBackend : public wxMediaBackend
 885 {
 886 public:
 887     wxQTMediaBackend();
 888     ~wxQTMediaBackend();
 889
 890     virtual bool CreateControl(wxControl* ctrl, wxWindow* parent,
 891                                      wxWindowID id,
 892                                      const wxPoint& pos,
 893                                      const wxSize& size,
 894                                      long style,
 895                                      const wxValidator& validator,
 896                                      const wxString& name);
 897
 898     virtual bool Play();
 899     virtual bool Pause();
 900     virtual bool Stop();
 901
 902     virtual bool Load(const wxString& fileName);
 903     virtual bool Load(const wxURI& location);
 904
 905     virtual wxMediaState GetState();
 906
 907     virtual bool SetPosition(wxLongLong where);
 908     virtual wxLongLong GetPosition();
 909     virtual wxLongLong GetDuration();
 910
 911     virtual void Move(int x, int y, int w, int h);
 912     wxSize GetVideoSize() const;
 913
 914     virtual double GetPlaybackRate();
 915     virtual bool SetPlaybackRate(double dRate);
 916
 917     virtual double GetVolume();
 918     virtual bool SetVolume(double);
 919
 920     void Cleanup();
 921     void FinishLoad();
 922
 923     wxSize m_bestSize;              //Original movie size
 924     Movie m_movie;    //QT Movie handle/instance
 925     wxControl* m_ctrl;              //Parent control
 926     bool m_bVideo;                  //Whether or not we have video
 927     class _wxQTTimer* m_timer;      //Timer for streaming the movie
 928     wxQuickTimeLibrary m_lib;
 929
 930     DECLARE_DYNAMIC_CLASS(wxQTMediaBackend)
 931 };
 932
 933
 934 //===========================================================================
 935 //  IMPLEMENTATION
 936 //===========================================================================
 937
 938 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 939 //
 940 // wxAMMediaBackend
 941 //
 942 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 943
 944 IMPLEMENT_DYNAMIC_CLASS(wxAMMediaBackend, wxMediaBackend);
 945
 946 //---------------------------------------------------------------------------
 947 // Usual debugging macros
 948 //---------------------------------------------------------------------------
 949 #ifdef __WXDEBUG__
 950 #define MAX_ERROR_TEXT_LEN 160
 951 #include "wx/log.h"             //wxLogDebug et al.
 952
 953 //Get the error string for Active Movie
 954 wxString wxAMMediaBackend::GetErrorString(HRESULT hrdsv)
 955 {
 956     wxChar szError[MAX_ERROR_TEXT_LEN];
 957     if( m_lpAMGetErrorText != NULL &&
 958        (*m_lpAMGetErrorText)(hrdsv, szError, MAX_ERROR_TEXT_LEN) == 0)
 959     {
 960         return wxString::Format(wxT("DirectShow error \"%s\" \n")
 961                                      wxT("(numeric %i)\n")
 962                                      wxT("occured at line %i in ")
 963                                      wxT("mediactrl.cpp"),
 964                                      (int)hrdsv, szError, __LINE__);
 965     }
 966     else
 967     {
 968         return wxString::Format(wxT("Unknown error (%i) ")
 969                                      wxT("occurred at")
 970                                      wxT(" line %i in mediactrl.cpp."),
 971                                      (int)hrdsv, __LINE__);
 972     }
 973 }
 974
 975 #define wxAMFAIL(x) wxFAIL_MSG(GetErrorString(x));
 976 #define wxVERIFY(x) wxASSERT((x))
 977 #define wxAMLOG(x) wxLogDebug(GetErrorString(x))
 978 #else
 979 #define wxAMVERIFY(x) (x)
 980 #define wxVERIFY(x) (x)
 981 #define wxAMLOG(x)
 982 #define wxAMFAIL(x)
 983 #endif
 984
 985 //---------------------------------------------------------------------------
 986 // Standard macros for ease of use
 987 //---------------------------------------------------------------------------
 988 #define SAFE_RELEASE(x) { if (x) x->Release(); x = NULL; }
 989
 990 //---------------------------------------------------------------------------
 991 // wxAMMediaBackend Constructor
 992 //
 993 // Sets m_hNotifyWnd to NULL to signify that we haven't loaded anything yet
 994 //---------------------------------------------------------------------------
 995 wxAMMediaBackend::wxAMMediaBackend()
 996                  :m_state(wxMEDIASTATE_STOPPED)
 997                  ,m_pVMC(NULL)
 998                  ,m_pGB(NULL)
 999                  ,m_pBA(NULL)
1000                  ,m_pMC(NULL)
1001                  ,m_pME(NULL)
1002                  ,m_pMS(NULL)
1003                  ,m_pThread(NULL)
1004 #ifdef __WXDEBUG__
1005                  ,m_hQuartzDll(NULL)
1006 #endif
1007 {
1008 }
1009
1010 //---------------------------------------------------------------------------
1011 // wxAMMediaBackend Destructor
1012 //
1013 // Cleans up everything
1014 //---------------------------------------------------------------------------
1015 wxAMMediaBackend::~wxAMMediaBackend()
1016 {
1017     if (m_pVMC)
1018         Cleanup();
1019 #ifdef __WXDEBUG__
1020     if(m_hQuartzDll)
1021         ::FreeLibrary(m_hQuartzDll);
1022 #endif
1023 }
1024
1025 //---------------------------------------------------------------------------
1026 // wxAMMediaBackend::CreateControl
1027 //
1028 // 1) Check to see if Active Movie supports windowless controls
1029 // 2) Connect events to the media control and its TLW
1030 //---------------------------------------------------------------------------
1031 bool wxAMMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
1032                                      wxWindowID id,
1033                                      const wxPoint& pos,
1034                                      const wxSize& size,
1035                                      long style,
1036                                      const wxValidator& validator,
1037                                      const wxString& name)
1038 {
1039 #ifdef __WXDEBUG__
1040     m_hQuartzDll = ::LoadLibrary(wxT("quartz.dll"));
1041     if(m_hQuartzDll)
1042     {
1043             m_lpAMGetErrorText = (LPAMGETERRORTEXT) ::GetProcAddress(
1044                 m_hQuartzDll,
1045             wxString::Format(wxT("AMGetErrorText%s"),
1046
1047 #ifdef __WXUNICODE__
1048             wxT("W")
1049 #else
1050             wxT("A")
1051 #endif
1052 #ifdef __WXWINCE__
1053                              )
1054 #else
1055                              ).mb_str(wxConvLocal)
1056 #endif
1057                              );
1058     }
1059 #endif
1060
1061     //Make sure a valid windowless video mixing interface exists
1062     IGraphBuilder* pGB;
1063     if( ::CoCreateInstance(CLSID_FilgraphManager, NULL,
1064                                   CLSCTX_INPROC_SERVER,
1065                                   IID_IGraphBuilder, (void**)&pGB) != 0 )
1066         return false;
1067
1068     if( !SetWindowlessMode(pGB) )
1069         return false;
1070
1071     //clean up
1072     pGB->Release();
1073
1074     //
1075     // Create window
1076     // By default wxWindow(s) is created with a border -
1077     // so we need to get rid of those, and create with
1078     // wxCLIP_CHILDREN, so that if the driver/backend
1079     // is a child window, it refreshes properly
1080     //
1081     if ( !ctrl->wxControl::Create(parent, id, pos, size,
1082                             (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
1083                             validator, name) )
1084         return false;
1085
1086     // My problem with this was only with a previous patch, probably the third rewrite
1087     // fixed it as a side-effect. In fact, the erase background style of drawing not
1088     // only works now, but is much better than paint-based updates (the paint event
1089     // handler flickers if the wxMediaCtrl shares a sizer with another child window,
1090     // or is on a notebook)
1091     //  - Greg Hazel
1092     ctrl->Connect(ctrl->GetId(), wxEVT_ERASE_BACKGROUND,
1093         wxEraseEventHandler(wxAMMediaEvtHandler::OnEraseBackground),
1094         NULL, (wxEvtHandler*) this);
1095
1096     //
1097     // done...
1098     //
1099     m_ctrl = ctrl;
1100     return true;
1101 }
1102
1103 //---------------------------------------------------------------------------
1104 // wxAMMediaBackend::SetWindowlessMode
1105 //
1106 // Adds a Video Mixing Renderer to a Filter Graph and obtains the
1107 // windowless control from it
1108 //---------------------------------------------------------------------------
1109 bool wxAMMediaBackend::SetWindowlessMode(IGraphBuilder* pGB,
1110                                          IVMRWindowlessControl** ppVMC)
1111 {
1112     HRESULT hr;
1113
1114     //
1115     // Create and add a custom Video Mixing Render to the graph
1116     //
1117     IBaseFilter* pVMR;
1118     if( ::CoCreateInstance(CLSID_VideoMixingRenderer, NULL,
1119                 CLSCTX_INPROC_SERVER, IID_IBaseFilter, (void**)&pVMR) != 0 )
1120         return false;
1121
1122     hr = pGB->AddFilter(pVMR, L"Video Mixing Renderer");
1123     if ( hr != 0)
1124     {
1125         wxAMLOG(hr);
1126         pVMR->Release();
1127         return false;
1128     }
1129
1130     //
1131     // Set the graph to windowless mode
1132     //
1133     IVMRFilterConfig* pConfig;
1134     hr = pVMR->QueryInterface(IID_IVMRFilterConfig, (void**)&pConfig);
1135     if( hr != 0 )
1136     {
1137         wxAMLOG(hr);
1138         pVMR->Release();
1139         return false;
1140     }
1141
1142     hr = pConfig->SetRenderingMode(2);
1143     if( hr != 0) //2 == VMRMode_Windowless
1144     {
1145         wxAMLOG(hr);
1146         pConfig->Release();
1147         pVMR->Release();
1148         return false;
1149     }
1150
1151     pConfig->Release();
1152
1153     //
1154     // Obtain the windowless control
1155     //
1156     IVMRWindowlessControl* pVMC;
1157     hr = pVMR->QueryInterface(IID_IVMRWindowlessControl, (void**)&pVMC);
1158     if( hr != 0 )
1159     {
1160         wxAMLOG(hr);
1161         pVMR->Release();
1162         return false;
1163     }
1164
1165     //
1166     // Success
1167     //
1168     if(ppVMC)
1169         *ppVMC = pVMC;
1170     else
1171         pVMC->Release();
1172
1173     pVMR->Release();
1174     return true;
1175 }
1176
1177 //---------------------------------------------------------------------------
1178 // wxAMMediaBackend::Load (file version)
1179 //
1180 // 1) Cleans up previously loaded data
1181 // 2) Creates a filter graph
1182 // 3) Add a video mixer, set the graph to windowless mode and clip
1183 //    output to our media control
1184 // 4) Query interfaces to use later
1185 // 5) Get native video size (which becomes our best size)
1186 // 6) Refresh parent's sizers
1187 // 7) Start event/rendering thread
1188 //---------------------------------------------------------------------------
1189 bool wxAMMediaBackend::Load(const wxString& fileName)
1190 {
1191     HRESULT hr;
1192
1193     //if previously loaded cleanup
1194     if(m_pVMC)
1195         Cleanup();
1196
1197     //Create interfaces - we already checked for success in CreateControl
1198     ::CoCreateInstance(CLSID_FilgraphManager, NULL, CLSCTX_INPROC_SERVER,
1199                      IID_IGraphBuilder, (void**)&m_pGB);
1200
1201
1202     // Set and clip output
1203     SetWindowlessMode(m_pGB, &m_pVMC);
1204     hr = m_pVMC->SetVideoClippingWindow((HWND)m_ctrl->GetHandle());
1205
1206     if(hr != 0)
1207     {
1208         m_bestSize.x = m_bestSize.y = 0;
1209         wxAMFAIL(hr);
1210         return false;
1211     }
1212
1213     //load the graph & render
1214     if( m_pGB->RenderFile(fileName.wc_str(wxConvLocal), NULL) != 0 )
1215         return false;
1216
1217     //
1218     //Get the interfaces, all of them
1219     //
1220     hr = m_pGB->QueryInterface(IID_IMediaEvent, (void**)&m_pME);
1221     if(FAILED(hr))
1222     {
1223         wxAMLOG(hr);
1224         return false;
1225     }
1226
1227     hr = m_pGB->QueryInterface(IID_IMediaControl, (void**)&m_pMC);
1228     if(FAILED(hr))
1229     {
1230         wxAMLOG(hr);
1231         return false;
1232     }
1233
1234     hr = m_pGB->QueryInterface(IID_IMediaPosition, (void**)&m_pMS);
1235     if(FAILED(hr))
1236     {
1237         wxAMLOG(hr);
1238         return false;
1239     }
1240
1241     hr = m_pGB->QueryInterface(IID_IBasicAudio, (void**)&m_pBA);
1242     if(FAILED(hr))
1243     {
1244         wxAMLOG(hr);
1245         //not critical
1246     }
1247
1248     //
1249     // Get original video size
1250     //
1251     hr = m_pVMC->GetNativeVideoSize((LONG*)&m_bestSize.x, (LONG*)&m_bestSize.y,
1252                                    NULL, NULL);
1253     if(hr != 0)
1254     {
1255         m_bestSize.x = m_bestSize.y = 0;
1256         wxAMFAIL(hr);
1257         return false;
1258     }
1259
1260     if(m_bestSize.x == 0 && m_bestSize.y == 0)
1261         m_bVideo = false;
1262     else
1263         m_bVideo = true;
1264
1265     //
1266     // Force the parent window of this control to recalculate
1267     // the size of this if sizers are being used
1268     // and render the results immediately
1269     //
1270     m_ctrl->InvalidateBestSize();
1271     m_ctrl->GetParent()->Layout();
1272     m_ctrl->GetParent()->Refresh();
1273     m_ctrl->GetParent()->Update();
1274     m_ctrl->SetSize(m_ctrl->GetSize());
1275
1276     //
1277     //  Create the event thread
1278     //
1279     m_pThread = new wxAMMediaThread;
1280     m_pThread->pThis = this;
1281     m_pThread->Create();
1282     m_pThread->Run();
1283
1284     //
1285     //  done
1286     //
1287     return true;
1288 }
1289
1290 //---------------------------------------------------------------------------
1291 // wxAMMediaBackend::Load (URL Version)
1292 //
1293 // Loads media from a URL.  Interestingly enough DirectShow
1294 // appears (?) to escape the URL for us, at least on normal
1295 // files
1296 //---------------------------------------------------------------------------
1297 bool wxAMMediaBackend::Load(const wxURI& location)
1298 {
1299     return Load(location.BuildUnescapedURI());
1300 }
1301
1302 //---------------------------------------------------------------------------
1303 // wxAMMediaBackend::Cleanup
1304 //
1305 // Releases all the directshow interfaces we use
1306 // TODO: Maybe only create one instance of IAMMultiMediaStream and reuse it
1307 // rather than recreating it each time?
1308 //---------------------------------------------------------------------------
1309 void wxAMMediaBackend::Cleanup()
1310 {
1311     // RN:  This could be a bad ptr if load failed after
1312     // m_pVMC was created
1313     if(m_pThread)
1314     {
1315         m_pThread->Delete();
1316         m_pThread = NULL;
1317     }
1318
1319     // Release and zero DirectShow interfaces
1320     SAFE_RELEASE(m_pMC);
1321     SAFE_RELEASE(m_pME);
1322     SAFE_RELEASE(m_pMS);
1323     SAFE_RELEASE(m_pBA);
1324     SAFE_RELEASE(m_pGB);
1325     SAFE_RELEASE(m_pVMC);
1326 }
1327
1328
1329 //---------------------------------------------------------------------------
1330 // wxAMMediaBackend::Play
1331 //
1332 // Plays the stream.  If it is non-seekable, it will restart it (implicit).
1333 //
1334 // Note that we use SUCCEEDED here because run/pause/stop tend to be overly
1335 // picky and return warnings on pretty much every call
1336 //---------------------------------------------------------------------------
1337 bool wxAMMediaBackend::Play()
1338 {
1339     wxCriticalSectionLocker lock(m_rendercs);
1340
1341     if( SUCCEEDED(m_pMC->Run()) )
1342     {
1343         m_state = wxMEDIASTATE_PLAYING;
1344         m_ctrl->Refresh(); //videoless control finicky about refreshing
1345         return true;
1346     }
1347
1348     return false;
1349 }
1350
1351 //---------------------------------------------------------------------------
1352 // wxAMMediaBackend::Pause
1353 //
1354 // Pauses the stream.
1355 //---------------------------------------------------------------------------
1356 bool wxAMMediaBackend::Pause()
1357 {
1358     wxCriticalSectionLocker lock(m_rendercs);
1359
1360     if( SUCCEEDED(m_pMC->Pause()) )
1361     {
1362         m_state = wxMEDIASTATE_PAUSED;
1363         return true;
1364     }
1365
1366     return false;
1367 }
1368
1369 //---------------------------------------------------------------------------
1370 // wxAMMediaBackend::Stop
1371 //
1372 // Stops the stream.
1373 //---------------------------------------------------------------------------
1374 bool wxAMMediaBackend::Stop()
1375 {
1376     wxCriticalSectionLocker lock(m_rendercs);
1377
1378     if( SUCCEEDED(m_pMC->Stop()) )
1379     {
1380     //We don't care if it can't get to the beginning in directshow -
1381     //it could be a non-seeking filter (wince midi) in which case playing
1382     //starts all over again
1383         wxAMMediaBackend::SetPosition(0);
1384
1385         m_state = wxMEDIASTATE_STOPPED;
1386         return true;
1387     }
1388
1389     return false;
1390 }
1391
1392 //---------------------------------------------------------------------------
1393 // wxAMMediaBackend::SetPosition
1394 //
1395 // 1) Translates the current position's time to directshow time,
1396 //    which is in a scale of 1 second (in a double)
1397 // 2) Sets the play position of the IMediaSeeking interface -
1398 //    passing NULL as the stop position means to keep the old
1399 //    stop position
1400 //---------------------------------------------------------------------------
1401 bool wxAMMediaBackend::SetPosition(wxLongLong where)
1402 {
1403     HRESULT hr = m_pMS->put_CurrentPosition(
1404                         ((LONGLONG)where.GetValue()) / 1000.0
1405                                      );
1406     if(FAILED(hr))
1407     {
1408         wxAMLOG(hr);
1409         return false;
1410     }
1411
1412     return true;
1413 }
1414
1415 //---------------------------------------------------------------------------
1416 // wxAMMediaBackend::GetPosition
1417 //
1418 // 1) Obtains the current play and stop positions from IMediaSeeking
1419 // 2) Returns the play position translated to our time base
1420 //---------------------------------------------------------------------------
1421 wxLongLong wxAMMediaBackend::GetPosition()
1422 {
1423     double outCur;
1424     HRESULT hr = m_pMS->get_CurrentPosition(&outCur);
1425     if(FAILED(hr))
1426     {
1427         wxAMLOG(hr);
1428         return 0;
1429     }
1430
1431     //h,m,s,milli - outdur is in 1 second (double)
1432     outCur *= 1000;
1433     wxLongLong ll;
1434     ll.Assign(outCur);
1435
1436     return ll;
1437 }
1438
1439 //---------------------------------------------------------------------------
1440 // wxAMMediaBackend::GetVolume
1441 //
1442 // Gets the volume through the IBasicAudio interface -
1443 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
1444 // -100 per decibel.
1445 //---------------------------------------------------------------------------
1446 double wxAMMediaBackend::GetVolume()
1447 {
1448     if(m_pBA)
1449     {
1450         long lVolume;
1451         HRESULT hr = m_pBA->get_Volume(&lVolume);
1452         if(FAILED(hr))
1453         {
1454             wxAMLOG(hr);
1455             return 0.0;
1456         }
1457
1458         return (((double)(lVolume + 10000)) / 10000.0);
1459     }
1460
1461     wxLogDebug(wxT("No directshow audio interface"));
1462     return 0.0;
1463 }
1464
1465 //---------------------------------------------------------------------------
1466 // wxAMMediaBackend::SetVolume
1467 //
1468 // Sets the volume through the IBasicAudio interface -
1469 // value ranges from 0 (MAX volume) to -10000 (minimum volume).
1470 // -100 per decibel.
1471 //---------------------------------------------------------------------------
1472 bool wxAMMediaBackend::SetVolume(double dVolume)
1473 {
1474     if(m_pBA)
1475     {
1476         HRESULT hr = m_pBA->put_Volume( (long) ((dVolume-1.0) * 10000.0) );
1477         if(FAILED(hr))
1478         {
1479             wxAMLOG(hr);
1480             return false;
1481         }
1482         return true;
1483     }
1484
1485     wxLogDebug(wxT("No directshow audio interface"));
1486     return false;
1487 }
1488
1489 //---------------------------------------------------------------------------
1490 // wxAMMediaBackend::GetDuration
1491 //
1492 // 1) Obtains the duration of the media from IAMMultiMediaStream
1493 // 2) Converts that value to our time base, and returns it
1494 //
1495 // NB: With VBR MP3 files the default DirectShow MP3 render does not
1496 // read the Xing header correctly, resulting in skewed values for duration
1497 // and seeking
1498 //---------------------------------------------------------------------------
1499 wxLongLong wxAMMediaBackend::GetDuration()
1500 {
1501     double outDuration;
1502     HRESULT hr = m_pMS->get_Duration(&outDuration);
1503     if(FAILED(hr))
1504     {
1505         wxAMLOG(hr);
1506         return 0;
1507     }
1508
1509     //h,m,s,milli - outdur is in 1 second (double)
1510     outDuration *= 1000;
1511     wxLongLong ll;
1512     ll.Assign(outDuration);
1513
1514     return ll;
1515 }
1516
1517 //---------------------------------------------------------------------------
1518 // wxAMMediaBackend::GetState
1519 //
1520 // Returns the cached state
1521 //---------------------------------------------------------------------------
1522 wxMediaState wxAMMediaBackend::GetState()
1523 {
1524     return m_state;
1525 }
1526
1527 //---------------------------------------------------------------------------
1528 // wxAMMediaBackend::GetPlaybackRate
1529 //
1530 // Pretty simple way of obtaining the playback rate from
1531 // the IMediaSeeking interface
1532 //---------------------------------------------------------------------------
1533 double wxAMMediaBackend::GetPlaybackRate()
1534 {
1535     double dRate;
1536     HRESULT hr = m_pMS->get_Rate(&dRate);
1537     if(FAILED(hr))
1538     {
1539         wxAMLOG(hr);
1540         return 0.0;
1541     }
1542     return dRate;
1543 }
1544
1545 //---------------------------------------------------------------------------
1546 // wxAMMediaBackend::SetPlaybackRate
1547 //
1548 // Sets the playback rate of the media - DirectShow is pretty good
1549 // about this, actually
1550 //---------------------------------------------------------------------------
1551 bool wxAMMediaBackend::SetPlaybackRate(double dRate)
1552 {
1553     HRESULT hr = m_pMS->put_Rate(dRate);
1554     if(FAILED(hr))
1555     {
1556         wxAMLOG(hr);
1557         return false;
1558     }
1559
1560     return true;
1561 }
1562
1563 //---------------------------------------------------------------------------
1564 // wxAMMediaBackend::GetVideoSize
1565 //
1566 // Obtains the cached original video size
1567 //---------------------------------------------------------------------------
1568 wxSize wxAMMediaBackend::GetVideoSize() const
1569 {
1570     return m_bestSize;
1571 }
1572
1573 //---------------------------------------------------------------------------
1574 // wxAMMediaBackend::Move
1575 //
1576 // We take care of this in our redrawing
1577 //---------------------------------------------------------------------------
1578 void wxAMMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y),
1579                             int w, int h)
1580 {
1581     //don't use deferred positioning on windows
1582     if(m_pVMC && m_bVideo)
1583     {
1584         RECT srcRect, destRect;
1585
1586         //portion of video to display in window
1587         srcRect.top = 0; srcRect.left = 0;
1588         srcRect.bottom = m_bestSize.y; srcRect.right = m_bestSize.x;
1589
1590         //it happens.
1591         if (w < 0)
1592         {
1593             w = 0;
1594         }
1595         if (h < 0)
1596         {
1597             h = 0;
1598         }
1599
1600         //position in window client coordinates to display and stretch to
1601         destRect.top = 0; destRect.left = 0;
1602         destRect.bottom = h; destRect.right = w;
1603
1604         //set the windowless control positions
1605         HRESULT hr = m_pVMC->SetVideoPosition(&srcRect, &destRect);
1606         if(FAILED(hr))
1607         {
1608             wxAMLOG(hr);
1609         }
1610     }
1611 }
1612
1613 //---------------------------------------------------------------------------
1614 // wxAMMediaThread::Entry
1615 //
1616 // Render the current movie frame
1617 //---------------------------------------------------------------------------
1618 wxThread::ExitCode wxAMMediaThread::Entry()
1619 {
1620     while(!TestDestroy())
1621     {
1622         LONG    evCode,
1623                 evParam1,
1624                 evParam2;
1625
1626         //
1627         // DirectShow keeps a list of queued events, and we need
1628         // to go through them one by one, stopping at (Hopefully only one)
1629         // EC_COMPLETE message
1630         //
1631         while( pThis->m_pME->GetEvent(&evCode, (LONG_PTR *) &evParam1,
1632                                       (LONG_PTR *) &evParam2, 0) == 0 )
1633         {
1634             // Cleanup memory that GetEvent allocated
1635             HRESULT hr = pThis->m_pME->FreeEventParams(evCode,
1636                                                 evParam1, evParam2);
1637             if(hr != 0)
1638             {
1639                 //Even though this makes a messagebox this
1640                 //is windows where we can do gui stuff in seperate
1641                 //threads :)
1642                 wxFAIL_MSG(pThis->GetErrorString(hr));
1643             }
1644             // If this is the end of the clip, notify handler
1645             else if(1 == evCode) //EC_COMPLETE
1646             {
1647                 pThis->OnStop();
1648             }
1649         }
1650
1651         Sleep(10);
1652     }
1653
1654     return NULL;
1655 }
1656
1657
1658 //---------------------------------------------------------------------------
1659 // wxAMMediaBackend::OnStop
1660 //
1661 // Handle stopping when the stream ends
1662 //---------------------------------------------------------------------------
1663 void wxAMMediaBackend::OnStop()
1664 {
1665     //send the event to our child
1666     wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
1667     m_ctrl->ProcessEvent(theEvent);
1668
1669     //if the user didn't veto it, stop the stream
1670     if (theEvent.IsAllowed())
1671     {
1672         //Interestingly enough, DirectShow does not actually stop
1673         //the filters - even when it reaches the end!
1674         wxVERIFY( Stop() );
1675
1676         //send the event to our child
1677         wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
1678                               m_ctrl->GetId());
1679         m_ctrl->ProcessEvent(theEvent);
1680     }
1681 }
1682
1683 //---------------------------------------------------------------------------
1684 // wxAMMediaEvtHandler::OnEraseBackground
1685 //
1686 // Tell WX not to erase the background of our control window
1687 //---------------------------------------------------------------------------
1688 void wxAMMediaEvtHandler::OnEraseBackground(wxEraseEvent& evt)
1689 {
1690     wxAMMediaBackend* pThis = (wxAMMediaBackend*) this;
1691     if(pThis->m_pVMC && pThis->m_bVideo)
1692     {
1693         //TODO: Use wxClientDC?
1694         HDC hdc = ::GetDC((HWND)pThis->m_ctrl->GetHandle());
1695         HRESULT hr = pThis->m_pVMC->RepaintVideo((HWND)pThis->m_ctrl->GetHandle(),
1696                                         hdc);
1697         if(FAILED(hr))
1698         {
1699             wxFAIL_MSG(pThis->GetErrorString(hr));
1700         }
1701         ::ReleaseDC((HWND)pThis->m_ctrl->GetHandle(), hdc);
1702     }
1703     else
1704     {
1705         evt.Skip();
1706     }
1707 }
1708
1709 //---------------------------------------------------------------------------
1710 // End of wxAMMediaBackend
1711 //---------------------------------------------------------------------------
1712
1713 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1714 //
1715 // wxMCIMediaBackend
1716 //
1717 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1718
1719 IMPLEMENT_DYNAMIC_CLASS(wxMCIMediaBackend, wxMediaBackend);
1720
1721 //---------------------------------------------------------------------------
1722 // Usual debugging macros for MCI returns
1723 //---------------------------------------------------------------------------
1724
1725 #ifdef __WXDEBUG__
1726 #define wxMCIVERIFY(arg) \
1727 { \
1728     DWORD nRet; \
1729     if ( (nRet = (arg)) != 0) \
1730     { \
1731         TCHAR sz[5000]; \
1732         mciGetErrorString(nRet, sz, 5000); \
1733         wxFAIL_MSG(wxString::Format(_T("MCI Error:%s"), sz)); \
1734     } \
1735 }
1736 #else
1737 #define wxMCIVERIFY(arg) (arg);
1738 #endif
1739
1740 //---------------------------------------------------------------------------
1741 // Simulation for <digitalv.h>
1742 //
1743 // Mingw and possibly other compilers don't have the digitalv.h header
1744 // that is needed to have some essential features of mci work with
1745 // windows - so we provide the declarations for the types we use here
1746 //---------------------------------------------------------------------------
1747
1748 typedef struct {
1749     DWORD_PTR   dwCallback;
1750 #ifdef MCI_USE_OFFEXT
1751     POINT   ptOffset;
1752     POINT   ptExtent;
1753 #else
1754     RECT    rc;
1755 #endif
1756 } MCI_DGV_RECT_PARMS;
1757
1758 typedef struct {
1759     DWORD_PTR   dwCallback;
1760     HWND    hWnd;
1761 #ifndef _WIN32
1762     WORD    wReserved1;
1763 #endif
1764     UINT    nCmdShow;
1765 #ifndef _WIN32
1766     WORD    wReserved2;
1767 #endif
1768     wxChar*   lpstrText;
1769 } MCI_DGV_WINDOW_PARMS;
1770
1771 typedef struct {
1772     DWORD_PTR dwCallback;
1773     DWORD     dwTimeFormat;
1774     DWORD     dwAudio;
1775     DWORD     dwFileFormat;
1776     DWORD     dwSpeed;
1777 } MCI_DGV_SET_PARMS;
1778
1779 typedef struct {
1780     DWORD_PTR   dwCallback;
1781     DWORD   dwItem;
1782     DWORD   dwValue;
1783     DWORD   dwOver;
1784     wxChar*   lpstrAlgorithm;
1785     wxChar*   lpstrQuality;
1786 } MCI_DGV_SETAUDIO_PARMS;
1787
1788 //---------------------------------------------------------------------------
1789 // wxMCIMediaBackend Constructor
1790 //
1791 // Here we don't need to do much except say we don't have any video :)
1792 //---------------------------------------------------------------------------
1793 wxMCIMediaBackend::wxMCIMediaBackend() : m_hNotifyWnd(NULL), m_bVideo(false)
1794 {
1795 }
1796
1797 //---------------------------------------------------------------------------
1798 // wxMCIMediaBackend Destructor
1799 //
1800 // We close the mci device - note that there may not be an mci device here,
1801 // or it may fail - but we don't really care, since we're destructing
1802 //---------------------------------------------------------------------------
1803 wxMCIMediaBackend::~wxMCIMediaBackend()
1804 {
1805     if(m_hNotifyWnd)
1806     {
1807         mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
1808         DestroyWindow(m_hNotifyWnd);
1809         m_hNotifyWnd = NULL;
1810     }
1811 }
1812
1813 //---------------------------------------------------------------------------
1814 // wxMCIMediaBackend::Create
1815 //
1816 // Here we just tell wxMediaCtrl that mci does exist (which it does, on all
1817 // msw systems, at least in some form dating back to win16 days)
1818 //---------------------------------------------------------------------------
1819 bool wxMCIMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
1820                                      wxWindowID id,
1821                                      const wxPoint& pos,
1822                                      const wxSize& size,
1823                                      long style,
1824                                      const wxValidator& validator,
1825                                      const wxString& name)
1826 {
1827     //
1828     // Create window
1829     // By default wxWindow(s) is created with a border -
1830     // so we need to get rid of those, and create with
1831     // wxCLIP_CHILDREN, so that if the driver/backend
1832     // is a child window, it refereshes properly
1833     //
1834     if ( !ctrl->wxControl::Create(parent, id, pos, size,
1835                             (style & ~wxBORDER_MASK) | wxBORDER_NONE | wxCLIP_CHILDREN,
1836                             validator, name) )
1837         return false;
1838
1839     m_ctrl = ctrl;
1840     return true;
1841 }
1842
1843 //---------------------------------------------------------------------------
1844 // wxMCIMediaBackend::Load (file version)
1845 //
1846 // Here we have MCI load a file and device, set the time format to our
1847 // default (milliseconds), and set the video (if any) to play in the control
1848 //---------------------------------------------------------------------------
1849 bool wxMCIMediaBackend::Load(const wxString& fileName)
1850 {
1851     //
1852     //if the user already called load close the previous MCI device
1853     //
1854     if(m_hNotifyWnd)
1855     {
1856         mciSendCommand(m_hDev, MCI_CLOSE, 0, 0);
1857         DestroyWindow(m_hNotifyWnd);
1858         m_hNotifyWnd = NULL;
1859     }
1860
1861     //
1862     //Opens a file and has MCI select a device.  Normally you'd put
1863     //MCI_OPEN_TYPE in addition to MCI_OPEN_ELEMENT - however if you
1864     //omit this it tells MCI to select the device instead.  This is
1865     //good because we have no reliable way of "enumerating" the devices
1866     //in MCI
1867     //
1868     MCI_OPEN_PARMS openParms;
1869     openParms.lpstrElementName = (wxChar*) fileName.c_str();
1870
1871     if ( mciSendCommand(0, MCI_OPEN, MCI_OPEN_ELEMENT,
1872                         (DWORD)(LPVOID)&openParms) != 0)
1873         return false;
1874
1875     m_hDev = openParms.wDeviceID;
1876
1877     //
1878     //Now set the time format for the device to milliseconds
1879     //
1880     MCI_SET_PARMS setParms;
1881     setParms.dwCallback = 0;
1882     setParms.dwTimeFormat = MCI_FORMAT_MILLISECONDS;
1883
1884     if (mciSendCommand(m_hDev, MCI_SET, MCI_SET_TIME_FORMAT,
1885                          (DWORD)(LPVOID)&setParms) != 0)
1886         return false;
1887
1888     //
1889     //Now tell the MCI device to display the video in our wxMediaCtrl
1890     //
1891     MCI_DGV_WINDOW_PARMS windowParms;
1892     windowParms.hWnd = (HWND)m_ctrl->GetHandle();
1893
1894     m_bVideo = (mciSendCommand(m_hDev, MCI_WINDOW,
1895                                0x00010000L, //MCI_DGV_WINDOW_HWND
1896                                (DWORD)(LPVOID)&windowParms) == 0);
1897
1898     //
1899     // Create a hidden window and register to handle
1900     // MCI events
1901     // Note that wxCanvasClassName is already registered
1902     // and used by all wxWindows and normal wxControls
1903     //
1904     m_hNotifyWnd = ::CreateWindow
1905                     (
1906                         wxCanvasClassName,
1907                         NULL,
1908                         0, 0, 0, 0,
1909                         0,
1910                         (HWND) NULL,
1911                         (HMENU)NULL,
1912                         wxGetInstance(),
1913                         (LPVOID) NULL
1914                     );
1915
1916     if(!m_hNotifyWnd)
1917     {
1918         wxLogSysError( wxT("Could not create hidden needed for ")
1919                        wxT("registering for DirectShow events!")  );
1920
1921         return false;
1922     }
1923
1924     wxSetWindowProc(m_hNotifyWnd, wxMCIMediaBackend::NotifyWndProc);
1925
1926     ::SetWindowLong(m_hNotifyWnd, GWL_USERDATA,
1927                        (LONG) this);
1928
1929     //
1930     //Here, if the parent of the control has a sizer - we
1931     //tell it to recalculate the size of this control since
1932     //the user opened a separate media file
1933     //
1934     m_ctrl->InvalidateBestSize();
1935     m_ctrl->GetParent()->Layout();
1936     m_ctrl->GetParent()->Refresh();
1937     m_ctrl->GetParent()->Update();
1938     m_ctrl->SetSize(m_ctrl->GetSize());
1939
1940     return true;
1941 }
1942
1943 //---------------------------------------------------------------------------
1944 // wxMCIMediaBackend::Load (URL version)
1945 //
1946 // MCI doesn't support URLs directly (?)
1947 //
1948 // TODO:  Use wxURL/wxFileSystem and mmioInstallProc
1949 //---------------------------------------------------------------------------
1950 bool wxMCIMediaBackend::Load(const wxURI& WXUNUSED(location))
1951 {
1952     return false;
1953 }
1954
1955 //---------------------------------------------------------------------------
1956 // wxMCIMediaBackend::Play
1957 //
1958 // Plays/Resumes the MCI device... a couple notes:
1959 // 1) Certain drivers will crash and burn if we don't pass them an
1960 //    MCI_PLAY_PARMS, despite the documentation that says otherwise...
1961 // 2) There is a MCI_RESUME command, but MCI_PLAY does the same thing
1962 //    and will resume from a stopped state also, so there's no need to
1963 //    call both, for example
1964 //---------------------------------------------------------------------------
1965 bool wxMCIMediaBackend::Play()
1966 {
1967     MCI_PLAY_PARMS playParms;
1968     playParms.dwCallback = (DWORD)m_hNotifyWnd;
1969
1970     bool bOK = ( mciSendCommand(m_hDev, MCI_PLAY, MCI_NOTIFY,
1971                             (DWORD)(LPVOID)&playParms) == 0 );
1972
1973     if(bOK)
1974         m_ctrl->Show(m_bVideo);
1975
1976     return bOK;
1977 }
1978
1979 //---------------------------------------------------------------------------
1980 // wxMCIMediaBackend::Pause
1981 //
1982 // Pauses the MCI device - nothing special
1983 //---------------------------------------------------------------------------
1984 bool wxMCIMediaBackend::Pause()
1985 {
1986     return (mciSendCommand(m_hDev, MCI_PAUSE, MCI_WAIT, 0) == 0);
1987 }
1988
1989 //---------------------------------------------------------------------------
1990 // wxMCIMediaBackend::Stop
1991 //
1992 // Stops the MCI device & seeks to the beginning as wxMediaCtrl docs outline
1993 //---------------------------------------------------------------------------
1994 bool wxMCIMediaBackend::Stop()
1995 {
1996     return (mciSendCommand(m_hDev, MCI_STOP, MCI_WAIT, 0) == 0) &&
1997            (mciSendCommand(m_hDev, MCI_SEEK, MCI_SEEK_TO_START, 0) == 0);
1998 }
1999
2000 //---------------------------------------------------------------------------
2001 // wxMCIMediaBackend::GetState
2002 //
2003 // Here we get the state and convert it to a wxMediaState -
2004 // since we use direct comparisons with MCI_MODE_PLAY and
2005 // MCI_MODE_PAUSE, we don't care if the MCI_STATUS call
2006 // fails or not
2007 //---------------------------------------------------------------------------
2008 wxMediaState wxMCIMediaBackend::GetState()
2009 {
2010     MCI_STATUS_PARMS statusParms;
2011     statusParms.dwItem = MCI_STATUS_MODE;
2012
2013     mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2014                          (DWORD)(LPVOID)&statusParms);
2015
2016     if(statusParms.dwReturn == MCI_MODE_PAUSE)
2017         return wxMEDIASTATE_PAUSED;
2018     else if(statusParms.dwReturn == MCI_MODE_PLAY)
2019         return wxMEDIASTATE_PLAYING;
2020     else
2021         return wxMEDIASTATE_STOPPED;
2022 }
2023
2024 //---------------------------------------------------------------------------
2025 // wxMCIMediaBackend::SetPosition
2026 //
2027 // Here we set the position of the device in the stream.
2028 // Note that MCI actually stops the device after you seek it if the
2029 // device is playing/paused, so we need to play the file after
2030 // MCI seeks like normal APIs would
2031 //---------------------------------------------------------------------------
2032 bool wxMCIMediaBackend::SetPosition(wxLongLong where)
2033 {
2034     MCI_SEEK_PARMS seekParms;
2035     seekParms.dwCallback = 0;
2036 #if wxUSE_LONGLONG_NATIVE && !wxUSE_LONGLONG_WX
2037     seekParms.dwTo = (DWORD)where.GetValue();
2038 #else /* wxUSE_LONGLONG_WX */
2039     /* no way to return it in one piece */
2040     wxASSERT( where.GetHi()==0 );
2041     seekParms.dwTo = (DWORD)where.GetLo();
2042 #endif /* wxUSE_LONGLONG_* */
2043
2044     //device was playing?
2045     bool bReplay = GetState() == wxMEDIASTATE_PLAYING;
2046
2047     if( mciSendCommand(m_hDev, MCI_SEEK, MCI_TO,
2048                        (DWORD)(LPVOID)&seekParms) != 0)
2049         return false;
2050
2051     //If the device was playing, resume it
2052     if (bReplay)
2053         return Play();
2054     else
2055         return true;
2056 }
2057
2058 //---------------------------------------------------------------------------
2059 // wxMCIMediaBackend::GetPosition
2060 //
2061 // Gets the position of the device in the stream using the current
2062 // time format... nothing special here...
2063 //---------------------------------------------------------------------------
2064 wxLongLong wxMCIMediaBackend::GetPosition()
2065 {
2066     MCI_STATUS_PARMS statusParms;
2067     statusParms.dwItem = MCI_STATUS_POSITION;
2068
2069     if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2070                        (DWORD)(LPSTR)&statusParms) != 0)
2071         return 0;
2072
2073     return statusParms.dwReturn;
2074 }
2075
2076 //---------------------------------------------------------------------------
2077 // wxMCIMediaBackend::GetVolume
2078 //
2079 // Gets the volume of the current media via the MCI_DGV_STATUS_VOLUME
2080 // message.  Value ranges from 0 (minimum) to 1000 (maximum volume).
2081 //---------------------------------------------------------------------------
2082 double wxMCIMediaBackend::GetVolume()
2083 {
2084     MCI_STATUS_PARMS statusParms;
2085     statusParms.dwCallback = 0;
2086     statusParms.dwItem = 0x4019; //MCI_DGV_STATUS_VOLUME
2087
2088     if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2089                        (DWORD)(LPSTR)&statusParms) != 0)
2090         return 0;
2091
2092     return ((double)statusParms.dwReturn) / 1000.0;
2093 }
2094
2095 //---------------------------------------------------------------------------
2096 // wxMCIMediaBackend::SetVolume
2097 //
2098 // Sets the volume of the current media via the MCI_DGV_SETAUDIO_VOLUME
2099 // message.  Value ranges from 0 (minimum) to 1000 (maximum volume).
2100 //---------------------------------------------------------------------------
2101 bool wxMCIMediaBackend::SetVolume(double dVolume)
2102 {
2103     MCI_DGV_SETAUDIO_PARMS audioParms;
2104     audioParms.dwCallback = 0;
2105     audioParms.dwItem = 0x4002; //MCI_DGV_SETAUDIO_VOLUME
2106     audioParms.dwValue = (DWORD) (dVolume * 1000.0);
2107     audioParms.dwOver = 0;
2108     audioParms.lpstrAlgorithm = NULL;
2109     audioParms.lpstrQuality = NULL;
2110
2111     if (mciSendCommand(m_hDev, 0x0873, //MCI_SETAUDIO
2112                         0x00800000L | 0x01000000L, //MCI_DGV_SETAUDIO+(_ITEM | _VALUE)
2113                        (DWORD)(LPSTR)&audioParms) != 0)
2114         return false;
2115     return true;
2116 }
2117
2118 //---------------------------------------------------------------------------
2119 // wxMCIMediaBackend::GetDuration
2120 //
2121 // Gets the duration of the stream... nothing special
2122 //---------------------------------------------------------------------------
2123 wxLongLong wxMCIMediaBackend::GetDuration()
2124 {
2125     MCI_STATUS_PARMS statusParms;
2126     statusParms.dwItem = MCI_STATUS_LENGTH;
2127
2128     if (mciSendCommand(m_hDev, MCI_STATUS, MCI_STATUS_ITEM,
2129                         (DWORD)(LPSTR)&statusParms) != 0)
2130         return 0;
2131
2132     return statusParms.dwReturn;
2133 }
2134
2135 //---------------------------------------------------------------------------
2136 // wxMCIMediaBackend::Move
2137 //
2138 // Moves the window to a location
2139 //---------------------------------------------------------------------------
2140 void wxMCIMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y),
2141                                        int w,           int h)
2142 {
2143     if (m_hNotifyWnd && m_bVideo)
2144     {
2145         MCI_DGV_RECT_PARMS putParms; //ifdefed MCI_DGV_PUT_PARMS
2146         memset(&putParms, 0, sizeof(MCI_DGV_RECT_PARMS));
2147         putParms.rc.bottom = h;
2148         putParms.rc.right = w;
2149
2150         //wxStackWalker will crash and burn here on assert
2151         //and mci doesn't like 0 and 0 for some reason (out of range )
2152         //so just don't it in that case
2153         if(w || h)
2154         {
2155             wxMCIVERIFY( mciSendCommand(m_hDev, MCI_PUT,
2156                                    0x00040000L, //MCI_DGV_PUT_DESTINATION
2157                                    (DWORD)(LPSTR)&putParms) );
2158         }
2159     }
2160 }
2161
2162 //---------------------------------------------------------------------------
2163 // wxMCIMediaBackend::GetVideoSize
2164 //
2165 // Gets the original size of the movie for sizers
2166 //---------------------------------------------------------------------------
2167 wxSize wxMCIMediaBackend::GetVideoSize() const
2168 {
2169     if(m_bVideo)
2170     {
2171         MCI_DGV_RECT_PARMS whereParms; //ifdefed MCI_DGV_WHERE_PARMS
2172
2173         wxMCIVERIFY( mciSendCommand(m_hDev, MCI_WHERE,
2174                        0x00020000L, //MCI_DGV_WHERE_SOURCE
2175                        (DWORD)(LPSTR)&whereParms) );
2176
2177         return wxSize(whereParms.rc.right, whereParms.rc.bottom);
2178     }
2179     return wxSize(0,0);
2180 }
2181
2182 //---------------------------------------------------------------------------
2183 // wxMCIMediaBackend::GetPlaybackRate
2184 //
2185 // TODO
2186 //---------------------------------------------------------------------------
2187 double wxMCIMediaBackend::GetPlaybackRate()
2188 {
2189     return 1.0;
2190 }
2191
2192 //---------------------------------------------------------------------------
2193 // wxMCIMediaBackend::SetPlaybackRate
2194 //
2195 // TODO
2196 //---------------------------------------------------------------------------
2197 bool wxMCIMediaBackend::SetPlaybackRate(double WXUNUSED(dRate))
2198 {
2199 /*
2200     MCI_WAVE_SET_SAMPLESPERSEC
2201     MCI_DGV_SET_PARMS setParms;
2202     setParms.dwSpeed = (DWORD) (dRate * 1000.0);
2203
2204     return (mciSendCommand(m_hDev, MCI_SET,
2205                        0x00020000L, //MCI_DGV_SET_SPEED
2206                        (DWORD)(LPSTR)&setParms) == 0);
2207 */
2208     return false;
2209 }
2210
2211 //---------------------------------------------------------------------------
2212 // [static] wxMCIMediaBackend::MSWWindowProc
2213 //
2214 // Here we process a message when MCI reaches the stopping point
2215 // in the stream
2216 //---------------------------------------------------------------------------
2217 LRESULT CALLBACK wxMCIMediaBackend::NotifyWndProc(HWND hWnd, UINT nMsg,
2218                                                   WPARAM wParam,
2219                                                   LPARAM lParam)
2220 {
2221     wxMCIMediaBackend* backend = (wxMCIMediaBackend*)
2222 #ifdef _WIN32
2223         ::GetWindowLong(hWnd, GWL_USERDATA);
2224 #else
2225         ::GetWindowLongPtr(hWnd, GWLP_USERDATA);
2226 #endif
2227     wxASSERT(backend);
2228
2229     return backend->OnNotifyWndProc(hWnd, nMsg, wParam, lParam);
2230 }
2231
2232 LRESULT CALLBACK wxMCIMediaBackend::OnNotifyWndProc(HWND hWnd, UINT nMsg,
2233                                                   WPARAM wParam,
2234                                                   LPARAM lParam)
2235 {
2236     if(nMsg == MM_MCINOTIFY)
2237     {
2238         wxASSERT(lParam == (LPARAM) m_hDev);
2239         if(wParam == MCI_NOTIFY_SUCCESSFUL && lParam == (LPARAM)m_hDev)
2240         {
2241             wxMediaEvent theEvent(wxEVT_MEDIA_STOP, m_ctrl->GetId());
2242             m_ctrl->ProcessEvent(theEvent);
2243
2244             if(theEvent.IsAllowed())
2245             {
2246                 wxMCIVERIFY( mciSendCommand(m_hDev, MCI_SEEK,
2247                                             MCI_SEEK_TO_START, 0) );
2248
2249                 //send the event to our child
2250                 wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
2251                                       m_ctrl->GetId());
2252                 m_ctrl->ProcessEvent(theEvent);
2253             }
2254         }
2255     }
2256     return DefWindowProc(hWnd, nMsg, wParam, lParam);
2257 }
2258 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2259 //
2260 // wxQTMediaBackend
2261 //
2262 // TODO: Use a less cludgy way to pause/get state/set state
2263 // TODO: Dynamically load from qtml.dll
2264 //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
2265
2266 IMPLEMENT_DYNAMIC_CLASS(wxQTMediaBackend, wxMediaBackend);
2267
2268 //Time between timer calls
2269 #define MOVIE_DELAY 100
2270
2271 #include "wx/timer.h"
2272
2273 // --------------------------------------------------------------------------
2274 //          wxQTTimer - Handle Asyncronous Playing
2275 // --------------------------------------------------------------------------
2276 class _wxQTTimer : public wxTimer
2277 {
2278 public:
2279     _wxQTTimer(Movie movie, wxQTMediaBackend* parent, wxQuickTimeLibrary* pLib) :
2280         m_movie(movie), m_bPaused(false), m_parent(parent), m_pLib(pLib)
2281     {
2282     }
2283
2284     ~_wxQTTimer()
2285     {
2286     }
2287
2288     bool GetPaused() {return m_bPaused;}
2289     void SetPaused(bool bPaused) {m_bPaused = bPaused;}
2290
2291     //-----------------------------------------------------------------------
2292     // _wxQTTimer::Notify
2293     //
2294     // 1) Checks to see if the movie is done, and if not continues
2295     //    streaming the movie
2296     // 2) Sends the wxEVT_MEDIA_STOP event if we have reached the end of
2297     //    the movie.
2298     //-----------------------------------------------------------------------
2299     void Notify()
2300     {
2301         if (!m_bPaused)
2302         {
2303             if(!m_pLib->IsMovieDone(m_movie))
2304                 m_pLib->MoviesTask(m_movie, MOVIE_DELAY);
2305             else
2306             {
2307                 wxMediaEvent theEvent(wxEVT_MEDIA_STOP,
2308                                       m_parent->m_ctrl->GetId());
2309                 m_parent->m_ctrl->ProcessEvent(theEvent);
2310
2311                 if(theEvent.IsAllowed())
2312                 {
2313                     Stop();
2314                     m_parent->Stop();
2315                     wxASSERT(m_pLib->GetMoviesError() == noErr);
2316
2317                     //send the event to our child
2318                     wxMediaEvent theEvent(wxEVT_MEDIA_FINISHED,
2319                                           m_parent->m_ctrl->GetId());
2320                     m_parent->m_ctrl->ProcessEvent(theEvent);
2321                 }
2322             }
2323         }
2324     }
2325
2326 protected:
2327     Movie m_movie;                  //Our movie instance
2328     bool m_bPaused;                 //Whether we are paused or not
2329     wxQTMediaBackend* m_parent;     //Backend pointer
2330     wxQuickTimeLibrary* m_pLib;         //Interfaces
2331 };
2332
2333 //---------------------------------------------------------------------------
2334 // wxQTMediaBackend Destructor
2335 //
2336 // Sets m_timer to NULL signifying we havn't loaded anything yet
2337 //---------------------------------------------------------------------------
2338 wxQTMediaBackend::wxQTMediaBackend() : m_timer(NULL)
2339 {
2340 }
2341
2342 //---------------------------------------------------------------------------
2343 // wxQTMediaBackend Destructor
2344 //
2345 // 1) Cleans up the QuickTime movie instance
2346 // 2) Decrements the QuickTime reference counter - if this reaches
2347 //    0, QuickTime shuts down
2348 // 3) Decrements the QuickTime Windows Media Layer reference counter -
2349 //    if this reaches 0, QuickTime shuts down the Windows Media Layer
2350 //---------------------------------------------------------------------------
2351 wxQTMediaBackend::~wxQTMediaBackend()
2352 {
2353     if(m_timer)
2354         Cleanup();
2355
2356     if(m_lib.IsOk())
2357     {
2358         //Note that ExitMovies() is not necessary, but
2359         //the docs are fuzzy on whether or not TerminateQTML is
2360         m_lib.ExitMovies();
2361         m_lib.TerminateQTML();
2362     }
2363 }
2364
2365 //---------------------------------------------------------------------------
2366 // wxQTMediaBackend::CreateControl
2367 //
2368 // 1) Intializes QuickTime
2369 // 2) Creates the control window
2370 //---------------------------------------------------------------------------
2371 bool wxQTMediaBackend::CreateControl(wxControl* ctrl, wxWindow* parent,
2372                                      wxWindowID id,
2373                                      const wxPoint& pos,
2374                                      const wxSize& size,
2375                                      long style,
2376                                      const wxValidator& validator,
2377                                      const wxString& name)
2378 {
2379     if(!m_lib.Initialize())
2380         return false;
2381
2382     int nError = m_lib.InitializeQTML(0);
2383     if (nError != noErr)    //-2093 no dll
2384     {
2385         wxFAIL_MSG(wxString::Format(wxT("Couldn't Initialize Quicktime-%i"), nError));
2386         return false;
2387     }
2388     m_lib.EnterMovies();
2389
2390     //
2391     // Create window
2392     // By default wxWindow(s) is created with a border -
2393     // so we need to get rid of those
2394     //
2395     // Since we don't have a child window like most other
2396     // backends, we don't need wxCLIP_CHILDREN
2397     //
2398     if ( !ctrl->wxControl::Create(parent, id, pos, size,
2399                             (style & ~wxBORDER_MASK) | wxBORDER_NONE,
2400                             validator, name) )
2401         return false;
2402
2403     m_ctrl = ctrl;
2404     return true;
2405 }
2406
2407 //---------------------------------------------------------------------------
2408 // wxQTMediaBackend::Load (file version)
2409 //
2410 // 1) Get an FSSpec from the Windows path name
2411 // 2) Open the movie
2412 // 3) Obtain the movie instance from the movie resource
2413 // 4)
2414 //---------------------------------------------------------------------------
2415 bool wxQTMediaBackend::Load(const wxString& fileName)
2416 {
2417     if(m_timer)
2418         Cleanup();
2419
2420     short movieResFile = 0; //= 0 because of annoying VC6 warning
2421     FSSpec sfFile;
2422
2423     if (m_lib.NativePathNameToFSSpec ((char*) (const char*) fileName.mb_str(),
2424                                 &sfFile, 0) != noErr)
2425         return false;
2426
2427     if (m_lib.OpenMovieFile (&sfFile, &movieResFile, fsRdPerm) != noErr)
2428         return false;
2429
2430     short movieResID = 0;
2431     Str255 movieName;
2432
2433     OSErr err = m_lib.NewMovieFromFile (
2434                    &m_movie,
2435                    movieResFile,
2436                    &movieResID,
2437                    movieName,
2438                    newMovieActive,
2439                    NULL
2440                 ); //wasChanged
2441
2442     m_lib.CloseMovieFile (movieResFile);
2443
2444     if (err != noErr)
2445         return false;
2446
2447     FinishLoad();
2448
2449     return m_lib.GetMoviesError() == noErr;
2450 }
2451
2452 //---------------------------------------------------------------------------
2453 // wxQTMediaBackend::Move
2454 //
2455 // TODO
2456 //---------------------------------------------------------------------------
2457 bool wxQTMediaBackend::Load(const wxURI& location)
2458 {
2459     if(m_timer)
2460         Cleanup();
2461
2462     wxString theURI = location.BuildURI();
2463
2464     Handle theHandle = m_lib.NewHandleClear(theURI.length() + 1);
2465     wxASSERT(theHandle);
2466
2467     m_lib.BlockMove(theURI.mb_str(), *theHandle, theURI.length() + 1);
2468
2469     //create the movie from the handle that refers to the URI
2470     OSErr err = m_lib.NewMovieFromDataRef(&m_movie, newMovieActive,
2471                                 NULL, theHandle,
2472                                 URLDataHandlerSubType);
2473
2474     m_lib.DisposeHandle(theHandle);
2475
2476     if (err != noErr)
2477         return false;
2478
2479     //preroll movie for streaming
2480     //TODO:Async this?
2481  /*
2482      TimeValue timeNow;
2483     Fixed playRate;
2484     timeNow = GetMovieTime(m_movie, NULL);
2485     playRate = GetMoviePreferredRate(m_movie);
2486     PrePrerollMovie(m_movie, timeNow, playRate, NULL, NULL);
2487     PrerollMovie(m_movie, timeNow, playRate);
2488     m_lib.SetMovieRate(m_movie, playRate);
2489 */
2490
2491     FinishLoad();
2492
2493     return m_lib.GetMoviesError() == noErr;
2494 }
2495
2496 //---------------------------------------------------------------------------
2497 // wxQTMediaBackend::Move
2498 //
2499 // TODO
2500 //---------------------------------------------------------------------------
2501 void wxQTMediaBackend::FinishLoad()
2502 {
2503     m_timer = new _wxQTTimer(m_movie, (wxQTMediaBackend*) this, &m_lib);
2504     wxASSERT(m_timer);
2505
2506     //get the real size of the movie
2507     Rect outRect;
2508     memset(&outRect, 0, sizeof(Rect)); //for annoying VC6 warning
2509     m_lib.GetMovieNaturalBoundsRect (m_movie, &outRect);
2510     wxASSERT(m_lib.GetMoviesError() == noErr);
2511
2512     m_bestSize.x = outRect.right - outRect.left;
2513     m_bestSize.y = outRect.bottom - outRect.top;
2514
2515     //reparent movie/*AudioMediaCharacteristic*/
2516     if(m_lib.GetMovieIndTrackType(m_movie, 1,
2517                             VisualMediaCharacteristic,
2518                             (1 << 1) //movieTrackCharacteristic
2519                             | (1 << 2) //movieTrackEnabledOnly
2520                             ) != NULL)
2521     {
2522         m_lib.CreatePortAssociation(m_ctrl->GetHWND(), NULL, 0L);
2523
2524         m_lib.SetMovieGWorld(m_movie,
2525                        (CGrafPtr) m_lib.GetNativeWindowPort(m_ctrl->GetHWND()),
2526                        NULL);
2527     }
2528
2529     //we want millisecond precision
2530     m_lib.SetMovieTimeScale(m_movie, 1000);
2531     wxASSERT(m_lib.GetMoviesError() == noErr);
2532
2533     //
2534     //Here, if the parent of the control has a sizer - we
2535     //tell it to recalculate the size of this control since
2536     //the user opened a separate media file
2537     //
2538     m_ctrl->InvalidateBestSize();
2539     m_ctrl->GetParent()->Layout();
2540     m_ctrl->GetParent()->Refresh();
2541     m_ctrl->GetParent()->Update();
2542 }
2543
2544 //---------------------------------------------------------------------------
2545 // wxQTMediaBackend::Move
2546 //
2547 // TODO
2548 //---------------------------------------------------------------------------
2549 bool wxQTMediaBackend::Play()
2550 {
2551     m_lib.StartMovie(m_movie);
2552     m_timer->SetPaused(false);
2553     m_timer->Start(MOVIE_DELAY, wxTIMER_CONTINUOUS);
2554     return m_lib.GetMoviesError() == noErr;
2555 }
2556
2557 //---------------------------------------------------------------------------
2558 // wxQTMediaBackend::Move
2559 //
2560 // TODO
2561 //---------------------------------------------------------------------------
2562 bool wxQTMediaBackend::Pause()
2563 {
2564     m_lib.StopMovie(m_movie);
2565     m_timer->SetPaused(true);
2566     m_timer->Stop();
2567     return m_lib.GetMoviesError() == noErr;
2568 }
2569
2570 //---------------------------------------------------------------------------
2571 // wxQTMediaBackend::Move
2572 //
2573 // TODO
2574 //---------------------------------------------------------------------------
2575 bool wxQTMediaBackend::Stop()
2576 {
2577     m_timer->SetPaused(false);
2578     m_timer->Stop();
2579
2580     m_lib.StopMovie(m_movie);
2581     if(m_lib.GetMoviesError() != noErr)
2582         return false;
2583
2584     m_lib.GoToBeginningOfMovie(m_movie);
2585     return m_lib.GetMoviesError() == noErr;
2586 }
2587
2588 //---------------------------------------------------------------------------
2589 // wxQTMediaBackend::Move
2590 //
2591 // TODO
2592 //---------------------------------------------------------------------------
2593 double wxQTMediaBackend::GetPlaybackRate()
2594 {
2595     return ( ((double)m_lib.GetMovieRate(m_movie)) / 0x10000);
2596 }
2597
2598 //---------------------------------------------------------------------------
2599 // wxQTMediaBackend::Move
2600 //
2601 // TODO
2602 //---------------------------------------------------------------------------
2603 bool wxQTMediaBackend::SetPlaybackRate(double dRate)
2604 {
2605     m_lib.SetMovieRate(m_movie, (Fixed) (dRate * 0x10000));
2606     return m_lib.GetMoviesError() == noErr;
2607 }
2608
2609 //---------------------------------------------------------------------------
2610 // wxQTMediaBackend::Move
2611 //
2612 // TODO
2613 //---------------------------------------------------------------------------
2614 bool wxQTMediaBackend::SetPosition(wxLongLong where)
2615 {
2616     TimeRecord theTimeRecord;
2617     memset(&theTimeRecord, 0, sizeof(TimeRecord));
2618     theTimeRecord.value.lo = where.GetLo();
2619     theTimeRecord.scale = m_lib.GetMovieTimeScale(m_movie);
2620     theTimeRecord.base = m_lib.GetMovieTimeBase(m_movie);
2621     m_lib.SetMovieTime(m_movie, &theTimeRecord);
2622
2623     if (m_lib.GetMoviesError() != noErr)
2624         return false;
2625
2626     return true;
2627 }
2628
2629 //---------------------------------------------------------------------------
2630 // wxQTMediaBackend::GetPosition
2631 //
2632 // 1) Calls GetMovieTime to get the position we are in in the movie
2633 // in milliseconds (we called
2634 //---------------------------------------------------------------------------
2635 wxLongLong wxQTMediaBackend::GetPosition()
2636 {
2637     return m_lib.GetMovieTime(m_movie, NULL);
2638 }
2639
2640 //---------------------------------------------------------------------------
2641 // wxQTMediaBackend::GetVolume
2642 //
2643 // Gets the volume through GetMovieVolume - which returns a 16 bit short -
2644 //
2645 // +--------+--------+
2646 // +   (1)  +   (2)  +
2647 // +--------+--------+
2648 //
2649 // (1) first 8 bits are value before decimal
2650 // (2) second 8 bits are value after decimal
2651 //
2652 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
2653 // 1 (full gain and sound)
2654 //---------------------------------------------------------------------------
2655 double wxQTMediaBackend::GetVolume()
2656 {
2657     short sVolume = m_lib.GetMovieVolume(m_movie);
2658
2659     if(sVolume & (128 << 8)) //negative - no sound
2660         return 0.0;
2661
2662     return (sVolume & (127 << 8)) ? 1.0 : ((double)(sVolume & 255)) / 255.0;
2663 }
2664
2665 //---------------------------------------------------------------------------
2666 // wxQTMediaBackend::SetVolume
2667 //
2668 // Sets the volume through SetMovieVolume - which takes a 16 bit short -
2669 //
2670 // +--------+--------+
2671 // +   (1)  +   (2)  +
2672 // +--------+--------+
2673 //
2674 // (1) first 8 bits are value before decimal
2675 // (2) second 8 bits are value after decimal
2676 //
2677 // Volume ranges from -1.0 (gain but no sound), 0 (no sound and no gain) to
2678 // 1 (full gain and sound)
2679 //---------------------------------------------------------------------------
2680 bool wxQTMediaBackend::SetVolume(double dVolume)
2681 {
2682     short sVolume = (short) (dVolume >= .9999 ? 1 << 8 : (dVolume * 255) );
2683     m_lib.SetMovieVolume(m_movie, sVolume);
2684     return true;
2685 }
2686
2687 //---------------------------------------------------------------------------
2688 // wxQTMediaBackend::Move
2689 //
2690 // TODO
2691 //---------------------------------------------------------------------------
2692 wxLongLong wxQTMediaBackend::GetDuration()
2693 {
2694     return m_lib.GetMovieDuration(m_movie);
2695 }
2696
2697 //---------------------------------------------------------------------------
2698 // wxQTMediaBackend::Move
2699 //
2700 // TODO
2701 //---------------------------------------------------------------------------
2702 wxMediaState wxQTMediaBackend::GetState()
2703 {
2704     if ( !m_timer || (m_timer->IsRunning() == false &&
2705                       m_timer->GetPaused() == false) )
2706         return wxMEDIASTATE_STOPPED;
2707
2708     if( m_timer->IsRunning() == true )
2709         return wxMEDIASTATE_PLAYING;
2710     else
2711         return wxMEDIASTATE_PAUSED;
2712 }
2713
2714 //---------------------------------------------------------------------------
2715 // wxQTMediaBackend::Move
2716 //
2717 // TODO
2718 //---------------------------------------------------------------------------
2719 void wxQTMediaBackend::Cleanup()
2720 {
2721     delete m_timer;
2722     m_timer = NULL;
2723
2724     m_lib.StopMovie(m_movie);
2725     m_lib.DisposeMovie(m_movie);
2726 }
2727
2728 //---------------------------------------------------------------------------
2729 // wxQTMediaBackend::Move
2730 //
2731 // TODO
2732 //---------------------------------------------------------------------------
2733 wxSize wxQTMediaBackend::GetVideoSize() const
2734 {
2735     return m_bestSize;
2736 }
2737
2738 //---------------------------------------------------------------------------
2739 // wxQTMediaBackend::Move
2740 //
2741 // TODO
2742 //---------------------------------------------------------------------------
2743 void wxQTMediaBackend::Move(int WXUNUSED(x), int WXUNUSED(y), int w, int h)
2744 {
2745     if(m_timer)
2746     {
2747         Rect theRect = {0, 0, (short)h, (short)w};
2748
2749         m_lib.SetMovieBox(m_movie, &theRect);
2750         wxASSERT(m_lib.GetMoviesError() == noErr);
2751     }
2752 }
2753
2754 //---------------------------------------------------------------------------
2755 //  End QT Backend
2756 //---------------------------------------------------------------------------
2757
2758 //in source file that contains stuff you don't directly use
2759 #include <wx/html/forcelnk.h>
2760 FORCE_LINK_ME(basewxmediabackends);
2761
2762 //---------------------------------------------------------------------------
2763 //  End wxMediaCtrl Compilation Guard and this file
2764 //---------------------------------------------------------------------------
2765 #endif //wxUSE_MEDIACTRL
2766
2767