AVI file playing on Windows is working

Many fixes


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@6219 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

utils/wxMMedia2/board/mmbman.cpp

@@ -263,13 +263,13 @@ wxString MMBoardSoundFile::GetStringType()
 {
   switch (m_file_type) {
   case MMBoard_WAVE:
-    return wxString("WAVE file");
+    return wxString(wxT("WAVE file"));
     break;
   case MMBoard_AIFF:
-    return wxString("AIFF file");
+    return wxString(wxT("AIFF file"));
     break;
   default:
-    return wxString("Unknown file");
+    return wxString(wxT("Unknown file"));
     break;
   }
 }
@@ -281,15 +281,15 @@ wxString MMBoardSoundFile::GetStringInformation()
     
     format = &(m_file_stream->GetSoundFormat());
     
-  info = _T("Data encoding: ");
+    info = wxT("Data encoding: ");
     switch (format->GetType()) {
     case wxSOUND_PCM: {
         wxSoundFormatPcm *pcm_format = (wxSoundFormatPcm *)format;
       
-    info += _T("PCM\n");
+	info += wxT("PCM\n");
-    info += wxString::Format(_T("Sampling rate: %d\n")
+	info += wxString::Format(wxT("Sampling rate: %d\n")
-			     _T("Bits per sample: %d\n")
+				 wxT("Bits per sample: %d\n")
-			     _T("Number of channels: %d\n"),
+				 wxT("Number of channels: %d\n"),
 				 pcm_format->GetSampleRate(),
 				 pcm_format->GetBPS(),
 				 pcm_format->GetChannels());
@@ -298,12 +298,12 @@ wxString MMBoardSoundFile::GetStringInformation()
     }
     case wxSOUND_ULAW: {
         wxSoundFormatUlaw *ulaw_format = (wxSoundFormatUlaw *)format;
-    info += _T("ULAW\n");
+	info += wxT("ULAW\n");
-    info += wxString::Format(_T("Sampling rate: %d\n"), ulaw_format->GetSampleRate());
+	info += wxString::Format(wxT("Sampling rate: %d\n"), ulaw_format->GetSampleRate());
 	break;
     }
     default:
-    info += _T("Unknown");
+        info += wxT("Unknown");
 	break;
     }
     return info;
@@ -318,12 +318,11 @@ wxString MMBoardSoundFile::GetStringInformation()
 MMBoardVideoFile::MMBoardVideoFile(const wxString& filename)
 {
     m_output_window = NULL;
-  m_input_stream = new wxFileInputStream(filename);
   
 #if defined(__UNIX__)
-  m_video_driver = new wxVideoXANIM(*m_input_stream);
+    m_video_driver = new wxVideoXANIM(filename);
 #elif defined(__WIN32__)
-  m_video_driver = new wxVideoWindows(m_input_stream);
+    m_video_driver = new wxVideoWindows(filename);
 #else
     m_video_driver = NULL;
     SetError(MMBoard_UnknownFile);
@@ -398,12 +397,12 @@ bool MMBoardVideoFile::IsPaused()
 
 wxString MMBoardVideoFile::GetStringType()
 {
-  return wxString("Video XANIM");
+    return wxString(wxT("Video XANIM"));
 }
 
 wxString MMBoardVideoFile::GetStringInformation()
 {
-  return wxString("No info");
+    return wxString(wxT("No info"));
 }
 
 // ----------------------------------------------------------------------------

utils/wxMMedia2/board/mmboard.cpp

@@ -196,19 +196,19 @@ wxUint8 MMBoardApp::TestMultimediaCaps()
   caps = 0;
 
 #ifdef __UNIX__
-  // We test the OSS (Open Sound System) support.
-
-  dev = new wxSoundStreamOSS();
-  if (dev->GetError() == wxSOUND_NOERR) 
-    caps |= MM_SOUND_OSS;
-  delete dev;
-
   // We now test the ESD support
 
   dev = new wxSoundStreamESD();
   if (dev->GetError() == wxSOUND_NOERR) 
     caps |= MM_SOUND_ESD;
   delete dev;
+
+  // We test the OSS (Open Sound System) support.
+
+  dev = new wxSoundStreamOSS();
+  if (dev->GetError() == wxSOUND_NOERR)
+    caps |= MM_SOUND_OSS;
+  delete dev;
 #endif
 
 #ifdef __WIN32__
@@ -355,9 +355,9 @@ void MMBoardFrame::OpenVideoWindow()
   if (m_video_window)
     return;
 
-  m_video_window = new wxWindow(m_panel, -1, wxDefaultPosition, wxSize(400, 400));
+  m_video_window = new wxWindow(m_panel, -1, wxDefaultPosition, wxSize(200, 200));
   m_video_window->SetBackgroundColour(*wxBLACK);
-  m_sizer->Prepend(m_video_window, 0, wxGROW | wxSHRINK | wxCENTRE, 0);
+  m_sizer->Prepend(m_video_window, 2, wxGROW | wxSHRINK | wxCENTRE, 1);
 
   m_sizer->Fit(this);
 }

utils/wxMMedia2/lib/makefile.vc

@@ -21,7 +21,7 @@ LIBTARGET=$(WXDIR)\lib\mmedia2.lib
 OBJECTS = cdbase.obj cdwin.obj g711.obj g721.obj g723_24.obj sndg72x.obj \
         g723_40.obj g72x.obj sndbase.obj sndcodec.obj sndpcm.obj \
         sndcpcm.obj sndulaw.obj sndfile.obj sndwav.obj sndaiff.obj sndwin.obj \
-        vidbase.obj
+        vidbase.obj vidwin.obj
 
 !include $(WXDIR)\src\makelib.vc
 
@@ -104,3 +104,9 @@ vidbase.obj:      vidbase.h vidbase.$(SRCSUFF)
         $(cc) @<<
 $(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
 <<
+
+vidwin.obj:      vidwin.h vidwin.$(SRCSUFF)
+        $(cc) @<<
+$(CPPFLAGS) /c /Tp $*.$(SRCSUFF)
+<<
+

utils/wxMMedia2/lib/sndoss.cpp

@@ -28,7 +28,7 @@ wxSoundStreamOSS::wxSoundStreamOSS(const wxString& dev_name)
 {
   wxSoundFormatPcm pcm_default;
 
-  m_fd = open(dev_name.mb_str(), O_RDWR);
+  m_fd = open(dev_name.mb_str(), O_WRONLY);
 
   if (m_fd == -1) {
     m_snderror = wxSOUND_INVDEV;

utils/wxMMedia2/lib/vidbase.cpp

@@ -37,6 +37,11 @@ wxVideoBaseDriver::wxVideoBaseDriver(wxInputStream& str)
   m_video_output = NULL;
 }
 
+wxVideoBaseDriver::wxVideoBaseDriver(const wxString& filename)
+{
+  m_video_output = NULL;
+}
+
 wxVideoBaseDriver::~wxVideoBaseDriver()
 {
 }

utils/wxMMedia2/lib/vidbase.h

@@ -13,14 +13,32 @@
 #define __VID_bdrv_H__
 
 #ifdef __GNUG__
-#pragma interface
+#pragma interface "vidbase.h"
 #endif
 
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers (this file is usually all you
+// need because it includes almost all "standard" wxWindows headers
+#ifndef WX_PRECOMP
+    #include "wx/defs.h"
+    #include "wx/stream.h"
     #include "wx/string.h"
     #include "wx/window.h"
     #include "wx/frame.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// wxMMedia2 (video) types
 
-///
 typedef enum {
   wxVIDEO_MSAVI,
   wxVIDEO_MPEG,
@@ -31,58 +49,49 @@ typedef enum {
   wxVIDEO_IFF,
   wxVIDEO_SGI,
   wxVIDEO_MPEG2
-} ///
+} wxVideoType;
- wxVideoType;
 
-///
+// ----------------------------------------------------------------------------
-class wxVideoBaseDriver;
+// Classes definition
 
-///
+class WXDLLEXPORT wxVideoBaseDriver : public wxObject {
-class wxVideoBaseDriver : public wxObject {
-  ///
     DECLARE_ABSTRACT_CLASS(wxVideoBaseDriver)
 protected:
     wxWindow *m_video_output;
 public:
-  //
+    // Ctors
     wxVideoBaseDriver();
-  //
     wxVideoBaseDriver(wxInputStream& str);
-  //
+    wxVideoBaseDriver(const wxString& filename);
+    // Dtor
     virtual ~wxVideoBaseDriver();
     
-  //
+    // Usual functions ... They all return FALSE in case of errors.
     virtual bool Play() = 0;
-  //
     virtual bool Stop() = 0;
-  //
     virtual bool Pause() = 0;
-  //
     virtual bool Resume() = 0;
     
-  //
+    // Size management
-  virtual bool SetVolume(wxUint8 vol) = 0;
-  //
     virtual bool Resize(wxUint16 w, wxUint16 h) = 0;
-  //
     virtual bool GetSize(wxSize& size) const = 0;
     
-  //
+    // Test the capability of the driver to handle the specified type
     virtual bool IsCapable(wxVideoType WXUNUSED(v_type)) { return FALSE; }
     
-  //
+    // Called when the movie finished
     virtual void OnFinished() {}
     
-  //
+    // Attaches the video output to a window. The video will be shown in that window.
     virtual bool AttachOutput(wxWindow& output);
-  //
     virtual void DetachOutput();
     
+    // They return the state of the movie.
     virtual bool IsPaused() = 0;
     virtual bool IsStopped() = 0;
 };
 
-extern wxFrame *wxVideoCreateFrame(wxVideoBaseDriver *vid_drv);
+WXDLLEXPORT wxFrame *wxVideoCreateFrame(wxVideoBaseDriver *vid_drv);
 
 
 #endif

utils/wxMMedia2/lib/vidwin.cpp

@@ -12,76 +12,107 @@
 #pragma implementation "vidwin.h"
 #endif
 
-#if 0
 #include "wx/wxprec.h"
-#else
+
+#ifndef WX_PRECOMP
 #include "wx/wx.h"
 #endif
 
+#include "wx/stream.h"
+#include "wx/wfstream.h"
+
 #define WXMMEDIA_INTERNAL
 #include <windows.h>
 #include <mmsystem.h>
 #include <digitalv.h>
-#include "mmtype.h"
-#include "mmfile.h"
 #include "vidwin.h"
 
 #ifdef __BORLANDC__
 #pragma hdrstop
 #endif
 
-wxVideoWindows::wxVideoWindows(void)
+IMPLEMENT_DYNAMIC_CLASS(wxVideoWindows, wxVideoBaseDriver)
+
+wxVideoWindows::wxVideoWindows()
 {
 }
 
-wxVideoWindows::wxVideoWindows(wxInputStream& str, bool seekable)
+wxVideoWindows::wxVideoWindows(wxInputStream& str)
-  : wxVideoBaseDriver(str, seekable)
+  : wxVideoBaseDriver(str)
 {
-  OpenFile(GetCurrentFile());
+    m_internal    = new wxVIDWinternal;
+    m_remove_file = TRUE;
+    m_filename    = wxGetTempFileName("wxvid");
+    m_paused      = FALSE;
+    m_stopped     = TRUE;
+    
+    wxFileOutputStream temp_file(m_filename);
+    temp_file << str;
+
+    OpenFile();
 }
 
-wxVideoWindows::wxVideoWindows(const char *fname)
+wxVideoWindows::wxVideoWindows(const wxString& filename)
-  : wxVideoBaseDriver(fname)
+  : wxVideoBaseDriver(filename)
 {
-  OpenFile(fname);
+    m_internal    = new wxVIDWinternal;
+    m_remove_file = FALSE;
+    m_filename    = filename;
+    m_paused      = FALSE;
+    m_stopped     = TRUE;
+    OpenFile();
 }
 
 wxVideoWindows::~wxVideoWindows(void)
 {
-  mciSendCommand(internal->dev_id, MCI_CLOSE, 0, 0);
+    mciSendCommand(m_internal->m_dev_id, MCI_CLOSE, 0, 0);
 
-  if (internal)
+    if (m_internal)
-    delete internal;
+        delete m_internal;
 }
 
-void wxVideoWindows::OpenFile(const char *fname)
+void wxVideoWindows::OpenFile()
 {
     MCI_DGV_OPEN_PARMS open_struct;
     DWORD ret;
 
-  internal = new VIDW_Internal;
-
     open_struct.lpstrDeviceType = "avivideo";
-  open_struct.lpstrElementName = (LPSTR)fname;
+    open_struct.lpstrElementName = (LPSTR)(m_filename.mb_str());
     open_struct.hWndParent = 0;
     
     ret = mciSendCommand(0, MCI_OPEN,
 			 MCI_OPEN_ELEMENT|MCI_DGV_OPEN_PARENT|MCI_OPEN_TYPE|MCI_DGV_OPEN_32BIT,
 			 (DWORD)(LPVOID)&open_struct);
-  internal->dev_id = open_struct.wDeviceID;
+    m_internal->m_dev_id = open_struct.wDeviceID;
 }
 
-bool wxVideoWindows::Pause(void)
+bool wxVideoWindows::Pause()
 {
-  return (mciSendCommand(internal->dev_id, MCI_PAUSE, 0, 0) == 0);
+    if (m_paused || m_stopped)
+        return TRUE;
+    m_paused = TRUE;
+    return (mciSendCommand(m_internal->m_dev_id, MCI_PAUSE, 0, 0) == 0);
 }
 
-bool wxVideoWindows::Resume(void)
+bool wxVideoWindows::Resume()
 {
-  return (mciSendCommand(internal->dev_id, MCI_PAUSE, 0, 0) == 0);
+    if (!m_paused || m_stopped)
+        return TRUE;
+    m_paused = FALSE;
+    return (mciSendCommand(m_internal->m_dev_id, MCI_PAUSE, 0, 0) == 0);
 }
 
-bool wxVideoWindows::SetVolume(wxUint8 vol)
+bool wxVideoWindows::IsPaused()
+{
+    return m_paused;
+}
+
+bool wxVideoWindows::IsStopped()
+{
+    return m_stopped;
+}
+
+bool wxVideoWindows::GetSize(wxSize& size) const
 {
     return TRUE;
 }
@@ -96,7 +127,7 @@ bool wxVideoWindows::IsCapable(wxVideoType v_type)
     return (v_type == wxVIDEO_MSAVI);
 }
 
-bool wxVideoWindows::AttachOutput(wxVideoOutput& output)
+bool wxVideoWindows::AttachOutput(wxWindow& output)
 {
     MCI_DGV_WINDOW_PARMS win_struct;
     
@@ -104,28 +135,34 @@ bool wxVideoWindows::AttachOutput(wxVideoOutput& output)
         return FALSE;
     
     win_struct.hWnd = (HWND)output.GetHWND();
-  mciSendCommand(internal->dev_id, MCI_WINDOW,
+    mciSendCommand(m_internal->m_dev_id, MCI_WINDOW,
 		   MCI_DGV_WINDOW_HWND, (DWORD)(LPVOID)&win_struct);
     return TRUE;
 }
 
-void wxVideoWindows::DetachOutput(void)
+void wxVideoWindows::DetachOutput()
 {
     MCI_DGV_WINDOW_PARMS win_struct;
 
     wxVideoBaseDriver::DetachOutput();
     
     win_struct.hWnd = 0;
-  mciSendCommand(internal->dev_id, MCI_WINDOW,
+    mciSendCommand(m_internal->m_dev_id, MCI_WINDOW,
 		   MCI_DGV_WINDOW_HWND, (DWORD)(LPVOID)&win_struct);
 }
 
-bool wxVideoWindows::StartPlay(void)
+bool wxVideoWindows::Play()
 {
-  return (mciSendCommand(internal->dev_id, MCI_PLAY, 0, NULL) == 0);
+    if (!m_stopped)
+        return FALSE;
+    m_stopped = FALSE;
+    return (mciSendCommand(m_internal->m_dev_id, MCI_PLAY, 0, NULL) == 0);
 }
 
-void wxVideoWindows::StopPlay(void)
+bool wxVideoWindows::Stop()
 {
-  mciSendCommand(internal->dev_id, MCI_STOP, 0, NULL);
+    if (m_stopped)
+        return FALSE;
+    m_stopped = TRUE;
+    return (mciSendCommand(m_internal->m_dev_id, MCI_STOP, 0, NULL) == 0);
 }

utils/wxMMedia2/lib/vidwin.h

@@ -1,4 +1,4 @@
-// /////////////////////////////////////////////////////////////////////////////
+// ----------------------------------------------------------------------------
 // Name:       vidwin.h
 // Purpose:    wxMMedia
 // Author:     Guilhem Lavaux
@@ -6,57 +6,82 @@
 // Updated:
 // Copyright:  (C) 1998, Guilhem Lavaux
 // License:    wxWindows license
-// /////////////////////////////////////////////////////////////////////////////
+// ----------------------------------------------------------------------------
-/* Real -*- C++ -*- */
+
 #ifndef __VID_windows_H__
 #define __VID_windows_H__
 
 #ifdef __GNUG__
-#pragma interface
+    #pragma interface "vidwin.h"
 #endif
 
-#include "mmtype.h"
+// ----------------------------------------------------------------------------
-#include "mmfile.h"
+// headers
-#ifdef WX_PRECOMP
+// ----------------------------------------------------------------------------
+// For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
-#else
+
-#include "wx/wx.h"
+#ifdef __BORLANDC__
+    #pragma hdrstop
 #endif
+
+// for all others, include the necessary headers (this file is usually all you
+// need because it includes almost all "standard" wxWindows headers
+#ifndef WX_PRECOMP
+    #include "wx/string.h"
+    #include "wx/stream.h"
+    #include "wx/window.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// wxMMedia2 headers
+
 #include "vidbase.h"
 
+// ----------------------------------------------------------------------------
+// System headers and private types
+
 #ifdef WXMMEDIA_INTERNAL
 #include <windows.h>
 #include <mmsystem.h>
 
 typedef struct VIDW_Internal {
-  MCIDEVICEID dev_id;
+    MCIDEVICEID m_dev_id;
-} VIDW_Internal;
+} wxVIDWinternal;
 #endif
 
-class wxVideoWindows : public wxVideoBaseDriver {
+// ----------------------------------------------------------------------------
+// Class definition
+
+class WXDLLEXPORT wxVideoWindows : public wxVideoBaseDriver {
     DECLARE_DYNAMIC_CLASS(wxVideoWindows)
 protected:
-  struct VIDW_Internal *internal;
+    struct VIDW_Internal *m_internal;
+    bool m_paused, m_stopped, m_remove_file;
+    wxString m_filename;
 
-  void OpenFile(const char *fname);
+    void OpenFile();
 public:
     wxVideoWindows(void);
-  wxVideoWindows(wxInputStream& str, bool seekable = FALSE);
+    wxVideoWindows(wxInputStream& str);
-  wxVideoWindows(const char *fname);
+    wxVideoWindows(const wxString& fname);
-  virtual ~wxVideoWindows(void);
+    ~wxVideoWindows(void);
 
-  virtual bool StartPlay(void);
+    bool Play();
-  virtual void StopPlay(void);
+    bool Stop();
-  virtual bool Pause(void);
+    bool Pause();
-  virtual bool Resume(void);
+    bool Resume();
     
-  virtual bool SetVolume(wxUint8 vol);
+    bool Resize(wxUint16 w, wxUint16 h);
-  virtual bool Resize(wxUint16 w, wxUint16 h);
+    bool GetSize(wxSize& size) const;
     
-  virtual bool IsCapable(wxVideoType v_type);
+    bool IsCapable(wxVideoType v_type);
     
-  virtual bool AttachOutput(wxVideoOutput& output);
+    bool AttachOutput(wxWindow& output);
-  virtual void DetachOutput(void);
+    void DetachOutput(void);
+    
+    bool IsPaused();
+    bool IsStopped();
 };
 
 #endif

utils/wxMMedia2/lib/vidxanm.cpp

@@ -1,4 +1,4 @@
-////////////////////////////////////////////////////////////////////////////////
+// -------------------------------------------------------------------------
 // Name:       vidxanm.cpp
 // Purpose:    wxMMedia
 // Author:     Guilhem Lavaux
@@ -6,13 +6,15 @@
 // Updated:    1998
 // Copyright:  (C) 1997, 1998, 1999 Guilhem Lavaux
 // License:    wxWindows license
-////////////////////////////////////////////////////////////////////////////////
+// -------------------------------------------------------------------------
+
 #ifdef __GNUG__
 #pragma implementation "vidxanm.h"
 #endif
-#ifdef WX_PRECOMP
+
-#include <wx_prec.h>
+#include <wx/wxprec.h>
-#else
+
+#ifndef WX_PRECOMP
 #include <wx/wx.h>
 #endif
 
@@ -37,6 +39,9 @@
 
 IMPLEMENT_DYNAMIC_CLASS(wxVideoXANIM, wxVideoBaseDriver)
 
+// -------------------------------------------------------------------------
+// End process detector
+
 class wxVideoXANIMProcess: public wxProcess {
 public:
     wxVideoXANIMProcess(wxVideoXANIM *xanim);
@@ -47,6 +52,8 @@ class wxVideoXANIMProcess: public wxProcess {
     wxVideoXANIM *m_vid_xanim;
 };
 
+// -------------------------------------------------------------------------
+// XAnim video driver (implementation)
 
 wxVideoXANIMProcess::wxVideoXANIMProcess(wxVideoXANIM *xanim)
 {
@@ -56,6 +63,7 @@ wxVideoXANIMProcess::wxVideoXANIMProcess(wxVideoXANIM *xanim)
 void wxVideoXANIMProcess::OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
 {
     m_vid_xanim->m_xanim_started = FALSE;
+    m_vid_xanim->OnFinished();
 }
 
 wxVideoXANIM::wxVideoXANIM()
@@ -66,6 +74,7 @@ wxVideoXANIM::wxVideoXANIM()
     m_xanim_started  = FALSE;
     m_paused         = FALSE;
     m_filename       = "";
+    m_remove_file    = FALSE;
 }
 
 wxVideoXANIM::wxVideoXANIM(wxInputStream& str)
@@ -77,11 +86,23 @@ wxVideoXANIM::wxVideoXANIM(wxInputStream& str)
     m_paused         = FALSE;
     
     m_filename       = wxGetTempFileName("vidxa");
+    m_remove_file    = TRUE;
     wxFileOutputStream fout(m_filename);
     
     fout << str;
 }
 
+wxVideoXANIM::wxVideoXANIM(const wxString& filename)
+{
+    m_internal       = new wxXANIMinternal;
+    m_xanim_detector = new wxVideoXANIMProcess(this);
+    m_xanim_started  = FALSE;
+    m_paused         = FALSE;
+
+    m_filename       = filename;
+    m_remove_file    = FALSE;
+}
+
 wxVideoXANIM::~wxVideoXANIM()
 {
     if (m_xanim_started)
@@ -89,6 +110,7 @@ wxVideoXANIM::~wxVideoXANIM()
     delete m_internal;
     delete m_xanim_detector;
     
+    if (m_remove_file)
         wxRemoveFile(m_filename);
 }
 
@@ -134,31 +156,27 @@ bool wxVideoXANIM::Stop()
 
     SendCommand("q");
 
-  m_xanim_started = FALSE;
+    // We are waiting for the termination of the subprocess.
+    while (m_xanim_started) { 
+      wxYield();
+    }
+
     m_paused = FALSE;
     
     return TRUE;
 }
 
-bool wxVideoXANIM::SetVolume(wxUint8 vol)
+bool wxVideoXANIM::Resize(wxUint16 w, wxUint16 h)
 {
-  if (vol > 100)
+    if (!m_video_output)
-    vol = 100;
+      return FALSE;
 
-  wxString str_vol("v%d", vol);
+    m_video_output->SetSize(w, h);
-  return SendCommand(str_vol.GetData());
-}
-
-bool wxVideoXANIM::Resize(wxUint16 WXUNUSED(w), wxUint16 WXUNUSED(h))
-{
-  // Not implemented
-  //  Actually, I think that we just need to resize the output window ...
     return FALSE;
 }
 
 bool wxVideoXANIM::GetSize(wxSize& size) const
 {
-  // Not implemented
     return FALSE;
 }
 
@@ -244,7 +262,6 @@ bool wxVideoXANIM::RestartXANIM()
     // Get current display
 #ifdef __WXGTK__
     m_internal->xanim_dpy = gdk_display;
-  // We absolutely need the window to be realized.
     GtkPizza *pizza = GTK_PIZZA( m_video_output->m_wxwindow );
     GdkWindow *window = pizza->bin_window;
     
@@ -256,7 +273,7 @@ bool wxVideoXANIM::RestartXANIM()
 					 "XANIM_PROPERTY", False);
     
     // Build the command
-  xanim_command.Printf(_T("xanim -Zr +Ze +Sr +f +W%d +f +q "
+    xanim_command.Printf(wxT("xanim -Zr +Ze +Sr +f +W%d +f +q "
 			     "+Av70 %s %s"), m_internal->xanim_window,
 			 (xanim_chg_size) ? _T("") : _T(""),
 			 WXSTRINGCAST m_filename);
@@ -277,6 +294,9 @@ bool wxVideoXANIM::RestartXANIM()
       wxYield();
     }
 
+    m_video_output->SetSize(m_video_output->GetSize());
+       // Very useful ! Actually it sends a SETSIZE event to XAnim
+    
     m_paused = FALSE;
     
     return TRUE;

utils/wxMMedia2/lib/vidxanm.h

@@ -15,17 +15,40 @@
     #pragma interface "vidxanm.h"
 #endif
 
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+// For compilers that support precompilation, includes "wx/wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+    #pragma hdrstop
+#endif
+
+// for all others, include the necessary headers (this file is usually all you
+// need because it includes almost all "standard" wxWindows headers
+#ifndef WX_PRECOMP
     #include "wx/defs.h"
     #include "wx/string.h"
     #include "wx/process.h"
+#endif
+
+// ----------------------------------------------------------------------------
+// System dependent headers
 
 #if defined(WXMMEDIA_INTERNAL) && (defined(__X__) || defined(__WXGTK__))
 #include <X11/Xlib.h>
 #include <X11/Xatom.h>
 #endif
 
+// ----------------------------------------------------------------------------
+// wxMMedia2 headers
+
 #include "vidbase.h"
 
+// ----------------------------------------------------------------------------
+// Internal types
+
 #ifdef WXMMEDIA_INTERNAL
 typedef struct wxXANIMinternal {
     Display *xanim_dpy;
@@ -36,18 +59,27 @@ typedef struct wxXANIMinternal {
 #ifndef __XANIM_COMMAND__
     #define __XANIM_COMMAND__ "/usr/X11R6/bin/xanim"
 #endif
+
 #endif
 
-class wxVideoXANIM : public wxVideoBaseDriver {
+// ----------------------------------------------------------------------------
+// Class definition
+
+class WXDLLEXPORT wxVideoXANIM : public wxVideoBaseDriver {
     DECLARE_DYNAMIC_CLASS(wxVideoXANIM)
 protected:
+    // Remember the state of the subprocess
     bool m_xanim_started, m_paused;
+    // Pure X11 variables
     struct wxXANIMinternal *m_internal;
     wxString m_filename;
     wxProcess *m_xanim_detector;
+    // Remember to delete the temporary file when necessary
+    bool m_remove_file;
 public:
     wxVideoXANIM();
     wxVideoXANIM(wxInputStream& str);
+    wxVideoXANIM(const wxString& filename);
     ~wxVideoXANIM();
     
     bool Play();
@@ -70,9 +102,9 @@ public:
     friend class wxVideoXANIMProcess;
     
 protected:
-  ///
+    // Start the subprocess with the right parameters
     bool RestartXANIM();
-  ///
+    // Send a command to the subprocess
     bool SendCommand(const char *command,char **ret = NULL,
                      wxUint32 *size = NULL);
 };