contrib/samples/mmedia/mmbman.cpp

   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"
  44 #include "wx/mmedia/sndmsad.h"
  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
 251 void MMBoardSoundFile::SetWindow(wxWindow *window)
 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"));
 280             break;
 281         case MMBoard_AIFF:
 282             return wxString(wxT("AIFF file"));
 283             break;
 284         default:
 285             return wxString(wxT("Unknown file"));
 286             break;
 287     }
 288 }
 289
 290 wxString MMBoardSoundFile::GetStringInformation()
 291 {
 292     wxString info;
 293     wxSoundFormatBase *format;
 294
 295     format = &(m_file_stream->GetSoundFormat());
 296
 297     info = wxT("Data encoding: ");
 298     switch (format->GetType()) {
 299     case wxSOUND_PCM: {
 300         wxSoundFormatPcm *pcm_format = (wxSoundFormatPcm *)format;
 301
 302         info += wxString::Format(wxT("PCM %s %s\n"),
 303                                  pcm_format->Signed() ? wxT("signed") : wxT("unsigned"),
 304                                  pcm_format->GetOrder() == wxLITTLE_ENDIAN ? wxT("little endian") : wxT("big endian"));
 305         info += wxString::Format(wxT("Sampling rate: %d\n")
 306                                  wxT("Bits per sample: %d\n")
 307                                  wxT("Number of channels: %d\n"),
 308                                  pcm_format->GetSampleRate(),
 309                                  pcm_format->GetBPS(),
 310                                  pcm_format->GetChannels());
 311
 312         break;
 313     }
 314     case wxSOUND_MSADPCM: {
 315         wxSoundFormatMSAdpcm *adpcm_format = (wxSoundFormatMSAdpcm *)format;
 316
 317         info += wxString::Format(wxT("Microsoft ADPCM\n"));
 318         info += wxString::Format(wxT("Sampling Rate: %d\n")
 319                                  wxT("Number of channels: %d\n"),
 320                                  adpcm_format->GetSampleRate(),
 321                                  adpcm_format->GetChannels());
 322         break;
 323     }
 324     case wxSOUND_ULAW: {
 325         wxSoundFormatUlaw *ulaw_format = (wxSoundFormatUlaw *)format;
 326         info += wxT("ULAW\n");
 327         info += wxString::Format(wxT("Sampling rate: %d\n"), ulaw_format->GetSampleRate());
 328         break;
 329     }
 330     default:
 331         info += wxT("Unknown");
 332         break;
 333     }
 334     return info;
 335 }
 336
 337 // ----------------------------------------------------------------------------
 338
 339
 340 // ----------------------------------------------------------------------------
 341 // MMBoardVideoFile
 342
 343 MMBoardVideoFile::MMBoardVideoFile(const wxString& filename)
 344 {
 345     m_output_window = NULL;
 346
 347 #if defined(__UNIX__)
 348     m_video_driver = new wxVideoXANIM(filename);
 349 #elif defined(__WIN32__)
 350     m_video_driver = new wxVideoWindows(filename);
 351 #else
 352     m_video_driver = NULL;
 353     SetError(MMBoard_UnknownFile);
 354 #endif
 355 }
 356
 357 MMBoardVideoFile::~MMBoardVideoFile()
 358 {
 359     if (m_video_driver)
 360         delete m_video_driver;
 361 }
 362
 363 bool MMBoardVideoFile::NeedWindow()
 364 {
 365     return TRUE;
 366 }
 367
 368 void MMBoardVideoFile::SetWindow(wxWindow *window)
 369 {
 370     m_output_window = window;
 371     m_video_driver->AttachOutput(*window);
 372
 373     wxSize size;
 374     m_video_driver->GetSize(size);
 375     window->SetSize(size);
 376     // BAD BAD
 377     // and we remove
 378     // window->GetParent()->GetSizer()->Fit(window->GetParent());
 379 }
 380
 381 void MMBoardVideoFile::Play()
 382 {
 383     m_video_driver->Play();
 384 }
 385
 386 void MMBoardVideoFile::Pause()
 387 {
 388     m_video_driver->Pause();
 389 }
 390
 391 void MMBoardVideoFile::Resume()
 392 {
 393     m_video_driver->Resume();
 394 }
 395
 396 void MMBoardVideoFile::Stop()
 397 {
 398     m_video_driver->Stop();
 399 }
 400
 401 MMBoardTime MMBoardVideoFile::GetPosition()
 402 {
 403     MMBoardTime btime;
 404
 405     btime.seconds = btime.minutes = btime.hours = 0;
 406     return btime;
 407 }
 408
 409 MMBoardTime MMBoardVideoFile::GetLength()
 410 {
 411     MMBoardTime btime;
 412     int frameTime;
 413
 414     frameTime = (int)( m_video_driver->GetNbFrames() / m_video_driver->GetFrameRate());
 415
 416     btime.seconds = frameTime % 60;
 417     btime.minutes = (frameTime / 60) % 60;
 418     btime.hours   = frameTime / 3600;
 419     return btime;
 420 }
 421
 422 void MMBoardVideoFile::SetPosition(MMBoardTime btime)
 423 {
 424 }
 425
 426 bool MMBoardVideoFile::IsStopped()
 427 {
 428     return m_video_driver->IsStopped();
 429 }
 430
 431 bool MMBoardVideoFile::IsPaused()
 432 {
 433     return m_video_driver->IsPaused();
 434 }
 435
 436 wxString MMBoardVideoFile::GetStringType()
 437 {
 438     return wxString(wxT("Video XANIM"));
 439 }
 440
 441 wxString MMBoardVideoFile::GetStringInformation()
 442 {
 443     wxString info;
 444
 445     info = wxT("Video codec: ");
 446     info += m_video_driver->GetMovieCodec() + "\n";
 447     info += wxT("Audio codec: ");
 448     info += m_video_driver->GetAudioCodec();
 449     info += wxString::Format(" Sample rate: %d Channels: %d\n", m_video_driver->GetSampleRate(),
 450                              m_video_driver->GetBPS());
 451     info += wxString::Format(" Frame rate: %.01f", m_video_driver->GetFrameRate());
 452     return info;
 453 }
 454
 455 // ----------------------------------------------------------------------------
 456
 457 // ----------------------------------------------------------------------------
 458 // MMBoardFile
 459
 460 MMBoardFile::MMBoardFile()
 461 {
 462   m_error = 0;
 463 }
 464
 465 MMBoardFile::~MMBoardFile()
 466 {
 467 }
 468
 469 //
 470 // ----------------------------------------------------------------------------
 471
 472 // ----------------------------------------------------------------------------
 473 // MMBoardManager
 474
 475 MMBoardFile *MMBoardManager::Open(const wxString& filename)
 476 {
 477   MMBoardFile *file;
 478
 479   // Test the audio codec
 480   file = new MMBoardSoundFile(filename);
 481   if (!file->GetError())
 482     return file;
 483   delete file;
 484
 485   // Test the video codec
 486   file = new MMBoardVideoFile(filename);
 487   if (!file->GetError())
 488     return file;
 489   delete file;
 490
 491   // Arrrgh, we just could not see what is that file ...
 492   return NULL;
 493 }
 494
 495 DECLARE_APP(MMBoardApp)
 496
 497 wxSoundStream *MMBoardManager::OpenSoundStream()
 498 {
 499 #ifdef __UNIX__
 500   if ((wxGetApp().m_caps & MM_SOUND_ESD) != 0)
 501     return new wxSoundStreamESD();
 502
 503   if ((wxGetApp().m_caps & MM_SOUND_OSS) != 0)
 504     return new wxSoundStreamOSS();
 505 #endif
 506
 507 #ifdef __WIN32__
 508   if ((wxGetApp().m_caps & MM_SOUND_WIN) != 0)
 509     return new wxSoundStreamWin();
 510 #endif
 511
 512   wxMessageBox("You are trying to open a multimedia but you have not devices", "Error", wxOK | wxICON_ERROR, NULL);
 513
 514   return NULL;
 515 }
 516
 517 void MMBoardManager::UnrefSoundStream(wxSoundStream *stream)
 518 {
 519   delete stream;
 520 }
 521
 522 // ----------------------------------------------------------------------------
 523