Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: orxonox.OLD/trunk/src/lib/sound/ogg_player.cc @ 7410

Last change on this file since 7410 was 7314, checked in by bensch, 19 years ago

orxonox/trunk: ShellBuffer is now ThreadSafe for printing to it
I must say: SDL_Thread's are way easier than simple pThreads

File size: 12.4 KB
Line 
1/*
2   orxonox - the future of 3D-vertical-scrollers
3
4   Copyright (C) 2004 orx
5
6   This program is free software; you can redistribute it and/or modify
7   it under the terms of the GNU General Public License as published by
8   the Free Software Foundation; either version 2, or (at your option)
9   any later version.
10
11### File Specific:
12   main-programmer: Benjamin Grauer
13   co-programmer: ...
14
15    Beware:
16   The Ogg-Player is a __Threaded__ Stream, this means, that invoking play()
17   creates a Thread, that loops through the Music-File. The Thread seems
18   to be safe, but it is not guarantied.
19
20   -------------------------------------------------------------------
21   A Simple Version of this can be found at http://www.devmaster.net
22   Thanks a lot for the nice work, and the easy portability to our Project.
23*/
24#define DEBUG_SPECIAL_MODULE DEBUG_MODULE_SOUND
25
26#include <iostream>
27
28#include "ogg_player.h"
29
30#include "sound_engine.h"
31
32#include "debug.h"
33
34/**
35 * initializes an Ogg-player from a file
36 * @param fileName the file to load
37 */
38OggPlayer::OggPlayer(const std::string& fileName)
39{
40  this->setClassID(CL_SOUND_OGG_PLAYER, "OggPlayer");
41
42  this->state = OggPlayer::None;
43
44  this->source = 0;
45  this->buffers[0] = 0;
46  this->buffers[1] = 0;
47  this->musicThreadID = NULL;
48  this->musicMutex = SDL_CreateMutex();
49
50  if (!fileName.empty())
51  {
52    if (this->open(fileName))
53      this->setName(fileName);
54  }
55
56}
57
58/**
59 * @brief deletes the OggPlayer
60 */
61OggPlayer::~OggPlayer()
62{
63  this->release();
64  SDL_DestroyMutex(this->musicMutex);
65}
66
67///////////////
68// INTERFACE //
69///////////////
70/**
71 * @brief opens a file for playback
72 * @param fileName the file to open
73 */
74bool OggPlayer::open(const std::string& fileName)
75{
76  MutexLock(this->musicMutex);
77  // release old Ogg-File (if loaded)
78  if (this->state & OggPlayer::FileOpened)
79    this->release();
80
81  // allocating Buffers
82  if (this->buffers[0] == 0)
83    alGenBuffers(2, this->buffers);
84  SoundEngine::checkError("Allocating Buffers", __LINE__);
85  if (this->buffers[0] != 0 && this->buffers[1] != 0)
86    state |= OggPlayer::BuffersAllocated;
87  else
88  {
89    PRINTF(2)("Unable to allocate al-Buffers\n");
90    this->release();
91    return false;
92  }
93  // allocating source
94  if (this->source == 0)
95    SoundEngine::getInstance()->popALSource(this->source);
96  if (this->source != 0)
97    state |= OggPlayer::SourceAllocated;
98  else
99  {
100    PRINTF(2)("No more Sources Availiable (maybe you should consider raising the source-count.)\n");
101    this->release();
102    return false;
103  }
104
105  // opening the FILE;
106  int result;
107  if(!(oggFile = fopen(fileName.c_str(), "rb")))
108  {
109    PRINTF(2)("Could not open Ogg file.");
110    this->release();
111    return false;
112  }
113  // reading the Stream.
114  if((result = ov_open(oggFile, &oggStream, NULL, 0)) < 0)
115  {
116    PRINTF(2)("Could not open Ogg stream. %s", getVorbisError(result));
117    fclose(oggFile);
118    this->release();
119    return false;
120  }
121  this->state |= OggPlayer::FileOpened;
122
123  // acquiring the vorbis-properties.
124  vorbisInfo = ov_info(&oggStream, -1);
125  vorbisComment = ov_comment(&oggStream, -1);
126
127  if(vorbisInfo->channels == 1)
128    format = AL_FORMAT_MONO16;
129  else
130    format = AL_FORMAT_STEREO16;
131
132  // setting the Source Properties.
133  alSource3f(source, AL_POSITION,        0.0, 0.0, 0.0);
134  alSource3f(source, AL_VELOCITY,        0.0, 0.0, 0.0);
135  alSource3f(source, AL_DIRECTION,       0.0, 0.0, 0.0);
136  alSourcef (source, AL_ROLLOFF_FACTOR,  0.0          );
137  alSourcei (source, AL_SOURCE_RELATIVE, AL_TRUE      );
138  alSourcef (source, AL_GAIN,            SoundEngine::getInstance()->getMusicVolume());
139  SoundEngine::checkError("OggPlayer::open()::SetSourceProperties", __LINE__);
140
141  // Set to State Stopped
142  this->state |= OggPlayer::Stopped;
143  return true;
144}
145
146
147/**
148 * @brief start Playing Music.
149 * @returns true on success false otherwise.
150 */
151bool OggPlayer::play()
152{
153  if (!(this->state & OggPlayer::FileOpened))
154    return false;
155
156  this->state &= ~(OggPlayer::Stopped | OggPlayer::Paused);
157
158  if (!this->playback())
159    return false;
160
161  if (this->musicThreadID == NULL)
162    return ((this->musicThreadID = SDL_CreateThread(OggPlayer::musicThread, (void*)this)) != NULL);
163  return true;
164}
165
166/**
167 * @brief stop the OggPlayer from Playing.
168 */
169void OggPlayer::stop()
170{
171  this->state &= ~(OggPlayer::Playing | OggPlayer::Paused);
172  this->state |= OggPlayer::Stopped;
173
174  this->suspend();
175  this->rewind();
176}
177
178/**
179 * @brief Pause the Playing.
180 */
181void OggPlayer::pause()
182{
183  this->state &= ~OggPlayer::Playing;
184
185  if (!(this->state & OggPlayer::Stopped))
186    this->state |= OggPlayer::Paused;
187
188  this->suspend();
189}
190
191/**
192 * @brief rewind to the beginning, and play (if already playing)
193 */
194void OggPlayer::rewind()
195{
196  this->jumpTo(0.0f);
197}
198
199/**
200 * @brief jump to Second timeCode in the MusicFile
201 * @param timeCode where to jump to.
202 */
203void OggPlayer::jumpTo(float timeCode)
204{
205
206  if (this->state & OggPlayer::FileOpened)
207  {
208    SDL_mutexP(this->musicMutex);
209    ov_time_seek(&this->oggStream, timeCode);
210    SDL_mutexV(this->musicMutex);
211  }
212}
213
214/**
215 * @returns the Length of the Music in Seconds
216 */
217float OggPlayer::length()
218{
219  if (this->state & OggPlayer::FileOpened)
220    return ov_time_total(&this->oggStream, -1);
221  else
222    return 0.0f;
223}
224
225
226/**
227 * @returns true if the file is playing
228 */
229bool OggPlayer::isPlaying()
230{
231  if (!(this->state & OggPlayer::FileOpened))
232    return false;
233  ALenum state;
234
235  alGetSourcei(this->source, AL_SOURCE_STATE, &state);
236
237  return (state == AL_PLAYING);
238}
239
240
241
242////////////////////////
243// INTERNAL FUNCTIONS //
244////////////////////////
245/**
246 * @brief creates a Thread for Playing back the music even if the rest of the Engine is slow
247 * @param oggPlayer the OggPlayer to play back
248 * @returns -1 on error.
249 */
250int OggPlayer::musicThread(void* oggPlayer)
251{
252  if (oggPlayer == NULL)
253    return -1;
254  OggPlayer* ogg = (OggPlayer*)oggPlayer;
255
256  PRINTF(4)("STARTIG AUDIO THREAD\n");
257  while (ogg->state & OggPlayer::Playing)
258  {
259    SDL_mutexP(ogg->musicMutex);
260    ogg->update();
261    SDL_mutexV(ogg->musicMutex);
262    SDL_Delay(1);
263  }
264  PRINTF(4)("End the AudioThread\n");
265}
266
267
268/**
269 * @brief plays back the sound
270 * @return true if running, false otherwise
271 */
272bool OggPlayer::playback()
273{
274  if (!(this->state & OggPlayer::FileOpened))
275    return false;
276
277  if(this->state & OggPlayer::Playing)
278    return true;
279  this->state |= OggPlayer::Playing;
280
281  SDL_mutexP(this->musicMutex);
282  if(!this->stream(this->buffers[0]) || !this->stream(this->buffers[1]))
283  {
284    SDL_mutexV(this->musicMutex);
285    this->state &= ~OggPlayer::Playing;
286    return false;
287  }
288
289  alSourceQueueBuffers(this->source, 2, this->buffers);
290  if (DEBUG >= 3)
291    SoundEngine::checkError("OggPlayer::playback()::alSourceQueueBuffers", __LINE__);
292
293  alSourcePlay(this->source);
294  if (DEBUG >= 3)
295    SoundEngine::checkError("OggPlayer::playback()::alSourcePlay", __LINE__);
296  SDL_mutexV(this->musicMutex);
297  return true;
298}
299
300
301/**
302 * @brief waits for the AudioThread to be finished.
303 */
304void OggPlayer::suspend()
305{
306  if (this->musicThreadID != NULL)
307  {
308    assert (!(this->state & Playing));
309    SDL_WaitThread(this->musicThreadID, NULL);
310    this->musicThreadID = NULL;
311  }
312  if (this->state & OggPlayer::SourceAllocated)
313  {
314    alSourceStop(this->source);
315    alSourcei(this->source, AL_BUFFER, 0);
316  }
317}
318
319/**
320 * @brief updates the stream, this has to be done every few parts of a second, for sound-consistency
321 * @returns true, if the Sound is playing flawlessly
322 */
323bool OggPlayer::update()
324{
325  int processed = 0;
326  bool active = true;
327
328  alGetSourcei(source, AL_BUFFERS_PROCESSED, &processed);
329  if (DEBUG >= 3)
330    SoundEngine::checkError("OggPlayer::update()::alGetSourceI", __LINE__);
331
332  while(processed--)
333  {
334    ALuint buffer;
335
336    alSourceUnqueueBuffers(source, 1, &buffer);
337    if (DEBUG >= 3)
338      SoundEngine::checkError("OggPlayer::update()::unqueue", __LINE__);
339
340    active = stream(buffer);
341
342    alSourceQueueBuffers(source, 1, &buffer);
343    if (DEBUG >= 3)
344      SoundEngine::checkError("OggPlayer::update()::queue", __LINE__);
345  }
346
347  return active;
348}
349
350/**
351 * @brief gets a new Stream from buffer
352 * @param buffer the buffer to get the stream from
353 * @return true, if everything worked as planed
354 */
355bool OggPlayer::stream(ALuint buffer)
356{
357  if (unlikely(!(this->state & Playing)))
358    return false;
359  char pcm[OGG_PLAYER_BUFFER_SIZE];
360  int  size = 0;
361  int  section;
362  int  result;
363
364  while(size < OGG_PLAYER_BUFFER_SIZE)
365  {
366    result = ov_read(&this->oggStream, pcm + size, OGG_PLAYER_BUFFER_SIZE - size, 0, 2, 1, &section);
367
368    if(result > 0)
369      size += result;
370    else if(result < 0)
371      throw getVorbisError(result);
372    else /* eof */
373      ov_time_seek(&this->oggStream, 0.0);
374  }
375
376  if(size == 0)
377    return false;
378
379  alBufferData(buffer, format, pcm, size, vorbisInfo->rate);
380  if (DEBUG >= 3)
381    SoundEngine::checkError("OggPlayer::stream()::BUFFER", __LINE__);
382
383  return true;
384}
385
386
387/**
388 * @brief releases a stream
389 */
390void OggPlayer::release()
391{
392  if (this->state & OggPlayer::SourceAllocated)
393  {
394    assert(alIsSource(this->source));
395    if (this->state & OggPlayer::Playing);
396    {
397      // Kill the Music Thread.
398      this->state &= ~OggPlayer::Playing;
399      this->suspend();
400
401      SoundEngine::checkError("OggPlayer::release()::alSourceStop", __LINE__);
402    }
403    empty();
404    alSourcei(this->source, AL_BUFFER, 0);
405    SoundEngine::getInstance()->pushALSource(this->source);
406    this->source = 0;
407    this->state &= ~SourceAllocated;
408  }
409  if (this->state & OggPlayer::BuffersAllocated)
410  {
411    assert (this->buffers[0] != 0 && this->buffers[1] != 0);
412    alDeleteBuffers(2, buffers);
413    SoundEngine::checkError("OggPlayer::release()::alDeleteBuffers", __LINE__);
414    this->buffers[0] = 0;
415    this->buffers[1] = 0;
416    this->state &= ~OggPlayer::BuffersAllocated;
417  }
418
419  if (this->state & OggPlayer::FileOpened)
420  {
421    ov_clear(&oggStream);
422    this->state &= ~OggPlayer::FileOpened;
423  }
424
425}
426
427
428/**
429 * @brief empties the buffers
430 */
431void OggPlayer::empty()
432{
433  int queued;
434
435  alGetSourcei(source, AL_BUFFERS_QUEUED, &queued);
436
437  while(queued--)
438  {
439    ALuint buffer;
440
441    alSourceUnqueueBuffers(source, 1, &buffer);
442    SoundEngine::checkError("OggPlayer::empty()::unqueue Buffers", __LINE__);
443  }
444}
445
446
447/////////////////////
448// DEBUG FUNCTIONS //
449/////////////////////
450/**
451 * displays some info about the ogg-file
452 */
453void OggPlayer::debug() const
454{
455  cout
456  << "version         " << vorbisInfo->version         << "\n"
457  << "channels        " << vorbisInfo->channels        << "\n"
458  << "rate (hz)       " << vorbisInfo->rate            << "\n"
459  << "bitrate upper   " << vorbisInfo->bitrate_upper   << "\n"
460  << "bitrate nominal " << vorbisInfo->bitrate_nominal << "\n"
461  << "bitrate lower   " << vorbisInfo->bitrate_lower   << "\n"
462  << "bitrate window  " << vorbisInfo->bitrate_window  << "\n"
463  << "\n"
464  << "vendor " << vorbisComment->vendor << "\n";
465
466  for(int i = 0; i < vorbisComment->comments; i++)
467    cout << "   " << vorbisComment->user_comments[i] << "\n";
468
469  cout << endl;
470}
471
472
473void OggPlayer::printState() const
474{
475  PRINTF(0)("OggPlayer is in the following States: ");
476  if (this->state & OggPlayer::FileOpened)
477    PRINT(0)("FileOpened ");
478  if (this->state & OggPlayer::SourceAllocated)
479    PRINT(0)("SourceAllocated ");
480  if (this->state & OggPlayer::BuffersAllocated)
481    PRINT(0)("BuffersAllocated ");
482  if (this->state & OggPlayer::Stopped)
483    PRINT(0)("Stopped ");
484  if (this->state & OggPlayer::Playing)
485    PRINT(0)("Playing ");
486  if (this->state & OggPlayer::Paused)
487    PRINT(0)("Paused ");
488  if (this->state & OggPlayer::Error)
489    PRINT(0)("Error ");
490  PRINT(0)("\n");
491}
492
493/**
494 * returns errors
495 * @param code the error-code
496 * @return the error as a String
497 */
498const char* OggPlayer::getVorbisError(int code)
499{
500  switch(code)
501  {
502    case OV_EREAD:
503      return ("Read from media.");
504    case OV_ENOTVORBIS:
505      return ("Not Vorbis data.");
506    case OV_EVERSION:
507      return ("Vorbis version mismatch.");
508    case OV_EBADHEADER:
509      return ("Invalid Vorbis header.");
510    case OV_EFAULT:
511      return ("Internal logic fault (bug or heap/stack corruption.");
512    default:
513      return ("Unknown Ogg error.");
514  }
515}
516
Note: See TracBrowser for help on using the repository browser.