Ticket #8108: ogg.diff

Makefile

@@ -36 +36 @@
 # DEFINES += -DDUMP_SCRIPTS
 
 # Uncomment this to activate the MAD lib for compressed sound files
-DEFINES += -DCOMPRESSED_SOUND_FILE
+DEFINES += -DUSE_MAD
 LIBS    += -lmad
+
+# Uncomment this to activate the Ogg Vorbis lib for compressed sound files
+DEFINES += -DUSE_VORBIS
+LIBS    += -lvorbisfile -lvorbis
 
 # Uncomment this to activate the ALSA lib for midi
 # DEFINES += -DUSE_ALSA

common/scummsys.h

@@ -31 +31 @@
 const bool true(1), false(0);
 #endif  /*  HAVE_NO_BOOL  */
 
+#if defined(USE_MAD) || defined(USE_VORBIS)
+#define COMPRESSED_SOUND_FILE
+#endif
+
 #if defined(_MSC_VER)
   
   //#pragma warning (disable: 4244)

scumm/sound.cpp

@@ -738 +738 @@
         int rate, comp;
         byte *data;
 
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
         if (file_size > 0) {
                 data = (byte *)calloc(file_size + MAD_BUFFER_GUARD, 1);
 
@@ -1116 +1116 @@
 }
 
 int Sound::playSfxSound_MP3(void *sound, uint32 size) {
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
         if (_soundsPaused)
                 return -1;
         return _scumm->_mixer->playMP3(NULL, sound, size, SoundMixer::FLAG_AUTOFREE);
@@ -1219 +1219 @@
         char track_name[1024];
         File * file = new File();
         int current_index;
-        struct mad_stream stream;
-        struct mad_frame frame;
-        unsigned char buffer[8192];
-        unsigned int buflen = 0;
-        int count = 0;
 
         // See if we find the track in the cache
         for (i = 0; i < CACHE_TRACKS; i++)
                 if (_cached_tracks[i] == track) {
-                        if (_mp3_tracks[i])
+                        if (_track_info[i])
                                 return i;
                         else
                                 return -1;
@@ -1237 +1232 @@
         _current_cache %= CACHE_TRACKS;
 
         // Not found, see if it exists
+
+        // First, delete the previous track info object
+        delete _track_info[current_index];
+        _track_info[current_index] = NULL;
+
+        _cached_tracks[current_index] = track;
+
+#ifdef USE_MAD
         sprintf(track_name, "track%d.mp3", track);
         file->open(track_name, _scumm->getGameDataPath());
-        _cached_tracks[current_index] = track;
 
-        /* First, close the previous file */
-        if (_mp3_tracks[current_index])
-                _mp3_tracks[current_index]->close();
-
-        _mp3_tracks[current_index] = NULL;
-        if (file->isOpen() == false) {
-                // This warning is pretty pointless.
-                debug(1, "Track %d not available in mp3 format", track);
+        if (file->isOpen()) {
+                _track_info[current_index] = new MP3TrackInfo(file);
+                if (_track_info[current_index]->error()) {
+                        delete _track_info[current_index];
+                        _track_info[current_index] = NULL;
+                        return -1;
+                }
+                return current_index;
+        }
+#endif
+
+#ifdef USE_VORBIS
+        sprintf(track_name, "track%d.ogg", track);
+        file->open(track_name, _scumm->getGameDataPath());
+
+        if (file->isOpen()) {
+                _track_info[current_index] = new VorbisTrackInfo(file);
+                if (_track_info[current_index]->error()) {
+                        delete _track_info[current_index];
+                        _track_info[current_index] = NULL;
+                        return -1;
+                }
+                return current_index;
+        }
+#endif
+
+        debug(1, "Track %d not available in compressed format", track);
+        return -1;
+}
+
+int Sound::playMP3CDTrack(int track, int num_loops, int start, int delay) {
+        int index;
+        _scumm->_vars[_scumm->VAR_MI1_TIMER] = 0;
+
+        if (_soundsPaused)
+                return 0;
+
+        if ((num_loops == 0) && (start == 0)) {
+                return 0;
+        }
+
+        index = getCachedTrack(track);
+        if (index < 0)
+                return -1;
+
+        if (_dig_cd_playing)
+                _scumm->_mixer->stop(_dig_cd_index);
+        _dig_cd_index = _track_info[index]->play(_scumm->_mixer, start, delay);
+        _dig_cd_playing = true;
+        _dig_cd_track = track;
+        _dig_cd_num_loops = num_loops;
+        _dig_cd_start = start;
+        _dig_cd_delay = delay;
+        return 0;
+}
+
+int Sound::stopMP3CD() {
+        if (_dig_cd_playing == true) {
+                _scumm->_mixer->stop(_dig_cd_index);
+                _dig_cd_playing = false;
+                _dig_cd_track = 0;
+                _dig_cd_num_loops = 0;
+                _dig_cd_start = 0;
+                _dig_cd_delay = 0;
+                return 0;
+        }
+        return -1;
+}
+
+int Sound::pollMP3CD() {
+        if (_dig_cd_playing == true)
+                return 1;
+        return 0;
+}
+
+int Sound::updateMP3CD() {
+        if (_dig_cd_playing == false)
+                return -1;
+
+        if (_scumm->_mixer->_channels[_dig_cd_index] == NULL) {
+                warning("Error in MP3 decoding");
                 return -1;
         }
 
+        if (_scumm->_mixer->_channels[_dig_cd_index]->soundFinished()) {
+                if (_dig_cd_num_loops == -1 || --_dig_cd_num_loops > 0)
+                        playMP3CDTrack(_dig_cd_track, _dig_cd_num_loops, _dig_cd_start, _dig_cd_delay);
+                else
+                        stopMP3CD();
+        }
+
+        return 0;
+}
+
+#ifdef USE_MAD
+Sound::MP3TrackInfo::MP3TrackInfo(File *file) {
+        struct mad_stream stream;
+        struct mad_frame frame;
+        unsigned char buffer[8192];
+        unsigned int buflen = 0;
+        int count = 0;
+
         // Check the format and bitrate
         mad_stream_init(&stream);
         mad_frame_init(&frame);
@@ -1263 +1356 @@
                         bytes = file->read(buffer + buflen, sizeof(buffer) - buflen);
                         if (bytes <= 0) {
                                 if (bytes == -1) {
-                                        warning("Invalid format for track %d", track);
+                                        warning("Invalid file format");
                                         goto error;
                                 }
                                 break;
@@ -1295 +1388 @@
         }
 
         if (count)
-                memcpy(&_mad_header[current_index], &frame.header, sizeof(mad_header));
+                memcpy(&_mad_header, &frame.header, sizeof(mad_header));
         else {
-                warning("Invalid format for track %d", track);
+                warning("Invalid file format");
                 goto error;
         }
 
         mad_frame_finish(&frame);
         mad_stream_finish(&stream);
         // Get file size
-        _mp3_size[current_index] = file->size();
-        _mp3_tracks[current_index] = file;
-        
-        return current_index;
+        _size = file->size();
+        _file = file;
+        _error_flag = false;
+        return;
 
  error:
         mad_frame_finish(&frame);
         mad_stream_finish(&stream);
+        _error_flag = true;
         delete file;
-
-        return -1;
 }
 
-int Sound::playMP3CDTrack(int track, int num_loops, int start, int delay) {
-        int index;
+int Sound::MP3TrackInfo::play(SoundMixer *mixer, int start, int delay) {
         unsigned int offset;
         mad_timer_t duration;
-        _scumm->_vars[_scumm->VAR_MI1_TIMER] = 0;
-
-        if (_soundsPaused)
-                return 0;
-
-        if ((num_loops == 0) && (start == 0)) {
-                return 0;
-        }
-
-        index = getCachedTrack(track);
-        if (index < 0)
-                return -1;
 
         // Calc offset. As all bitrates are in kilobit per seconds, the division by 200 is always exact
-        offset = (start * (_mad_header[index].bitrate / (8 * 25))) / 3;
+        offset = (start * (_mad_header.bitrate / (8 * 25))) / 3;
 
         // Calc delay
         if (!delay) {
-                mad_timer_set(&duration, (_mp3_size[index] * 8) / _mad_header[index].bitrate,
-                              (_mp3_size[index] * 8) % _mad_header[index].bitrate, _mad_header[index].bitrate);
+                mad_timer_set(&duration, (_size * 8) / _mad_header.bitrate,
+                              (_size * 8) % _mad_header.bitrate, _mad_header.bitrate);
         } else {
                 mad_timer_set(&duration, delay / 75, delay % 75, 75);
         }       
 
         // Go
-        _mp3_tracks[index]->seek(offset, SEEK_SET);
+        _file->seek(offset, SEEK_SET);
 
-        if (_mp3_cd_playing == true)
-                _scumm->_mixer->stop(_mp3_index);               
-        _mp3_index = _scumm->_mixer->playMP3CDTrack(NULL, _mp3_tracks[index], duration);
-        _mp3_cd_playing = true;
-        _mp3_cd_track = track;
-        _mp3_cd_num_loops = num_loops;
-        _mp3_cd_start = start;
-        _mp3_cd_delay = delay;
-        return 0;
+        return mixer->playMP3CDTrack(NULL, _file, duration);
 }
 
-int Sound::stopMP3CD() {
-        if (_mp3_cd_playing == true) {
-                _scumm->_mixer->stop(_mp3_index);
-                _mp3_cd_playing = false;
-                _mp3_cd_track = 0;
-                _mp3_cd_num_loops = 0;
-                _mp3_cd_start = 0;
-                _mp3_cd_delay = 0;
-                return 0;
+Sound::MP3TrackInfo::~MP3TrackInfo() {
+        if (! _error_flag)
+                _file->close();
+}
+
+#endif
+
+#ifdef USE_VORBIS
+// These are wrapper functions to allow using a File object to
+// provide data to the OggVorbis_File object.
+
+struct file_info {
+        File *file;
+        int start, curr_pos;
+        size_t len;
+};
+
+static size_t read_wrap(void *ptr, size_t size, size_t nmemb, void *datasource) {
+        file_info *f = (file_info *) datasource;
+        int result;
+
+        nmemb *= size;
+        if (f->curr_pos > (int) f->len)
+                nmemb = 0;
+        else if (nmemb > f->len - f->curr_pos)
+                nmemb = f->len - f->curr_pos;
+        result = f->file->read(ptr, nmemb);
+        if (result == -1) {
+                f->curr_pos = f->file->pos() - f->start;
+                return (size_t) -1;
+        }
+        else {
+                f->curr_pos += result;
+                return result / size;
         }
-        return -1;
 }
 
-int Sound::pollMP3CD() {
-        if (_mp3_cd_playing == true)
-                return 1;
+static int seek_wrap(void *datasource, ogg_int64_t offset, int whence) {
+        file_info *f = (file_info *) datasource;
+
+        if (whence == SEEK_SET)
+                offset += f->start;
+        else if (whence == SEEK_END) {
+                offset += f->start + f->len;
+                whence = SEEK_SET;
+        }
+
+        f->file->seek(offset, whence);
+        f->curr_pos = f->file->pos() - f->start;
+        return f->curr_pos;
+}
+
+static int close_wrap(void *datasource) {
+        file_info *f = (file_info *) datasource;
+
+        f->file->close();
+        delete f;
         return 0;
 }
 
-int Sound::updateMP3CD() {
-        if (_mp3_cd_playing == false)
-                return -1;
+static long tell_wrap(void *datasource) {
+        file_info *f = (file_info *) datasource;
 
-        if (_scumm->_mixer->_channels[_mp3_index] == NULL) {
-                warning("Error in MP3 decoding");
-                return -1;
+        return f->file->pos();
+}
+
+static ov_callbacks File_wrap = {
+        read_wrap, seek_wrap, close_wrap, tell_wrap
+};
+
+Sound::VorbisTrackInfo::VorbisTrackInfo(File *file) {
+        file_info *f = new file_info;
+
+        f->file = file;
+        f->start = 0;
+        f->len = file->size();
+        f->curr_pos = file->pos();
+
+        if (ov_open_callbacks((void *) f, &_ov_file, NULL, 0, File_wrap) < 0) {
+                warning("Invalid file format");
+                _error_flag = true;
+                delete f;
+                delete file;
         }
+        else {
+                _error_flag = false;
+                _file = file;
 
-        if (_scumm->_mixer->_channels[_mp3_index]->soundFinished()) {
-                if (_mp3_cd_num_loops == -1 || --_mp3_cd_num_loops > 0)
-                        playMP3CDTrack(_mp3_cd_track, _mp3_cd_num_loops, _mp3_cd_start, _mp3_cd_delay);
-                else
-                        stopMP3CD();
+                // Check the file format
+                if (ov_info(&_ov_file, -1)->rate != 22050)
+                        warning("Vorbis code currently only supports files encoded at 22050 Hz");
         }
+}
 
-        return 0;
+int Sound::VorbisTrackInfo::play(SoundMixer *mixer, int start, int delay) {
+        ov_time_seek(&_ov_file, start / 75.0);
+        return mixer->playVorbisCDTrack(NULL, &_ov_file, delay / 75.0);
+}
+
+Sound::VorbisTrackInfo::~VorbisTrackInfo() {
+        if (! _error_flag) {
+                ov_clear(&_ov_file);
+                delete _file;
+        }
 }
+
+#endif
+
 #endif

scumm/sound.h

@@ -65 +65 @@
         uint16 _mouthSyncTimes[52];
         uint _curSoundPos;
 
+#ifdef COMPRESSED_SOUND_FILE
         MP3OffsetTable *offset_table;   // SO3 MP3 compressed audio
         int num_sound_effects;          // SO3 MP3 compressed audio
-#ifdef COMPRESSED_SOUND_FILE
 
         #define CACHE_TRACKS 10
 
         /* used for mp3 CD music */
 
         int _cached_tracks[CACHE_TRACKS];
-        struct mad_header _mad_header[CACHE_TRACKS];
-        long _mp3_size[CACHE_TRACKS];
-        File *_mp3_tracks[CACHE_TRACKS];
-        int _mp3_index;
-        int _mp3_cd_track;
-        int _mp3_cd_start;
-        int _mp3_cd_delay;
-        int _mp3_cd_num_loops;
-        bool _mp3_cd_playing;
+        int _dig_cd_index;
+        int _dig_cd_track;
+        int _dig_cd_start;
+        int _dig_cd_delay;
+        int _dig_cd_num_loops;
+        bool _dig_cd_playing;
+
+        class DigitalTrackInfo {
+        public:
+                virtual bool error() = 0;
+                virtual int play(SoundMixer *mixer, int start, int delay) = 0;
+                virtual ~DigitalTrackInfo() { }
+        };
+
+        DigitalTrackInfo *_track_info[CACHE_TRACKS];
+
+#ifdef USE_MAD
+        class MP3TrackInfo : public DigitalTrackInfo {
+        private:
+                struct mad_header _mad_header;
+                long _size;
+                File *_file;
+                bool _error_flag;
+
+        public:
+                MP3TrackInfo(File *file);
+                ~MP3TrackInfo();
+                bool error() { return _error_flag; }
+                int play(SoundMixer *mixer, int start, int delay);
+        };
+#endif
+
+#ifdef USE_VORBIS
+        class VorbisTrackInfo : public DigitalTrackInfo {
+        private:
+                File *_file;
+                OggVorbis_File _ov_file;
+                bool _error_flag;
+
+        public:
+                VorbisTrackInfo(File *file);
+                ~VorbisTrackInfo();
+                bool error() { return _error_flag; }
+                int play(SoundMixer *mixer, int start, int delay);
+        };
+#endif
+
 #endif
 
         Scumm * _scumm;

sound/mixer.cpp

@@ -120 +120 @@
         _beginSlots = index;
 }
 
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
 int SoundMixer::playMP3(PlayingSoundHandle * handle, void *sound, uint32 size, byte flags) {
         for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
                 if (_channels[i] == NULL) {
@@ -144 +144 @@
 }
 #endif
 
+#ifdef USE_VORBIS
+int SoundMixer::playVorbisCDTrack(PlayingSoundHandle * handle, OggVorbis_File * ov_file, double duration) {
+        for (int i = _beginSlots; i != NUM_CHANNELS; i++) {
+                if (_channels[i] == NULL) {
+                        return insertAt(handle, i, new ChannelVorbis(this, ov_file, duration));
+                }
+        }
+
+        warning("SoundMixer::out of mixer slots");
+        return -1;
+}
+#endif
+
 void SoundMixer::mix(int16 *buf, uint len) {
         if (_paused) {
                 memset(buf, 0, 2 * len * sizeof(int16));
@@ -713 +726 @@
         delete this;
 }
 
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
 SoundMixer::ChannelMP3::ChannelMP3(SoundMixer * mixer, void * sound, uint size, byte flags) {
         _mixer = mixer;
         _flags = flags;
@@ -959 +972 @@
         mad_stream_finish(&_stream);
 
         delete this;
+}
+
+#endif
+
+#ifdef USE_VORBIS
+SoundMixer::ChannelVorbis::ChannelVorbis(SoundMixer * mixer, OggVorbis_File * ov_file, double duration) {
+        _mixer = mixer;
+        _ov_file = ov_file;
+
+        if (duration)
+                _end_pos = ov_time_tell(ov_file) + duration;
+        else
+                _end_pos = 0;
+
+        _eof_flag = false;
+        _toBeDestroyed = false;
+}
+
+void SoundMixer::ChannelVorbis::mix(int16 * data, uint len) {
+        if (_toBeDestroyed) {
+                realDestroy();
+                return;
+        }
+
+        if (_eof_flag) {
+                memset(data, 0, sizeof(int16) * 2 * len);
+                return;
+        }
+
+        int channels = ov_info(_ov_file, -1)->channels;
+        uint len_left = len * channels * 2;
+        int16 *samples = new int16[len_left / 2];
+        char *read_pos = (char *) samples;
+        int volume = _mixer->_musicVolume;
+
+        // Read the samples
+        while (len_left > 0) {
+                long result = ov_read(_ov_file, read_pos, len_left,
+#ifdef SCUMM_BIG_ENDIAN
+                                      1,
+#else
+                                      0,
+#endif
+                                      2, 1, NULL);
+                if (result == 0) {
+                        _eof_flag = true;
+                        memset(read_pos, 0, len_left);
+                        break;
+                }
+                else if (result < 0) {
+                        debug(1, "Decode error %d in Vorbis file", result);
+                        // Don't delete it yet, that causes problems in
+                        // the CD player emulation code.
+                        _eof_flag = true;
+                        memset(read_pos, 0, len_left);
+                        break;
+                }
+                else {
+                        len_left -= result;
+                        read_pos += result;
+                }
+        }
+
+        // Mix the samples in
+        for (uint i = 0; i < len; i++) {
+                int16 sample = (int16) ((int32) samples[i * channels] * volume / 128);
+                *data++ += sample;
+                if (channels > 1)
+                        sample = (int16) ((int32) samples[i * channels + 1] * volume / 128);
+                *data++ += sample;
+        }
+
+        delete [] samples;
+}
+
+void SoundMixer::ChannelVorbis::realDestroy() {
+        _mixer->unInsert(this);
+        delete this;
+}
+
+bool SoundMixer::ChannelVorbis::soundFinished() {
+        return _eof_flag || (_end_pos > 0 &&
+                             ov_time_tell(_ov_file) >= _end_pos);
 }
 
 #endif

sound/mixer.h

@@ -25 +25 @@
 
 #include <stdio.h>
 
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
 #include <mad.h>
 #endif
 
+#ifdef USE_VORBIS
+#include <vorbis/vorbisfile.h>
+#endif
+
 #include "common/scummsys.h"
 #include "common/system.h"
 
@@ -92 +96 @@
                 void realDestroy();
         };
 
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
 
         class ChannelMP3 : public Channel {
                 SoundMixer * _mixer;
@@ -138 +142 @@
 
 #endif
 
+#ifdef USE_VORBIS
+        class ChannelVorbis : public Channel {
+                SoundMixer * _mixer;
+                OggVorbis_File * _ov_file;
+                double _end_pos;
+                bool _eof_flag;
+
+        public:
+                ChannelVorbis(SoundMixer * mixer, OggVorbis_File * ov_file, double duration);
+
+                void mix(int16 * data, uint len);
+                void realDestroy();
+                bool soundFinished();
+        };
+#endif
+
         static void onGenerateSamples(void * s, byte * samples, int len);
 
 public:
@@ -187 +207 @@
         int playRaw(PlayingSoundHandle * handle, void * sound, uint32 size, uint rate, byte flags, int id);
         int playStream(PlayingSoundHandle * handle, int index, void * sound, uint32 size, uint rate,
                                                                         byte flags, int32 timeout = 3, int32 buffer_size = 2000000);
-#ifdef COMPRESSED_SOUND_FILE
+#ifdef USE_MAD
         int playMP3(PlayingSoundHandle * handle, void * sound, uint32 size, byte flags);
         int playMP3CDTrack(PlayingSoundHandle * handle, File * file, mad_timer_t duration);
+#endif
+#ifdef USE_VORBIS
+        int playVorbisCDTrack(PlayingSoundHandle * handle, OggVorbis_File * ov_file, double duration);
 #endif
 
         /* Premix procedure, useful when using fmopl adlib */