sound/rate.cpp

   1 /* ScummVM - Graphic Adventure Engine
   2  *
   3  * ScummVM is the legal property of its developers, whose names
   4  * are too numerous to list here. Please refer to the COPYRIGHT
   5  * file distributed with this source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  20  *
  21  * $URL$
  22  * $Id$
  23  *
  24  */
  25
  26 /*
  27  * The code in this file is based on code with Copyright 1998 Fabrice Bellard
  28  * Fabrice original code is part of SoX (http://sox.sourceforge.net).
  29  * Max Horn adapted that code to the needs of ScummVM and rewrote it partial,
  30  * in the process removing any use of floating point arithmetic. Various other
  31  * improvments over the original code were made.
  32  */
  33
  34 #include "sound/audiostream.h"
  35 #include "sound/rate.h"
  36 #include "sound/mixer.h"
  37 #include "common/frac.h"
  38 #include "common/util.h"
  39
  40 namespace Audio {
  41
  42
  43 /**
  44  * The size of the intermediate input cache. Bigger values may increase
  45  * performance, but only until some point (depends largely on cache size,
  46  * target processor and various other factors), at which it will decrease
  47  * again.
  48  */
  49 #define INTERMEDIATE_BUFFER_SIZE 512
  50
  51
  52 /**
  53  * Audio rate converter based on simple resampling. Used when no
  54  * interpolation is required.
  55  *
  56  * Limited to sampling frequency <= 65535 Hz.
  57  */
  58 template<bool stereo, bool reverseStereo>
  59 class SimpleRateConverter : public RateConverter {
  60 protected:
  61         st_sample_t inBuf[INTERMEDIATE_BUFFER_SIZE];
  62         const st_sample_t *inPtr;
  63         int inLen;
  64
  65         /** position of how far output is ahead of input */
  66         /** Holds what would have been opos-ipos */
  67         long opos;
  68
  69         /** fractional position increment in the output stream */
  70         long opos_inc;
  71
  72 public:
  73         SimpleRateConverter(st_rate_t inrate, st_rate_t outrate);
  74         int flow(AudioStream &input, st_sample_t *obuf, st_size_t osamp, st_volume_t vol_l, st_volume_t vol_r);
  75         int drain(st_sample_t *obuf, st_size_t osamp, st_volume_t vol) {
  76                 return ST_SUCCESS;
  77         }
  78 };
  79
  80
  81 /*
  82  * Prepare processing.
  83  */
  84 template<bool stereo, bool reverseStereo>
  85 SimpleRateConverter<stereo, reverseStereo>::SimpleRateConverter(st_rate_t inrate, st_rate_t outrate) {
  86         if ((inrate % outrate) != 0) {
  87                 error("Input rate must be a multiple of output rate to use rate effect");
  88         }
  89
  90         if (inrate >= 65536 || outrate >= 65536) {
  91                 error("rate effect can only handle rates < 65536");
  92         }
  93
  94         opos = 1;
  95
  96         /* increment */
  97         opos_inc = inrate / outrate;
  98
  99         inLen = 0;
 100 }
 101
 102 /*
 103  * Processed signed long samples from ibuf to obuf.
 104  * Return number of samples processed.
 105  */
 106 template<bool stereo, bool reverseStereo>
 107 int SimpleRateConverter<stereo, reverseStereo>::flow(AudioStream &input, st_sample_t *obuf, st_size_t osamp, st_volume_t vol_l, st_volume_t vol_r) {
 108         st_sample_t *ostart, *oend;
 109
 110         ostart = obuf;
 111         oend = obuf + osamp * 2;
 112
 113         while (obuf < oend) {
 114
 115                 // read enough input samples so that opos >= 0
 116                 do {
 117                         // Check if we have to refill the buffer
 118                         if (inLen == 0) {
 119                                 inPtr = inBuf;
 120                                 inLen = input.readBuffer(inBuf, ARRAYSIZE(inBuf));
 121                                 if (inLen <= 0)
 122                                         return ST_EOF;
 123                         }
 124                         inLen -= (stereo ? 2 : 1);
 125                         opos--;
 126                         if (opos >= 0) {
 127                                 inPtr += (stereo ? 2 : 1);
 128                         }
 129                 } while (opos >= 0);
 130
 131                 st_sample_t out0, out1;
 132                 out0 = *inPtr++;
 133                 out1 = (stereo ? *inPtr++ : out0);
 134
 135                 // Increment output position
 136                 opos += opos_inc;
 137
 138                 // output left channel
 139                 clampedAdd(obuf[reverseStereo    ], (out0 * (int)vol_l) / Audio::Mixer::kMaxMixerVolume);
 140
 141                 // output right channel
 142                 clampedAdd(obuf[reverseStereo ^ 1], (out1 * (int)vol_r) / Audio::Mixer::kMaxMixerVolume);
 143
 144                 obuf += 2;
 145         }
 146         return ST_SUCCESS;
 147 }
 148
 149 /**
 150  * Audio rate converter based on simple linear Interpolation.
 151  *
 152  * The use of fractional increment allows us to use no buffer. It
 153  * avoid the problems at the end of the buffer we had with the old
 154  * method which stored a possibly big buffer of size
 155  * lcm(in_rate,out_rate).
 156  *
 157  * Limited to sampling frequency <= 65535 Hz.
 158  */
 159
 160 template<bool stereo, bool reverseStereo>
 161 class LinearRateConverter : public RateConverter {
 162 protected:
 163         st_sample_t inBuf[INTERMEDIATE_BUFFER_SIZE];
 164         const st_sample_t *inPtr;
 165         int inLen;
 166
 167         /** fractional position of the output stream in input stream unit */
 168         frac_t opos;
 169
 170         /** fractional position increment in the output stream */
 171         frac_t opos_inc;
 172
 173         /** last sample(s) in the input stream (left/right channel) */
 174         st_sample_t ilast0, ilast1;
 175         /** current sample(s) in the input stream (left/right channel) */
 176         st_sample_t icur0, icur1;
 177
 178 public:
 179         LinearRateConverter(st_rate_t inrate, st_rate_t outrate);
 180         int flow(AudioStream &input, st_sample_t *obuf, st_size_t osamp, st_volume_t vol_l, st_volume_t vol_r);
 181         int drain(st_sample_t *obuf, st_size_t osamp, st_volume_t vol) {
 182                 return ST_SUCCESS;
 183         }
 184 };
 185
 186
 187 /*
 188  * Prepare processing.
 189  */
 190 template<bool stereo, bool reverseStereo>
 191 LinearRateConverter<stereo, reverseStereo>::LinearRateConverter(st_rate_t inrate, st_rate_t outrate) {
 192         if (inrate >= 65536 || outrate >= 65536) {
 193                 error("rate effect can only handle rates < 65536");
 194         }
 195
 196         opos = FRAC_ONE;
 197
 198         // Compute the linear interpolation increment.
 199         // This will overflow if inrate >= 2^16, and underflow if outrate >= 2^16.
 200         // Also, if the quotient of the two rate becomes too small / too big, that
 201         // would cause problems, but since we rarely scale from 1 to 65536 Hz or vice
 202         // versa, I think we can live with that limiation ;-).
 203         opos_inc = (inrate << FRAC_BITS) / outrate;
 204
 205         ilast0 = ilast1 = 0;
 206         icur0 = icur1 = 0;
 207
 208         inLen = 0;
 209 }
 210
 211 /*
 212  * Processed signed long samples from ibuf to obuf.
 213  * Return number of samples processed.
 214  */
 215 template<bool stereo, bool reverseStereo>
 216 int LinearRateConverter<stereo, reverseStereo>::flow(AudioStream &input, st_sample_t *obuf, st_size_t osamp, st_volume_t vol_l, st_volume_t vol_r) {
 217         st_sample_t *ostart, *oend;
 218
 219         ostart = obuf;
 220         oend = obuf + osamp * 2;
 221
 222         while (obuf < oend) {
 223
 224                 // read enough input samples so that opos < 0
 225                 while ((frac_t)FRAC_ONE <= opos) {
 226                         // Check if we have to refill the buffer
 227                         if (inLen == 0) {
 228                                 inPtr = inBuf;
 229                                 inLen = input.readBuffer(inBuf, ARRAYSIZE(inBuf));
 230                                 if (inLen <= 0)
 231                                         return ST_EOF;
 232                         }
 233                         inLen -= (stereo ? 2 : 1);
 234                         ilast0 = icur0;
 235                         icur0 = *inPtr++;
 236                         if (stereo) {
 237                                 ilast1 = icur1;
 238                                 icur1 = *inPtr++;
 239                         }
 240                         opos -= FRAC_ONE;
 241                 }
 242
 243                 // Loop as long as the outpos trails behind, and as long as there is
 244                 // still space in the output buffer.
 245                 while (opos < (frac_t)FRAC_ONE && obuf < oend) {
 246                         // interpolate
 247                         st_sample_t out0, out1;
 248                         out0 = (st_sample_t)(ilast0 + (((icur0 - ilast0) * opos + FRAC_HALF) >> FRAC_BITS));
 249                         out1 = (stereo ?
 250                                                   (st_sample_t)(ilast1 + (((icur1 - ilast1) * opos + FRAC_HALF) >> FRAC_BITS)) :
 251                                                   out0);
 252
 253                         // output left channel
 254                         clampedAdd(obuf[reverseStereo    ], (out0 * (int)vol_l) / Audio::Mixer::kMaxMixerVolume);
 255
 256                         // output right channel
 257                         clampedAdd(obuf[reverseStereo ^ 1], (out1 * (int)vol_r) / Audio::Mixer::kMaxMixerVolume);
 258
 259                         obuf += 2;
 260
 261                         // Increment output position
 262                         opos += opos_inc;
 263                 }
 264         }
 265         return ST_SUCCESS;
 266 }
 267
 268
 269 #pragma mark -
 270
 271
 272 /**
 273  * Simple audio rate converter for the case that the inrate equals the outrate.
 274  */
 275 template<bool stereo, bool reverseStereo>
 276 class CopyRateConverter : public RateConverter {
 277         st_sample_t *_buffer;
 278         st_size_t _bufferSize;
 279 public:
 280         CopyRateConverter() : _buffer(0), _bufferSize(0) {}
 281         ~CopyRateConverter() {
 282                 free(_buffer);
 283         }
 284
 285         virtual int flow(AudioStream &input, st_sample_t *obuf, st_size_t osamp, st_volume_t vol_l, st_volume_t vol_r) {
 286                 assert(input.isStereo() == stereo);
 287
 288                 st_sample_t *ptr;
 289                 st_size_t len;
 290
 291                 if (stereo)
 292                         osamp *= 2;
 293
 294                 // Reallocate temp buffer, if necessary
 295                 if (osamp > _bufferSize) {
 296                         free(_buffer);
 297                         _buffer = (st_sample_t *)malloc(osamp * 2);
 298                         _bufferSize = osamp;
 299                 }
 300
 301                 // Read up to 'osamp' samples into our temporary buffer
 302                 len = input.readBuffer(_buffer, osamp);
 303
 304                 // Mix the data into the output buffer
 305                 ptr = _buffer;
 306                 for (; len > 0; len -= (stereo ? 2 : 1)) {
 307                         st_sample_t out0, out1;
 308                         out0 = *ptr++;
 309                         out1 = (stereo ? *ptr++ : out0);
 310
 311                         // output left channel
 312                         clampedAdd(obuf[reverseStereo    ], (out0 * (int)vol_l) / Audio::Mixer::kMaxMixerVolume);
 313
 314                         // output right channel
 315                         clampedAdd(obuf[reverseStereo ^ 1], (out1 * (int)vol_r) / Audio::Mixer::kMaxMixerVolume);
 316
 317                         obuf += 2;
 318                 }
 319                 return ST_SUCCESS;
 320         }
 321
 322         virtual int drain(st_sample_t *obuf, st_size_t osamp, st_volume_t vol) {
 323                 return ST_SUCCESS;
 324         }
 325 };
 326
 327
 328 #pragma mark -
 329
 330 template<bool stereo, bool reverseStereo>
 331 RateConverter *makeRateConverter(st_rate_t inrate, st_rate_t outrate) {
 332         if (inrate != outrate) {
 333                 if ((inrate % outrate) == 0) {
 334                         return new SimpleRateConverter<stereo, reverseStereo>(inrate, outrate);
 335                 } else {
 336                         return new LinearRateConverter<stereo, reverseStereo>(inrate, outrate);
 337                 }
 338         } else {
 339                 return new CopyRateConverter<stereo, reverseStereo>();
 340         }
 341 }
 342
 343 /**
 344  * Create and return a RateConverter object for the specified input and output rates.
 345  */
 346 RateConverter *makeRateConverter(st_rate_t inrate, st_rate_t outrate, bool stereo, bool reverseStereo) {
 347         if (stereo) {
 348                 if (reverseStereo)
 349                         return makeRateConverter<true, true>(inrate, outrate);
 350                 else
 351                         return makeRateConverter<true, false>(inrate, outrate);
 352         } else
 353                 return makeRateConverter<false, false>(inrate, outrate);
 354 }
 355
 356 } // End of namespace Audio