[wxWidgets.git] / contrib / samples / mmedia / mmbman.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        mmbman.cpp
// Purpose:     Multimedia Board manager
// Author:      Guilhem Lavaux, <guilhem.lavaux@libertysurf.fr>
// Modified by:
// Created:     13/02/2000
// RCS-ID:      $Id$
// Copyright:   (c) 2000, Guilhem Lavaux
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
  #pragma implementation "mmbman.cpp"
#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/wx.h"
#endif

// Personal headers

#include "wx/stream.h"
#include "wx/wfstream.h"

#include "wx/mmedia/sndbase.h"
#include "wx/mmedia/sndfile.h"
#include "wx/mmedia/sndwav.h"
#include "wx/mmedia/sndaiff.h"
#include "wx/mmedia/sndpcm.h"
#include "wx/mmedia/sndulaw.h"
#include "wx/mmedia/sndmsad.h"

#ifdef __UNIX__
#include "wx/mmedia/sndoss.h"
#include "wx/mmedia/sndesd.h"
#endif

#ifdef __WIN32__
#include "wx/mmedia/sndwin.h"
#endif

#include "wx/mmedia/vidbase.h"
#ifdef __UNIX__
#include "wx/mmedia/vidxanm.h"
#endif

#ifdef __WIN32__
#include "wx/mmedia/vidwin.h"
#endif

#include "mmboard.h"
#include "mmbman.h"

// ----------------------------------------------------------------------------
// Private class definitions
// ----------------------------------------------------------------------------

class MMBoardSoundFile: public MMBoardFile {
public:
    MMBoardSoundFile(const wxString& filename);
    ~MMBoardSoundFile();
    
    bool NeedWindow();
    
    void SetWindow(wxWindow *window);
    
    void Play();
    void Pause();
    void Resume();
    void Stop();
    
    MMBoardTime GetPosition();
    MMBoardTime GetLength();
    void SetPosition(MMBoardTime btime);
    
    bool IsStopped();
    bool IsPaused();
    
    wxString GetStringType();
    wxString GetStringInformation();
    
protected:
    wxSoundFileStream *GetDecoder();
    
    wxSoundStream *m_output_stream;
    wxInputStream *m_input_stream;
    wxSoundFileStream *m_file_stream;

    MMBoardTime m_length;
    wxUint8 m_file_type;
};

class MMBoardVideoFile: public MMBoardFile {
public:
    MMBoardVideoFile(const wxString& filename);
    ~MMBoardVideoFile();
    
    bool NeedWindow();
    
    void SetWindow(wxWindow *window);
    
    void Play();
    void Pause();
    void Resume();
    void Stop();
    
    MMBoardTime GetPosition();
    MMBoardTime GetLength();
    void SetPosition(MMBoardTime btime);
    
    bool IsStopped();
    bool IsPaused();
    
    wxString GetStringType();
    wxString GetStringInformation();
    
protected:
    wxWindow *m_output_window;
    wxVideoBaseDriver *m_video_driver;
};

// ----------------------------------------------------------------------------
// Implementation
// ----------------------------------------------------------------------------

#define MMBoard_UNKNOWNTYPE 0
#define MMBoard_WAVE 1
#define MMBoard_AIFF 2

// ----------------------------------------------------------------------------
// MMBoardSoundFile

MMBoardSoundFile::MMBoardSoundFile(const wxString& filename)
  : MMBoardFile()
{
    m_input_stream = new wxFileInputStream(filename);
    m_output_stream = MMBoardManager::OpenSoundStream();
    
    m_file_stream = GetDecoder();
    
    if (!m_file_stream) {
        SetError(MMBoard_UnknownFile);
        return;
    }
    
    // Compute length
    wxUint32 length, seconds;

    length = m_file_stream->GetLength();
    seconds = m_file_stream->GetSoundFormat().GetTimeFromBytes(length);
    m_length.seconds = seconds % 60;
    m_length.minutes = (seconds / 60) % 60;
    m_length.hours   = seconds / 3600;
}

MMBoardSoundFile::~MMBoardSoundFile()
{
    if (m_file_stream)
        delete m_file_stream;
    MMBoardManager::UnrefSoundStream(m_output_stream);
    delete m_input_stream;
}

wxSoundFileStream *MMBoardSoundFile::GetDecoder()
{
    wxSoundFileStream *f_stream;
    
    // First, we try a Wave decoder
    f_stream = new wxSoundWave(*m_input_stream, *m_output_stream);
    m_file_type = MMBoard_WAVE;
    if (f_stream->CanRead())
        return f_stream;
    delete f_stream;
    
    // Then, a AIFF decoder
    f_stream = new wxSoundAiff(*m_input_stream, *m_output_stream);
    m_file_type = MMBoard_AIFF;
    if (f_stream->CanRead())
        return f_stream;
    delete f_stream;
    
    m_file_type = MMBoard_UNKNOWNTYPE;
    
    // TODO: automate
    
    return NULL;
}

MMBoardTime MMBoardSoundFile::GetLength()
{
    return m_length;
}

bool MMBoardSoundFile::IsStopped()
{
    return m_file_stream->IsStopped();
}

bool MMBoardSoundFile::IsPaused()
{
    return m_file_stream->IsPaused();
}

MMBoardTime MMBoardSoundFile::GetPosition()
{
    wxUint32 length, seconds;
    MMBoardTime file_time;
    
    file_time.seconds = file_time.minutes = file_time.hours = 0;
    if (m_file_stream->IsStopped())
        return file_time;
    
    length = m_file_stream->GetPosition();
    seconds = m_file_stream->GetSoundFormat().GetTimeFromBytes(length);
    file_time.seconds = seconds % 60;
    file_time.minutes = (seconds / 60) % 60;
    file_time.hours   = seconds / 3600;
    
    return file_time;
}

void MMBoardSoundFile::SetPosition(MMBoardTime btime)
{
    wxUint32 itime;

    itime = btime.seconds + btime.minutes * 60 + btime.hours;

    m_file_stream->SetPosition(
        m_file_stream->GetSoundFormat().GetBytesFromTime(itime)
        );
}

bool MMBoardSoundFile::NeedWindow()
{
    return FALSE;
}

void MMBoardSoundFile::SetWindow(wxWindow *WXUNUSED(window))
{
}

void MMBoardSoundFile::Play()
{
    m_file_stream->Play();
}

void MMBoardSoundFile::Pause()
{
    m_file_stream->Pause();
}

void MMBoardSoundFile::Resume()
{
    m_file_stream->Resume();
}

void MMBoardSoundFile::Stop()
{
    m_file_stream->Stop();
}

wxString MMBoardSoundFile::GetStringType()
{
    switch (m_file_type) {
        case MMBoard_WAVE:
            return wxString(wxT("WAVE file"));
            #if 0
            // break is not reachable after return
            break;
            #endif
        case MMBoard_AIFF:
            return wxString(wxT("AIFF file"));
            #if 0
            // break is not reachable after return
            break;
            #endif
        #if 0
        // default moved outside switch for those compilers
        // which complain about lack of return in function
        default:
            return wxString(wxT("Unknown file"));
            break;
        #endif
    }
    return wxString(wxT("Unknown file"));
}

wxString MMBoardSoundFile::GetStringInformation()
{
    wxString info;
    wxSoundFormatBase *format;
    
    format = &(m_file_stream->GetSoundFormat());
    
    info = wxT("Data encoding: ");
    switch (format->GetType()) {
    case wxSOUND_PCM: {
        wxSoundFormatPcm *pcm_format = (wxSoundFormatPcm *)format;
      
	info += wxString::Format(wxT("PCM %s %s\n"),
                                 pcm_format->Signed() ? wxT("signed") : wxT("unsigned"),
                                 pcm_format->GetOrder() == wxLITTLE_ENDIAN ? wxT("little endian") : wxT("big endian"));
	info += wxString::Format(wxT("Sampling rate: %d\n")
				 wxT("Bits per sample: %d\n")
				 wxT("Number of channels: %d\n"),
				 pcm_format->GetSampleRate(),
				 pcm_format->GetBPS(),
				 pcm_format->GetChannels());
	
	break;
    }
    case wxSOUND_MSADPCM: {
        wxSoundFormatMSAdpcm *adpcm_format = (wxSoundFormatMSAdpcm *)format;

        info += wxString::Format(wxT("Microsoft ADPCM\n"));
        info += wxString::Format(wxT("Sampling Rate: %d\n")
                                 wxT("Number of channels: %d\n"),
                                 adpcm_format->GetSampleRate(),
                                 adpcm_format->GetChannels());
        break;
    }
    case wxSOUND_ULAW: {
        wxSoundFormatUlaw *ulaw_format = (wxSoundFormatUlaw *)format;
	info += wxT("ULAW\n");
	info += wxString::Format(wxT("Sampling rate: %d\n"), ulaw_format->GetSampleRate());
	break;
    }
    default:
        info += wxT("Unknown");
	break;
    }
    return info;
}

// ----------------------------------------------------------------------------


// ----------------------------------------------------------------------------
// MMBoardVideoFile

MMBoardVideoFile::MMBoardVideoFile(const wxString& filename)
{
    m_output_window = NULL;
  
#if defined(__UNIX__)
    m_video_driver = new wxVideoXANIM(filename);
#elif defined(__WINDOWS__) && !defined(__MINGW32__) && !defined(__WATCOMC__)
    // versions of Open Watcom and MinGW tested against this source does not
    // deliver "digitalv.h" required in this feature
    m_video_driver = new wxVideoWindows(filename);
#else
    m_video_driver = NULL;
    SetError(MMBoard_UnknownFile);
#endif
}

MMBoardVideoFile::~MMBoardVideoFile()
{
    if (m_video_driver)
        delete m_video_driver;
}

bool MMBoardVideoFile::NeedWindow()
{
    return TRUE;
}

void MMBoardVideoFile::SetWindow(wxWindow *window)
{
    m_output_window = window;
    m_video_driver->AttachOutput(*window);

    wxSize size;
    m_video_driver->GetSize(size);
    window->SetSize(size);
    // BAD BAD
    // and we remove
    // window->GetParent()->GetSizer()->Fit(window->GetParent());
}

void MMBoardVideoFile::Play()
{
    m_video_driver->Play();
}

void MMBoardVideoFile::Pause()
{
    m_video_driver->Pause();
}

void MMBoardVideoFile::Resume()
{
    m_video_driver->Resume();
}

void MMBoardVideoFile::Stop()
{
    m_video_driver->Stop();
}

MMBoardTime MMBoardVideoFile::GetPosition()
{
    MMBoardTime btime;

    btime.seconds = btime.minutes = btime.hours = 0;
    return btime;
}

MMBoardTime MMBoardVideoFile::GetLength()
{
    MMBoardTime btime;
    int frameTime;

    frameTime = (int)( m_video_driver->GetNbFrames() / m_video_driver->GetFrameRate());
    
    btime.seconds = frameTime % 60;
    btime.minutes = (frameTime / 60) % 60;
    btime.hours   = frameTime / 3600;
    return btime;
}

void MMBoardVideoFile::SetPosition(MMBoardTime WXUNUSED(btime))
{
}

bool MMBoardVideoFile::IsStopped()
{
    return m_video_driver->IsStopped();
}

bool MMBoardVideoFile::IsPaused()
{
    return m_video_driver->IsPaused();
}

wxString MMBoardVideoFile::GetStringType()
{
    return wxString(wxT("Video XANIM"));
}

wxString MMBoardVideoFile::GetStringInformation()
{
    wxString info;

    info = wxT("Video codec: ");
    info += m_video_driver->GetMovieCodec() + _T("\n");
    info += wxT("Audio codec: ");
    info += m_video_driver->GetAudioCodec();
    info += wxString::Format(_T(" Sample rate: %d Channels: %d\n"), m_video_driver->GetSampleRate(),
                             m_video_driver->GetBPS());
    info += wxString::Format(_T(" Frame rate: %.01f"), m_video_driver->GetFrameRate());
    return info;
}

// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// MMBoardFile

MMBoardFile::MMBoardFile()
{
  m_error = 0;
}

MMBoardFile::~MMBoardFile()
{
}

//
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
// MMBoardManager

MMBoardFile *MMBoardManager::Open(const wxString& filename)
{
  MMBoardFile *file;

  // Test the audio codec
  file = new MMBoardSoundFile(filename);
  if (!file->GetError())
    return file;
  delete file;

  // Test the video codec
  file = new MMBoardVideoFile(filename);
  if (!file->GetError())
    return file;
  delete file;

  // Arrrgh, we just could not see what is that file ...
  return NULL;
}

DECLARE_APP(MMBoardApp)

wxSoundStream *MMBoardManager::OpenSoundStream()
{
#ifdef __UNIX__
  if ((wxGetApp().m_caps & MM_SOUND_ESD) != 0)
    return new wxSoundStreamESD();

  if ((wxGetApp().m_caps & MM_SOUND_OSS) != 0)
    return new wxSoundStreamOSS();
#endif

#ifdef __WIN32__
  if ((wxGetApp().m_caps & MM_SOUND_WIN) != 0)
    return new wxSoundStreamWin();
#endif

  wxMessageBox(_T("You are trying to open a multimedia but you have not devices"), _T("Error"), wxOK | wxICON_ERROR, NULL);

  return NULL;
}

void MMBoardManager::UnrefSoundStream(wxSoundStream *stream)
{
  delete stream;
}

// ----------------------------------------------------------------------------
Commit	Line	Data
e8482f24 GL	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: mmbman.cpp
	3	// Purpose: Multimedia Board manager
	4	// Author: Guilhem Lavaux, <guilhem.lavaux@libertysurf.fr>
	5	// Modified by:
	6	// Created: 13/02/2000
	7	// RCS-ID: $Id$
	8	// Copyright: (c) 2000, Guilhem Lavaux
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "mmbman.cpp"
	14	#endif
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
	20	// For compilers that support precompilation, includes "wx/wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
	27	// for all others, include the necessary headers (this file is usually all you
	28	// need because it includes almost all "standard" wxWindows headers
	29	#ifndef WX_PRECOMP
	30	#include "wx/wx.h"
	31	#endif
	32
	33	// Personal headers
	34
	35	#include "wx/stream.h"
	36	#include "wx/wfstream.h"
	37
	38	#include "wx/mmedia/sndbase.h"
	39	#include "wx/mmedia/sndfile.h"
	40	#include "wx/mmedia/sndwav.h"
	41	#include "wx/mmedia/sndaiff.h"
	42	#include "wx/mmedia/sndpcm.h"
	43	#include "wx/mmedia/sndulaw.h"
c42b1de6	44	#include "wx/mmedia/sndmsad.h"
e8482f24 GL	45
	46	#ifdef __UNIX__
	47	#include "wx/mmedia/sndoss.h"
	48	#include "wx/mmedia/sndesd.h"
	49	#endif
	50
	51	#ifdef __WIN32__
	52	#include "wx/mmedia/sndwin.h"
	53	#endif
	54
	55	#include "wx/mmedia/vidbase.h"
	56	#ifdef __UNIX__
	57	#include "wx/mmedia/vidxanm.h"
	58	#endif
	59
	60	#ifdef __WIN32__
	61	#include "wx/mmedia/vidwin.h"
	62	#endif
	63
	64	#include "mmboard.h"
	65	#include "mmbman.h"
	66
	67	// ----------------------------------------------------------------------------
	68	// Private class definitions
	69	// ----------------------------------------------------------------------------
	70
	71	class MMBoardSoundFile: public MMBoardFile {
	72	public:
	73	MMBoardSoundFile(const wxString& filename);
	74	~MMBoardSoundFile();
	75
	76	bool NeedWindow();
	77
	78	void SetWindow(wxWindow *window);
	79
	80	void Play();
	81	void Pause();
	82	void Resume();
	83	void Stop();
	84
	85	MMBoardTime GetPosition();
	86	MMBoardTime GetLength();
	87	void SetPosition(MMBoardTime btime);
	88
	89	bool IsStopped();
	90	bool IsPaused();
	91
	92	wxString GetStringType();
	93	wxString GetStringInformation();
	94
	95	protected:
	96	wxSoundFileStream *GetDecoder();
	97
	98	wxSoundStream *m_output_stream;
	99	wxInputStream *m_input_stream;
	100	wxSoundFileStream *m_file_stream;
	101
	102	MMBoardTime m_length;
	103	wxUint8 m_file_type;
	104	};
	105
	106	class MMBoardVideoFile: public MMBoardFile {
	107	public:
	108	MMBoardVideoFile(const wxString& filename);
109	~MMBoardVideoFile();
110
111	bool NeedWindow();
112
113	void SetWindow(wxWindow *window);
114
115	void Play();
116	void Pause();
117	void Resume();
118	void Stop();
119
120	MMBoardTime GetPosition();
121	MMBoardTime GetLength();
122	void SetPosition(MMBoardTime btime);
123
124	bool IsStopped();
125	bool IsPaused();
126
127	wxString GetStringType();
128	wxString GetStringInformation();
129
130	protected:
131	wxWindow *m_output_window;
132	wxVideoBaseDriver *m_video_driver;
133	};
134
135	// ----------------------------------------------------------------------------
136	// Implementation
137	// ----------------------------------------------------------------------------
138
139	#define MMBoard_UNKNOWNTYPE 0
140	#define MMBoard_WAVE 1
141	#define MMBoard_AIFF 2
142
143	// ----------------------------------------------------------------------------
144	// MMBoardSoundFile
145
146	MMBoardSoundFile::MMBoardSoundFile(const wxString& filename)
147	: MMBoardFile()
148	{
149	m_input_stream = new wxFileInputStream(filename);
150	m_output_stream = MMBoardManager::OpenSoundStream();
151
152	m_file_stream = GetDecoder();
153
154	if (!m_file_stream) {
155	SetError(MMBoard_UnknownFile);
156	return;
157	}
158
159	// Compute length
160	wxUint32 length, seconds;
161
162	length = m_file_stream->GetLength();
163	seconds = m_file_stream->GetSoundFormat().GetTimeFromBytes(length);
164	m_length.seconds = seconds % 60;
165	m_length.minutes = (seconds / 60) % 60;
166	m_length.hours = seconds / 3600;
167	}
168
169	MMBoardSoundFile::~MMBoardSoundFile()
170	{
171	if (m_file_stream)
172	delete m_file_stream;
173	MMBoardManager::UnrefSoundStream(m_output_stream);
174	delete m_input_stream;
175	}
176
177	wxSoundFileStream *MMBoardSoundFile::GetDecoder()
178	{
179	wxSoundFileStream *f_stream;
180
181	// First, we try a Wave decoder
182	f_stream = new wxSoundWave(m_input_stream, m_output_stream);
183	m_file_type = MMBoard_WAVE;
184	if (f_stream->CanRead())
185	return f_stream;
186	delete f_stream;
187
188	// Then, a AIFF decoder
189	f_stream = new wxSoundAiff(m_input_stream, m_output_stream);
190	m_file_type = MMBoard_AIFF;
191	if (f_stream->CanRead())
192	return f_stream;
193	delete f_stream;
194
195	m_file_type = MMBoard_UNKNOWNTYPE;
196
197	// TODO: automate
198
199	return NULL;
200	}
201
202	MMBoardTime MMBoardSoundFile::GetLength()
203	{
204	return m_length;
205	}
206
207	bool MMBoardSoundFile::IsStopped()
208	{
209	return m_file_stream->IsStopped();
210	}
211
212	bool MMBoardSoundFile::IsPaused()
213	{
214	return m_file_stream->IsPaused();
215	}
216
217	MMBoardTime MMBoardSoundFile::GetPosition()
218	{
219	wxUint32 length, seconds;
220	MMBoardTime file_time;
221
222	file_time.seconds = file_time.minutes = file_time.hours = 0;
223	if (m_file_stream->IsStopped())
224	return file_time;
225
226	length = m_file_stream->GetPosition();
227	seconds = m_file_stream->GetSoundFormat().GetTimeFromBytes(length);
228	file_time.seconds = seconds % 60;
229	file_time.minutes = (seconds / 60) % 60;
230	file_time.hours = seconds / 3600;
231
232	return file_time;
233	}
234
235	void MMBoardSoundFile::SetPosition(MMBoardTime btime)
236	{
237	wxUint32 itime;
238
239	itime = btime.seconds + btime.minutes * 60 + btime.hours;
240
241	m_file_stream->SetPosition(
242	m_file_stream->GetSoundFormat().GetBytesFromTime(itime)
243	);
244	}
245
246	bool MMBoardSoundFile::NeedWindow()
247	{
248	return FALSE;
249	}
250
2bbf230a	251	void MMBoardSoundFile::SetWindow(wxWindow *WXUNUSED(window))
e8482f24 GL	252	{
	253	}
	254
	255	void MMBoardSoundFile::Play()
	256	{
	257	m_file_stream->Play();
	258	}
	259
	260	void MMBoardSoundFile::Pause()
	261	{
	262	m_file_stream->Pause();
	263	}
	264
	265	void MMBoardSoundFile::Resume()
	266	{
	267	m_file_stream->Resume();
	268	}
	269
	270	void MMBoardSoundFile::Stop()
	271	{
	272	m_file_stream->Stop();
	273	}
	274
	275	wxString MMBoardSoundFile::GetStringType()
	276	{
	277	switch (m_file_type) {
	278	case MMBoard_WAVE:
	279	return wxString(wxT("WAVE file"));
2bbf230a JS	280	#if 0
2bbf230a JS	281	// break is not reachable after return
e8482f24	282	break;
2bbf230a	283	#endif
e8482f24 GL	284	case MMBoard_AIFF:
e8482f24 GL	285	return wxString(wxT("AIFF file"));
2bbf230a JS	286	#if 0
2bbf230a JS	287	// break is not reachable after return
e8482f24	288	break;
2bbf230a JS	289	#endif
	290	#if 0
	291	// default moved outside switch for those compilers
	292	// which complain about lack of return in function
e8482f24 GL	293	default:
	294	return wxString(wxT("Unknown file"));
	295	break;
2bbf230a	296	#endif
e8482f24	297	}
2bbf230a	298	return wxString(wxT("Unknown file"));
e8482f24 GL	299	}
	300
	301	wxString MMBoardSoundFile::GetStringInformation()
	302	{
	303	wxString info;
	304	wxSoundFormatBase *format;
	305
	306	format = &(m_file_stream->GetSoundFormat());
	307
	308	info = wxT("Data encoding: ");
	309	switch (format->GetType()) {
	310	case wxSOUND_PCM: {
	311	wxSoundFormatPcm pcm_format = (wxSoundFormatPcm )format;
	312
	313	info += wxString::Format(wxT("PCM %s %s\n"),
	314	pcm_format->Signed() ? wxT("signed") : wxT("unsigned"),
	315	pcm_format->GetOrder() == wxLITTLE_ENDIAN ? wxT("little endian") : wxT("big endian"));
	316	info += wxString::Format(wxT("Sampling rate: %d\n")
	317	wxT("Bits per sample: %d\n")
	318	wxT("Number of channels: %d\n"),
	319	pcm_format->GetSampleRate(),
	320	pcm_format->GetBPS(),
	321	pcm_format->GetChannels());
	322
	323	break;
	324	}
c42b1de6 GL	325	case wxSOUND_MSADPCM: {
	326	wxSoundFormatMSAdpcm adpcm_format = (wxSoundFormatMSAdpcm )format;
	327
	328	info += wxString::Format(wxT("Microsoft ADPCM\n"));
	329	info += wxString::Format(wxT("Sampling Rate: %d\n")
	330	wxT("Number of channels: %d\n"),
	331	adpcm_format->GetSampleRate(),
	332	adpcm_format->GetChannels());
	333	break;
	334	}
e8482f24 GL	335	case wxSOUND_ULAW: {
	336	wxSoundFormatUlaw ulaw_format = (wxSoundFormatUlaw )format;
	337	info += wxT("ULAW\n");
	338	info += wxString::Format(wxT("Sampling rate: %d\n"), ulaw_format->GetSampleRate());
	339	break;
	340	}
	341	default:
	342	info += wxT("Unknown");
	343	break;
	344	}
	345	return info;
	346	}
	347
	348	// ----------------------------------------------------------------------------
	349
	350
	351	// ----------------------------------------------------------------------------
	352	// MMBoardVideoFile
	353
	354	MMBoardVideoFile::MMBoardVideoFile(const wxString& filename)
	355	{
	356	m_output_window = NULL;
	357
	358	#if defined(__UNIX__)
	359	m_video_driver = new wxVideoXANIM(filename);
2b3644c7 JS	360	#elif defined(__WINDOWS__) && !defined(__MINGW32__) && !defined(__WATCOMC__)
	361	// versions of Open Watcom and MinGW tested against this source does not
	362	// deliver "digitalv.h" required in this feature
e8482f24 GL	363	m_video_driver = new wxVideoWindows(filename);
	364	#else
	365	m_video_driver = NULL;
	366	SetError(MMBoard_UnknownFile);
	367	#endif
	368	}
	369
	370	MMBoardVideoFile::~MMBoardVideoFile()
	371	{
	372	if (m_video_driver)
	373	delete m_video_driver;
	374	}
	375
	376	bool MMBoardVideoFile::NeedWindow()
	377	{
	378	return TRUE;
	379	}
	380
	381	void MMBoardVideoFile::SetWindow(wxWindow *window)
	382	{
	383	m_output_window = window;
	384	m_video_driver->AttachOutput(*window);
	385
	386	wxSize size;
	387	m_video_driver->GetSize(size);
	388	window->SetSize(size);
	389	// BAD BAD
	390	// and we remove
	391	// window->GetParent()->GetSizer()->Fit(window->GetParent());
	392	}
	393
	394	void MMBoardVideoFile::Play()
	395	{
	396	m_video_driver->Play();
	397	}
	398
	399	void MMBoardVideoFile::Pause()
	400	{
	401	m_video_driver->Pause();
	402	}
	403
	404	void MMBoardVideoFile::Resume()
	405	{
	406	m_video_driver->Resume();
	407	}
	408
	409	void MMBoardVideoFile::Stop()
	410	{
	411	m_video_driver->Stop();
	412	}
	413
	414	MMBoardTime MMBoardVideoFile::GetPosition()
	415	{
	416	MMBoardTime btime;
	417
	418	btime.seconds = btime.minutes = btime.hours = 0;
	419	return btime;
	420	}
	421
	422	MMBoardTime MMBoardVideoFile::GetLength()
	423	{
	424	MMBoardTime btime;
	425	int frameTime;
	426
427	frameTime = (int)( m_video_driver->GetNbFrames() / m_video_driver->GetFrameRate());
428
429	btime.seconds = frameTime % 60;
430	btime.minutes = (frameTime / 60) % 60;
431	btime.hours = frameTime / 3600;
432	return btime;
433	}
434
2bbf230a	435	void MMBoardVideoFile::SetPosition(MMBoardTime WXUNUSED(btime))
e8482f24 GL	436	{
	437	}
	438
	439	bool MMBoardVideoFile::IsStopped()
	440	{
	441	return m_video_driver->IsStopped();
	442	}
	443
	444	bool MMBoardVideoFile::IsPaused()
	445	{
	446	return m_video_driver->IsPaused();
	447	}
	448
	449	wxString MMBoardVideoFile::GetStringType()
	450	{
	451	return wxString(wxT("Video XANIM"));
	452	}
	453
	454	wxString MMBoardVideoFile::GetStringInformation()
	455	{
	456	wxString info;
	457
	458	info = wxT("Video codec: ");
2bbf230a	459	info += m_video_driver->GetMovieCodec() + _T("\n");
e8482f24 GL	460	info += wxT("Audio codec: ");
e8482f24 GL	461	info += m_video_driver->GetAudioCodec();
2bbf230a	462	info += wxString::Format(_T(" Sample rate: %d Channels: %d\n"), m_video_driver->GetSampleRate(),
e8482f24	463	m_video_driver->GetBPS());
2bbf230a	464	info += wxString::Format(_T(" Frame rate: %.01f"), m_video_driver->GetFrameRate());
e8482f24 GL	465	return info;
	466	}
	467
	468	// ----------------------------------------------------------------------------
	469
	470	// ----------------------------------------------------------------------------
	471	// MMBoardFile
	472
	473	MMBoardFile::MMBoardFile()
	474	{
	475	m_error = 0;
	476	}
	477
	478	MMBoardFile::~MMBoardFile()
	479	{
	480	}
	481
	482	//
	483	// ----------------------------------------------------------------------------
	484
	485	// ----------------------------------------------------------------------------
	486	// MMBoardManager
	487
	488	MMBoardFile *MMBoardManager::Open(const wxString& filename)
	489	{
	490	MMBoardFile *file;
	491
	492	// Test the audio codec
	493	file = new MMBoardSoundFile(filename);
	494	if (!file->GetError())
	495	return file;
	496	delete file;
	497
	498	// Test the video codec
	499	file = new MMBoardVideoFile(filename);
	500	if (!file->GetError())
	501	return file;
	502	delete file;
	503
	504	// Arrrgh, we just could not see what is that file ...
	505	return NULL;
	506	}
	507
	508	DECLARE_APP(MMBoardApp)
	509
	510	wxSoundStream *MMBoardManager::OpenSoundStream()
	511	{
	512	#ifdef __UNIX__
	513	if ((wxGetApp().m_caps & MM_SOUND_ESD) != 0)
	514	return new wxSoundStreamESD();
	515
	516	if ((wxGetApp().m_caps & MM_SOUND_OSS) != 0)
	517	return new wxSoundStreamOSS();
	518	#endif
	519
	520	#ifdef __WIN32__
	521	if ((wxGetApp().m_caps & MM_SOUND_WIN) != 0)
	522	return new wxSoundStreamWin();
	523	#endif
	524
2bbf230a	525	wxMessageBox(_T("You are trying to open a multimedia but you have not devices"), _T("Error"), wxOK \| wxICON_ERROR, NULL);
e8482f24 GL	526
	527	return NULL;
	528	}
	529
	530	void MMBoardManager::UnrefSoundStream(wxSoundStream *stream)
	531	{
	532	delete stream;
	533	}
	534
	535	// ----------------------------------------------------------------------------
	536