src/sound.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file sound.cpp Handling of playing sounds. */
   9
  10 #include "stdafx.h"
  11 #include "landscape.h"
  12 #include "mixer.h"
  13 #include "newgrf_sound.h"
  14 #include "random_access_file_type.h"
  15 #include "window_gui.h"
  16 #include "vehicle_base.h"
  17
  18 /* The type of set we're replacing */
  19 #define SET_TYPE "sounds"
  20 #include "base_media_func.h"
  21
  22 #include "safeguards.h"
  23
  24 static SoundEntry _original_sounds[ORIGINAL_SAMPLE_COUNT];
  25
  26 static void OpenBankFile(const std::string &filename)
  27 {
  28         /**
  29          * The sound file for the original sounds, i.e. those not defined/overridden by a NewGRF.
  30          * Needs to be kept alive during the game as _original_sounds[n].file refers to this.
  31          */
  32         static std::unique_ptr<RandomAccessFile> original_sound_file;
  33
  34         memset(_original_sounds, 0, sizeof(_original_sounds));
  35
  36         /* If there is no sound file (nosound set), don't load anything */
  37         if (filename.empty()) return;
  38
  39         original_sound_file.reset(new RandomAccessFile(filename, BASESET_DIR));
  40         size_t pos = original_sound_file->GetPos();
  41         uint count = original_sound_file->ReadDword();
  42
  43         /* The new format has the highest bit always set */
  44         bool new_format = HasBit(count, 31);
  45         ClrBit(count, 31);
  46         count /= 8;
  47
  48         /* Simple check for the correct number of original sounds. */
  49         if (count != ORIGINAL_SAMPLE_COUNT) {
  50                 /* Corrupt sample data? Just leave the allocated memory as those tell
  51                  * there is no sound to play (size = 0 due to calloc). Not allocating
  52                  * the memory disables valid NewGRFs that replace sounds. */
  53                 Debug(misc, 6, "Incorrect number of sounds in '{}', ignoring.", filename);
  54                 return;
  55         }
  56
  57         original_sound_file->SeekTo(pos, SEEK_SET);
  58
  59         for (uint i = 0; i != ORIGINAL_SAMPLE_COUNT; i++) {
  60                 _original_sounds[i].file = original_sound_file.get();
  61                 _original_sounds[i].file_offset = GB(original_sound_file->ReadDword(), 0, 31) + pos;
  62                 _original_sounds[i].file_size = original_sound_file->ReadDword();
  63         }
  64
  65         for (uint i = 0; i != ORIGINAL_SAMPLE_COUNT; i++) {
  66                 SoundEntry *sound = &_original_sounds[i];
  67                 char name[255];
  68
  69                 original_sound_file->SeekTo(sound->file_offset, SEEK_SET);
  70
  71                 /* Check for special case, see else case */
  72                 original_sound_file->ReadBlock(name, original_sound_file->ReadByte()); // Read the name of the sound
  73                 if (new_format || strcmp(name, "Corrupt sound") != 0) {
  74                         original_sound_file->SeekTo(12, SEEK_CUR); // Skip past RIFF header
  75
  76                         /* Read riff tags */
  77                         for (;;) {
  78                                 uint32_t tag = original_sound_file->ReadDword();
  79                                 uint32_t size = original_sound_file->ReadDword();
  80
  81                                 if (tag == ' tmf') {
  82                                         original_sound_file->ReadWord();                          // wFormatTag
  83                                         sound->channels = original_sound_file->ReadWord();        // wChannels
  84                                         sound->rate     = original_sound_file->ReadDword();       // samples per second
  85                                         if (!new_format) sound->rate = 11025;                      // seems like all old samples should be played at this rate.
  86                                         original_sound_file->ReadDword();                         // avg bytes per second
  87                                         original_sound_file->ReadWord();                          // alignment
  88                                         sound->bits_per_sample = original_sound_file->ReadByte(); // bits per sample
  89                                         original_sound_file->SeekTo(size - (2 + 2 + 4 + 4 + 2 + 1), SEEK_CUR);
  90                                 } else if (tag == 'atad') {
  91                                         sound->file_size = size;
  92                                         sound->file = original_sound_file.get();
  93                                         sound->file_offset = original_sound_file->GetPos();
  94                                         break;
  95                                 } else {
  96                                         sound->file_size = 0;
  97                                         break;
  98                                 }
  99                         }
 100                 } else {
 101                         /*
 102                          * Special case for the jackhammer sound
 103                          * (name in sample.cat is "Corrupt sound")
 104                          * It's no RIFF file, but raw PCM data
 105                          */
 106                         sound->channels = 1;
 107                         sound->rate = 11025;
 108                         sound->bits_per_sample = 8;
 109                         sound->file = original_sound_file.get();
 110                         sound->file_offset = original_sound_file->GetPos();
 111                 }
 112         }
 113 }
 114
 115 static bool SetBankSource(MixerChannel *mc, const SoundEntry *sound)
 116 {
 117         assert(sound != nullptr);
 118
 119         /* Check for valid sound size. */
 120         if (sound->file_size == 0 || sound->file_size > ((size_t)-1) - 2) return false;
 121
 122         int8_t *mem = MallocT<int8_t>(sound->file_size + 2);
 123         /* Add two extra bytes so rate conversion can read these
 124          * without reading out of its input buffer. */
 125         mem[sound->file_size    ] = 0;
 126         mem[sound->file_size + 1] = 0;
 127
 128         RandomAccessFile *file = sound->file;
 129         file->SeekTo(sound->file_offset, SEEK_SET);
 130         file->ReadBlock(mem, sound->file_size);
 131
 132         /* 16-bit PCM WAV files should be signed by default */
 133         if (sound->bits_per_sample == 8) {
 134                 for (uint i = 0; i != sound->file_size; i++) {
 135                         mem[i] += -128; // Convert unsigned sound data to signed
 136                 }
 137         }
 138
 139 #if TTD_ENDIAN == TTD_BIG_ENDIAN
 140         if (sound->bits_per_sample == 16) {
 141                 uint num_samples = sound->file_size / 2;
 142                 int16_t *samples = (int16_t *)mem;
 143                 for (uint i = 0; i < num_samples; i++) {
 144                         samples[i] = BSWAP16(samples[i]);
 145                 }
 146         }
 147 #endif
 148
 149         assert(sound->bits_per_sample == 8 || sound->bits_per_sample == 16);
 150         assert(sound->channels == 1);
 151         assert(sound->file_size != 0 && sound->rate != 0);
 152
 153         MxSetChannelRawSrc(mc, mem, sound->file_size, sound->rate, sound->bits_per_sample == 16);
 154
 155         return true;
 156 }
 157
 158 void InitializeSound()
 159 {
 160         Debug(misc, 1, "Loading sound effects...");
 161         OpenBankFile(BaseSounds::GetUsedSet()->files->filename);
 162 }
 163
 164 /* Low level sound player */
 165 static void StartSound(SoundID sound_id, float pan, uint volume)
 166 {
 167         if (volume == 0) return;
 168
 169         SoundEntry *sound = GetSound(sound_id);
 170         if (sound == nullptr) return;
 171
 172         /* NewGRF sound that wasn't loaded yet? */
 173         if (sound->rate == 0 && sound->file != nullptr) {
 174                 if (!LoadNewGRFSound(sound)) {
 175                         /* Mark as invalid. */
 176                         sound->file = nullptr;
 177                         return;
 178                 }
 179         }
 180
 181         /* Empty sound? */
 182         if (sound->rate == 0) return;
 183
 184         MixerChannel *mc = MxAllocateChannel();
 185         if (mc == nullptr) return;
 186
 187         if (!SetBankSource(mc, sound)) return;
 188
 189         /* Apply the sound effect's own volume. */
 190         volume = sound->volume * volume;
 191
 192         MxSetChannelVolume(mc, volume, pan);
 193         MxActivateChannel(mc);
 194 }
 195
 196
 197 static const byte _vol_factor_by_zoom[] = {255, 255, 255, 190, 134, 87};
 198 static_assert(lengthof(_vol_factor_by_zoom) == ZOOM_LVL_END);
 199
 200 static const byte _sound_base_vol[] = {
 201         128,  90, 128, 128, 128, 128, 128, 128,
 202         128,  90,  90, 128, 128, 128, 128, 128,
 203         128, 128, 128,  80, 128, 128, 128, 128,
 204         128, 128, 128, 128, 128, 128, 128, 128,
 205         128, 128,  90,  90,  90, 128,  90, 128,
 206         128,  90, 128, 128, 128,  90, 128, 128,
 207         128, 128, 128, 128,  90, 128, 128, 128,
 208         128,  90, 128, 128, 128, 128, 128, 128,
 209         128, 128,  90,  90,  90, 128, 128, 128,
 210          90,
 211 };
 212
 213 static const byte _sound_idx[] = {
 214          2,  3,  4,  5,  6,  7,  8,  9,
 215         10, 11, 12, 13, 14, 15, 16, 17,
 216         18, 19, 20, 21, 22, 23, 24, 25,
 217         26, 27, 28, 29, 30, 31, 32, 33,
 218         34, 35, 36, 37, 38, 39, 40,  0,
 219          1, 41, 42, 43, 44, 45, 46, 47,
 220         48, 49, 50, 51, 52, 53, 54, 55,
 221         56, 57, 58, 59, 60, 61, 62, 63,
 222         64, 65, 66, 67, 68, 69, 70, 71,
 223         72,
 224 };
 225
 226 void SndCopyToPool()
 227 {
 228         SoundEntry *sound = AllocateSound(ORIGINAL_SAMPLE_COUNT);
 229         for (uint i = 0; i < ORIGINAL_SAMPLE_COUNT; i++) {
 230                 sound[i] = _original_sounds[_sound_idx[i]];
 231                 sound[i].volume = _sound_base_vol[i];
 232                 sound[i].priority = 0;
 233         }
 234 }
 235
 236 /**
 237  * Decide 'where' (between left and right speaker) to play the sound effect.
 238  * Note: Callers must determine if sound effects are enabled. This plays a sound regardless of the setting.
 239  * @param sound Sound effect to play
 240  * @param left   Left edge of virtual coordinates where the sound is produced
 241  * @param right  Right edge of virtual coordinates where the sound is produced
 242  * @param top    Top edge of virtual coordinates where the sound is produced
 243  * @param bottom Bottom edge of virtual coordinates where the sound is produced
 244  */
 245 static void SndPlayScreenCoordFx(SoundID sound, int left, int right, int top, int bottom)
 246 {
 247         /* Iterate from back, so that main viewport is checked first */
 248         for (const Window *w : Window::IterateFromBack()) {
 249                 const Viewport *vp = w->viewport;
 250
 251                 if (vp != nullptr &&
 252                                 left < vp->virtual_left + vp->virtual_width && right > vp->virtual_left &&
 253                                 top < vp->virtual_top + vp->virtual_height && bottom > vp->virtual_top) {
 254                         int screen_x = (left + right) / 2 - vp->virtual_left;
 255                         int width = (vp->virtual_width == 0 ? 1 : vp->virtual_width);
 256                         float panning = (float)screen_x / width;
 257
 258                         StartSound(
 259                                 sound,
 260                                 panning,
 261                                 _vol_factor_by_zoom[vp->zoom]
 262                         );
 263                         return;
 264                 }
 265         }
 266 }
 267
 268 void SndPlayTileFx(SoundID sound, TileIndex tile)
 269 {
 270         /* emits sound from center of the tile */
 271         int x = std::min(Map::MaxX() - 1, TileX(tile)) * TILE_SIZE + TILE_SIZE / 2;
 272         int y = std::min(Map::MaxY() - 1, TileY(tile)) * TILE_SIZE - TILE_SIZE / 2;
 273         int z = (y < 0 ? 0 : GetSlopePixelZ(x, y));
 274         Point pt = RemapCoords(x, y, z);
 275         y += 2 * TILE_SIZE;
 276         Point pt2 = RemapCoords(x, y, GetSlopePixelZ(x, y));
 277         SndPlayScreenCoordFx(sound, pt.x, pt2.x, pt.y, pt2.y);
 278 }
 279
 280 void SndPlayVehicleFx(SoundID sound, const Vehicle *v)
 281 {
 282         SndPlayScreenCoordFx(sound,
 283                 v->coord.left, v->coord.right,
 284                 v->coord.top, v->coord.bottom
 285         );
 286 }
 287
 288 void SndPlayFx(SoundID sound)
 289 {
 290         StartSound(sound, 0.5, UINT8_MAX);
 291 }
 292
 293 INSTANTIATE_BASE_MEDIA_METHODS(BaseMedia<SoundsSet>, SoundsSet)
 294
 295 /** Names corresponding to the sound set's files */
 296 static const char * const _sound_file_names[] = { "samples" };
 297
 298
 299 template <class T, size_t Tnum_files, bool Tsearch_in_tars>
 300 /* static */ const char * const *BaseSet<T, Tnum_files, Tsearch_in_tars>::file_names = _sound_file_names;
 301
 302 template <class Tbase_set>
 303 /* static */ const char *BaseMedia<Tbase_set>::GetExtension()
 304 {
 305         return ".obs"; // OpenTTD Base Sounds
 306 }
 307
 308 template <class Tbase_set>
 309 /* static */ bool BaseMedia<Tbase_set>::DetermineBestSet()
 310 {
 311         if (BaseMedia<Tbase_set>::used_set != nullptr) return true;
 312
 313         const Tbase_set *best = nullptr;
 314         for (const Tbase_set *c = BaseMedia<Tbase_set>::available_sets; c != nullptr; c = c->next) {
 315                 /* Skip unusable sets */
 316                 if (c->GetNumMissing() != 0) continue;
 317
 318                 if (best == nullptr ||
 319                                 (best->fallback && !c->fallback) ||
 320                                 best->valid_files < c->valid_files ||
 321                                 (best->valid_files == c->valid_files &&
 322                                         (best->shortname == c->shortname && best->version < c->version))) {
 323                         best = c;
 324                 }
 325         }
 326
 327         BaseMedia<Tbase_set>::used_set = best;
 328         return BaseMedia<Tbase_set>::used_set != nullptr;
 329 }
 330