[wxWidgets.git] / contrib / src / mmedia / vidxanm.cpp

// -------------------------------------------------------------------------
// Name:       vidxanm.cpp
// Purpose:    wxMMedia
// Author:     Guilhem Lavaux
// Created:    1997
// Updated:    1998
// Copyright:  (C) 1997, 1998, 1999 Guilhem Lavaux
// License:    wxWindows license
// -------------------------------------------------------------------------

#ifdef __GNUG__
#pragma implementation "vidxanm.h"
#endif

#include <wx/wxprec.h>

#ifndef WX_PRECOMP
#include <wx/wx.h>
#endif

// Pizza !
#include <wx/gtk/win_gtk.h>

#include <X11/Xlib.h>
#include <X11/Intrinsic.h>
#ifdef __WXGTK__
#include <gtk/gtkwidget.h>
#include <gtk/gtkwindow.h>
#include <gdk/gdk.h>
#include <gdk/gdkprivate.h>
#endif

#include <wx/filefn.h>
#include <wx/wfstream.h>
#include <wx/datstrm.h>
#include <wx/tokenzr.h>

#define WXMMEDIA_INTERNAL
#include "wx/mmedia/vidbase.h"
#include "wx/mmedia/vidxanm.h"

IMPLEMENT_DYNAMIC_CLASS(wxVideoXANIM, wxVideoBaseDriver)

// -------------------------------------------------------------------------
// End process detector

class wxVideoXANIMProcess: public wxProcess {
public:
    wxVideoXANIMProcess(wxVideoXANIM *xanim);

    void OnTerminate(int pid, int status);

protected:
    wxVideoXANIM *m_vid_xanim;
};

class wxVideoXANIMOutput: public wxProcess {
public:
    wxVideoXANIMOutput();

    void OnTerminate(int pid, int status);
    
    bool IsTerminated() const;
protected:
    bool m_terminated;
};

// -------------------------------------------------------------------------
// XAnim video driver (process handling implementation)

wxVideoXANIMProcess::wxVideoXANIMProcess(wxVideoXANIM *xanim)
{
    m_vid_xanim = xanim;
}

void wxVideoXANIMProcess::OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
{
    m_vid_xanim->m_xanim_started = FALSE;
    m_vid_xanim->OnFinished();
}

wxVideoXANIMOutput::wxVideoXANIMOutput()
        : wxProcess(NULL, -1)
{
    m_terminated = FALSE;
    Redirect();
}

bool wxVideoXANIMOutput::IsTerminated() const
{
    return m_terminated;
}

void wxVideoXANIMOutput::OnTerminate(int pid, int status)
{
    m_terminated = TRUE;
}

// -------------------------------------------------------------------------
// XAnim video driver (implementation)

wxVideoXANIM::wxVideoXANIM()
 : wxVideoBaseDriver()
{
    m_internal       = new wxXANIMinternal;
    m_xanim_detector = new wxVideoXANIMProcess(this);
    m_xanim_started  = FALSE;
    m_paused         = FALSE;
    m_filename       = "";
    m_remove_file    = FALSE;
}

wxVideoXANIM::wxVideoXANIM(wxInputStream& str)
  : wxVideoBaseDriver(str)
{
    m_internal       = new wxXANIMinternal;
    m_xanim_detector = new wxVideoXANIMProcess(this);
    m_xanim_started  = FALSE;
    m_paused         = FALSE;
    m_size[0]        = 0;
    m_size[1]        = 0;
    
    m_filename       = wxGetTempFileName("vidxa");
    m_remove_file    = TRUE;
    wxFileOutputStream fout(m_filename);
    
    fout << str;

    CollectInfo();
}

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;
    m_size[0]        = 0;
    m_size[1]        = 0;
    
    CollectInfo();
}

wxVideoXANIM::~wxVideoXANIM()
{
    if (m_xanim_started)
        Stop();
    delete m_internal;
    delete m_xanim_detector;
    
    if (m_remove_file)
        wxRemoveFile(m_filename);
}

// -------------------------------------------------------------------------
// Movie controller

bool wxVideoXANIM::Play()
{
    if (!m_paused && m_xanim_started)
        return TRUE; 
    if (!m_video_output) {
        wxVideoCreateFrame(this);
	return TRUE;
    }

    // The movie starts with xanim
    if (RestartXANIM()) {
        m_paused = FALSE;
	return TRUE;
    }
    return FALSE;
}

bool wxVideoXANIM::Pause()
{
    if (!m_paused && SendCommand(" ")) {
        m_paused = TRUE;
	return TRUE;
    }
    return FALSE;
}

bool wxVideoXANIM::Resume()
{
    if (m_paused && SendCommand(" ")) {
        m_paused = FALSE;
	return TRUE;
    }
    return FALSE;
}

bool wxVideoXANIM::Stop()
{
    if (!m_xanim_started)
        return FALSE;

    SendCommand("q");

    // We are waiting for the termination of the subprocess.
    while (m_xanim_started) { 
      wxYield();
    }

    m_paused = FALSE;
    
    return TRUE;
}

// -------------------------------------------------------------------------
// Movie size controller

bool wxVideoXANIM::SetSize(wxSize size)
{
    if (!m_video_output)
      return FALSE;

    m_video_output->SetSize(size.GetWidth(), size.GetHeight());
    return FALSE;
}

bool wxVideoXANIM::GetSize(wxSize& size) const
{
    if (m_size[0] == 0)
        return FALSE;
    size.Set(m_size[0], m_size[1]);
    return TRUE;
}

// -------------------------------------------------------------------------
// Capabilities of XAnim

bool wxVideoXANIM::IsCapable(wxVideoType v_type) const
{
    if (v_type == wxVIDEO_MSAVI || v_type == wxVIDEO_MPEG ||
	v_type == wxVIDEO_QT || v_type == wxVIDEO_GIF || v_type == wxVIDEO_JMOV ||
	v_type == wxVIDEO_FLI || v_type == wxVIDEO_IFF || v_type == wxVIDEO_SGI)
        return TRUE;
    else
        return FALSE;
}

// -------------------------------------------------------------------------
// Movie state

wxString wxVideoXANIM::GetMovieCodec() const
{
    if (m_size[0] == 0)
        return wxT("");
    return m_movieCodec;
}

wxString wxVideoXANIM::GetAudioCodec() const
{
    if (m_size[0] == 0)
        return wxT("");
    return m_audioCodec;
}

wxUint32 wxVideoXANIM::GetSampleRate() const
{
    if (m_size[0] == 0)
        return 0;
    return m_sampleRate;
}

wxUint8 wxVideoXANIM::GetChannels() const
{
    if (m_size[0] == 0)
        return 0;
    return m_channels;
}

wxUint8 wxVideoXANIM::GetBPS() const
{
    if (m_size[0] == 0)
        return 0;
    return m_bps;
}

double wxVideoXANIM::GetFrameRate() const
{
    if (m_size[0] == 0)
        return 0.0;
    return m_frameRate;
}

wxUint32 wxVideoXANIM::GetNbFrames() const
{
    if (m_size[0] == 0)
        return 0;
    return m_frames;
}


bool wxVideoXANIM::IsPaused() const
{
    return m_paused;
}

bool wxVideoXANIM::IsStopped() const
{
    return !m_xanim_started;
}

// -------------------------------------------------------------------------
// Output management

bool wxVideoXANIM::AttachOutput(wxWindow& out)
{
    if (!wxVideoBaseDriver::AttachOutput(out))
        return FALSE;
    
    return TRUE;
}

void wxVideoXANIM::DetachOutput()
{
    SendCommand("q");
    m_xanim_started = FALSE;
    m_paused = FALSE;

    wxVideoBaseDriver::DetachOutput();
}

// -------------------------------------------------------------------------
// Lowlevel XAnim controller

bool wxVideoXANIM::SendCommand(const char *command, char **ret,
			       wxUint32 *size)
{
    if (!m_xanim_started)
        if (!RestartXANIM())
	    return FALSE;

    // Send a command to XAnim through X11 Property
    XChangeProperty(m_internal->xanim_dpy, m_internal->xanim_window,
		    m_internal->xanim_atom,
		    XA_STRING, 8, PropModeReplace, (unsigned char *)command,
		    strlen(command));
    XFlush(m_internal->xanim_dpy);
    if (ret) {
        int prop_format;
	Atom prop_type;
	unsigned long extra;
	
	XGetWindowProperty(m_internal->xanim_dpy, m_internal->xanim_window,
			   m_internal->xanim_ret, 0, 16, True, AnyPropertyType,
			   &prop_type, &prop_format, (unsigned long *)size,
			   &extra, (unsigned char **)ret);
    }
    return TRUE;
}

bool wxVideoXANIM::CollectInfo()
{
    wxVideoXANIMOutput *xanimProcess;
    wxString xanim_command;
    wxStringTokenizer tokenizer;
    
    xanimProcess = new wxVideoXANIMOutput;
    xanim_command = wxT("xanim +v +Zv -Ae ");
    xanim_command += m_filename;
    if (!wxExecute(xanim_command, FALSE, xanimProcess))
        return FALSE;

    wxInputStream *infoStream = xanimProcess->GetInputStream();
    wxString totalOutput;
        
    while (infoStream->LastError() == wxSTREAM_NOERROR) {
        char line[100];

        infoStream->Read(line, sizeof(line)-1);
        if (infoStream->LastRead() == 0)
            break;
        
        line[infoStream->LastRead()] = 0;
       
        totalOutput += line;        
    }

    // This is good for everything ... :-)
    int position = totalOutput.Find(wxT("Video Codec:"));
    
    totalOutput.Remove(0, position+13);

    position = totalOutput.Find(wxT("depth="));
    m_movieCodec = totalOutput(0, position);

    totalOutput.Remove(0, position);
    tokenizer.SetString(totalOutput, "\n\r");

    // the rest of the line
    wxString token = tokenizer.GetNextToken();
    unsigned long my_long;
    
#define GETINT(i) \
totalOutput.ToULong(&my_long); \
i = my_long;
    
    // 'Audio Codec:'
    totalOutput = tokenizer.GetString();
    totalOutput.Remove(0, totalOutput.Find(wxT(":"))+2);

    position = totalOutput.Find(wxT("Rate"));
    m_audioCodec = totalOutput(0, position-1);

    // 'Rate='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    GETINT(m_sampleRate);
    // 'Chans='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    GETINT(m_channels);
    // 'Bps='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    GETINT(m_bps);
    // 'Frame Stats:'
    tokenizer.Reinit(totalOutput);
    tokenizer.GetNextToken();
    totalOutput = tokenizer.GetString();
    totalOutput.Remove(0, totalOutput.Find(wxT(":"))+2);
    // 'Size='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    GETINT(m_size[0]);
    // 'x'
    totalOutput.Remove(0,1);
    GETINT(m_size[1]);
    // 'Frames='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    GETINT(m_frames);
    // 'avfps='
    totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
    totalOutput.ToDouble(&m_frameRate);

    // We wait for the conclusion
    while (!xanimProcess->IsTerminated())
        wxYield();

    delete xanimProcess;

    return TRUE;
}

bool wxVideoXANIM::RestartXANIM()
{
    wxString xanim_command;
    int ret;
    Atom prop_type;
    int prop_format;
    unsigned long nitems;
    unsigned long extra;
    char prop[4];
    bool xanim_chg_size;
    
    if (!m_video_output || m_xanim_started)
        return FALSE;
    
    // Check if we can change the size of the window dynamicly
    xanim_chg_size = TRUE;
    // Get current display
#ifdef __WXGTK__
    m_internal->xanim_dpy = gdk_display;
    GtkPizza *pizza = GTK_PIZZA( m_video_output->m_wxwindow );
    GdkWindow *window = pizza->bin_window;
    
    m_internal->xanim_window =
        ((GdkWindowPrivate *)window)->xwindow;
#endif
    // Get the XANIM atom
    m_internal->xanim_atom = XInternAtom(m_internal->xanim_dpy,
					 "XANIM_PROPERTY", False);
    
    // Build the command
    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);
    
        // Execute it
    if (!wxExecute(xanim_command, FALSE, m_xanim_detector))
        return FALSE;
    
    // Wait for XAnim to be ready
    nitems = 0;
    m_xanim_started = TRUE;
    while (nitems == 0 && m_xanim_started) {
      ret = XGetWindowProperty(m_internal->xanim_dpy, m_internal->xanim_window,
			       m_internal->xanim_atom,
			       0, 4, False, AnyPropertyType, &prop_type,
			       &prop_format, &nitems, &extra,
			       (unsigned char **)&prop);
      wxYield();
    }

    wxSize vibrato_size;
    
    vibrato_size = m_video_output->GetSize();
    
    vibrato_size.SetWidth(vibrato_size.GetWidth()+1);
    m_video_output->SetSize(vibrato_size);
    vibrato_size.SetWidth(vibrato_size.GetWidth()-1);
    m_video_output->SetSize(vibrato_size);
    // Very useful ! Actually it sends a SETSIZE event to XAnim
    
    m_paused = FALSE;
    
    return TRUE;
}
Commit	Line	Data
e8482f24 GL	1	// -------------------------------------------------------------------------
	2	// Name: vidxanm.cpp
	3	// Purpose: wxMMedia
	4	// Author: Guilhem Lavaux
	5	// Created: 1997
	6	// Updated: 1998
	7	// Copyright: (C) 1997, 1998, 1999 Guilhem Lavaux
	8	// License: wxWindows license
	9	// -------------------------------------------------------------------------
	10
	11	#ifdef __GNUG__
	12	#pragma implementation "vidxanm.h"
	13	#endif
	14
	15	#include <wx/wxprec.h>
	16
	17	#ifndef WX_PRECOMP
	18	#include <wx/wx.h>
	19	#endif
	20
	21	// Pizza !
	22	#include <wx/gtk/win_gtk.h>
	23
	24	#include <X11/Xlib.h>
	25	#include <X11/Intrinsic.h>
	26	#ifdef __WXGTK__
	27	#include <gtk/gtkwidget.h>
	28	#include <gtk/gtkwindow.h>
	29	#include <gdk/gdk.h>
	30	#include <gdk/gdkprivate.h>
	31	#endif
	32
	33	#include <wx/filefn.h>
	34	#include <wx/wfstream.h>
	35	#include <wx/datstrm.h>
	36	#include <wx/tokenzr.h>
	37
	38	#define WXMMEDIA_INTERNAL
	39	#include "wx/mmedia/vidbase.h"
	40	#include "wx/mmedia/vidxanm.h"
	41
	42	IMPLEMENT_DYNAMIC_CLASS(wxVideoXANIM, wxVideoBaseDriver)
	43
	44	// -------------------------------------------------------------------------
	45	// End process detector
	46
	47	class wxVideoXANIMProcess: public wxProcess {
	48	public:
	49	wxVideoXANIMProcess(wxVideoXANIM *xanim);
	50
	51	void OnTerminate(int pid, int status);
	52
	53	protected:
	54	wxVideoXANIM *m_vid_xanim;
	55	};
	56
	57	class wxVideoXANIMOutput: public wxProcess {
	58	public:
	59	wxVideoXANIMOutput();
	60
	61	void OnTerminate(int pid, int status);
	62
	63	bool IsTerminated() const;
	64	protected:
65	bool m_terminated;
66	};
67
68	// -------------------------------------------------------------------------
69	// XAnim video driver (process handling implementation)
70
71	wxVideoXANIMProcess::wxVideoXANIMProcess(wxVideoXANIM *xanim)
72	{
73	m_vid_xanim = xanim;
74	}
75
76	void wxVideoXANIMProcess::OnTerminate(int WXUNUSED(pid), int WXUNUSED(status))
77	{
78	m_vid_xanim->m_xanim_started = FALSE;
79	m_vid_xanim->OnFinished();
80	}
81
82	wxVideoXANIMOutput::wxVideoXANIMOutput()
83	: wxProcess(NULL, -1)
84	{
85	m_terminated = FALSE;
86	Redirect();
87	}
88
89	bool wxVideoXANIMOutput::IsTerminated() const
90	{
91	return m_terminated;
92	}
93
94	void wxVideoXANIMOutput::OnTerminate(int pid, int status)
95	{
96	m_terminated = TRUE;
97	}
98
99	// -------------------------------------------------------------------------
100	// XAnim video driver (implementation)
101
102	wxVideoXANIM::wxVideoXANIM()
103	: wxVideoBaseDriver()
104	{
105	m_internal = new wxXANIMinternal;
106	m_xanim_detector = new wxVideoXANIMProcess(this);
107	m_xanim_started = FALSE;
108	m_paused = FALSE;
109	m_filename = "";
110	m_remove_file = FALSE;
111	}
112
113	wxVideoXANIM::wxVideoXANIM(wxInputStream& str)
114	: wxVideoBaseDriver(str)
115	{
116	m_internal = new wxXANIMinternal;
117	m_xanim_detector = new wxVideoXANIMProcess(this);
118	m_xanim_started = FALSE;
119	m_paused = FALSE;
120	m_size[0] = 0;
121	m_size[1] = 0;
122
123	m_filename = wxGetTempFileName("vidxa");
124	m_remove_file = TRUE;
125	wxFileOutputStream fout(m_filename);
126
127	fout << str;
128
129	CollectInfo();
130	}
131
132	wxVideoXANIM::wxVideoXANIM(const wxString& filename)
133	{
134	m_internal = new wxXANIMinternal;
135	m_xanim_detector = new wxVideoXANIMProcess(this);
136	m_xanim_started = FALSE;
137	m_paused = FALSE;
138
139	m_filename = filename;
140	m_remove_file = FALSE;
141	m_size[0] = 0;
142	m_size[1] = 0;
143
144	CollectInfo();
145	}
146
147	wxVideoXANIM::~wxVideoXANIM()
148	{
149	if (m_xanim_started)
150	Stop();
151	delete m_internal;
152	delete m_xanim_detector;
153
154	if (m_remove_file)
155	wxRemoveFile(m_filename);
156	}
157
158	// -------------------------------------------------------------------------
159	// Movie controller
160
161	bool wxVideoXANIM::Play()
162	{
163	if (!m_paused && m_xanim_started)
164	return TRUE;
165	if (!m_video_output) {
166	wxVideoCreateFrame(this);
167	return TRUE;
168	}
169
170	// The movie starts with xanim
171	if (RestartXANIM()) {
172	m_paused = FALSE;
173	return TRUE;
174	}
175	return FALSE;
176	}
177
178	bool wxVideoXANIM::Pause()
179	{
180	if (!m_paused && SendCommand(" ")) {
181	m_paused = TRUE;
182	return TRUE;
183	}
184	return FALSE;
185	}
186
187	bool wxVideoXANIM::Resume()
188	{
189	if (m_paused && SendCommand(" ")) {
190	m_paused = FALSE;
191	return TRUE;
192	}
193	return FALSE;
194	}
195
196	bool wxVideoXANIM::Stop()
197	{
198	if (!m_xanim_started)
199	return FALSE;
200
201	SendCommand("q");
202
203	// We are waiting for the termination of the subprocess.
204	while (m_xanim_started) {
205	wxYield();
206	}
207
208	m_paused = FALSE;
209
210	return TRUE;
211	}
212
213	// -------------------------------------------------------------------------
214	// Movie size controller
215
216	bool wxVideoXANIM::SetSize(wxSize size)
217	{
218	if (!m_video_output)
219	return FALSE;
220
221	m_video_output->SetSize(size.GetWidth(), size.GetHeight());
222	return FALSE;
223	}
224
225	bool wxVideoXANIM::GetSize(wxSize& size) const
226	{
227	if (m_size[0] == 0)
228	return FALSE;
229	size.Set(m_size[0], m_size[1]);
230	return TRUE;
231	}
232
233	// -------------------------------------------------------------------------
234	// Capabilities of XAnim
235
236	bool wxVideoXANIM::IsCapable(wxVideoType v_type) const
237	{
238	if (v_type == wxVIDEO_MSAVI \|\| v_type == wxVIDEO_MPEG \|\|
239	v_type == wxVIDEO_QT \|\| v_type == wxVIDEO_GIF \|\| v_type == wxVIDEO_JMOV \|\|
240	v_type == wxVIDEO_FLI \|\| v_type == wxVIDEO_IFF \|\| v_type == wxVIDEO_SGI)
241	return TRUE;
242	else
243	return FALSE;
244	}
245
246	// -------------------------------------------------------------------------
247	// Movie state
248
249	wxString wxVideoXANIM::GetMovieCodec() const
250	{
251	if (m_size[0] == 0)
252	return wxT("");
253	return m_movieCodec;
254	}
255
256	wxString wxVideoXANIM::GetAudioCodec() const
257	{
258	if (m_size[0] == 0)
259	return wxT("");
260	return m_audioCodec;
261	}
262
263	wxUint32 wxVideoXANIM::GetSampleRate() const
264	{
265	if (m_size[0] == 0)
266	return 0;
267	return m_sampleRate;
268	}
269
270	wxUint8 wxVideoXANIM::GetChannels() const
271	{
272	if (m_size[0] == 0)
273	return 0;
274	return m_channels;
275	}
276
277	wxUint8 wxVideoXANIM::GetBPS() const
278	{
279	if (m_size[0] == 0)
280	return 0;
281	return m_bps;
282	}
283
284	double wxVideoXANIM::GetFrameRate() const
285	{
286	if (m_size[0] == 0)
287	return 0.0;
288	return m_frameRate;
289	}
290
291	wxUint32 wxVideoXANIM::GetNbFrames() const
292	{
293	if (m_size[0] == 0)
294	return 0;
295	return m_frames;
296	}
297
298
299	bool wxVideoXANIM::IsPaused() const
300	{
301	return m_paused;
302	}
303
304	bool wxVideoXANIM::IsStopped() const
305	{
306	return !m_xanim_started;
307	}
308
309	// -------------------------------------------------------------------------
310	// Output management
311
312	bool wxVideoXANIM::AttachOutput(wxWindow& out)
313	{
314	if (!wxVideoBaseDriver::AttachOutput(out))
315	return FALSE;
316
317	return TRUE;
318	}
319
320	void wxVideoXANIM::DetachOutput()
321	{
322	SendCommand("q");
323	m_xanim_started = FALSE;
324	m_paused = FALSE;
325
326	wxVideoBaseDriver::DetachOutput();
327	}
328
329	// -------------------------------------------------------------------------
330	// Lowlevel XAnim controller
331
332	bool wxVideoXANIM::SendCommand(const char command, char *ret,
333	wxUint32 *size)
334	{
335	if (!m_xanim_started)
336	if (!RestartXANIM())
337	return FALSE;
338
339	// Send a command to XAnim through X11 Property
340	XChangeProperty(m_internal->xanim_dpy, m_internal->xanim_window,
341	m_internal->xanim_atom,
342	XA_STRING, 8, PropModeReplace, (unsigned char *)command,
343	strlen(command));
344	XFlush(m_internal->xanim_dpy);
345	if (ret) {
346	int prop_format;
347	Atom prop_type;
348	unsigned long extra;
349
350	XGetWindowProperty(m_internal->xanim_dpy, m_internal->xanim_window,
351	m_internal->xanim_ret, 0, 16, True, AnyPropertyType,
352	&prop_type, &prop_format, (unsigned long *)size,
353	&extra, (unsigned char **)ret);
354	}
355	return TRUE;
356	}
357
358	bool wxVideoXANIM::CollectInfo()
359	{
360	wxVideoXANIMOutput *xanimProcess;
361	wxString xanim_command;
362	wxStringTokenizer tokenizer;
363
364	xanimProcess = new wxVideoXANIMOutput;
365	xanim_command = wxT("xanim +v +Zv -Ae ");
366	xanim_command += m_filename;
367	if (!wxExecute(xanim_command, FALSE, xanimProcess))
368	return FALSE;
369
370	wxInputStream *infoStream = xanimProcess->GetInputStream();
371	wxString totalOutput;
372
373	while (infoStream->LastError() == wxSTREAM_NOERROR) {
374	char line[100];
375
376	infoStream->Read(line, sizeof(line)-1);
377	if (infoStream->LastRead() == 0)
378	break;
379
380	line[infoStream->LastRead()] = 0;
381
382	totalOutput += line;
383	}
384
385	// This is good for everything ... :-)
386	int position = totalOutput.Find(wxT("Video Codec:"));
387
388	totalOutput.Remove(0, position+13);
389
390	position = totalOutput.Find(wxT("depth="));
391	m_movieCodec = totalOutput(0, position);
392
393	totalOutput.Remove(0, position);
394	tokenizer.SetString(totalOutput, "\n\r");
395
396	// the rest of the line
397	wxString token = tokenizer.GetNextToken();
398	unsigned long my_long;
399
400	#define GETINT(i) \
401	totalOutput.ToULong(&my_long); \
402	i = my_long;
403
404	// 'Audio Codec:'
405	totalOutput = tokenizer.GetString();
406	totalOutput.Remove(0, totalOutput.Find(wxT(":"))+2);
407
408	position = totalOutput.Find(wxT("Rate"));
409	m_audioCodec = totalOutput(0, position-1);
410
411	// 'Rate='
412	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
413	GETINT(m_sampleRate);
414	// 'Chans='
415	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
416	GETINT(m_channels);
417	// 'Bps='
418	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
419	GETINT(m_bps);
420	// 'Frame Stats:'
421	tokenizer.Reinit(totalOutput);
422	tokenizer.GetNextToken();
423	totalOutput = tokenizer.GetString();
424	totalOutput.Remove(0, totalOutput.Find(wxT(":"))+2);
425	// 'Size='
426	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
427	GETINT(m_size[0]);
428	// 'x'
429	totalOutput.Remove(0,1);
430	GETINT(m_size[1]);
431	// 'Frames='
432	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
433	GETINT(m_frames);
434	// 'avfps='
435	totalOutput.Remove(0, totalOutput.Find(wxT("="))+1);
436	totalOutput.ToDouble(&m_frameRate);
437
438	// We wait for the conclusion
439	while (!xanimProcess->IsTerminated())
440	wxYield();
441
442	delete xanimProcess;
443
444	return TRUE;
445	}
446
447	bool wxVideoXANIM::RestartXANIM()
448	{
449	wxString xanim_command;
450	int ret;
451	Atom prop_type;
452	int prop_format;
453	unsigned long nitems;
454	unsigned long extra;
455	char prop[4];
456	bool xanim_chg_size;
457
458	if (!m_video_output \|\| m_xanim_started)
459	return FALSE;
460
461	// Check if we can change the size of the window dynamicly
462	xanim_chg_size = TRUE;
463	// Get current display
464	#ifdef __WXGTK__
465	m_internal->xanim_dpy = gdk_display;
466	GtkPizza *pizza = GTK_PIZZA( m_video_output->m_wxwindow );
467	GdkWindow *window = pizza->bin_window;
468
469	m_internal->xanim_window =
470	((GdkWindowPrivate *)window)->xwindow;
471	#endif
472	// Get the XANIM atom
473	m_internal->xanim_atom = XInternAtom(m_internal->xanim_dpy,
474	"XANIM_PROPERTY", False);
475
476	// Build the command
477	xanim_command.Printf(wxT("xanim -Zr +Ze +Sr +f +W%d +f +q "
478	"+Av70 %s %s"), m_internal->xanim_window,
479	(xanim_chg_size) ? _T("") : _T(""),
480	WXSTRINGCAST m_filename);
481
482	// Execute it
483	if (!wxExecute(xanim_command, FALSE, m_xanim_detector))
484	return FALSE;
485
486	// Wait for XAnim to be ready
487	nitems = 0;
488	m_xanim_started = TRUE;
489	while (nitems == 0 && m_xanim_started) {
490	ret = XGetWindowProperty(m_internal->xanim_dpy, m_internal->xanim_window,
491	m_internal->xanim_atom,
492	0, 4, False, AnyPropertyType, &prop_type,
493	&prop_format, &nitems, &extra,
494	(unsigned char **)&prop);
495	wxYield();
496	}
497
498	wxSize vibrato_size;
499
500	vibrato_size = m_video_output->GetSize();
501
502	vibrato_size.SetWidth(vibrato_size.GetWidth()+1);
503	m_video_output->SetSize(vibrato_size);
504	vibrato_size.SetWidth(vibrato_size.GetWidth()-1);
505	m_video_output->SetSize(vibrato_size);
506	// Very useful ! Actually it sends a SETSIZE event to XAnim
507
508	m_paused = FALSE;
509
510	return TRUE;
511	}