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

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

#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, wxID_ANY)
{
    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       = wxEmptyString;
    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(_T("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->GetLastError() == wxSTREAM_NO_ERROR) {
        char line[100];

        infoStream->Read(line, sizeof(line)-1);
        if (infoStream->LastRead() == 0)
            break;

        line[infoStream->LastRead()] = 0;

        totalOutput += wxString::FromAscii(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, wxT("\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 = GDK_WINDOW_XWINDOW(window);
#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 "should" sends a SETSIZE event to XAnim
    // FIXME: This event is not sent !!

    m_paused = false;

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